datagatherer.hpp

Go to the documentation of this file.

//contains the runinfo class
#include <vector>
#include <map>
#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <cmath>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <sys/types.h>


#include "random.hpp"
#include "para_aux_funcs.hpp"

#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/progress.hpp>
#include <boost/regex.hpp>

#include "tinyxml.h"
#include "point.hpp"

#ifndef __DATAGATHERER_H__
#define __DATAGATHERER_H__

#include "runinfo.hpp"
#include "xml_preferences.hpp"
#include "timing.hpp"



class fileinfo {
    
    
public:
    
    fileinfo(){
        filesize = filecount = num_found_solns = 0;
        parser_index = -11;
        runningfile = "";
    }
    
    int filesize; 
    int filecount; 
    int num_found_solns; 
    
    std::string runningfile;  
    
    int parser_index;  
    
        
    
    
};


class datagatherer {

    
public:
    
    
    
    datagatherer(){
        fundamental_dir = "";
        numvariables = 0;
        base_dir = "";
    };
    
    datagatherer(boost::filesystem::path bdir, boost::filesystem::path fundir, int numvar){
        this->base_dir = bdir;
        this->fundamental_dir = fundir;
        this->numvariables = numvar;
        this->run_to_analyze = "";
    };
    
    datagatherer(int numvar, boost::filesystem::path loc){
        this->fundamental_dir = "";
        this->numvariables = numvar;
        this->run_to_analyze = loc;
    };
    

    
        //data members
    
    
    boost::filesystem::path fundamental_dir;
    boost::filesystem::path base_dir;
    int numvariables;
    
    boost::filesystem::path run_to_analyze;
    
    std::vector < std::string > gather_savefiles;
    std::vector < int > gather_parser_indices;
    

    std::vector<std::string> ParamNames;
    int numfiles;
    boost::filesystem::path DataCollectedbase_dir;
    int buffersize;
    int newfilethreshold;
    int myid;
    std::string real_filename;
    std::map< std::string, fileinfo> slavemap;  // a map between file names and fileinfo (as defined above)
    int standardstep2;
    
    
    int num_reals(){
            return this->slavemap[this->real_filename].num_found_solns;
    }
    
    void slave_init(){
        ParamNames.clear();
        slavemap.clear();
        this->standardstep2 = 0;
        this->numfiles = 0;
        this->buffersize = this->newfilethreshold = -1;
        this->myid = -1;
        this->DataCollectedbase_dir = "";
    }
    
    
    
    
    
    void add_file_to_save(std::string filename){
    
        fileinfo blankinfo;

        this->slavemap[filename] = blankinfo;
        this->numfiles ++;
        
        this->slavemap[filename].parser_index = GetFileParserIndex(filename);
        
        
    }
    
    boost::filesystem::path MakeTargetFilename(std::string filename);
    
    
    
    
    void SlaveSetup(ProgSettings & paramotopy_settings,
                                    runinfo & paramotopy_info,
                                    int myid,
                                    boost::filesystem::path called_dir);
    
    
    
    bool SlaveCollectAndWriteData(double *current_params,
                                                                ProgSettings & paramotopy_settings,
                                                                timer & process_timer);
    
    
    void AppendOnlyPosReal(std::string orig_filename,
                                                 double *current_params,
                                                 ProgSettings & paramotopy_settings);
    
    
    
    
    void AppendData(std::string orig_filename,
                                    double *current_params);
    
    
    
    
    
    void WriteAllData();
    
    
    
    void WriteData(std::string outstring,
                                 boost::filesystem::path target_file);
    

    
    
    
    
    
    
    
    
    
    
    
    bool GatherDataForFails(std::vector< point > terminal_fails,
                                                    std::vector< point > & successful_resolves);
    
    void GatherDataFromMenu();
    
    std::vector< point > CompareInitial_Gathered(std::vector< point > terminal_fails,
                                                                                             std::vector< point > current_data);
    
    std::vector < point > GatherFinalizedDataToMemory(boost::filesystem::path folder_with_data);
    
    void WriteUnsuccessfulResolves(std::map< int, point> successful_resolves);
    
    std::map< int, point > ReadSuccessfulResolves();
    
    void CheckForResolvedFailedPoint(std::string file_to_gather,
                                                                     int next_index,
                                                                     std::string & next_data,
                                                                     std::map< int, point> successful_resolves);
    
    boost::filesystem::path GetAvailableRuns();
    
    void CollectSpecificFiles(std::string file_to_gather,
                                                        std::vector < boost::filesystem::path > folders_with_data,
                                                        boost::filesystem::path run_to_analyze,
                                                        int parser_index,
                                                        bool mergefailed);
    
    std::vector< boost::filesystem::path > GetFoldersForData(boost::filesystem::path dir);
    
    void IncrementOutputFolder(boost::filesystem::path & output_folder_name,
                                                         boost::filesystem::path base_output_folder_name,
                                                         int & output_folder_index);
    
    void MergeFolders(std::string file_to_gather,
                                        boost::filesystem::path left_folder,
                                        boost::filesystem::path right_folder,
                                        boost::filesystem::path output_folder_name,
                                        int parser_index);
    
    void finalize_run_to_file(std::string file_to_gather, boost::filesystem::path source_folder,
                                                        boost::filesystem::path base_output_folder_name, int parser_index, bool mergefailed);
    
    void rest_of_files(std::ifstream & datafile, std::string & output_buffer, std::ofstream & outputfile,
                                         std::vector < boost::filesystem::path > filelist, int file_index, int parser_index);
    
    bool endoffile_stuff(std::ifstream & datafile, int & file_index, std::vector < boost::filesystem::path > filelist);
    
    
    bool ReadPoint(std::ifstream & fin, std::string & data, int parser_index);
    bool ReadPoint(std::ifstream & fin, int & next_index, std::string & data, int parser_index);
    
    std::string ParseSolutionsFile(std::ifstream & fin);
    
    std::vector< std::vector < std::pair< std::string, std::string > > > ParseSolutionsFile_ActualSolutions(std::ifstream & fin);
    
    std::string ParseFailedPaths(std::ifstream & fin);
    

    
    
private:
    
    
    
};


void DataManagementMainMenu(runinfo & paramotopy_info);



#endif