STD_save.h

Go to the documentation of this file.

#ifndef STD_SAVE_H
#define STD_SAVE_H

#include<string>
#include<vector>
#include<sstream>
#include<fstream>
#include<iostream>
#include<stdlib.h>

#ifdef HIGH_PRECISION
        typedef long double Mdouble;
#else 
        typedef double Mdouble;
#endif

using namespace std;

class STD_save {

public:

STD_save(){
        constructor();
        #ifdef CONSTUCTOR_OUTPUT
                        cerr << "STD_save() finished"<<endl;
        #endif  
}

STD_save(STD_save& other) {
        constructor();
        counter = other.get_counter();
        problem_name.str(other.get_name());
        set_options_fstat(other.get_options_fstat());
        set_options_data(other.get_options_data());
        set_options_ene(other.get_options_ene());
        set_options_stat(other.get_options_stat());
        set_options_restart(other.get_options_restart());
        #ifdef CONSTUCTOR_OUTPUT
                        cerr << "STD_save(STD_save& other) finished"<<endl;
        #endif  
};

void constructor(){
        counter=0;
        set_options_restart(1);
        set_options_fstat(1);
        set_options_ene(1);
        set_options_data(1);
        set_options_stat(1);
        file_counter = 0;
        step_size = 1;
        data_file.precision(13);
        fstat_file.precision(13);
        ene_file.precision(13);
        stat_file.precision(5);
        stat_file.setf(ios::left);
}


void inc_counter_in_file();

int read_run_num_from_file();

void set_counter_from_file();

void save_info_to_disk();

void set_counter(int new_counter);

int get_counter();

virtual void info(){}

bool FileExists(std::string strFilename);

void auto_number(){     set_counter_from_file(); inc_counter_in_file();}

std::vector<int> get_numbers(int size_x, int size_y);

int launch_new(const char* name, bool quick=false);

void set_name(const char* name){problem_name.str(""); problem_name << name;}
string get_name(){return problem_name.str();}

fstream& get_data_file(){return data_file;}     
fstream& get_stat_file(){return stat_file;}     
fstream& get_fstat_file(){return fstat_file;}   
fstream& get_ene_file(){return ene_file;}

void set_fstat_filename(string filename){fstat_filename.str(""); fstat_filename << filename;}
void set_data_filename(string filename){data_filename.str(""); data_filename << filename;}
void set_stat_filename(string filename){stat_filename.str(""); stat_filename << filename;}
void set_ene_filename(string filename){ene_filename.str(""); ene_filename << filename;}

void set_fstat_filename(){fstat_filename.str(""); fstat_filename << problem_name.str().c_str()  << ".fstat";}
void set_data_filename(){data_filename.str(""); data_filename << problem_name.str().c_str()  << ".data";}
void set_stat_filename(){stat_filename.str(""); stat_filename << problem_name.str().c_str()  << ".stat";}
void set_ene_filename(){ene_filename.str(""); ene_filename << problem_name.str().c_str()  << ".ene";}

string get_fstat_filename(){return fstat_filename.str();}
string get_data_filename(){return data_filename.str();}
string get_stat_filename(){return stat_filename.str();}
string get_ene_filename(){return ene_filename.str();}


void set_step_size(unsigned int new_){step_size= new_;} 
unsigned int get_step_size(){return step_size;} 

void set_options_fstat(unsigned int new_){options_fstat = new_;}
unsigned int get_options_fstat(void){return options_fstat;}

void set_options_data(unsigned int new_){options_data = new_;}
unsigned int get_options_data(void){return options_data;}

void set_options_stat(unsigned int new_){options_stat = new_;}
unsigned int get_options_stat(void){return options_stat;}

void set_options_restart(unsigned int new_){options_restart = new_;}
unsigned int get_options_restart(void){return options_restart;}

void set_options_ene(unsigned int new_){options_ene = new_;}
unsigned int get_options_ene(void){return options_ene;}


bool open_file (fstream& file, string filename, unsigned int options, fstream::openmode mode) 
{
        if (options==1) {
                //cout << "open " << filename << endl;
                file.open( filename.c_str(), mode);
                if (file.fail()) return false;
        }
        return true;
}

bool open_fstat_file (fstream::openmode mode = fstream::out) {
        return open_file (fstat_file, fstat_filename.str(), get_options_fstat(), mode);
}
bool open_data_file (fstream::openmode mode = fstream::out) {
        return open_file (data_file, data_filename.str(), get_options_data(), mode);
}
bool open_stat_file (fstream::openmode mode = fstream::out) {
        return open_file (stat_file, stat_filename.str(), get_options_stat(), mode);
}
bool open_ene_file (fstream::openmode mode = fstream::out) {
        return open_file (ene_file, ene_filename.str(), get_options_ene(), mode);
}

bool open_counted_file(fstream& file, string filenameNoCount, fstream::openmode mode){
        //create filename
        stringstream filename;
        filename << filenameNoCount << ".";
        if (file_counter<1000) filename << "0";
        if (file_counter<100) filename << "0";
        if (file_counter<10) filename << "0";
        filename << file_counter;
        //close old file
        if (file.is_open()) file.close();
        //open new file
        file.open(filename.str().c_str(), mode);
        if (!file.is_open()) {cerr << "Error in opening " << filename.str() << endl; return false;}
        //else cout << "open(" << mode << ") " << filename.str() << endl;
        //increase counter
        file_counter += step_size;
        return true;
}

bool increase_counter_fstat(fstream::openmode mode){
        file_counter -= step_size;
        return open_counted_file(fstat_file, fstat_filename.str(), mode);
}
bool increase_counter_data(fstream::openmode mode){
        return open_counted_file(data_file, data_filename.str(), mode);
}
bool increase_counter_stat(fstream::openmode mode){
        file_counter -= step_size;
        return open_counted_file(stat_file, stat_filename.str(), mode);
}
bool increase_counter_ene(fstream::openmode mode){
        file_counter -= step_size;
        return open_counted_file(ene_file, ene_filename.str(), mode);
}

void set_file_counter(int new_) {file_counter = new_;}
int get_file_counter() {return file_counter;}

private:
int counter;

protected:
stringstream problem_name;

stringstream data_filename;
stringstream stat_filename;
stringstream fstat_filename;
stringstream ene_filename;

fstream data_file;
fstream stat_file;
fstream fstat_file;
fstream ene_file;


unsigned int options_fstat; 
unsigned int options_data; 
unsigned int options_stat; 
unsigned int options_ene; 
unsigned int options_restart; 

unsigned int file_counter;
unsigned int step_size;
};


#endif