MeasureOfETH.cpp File Reference

Functions
int	main (int argc, char **argv)

Variables
namespace	filesystem = std::experimental::filesystem

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

                               {
  if(argc < 6) {
    std::cerr << "Usage: 1.This 2.Directory 3.Nmax 4.Nmin 5.dE 6.Emin 7.Emax (Op1).NdataMax" << std::endl;
    std::exit(EX_USAGE);
  }
     int const Nmax = (argc>=3 ? std::stoi(argv[2]) :16);
     int const Nmin = (argc>=4 ? std::stoi(argv[3]) :16);
  double const   dE = (argc>=5 ? std::stod(argv[4]) :0.02);
  double const Emin = (argc>=6 ? std::stod(argv[5]) :0.45);
  double const Emax = (argc>=7 ? std::stod(argv[6]) :0.55);
     int const NdataMax = (argc>=8 ? std::stod(argv[7]) :-1);
 
  std::string const baseDir(argv[1]);
  std::cout << "# Directory: " << baseDir << "\n";
  std::string const InDataDir(baseDir+"/RawData");
  std::vector<std::string> dirList;
  {
    std::string str;
    int dataNo;
    if(NdataMax>0) dirList.resize(NdataMax);
    for(const filesystem::directory_entry &entry : filesystem::directory_iterator(InDataDir)) {
      if ( entry.is_directory() ) {
        str = entry.path().string();
        dataNo = std::atoi(str.substr(str.find("_No")+3).c_str());
        if(NdataMax>0 && dataNo>=NdataMax) continue;
        debug_print("# dir=" << str << ", dataNo=" << dataNo);
        if(NdataMax<=0 && dirList.size()<=dataNo) dirList.resize(dataNo+1);
        dirList.at(dataNo) = str;
      }
    }
  }
 
 
  class measureOfETH {
    public:
      double Fluc;
      double MaxFluc;
      double MaxPos;
      Integer_t Ndata;
      measureOfETH() : Fluc(NAN), MaxFluc(NAN), MaxPos(NAN), Ndata(-1) {};
  };
  std::vector<std::vector<measureOfETH>> Data(Nmax+1);
  for(size_t n = Nmin;n <= Nmax; ++n) {
    Data.at(n).resize(dirList.size());
    // std::fill(Data.at(n).begin(), Data.at(n).end(), -1);
  }
 
  #pragma omp parallel for schedule(dynamic, 10)
  for(size_t sample = 0;sample < dirList.size(); ++sample) {
    std::string str;
    std::stringstream ss;
    Integer_t dim;
    std::vector<Integer_t> NdataInShell;
    std::vector<double> eigenEnergy;
    std::vector<double> eigenExpValue;
    std::vector<double> MCAverage;
    double OpRange, dtemp, energy;
 
    std::ifstream InExpValueFs;
    std::string InExpValueFname;
    std::vector<std::string> candidateFileNames;
 
 
    #pragma omp critical
    std::cout << "# " << dirList[sample] << std::endl;
    for(size_t n = Nmin;n <= Nmax; ++n) {
      bool failFlag = false;
      std::stringstream buff(""); buff << "_N" << n << ".txt";
      //-------------------- Load eigen-energies --------------------//
      candidateFileNames.resize(3);
      candidateFileNames[0] = dirList[sample] + "/EigenExpValueZ" + buff.str();
      candidateFileNames[1] = dirList[sample] + "/EigenExpValueC" + buff.str();
      candidateFileNames[2] = dirList[sample] + "/EigenExpValue" + buff.str();
      if( InExpValueFs.is_open() ) { InExpValueFs.close(); InExpValueFs.clear(); }
      for(auto name : candidateFileNames) {
        InExpValueFname = name;
        InExpValueFs.open(InExpValueFname);
        if( InExpValueFs.is_open() ) break;
      }
      if( !InExpValueFs.is_open() ) {
        #pragma omp critical
        std::cout << "Warning(N=" << n << "): Nodata file for '" << dirList[sample] <<"'." << std::endl;
        continue;
      }
      InExpValueFs.exceptions(std::ios::badbit | std::ios::failbit);
      #pragma omp critical
      debug_print("InFileName= " << InExpValueFname);
      while( std::getline(InExpValueFs, str) ) if(str.find("OpRange") != std::string::npos) break;
      OpRange = std::stod(str.substr(str.find("OpRange=")+8));
 
      eigenEnergy.resize(0);
      eigenExpValue.resize(0);
      try{
        skip_header(InExpValueFs);
        for(getline(InExpValueFs, str); !InExpValueFs.eof(); getline(InExpValueFs, str)) {
          // debug_print(" Read line= " << str);
          ss.str(str); ss.clear(std::stringstream::goodbit);
          ss >> energy; eigenEnergy.push_back(energy);
          ss >> dtemp;
          ss >> dtemp; eigenExpValue.push_back(dtemp/OpRange);
          if( (Emin<energy && energy<Emax) && (isnan(dtemp) || isinf(dtemp)) ) { failFlag=true; break; }
        }
      } catch(std::exception& e) {
        if( !InExpValueFs.eof() )
        std::cerr << "Error(" << InExpValueFs.eof() << InExpValueFs.fail() << InExpValueFs.bad() << "):" << e.what() << std::endl;
      }
      InExpValueFs.close(); InExpValueFs.clear();
      if(failFlag) {
        #pragma omp critical
        std::cerr << "File: " << InExpValueFname << " contains NAN." << std::endl;
        continue;
      }
 
      if(eigenEnergy.size() != eigenExpValue.size()) {
        std::cerr << "Error: eigenEnergy.size() != eigenExpValue.size() for a file\n"
                  << "\t" << InExpValueFname << std::endl;
        continue;
      }
      dim = eigenEnergy.size();
 
      debug_print("########## Some process ##########");
        // Calculate Microcanonical averages with energy corresponding to each eigenstate.
        MCAverage.resize(dim); NdataInShell.resize(dim);
        std::fill(   MCAverage.begin(),    MCAverage.end(), 0.0);
        std::fill(NdataInShell.begin(), NdataInShell.end(), 0.0);
        for(Integer_t i = 0;i < dim; ++i) {
          MCAverage[i] = MicroCanonicalAverage(NdataInShell[i], eigenEnergy[i], dE, dim, eigenEnergy, eigenExpValue, i);
        }
 
        double Fluc, MaxFluc, MaxPos;
        Integer_t ndata;
        ndata = MeasureOfETH(Fluc, MaxFluc, MaxPos, Emin, Emax, dim, eigenEnergy, eigenExpValue, MCAverage);
        // #pragma omp critical
        // debug_print("Fluc=" << Fluc << ", MaxFluc=" << MaxFluc << ", MaxPos=" << MaxPos << ", Ndata=" << ndata);
        Data.at(n).at(sample).Fluc    = Fluc;
        Data.at(n).at(sample).MaxFluc = MaxFluc;
        Data.at(n).at(sample).MaxPos  = MaxPos;
        Data.at(n).at(sample).Ndata   = (ndata > 0 ? ndata : -1);
      debug_print("########## (END)Some process ##########\n");
    }
  }
 
 
  std::string OutDir, OutFname;
  std::ofstream OutFs;
  {
    std::stringstream buff("");
    buff << "/Measure_Emin" << Emin << "_Emax" << Emax << "_dE" << dE;
    OutDir = baseDir+buff.str();
    filesystem::create_directories(OutDir);
  }
  #pragma omp parallel for
  for(size_t n = Nmin;n <= Nmax; ++n) {
    std::stringstream buff(""); buff << "/MeasureOfETH_N" << n << ".txt";
    std::string OutFname(OutDir + buff.str());
    std::ofstream OutFs(OutFname); checkIsFileOpen(OutFs, OutFname);
    OutFs << "# 1.(Sample No.) 2.(Fluc) 3.(MaxFluc) 4.(MaxPos) 5.(Ndata)\n\n";
    OutFs << std::scientific << std::showpos << std::setprecision(6);
    for(size_t sample = 0;sample < dirList.size(); ++sample) {
      if(Data.at(n).at(sample).Ndata == -1) continue;
      OutFs << sample                  << " "
            << Data[n][sample].Fluc    << " "
            << Data[n][sample].MaxFluc << " "
            << Data[n][sample].MaxPos  << " "
            << Data[n][sample].Ndata
            << std::endl;
    }
  }
 
  return EXIT_SUCCESS;
}

Variable Documentation

filesystem

namespace filesystem = std::experimental::filesystem