runinfo.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 <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/progress.hpp>
#include <boost/regex.hpp>

#include "tinyxml.h"


#ifndef __RUNINFO_H__
#define __RUNINFO_H__


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

#include "xml_preferences.hpp"


class runinfo {
    
public:
    
    // values of points -- two different ways storing the data
    // whether or not we are user-defined or not
    // if doing a mesh, the data is contained as follows
    // -- first vector size is the number of parameters
    // -- second vector size the number of mesh points for the given param
    // -- pair is the real (first) and imaginary (second)
    
    // if not doing a mesh, the data is contained as follows
    // -- first vector size is number of sample n-tuples)
    // -- second vector size is n
    // -- pair is the real (first) and imaginary (second)

  int numfunct;
  int numvariables;
  int numvargroup;
  
  int numparam; 
  int numconsts;
    
    //this may well be changed/ renamed/ deleted
  boost::filesystem::path location;
    
  boost::filesystem::path fundamental_dir;
    
  boost::filesystem::path base_dir;
  
  int run_number;
  time_t initiated;
  time_t updated;
  
    std::string paramotopy_file;
    
    boost::filesystem::path inputfilename;
  boost::filesystem::path prefix;
  
  int steptwomode;// indicates to step2 whether to use step2 or pathfailure bertini settings.
  
  std::vector<std::string> Functions;
  std::vector<std::string> VarGroups;
  std::vector<std::string> Parameters; 
  std::vector<std::string> ParameterNames;
  std::vector<std::string> Constants;
  std::vector<std::string> ConstantNames;
  std::string CustomLines;
  
  std::vector< std::vector< std::pair<double,double> > > Values;
  
    std::vector< std::pair<double,double> > BoundsLeft;
    std::vector< std::pair<double,double> > BoundsRight;
    
  bool userdefined;
  
  std::string mcfname;  
  std::vector< int > NumMeshPoints;
  
  // random initial values
  // -- vector size is the number of parameters
  // -- pair is the real (first) and imaginary (second)
  std::vector< std::pair<double,double> > RandomValues;
  
    
    
    
    
    
    
    
    
    //            methods
    
  runinfo(){
    steptwomode = -1;
  };//default constructor
  
  std::string WriteInputStepOne(ProgSettings paramotopy_settings);
  std::string WriteInputStepTwo(std::vector<std::pair<double, double> > tmprandomvalues,
                bool standardstep2);
  
  void GetOriginalParamotopy();
  void GetInputFileName();
  void GetInputFileName(boost::filesystem::path suppliedfilename);
  

  void make_base_dir_name();
  
  void mkdirstep1(){
        boost::filesystem::path tempstr = base_dir;
    boost::filesystem::create_directories(tempstr);
    tempstr /= "step1";
    boost::filesystem::create_directories(tempstr);
  };
  
  void clear(){
    Functions.clear(); VarGroups.clear(); 
    Parameters.clear(); ParameterNames.clear(); 
    Constants.clear(); ConstantNames.clear(); 
    Values.clear(); NumMeshPoints.clear();
    CustomLines.clear();
    RandomValues.clear(); 
    numfunct = 0; numvariables = 0; numvargroup = 0; numparam = 0; numconsts = 0; 
  };
  
  void ParseData();
  void ParseData(boost::filesystem::path dir);
  
  void ParseDataGuts(std::ifstream & fin);
  
  void ReadCustomLines(std::ifstream & fin);
  
  bool made_new_folder;
  
  void RandomMenu(){
    std::stringstream ss;
    ss << "1) save values\n"
       << "2) load random values\n"
       << "3) make new values\n"
       << "*\n0)return to paramotopy\n: ";
    int choice = get_int_choice(ss.str(),0,3);
    switch (choice) {
    case 0:
      
      break;
    case 1:
      runinfo::SaveRandom();
      break;
    case 2:
      runinfo::LoadRandom();
      break;
    case 3:
      runinfo::SetRandom();
      break;
    default:
      break;
    }
  };
  void SaveRandom();
  void LoadRandom();
  void SetRandom();
  bool GetPrevRandom();
  void SetLocation();
  bool test_if_finished();
  void DisplayAllValues();
  
  void CopyUserDefinedFile();
  
  std::vector<std::pair<double, double> > MakeRandomValues(int garbageint);
  
    
    void GetRandomValues();

    
    
  void WriteOriginalParamotopy(boost::filesystem::path dir);
  void WriteModifiedParamotopy(boost::filesystem::path dir, int iteration);
  void WriteRandomValues();
  
  
  //    ManageData
  void SetBaseDirZero();
  void SetBaseDirManual(std::vector< boost::filesystem::path > found_runs);
  void SetBaseDirMostRecent(std::vector< boost::filesystem::path > found_runs);
  void SetBaseDirNew(std::vector< boost::filesystem::path > found_runs);
  void AutoScanData(const int preferred_behaviour);
  void ScanData();
  void save();
  void load(boost::filesystem::path filename);
  void get_run_xml(boost::filesystem::path filename, int & run, time_t  & wheninitiated, time_t & whenupdated);
  void UpdateAndSave();
  
  void MakeRandomValues();
  
  bool CheckRunStepOne();
  
  void GatherData();
  

  boost::filesystem::path GetAvailableRuns();
  
  void CollectSpecificFiles(boost::filesystem::path 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, std::string left_folder, 
            std::string right_folder, std::string output_folder_name, int parser_index);
  void finalize_run_to_file(boost::filesystem::path 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, 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);
  

  //gets called repeatedly to see if any points had failed paths (each point has one failed_paths file.
  std::string ParseFailedPaths(std::ifstream & fin);
  void PrintRandom();
private:
  void GetNumVariables();
  void ReadSizes(std::ifstream & fin);
  void ReadParameters(std::ifstream & fin);
  void ReadFunctions(std::ifstream & fin);
  void ReadVarGroups(std::ifstream & fin);
  void ReadConstants(std::ifstream & fin);
  void ReadConstantStrings(std::ifstream & fin);
  void MakeParameterNames();
  void MakeVariableGroups(std::stringstream & fout, ProgSettings paramotopy_settings);
  void MakeDeclareConstants(std::stringstream & fout);
  void MakeConstants(std::stringstream & fout);
  void MakeConstantsStep2(std::vector<std::pair<double, double> > CurrentValues, std::stringstream & inputfilestream, bool standardstep2);
  void MakeCustomLines(std::stringstream & inputfilestream);
  void MakeDeclareFunctions(std::stringstream & inputstringstream);
  void MakeFunctions(std::stringstream & inputstringstream);
  void MakeRandomValues(std::vector< std::pair< std::pair< double, double >, 
            std::pair< double, double > > > RandomRanges);

  
  void MakeValues(std::ifstream & fin);
  void MakeValues();
    
  void MakeBounds();
    
  void SetDataFirst();
  void SetDataMostRecent();
  void SetDataInteractive();
  void WriteDataDateStarted();
  void DeleteRunFolder();


    
protected:

    
};



#endif