LevelSpacingRatio.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 < 5) {
    std::cerr << "Usage: 1.This 2.Directory 3.Nmax 4.Nmin 5.dE (Op1).SampleMin (Op2).SampleMax" << 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 = 0.5-dE;
  double const Emax = 0.5+dE;
  int const SampleMin = (argc>=6 ? std::stod(argv[5]) :-1);
  int const SampleMax = (argc>=7 ? std::stod(argv[6]) :-1);
 
 
  std::string const baseDir(argv[1]);
  std::cout << "# Directory: " << baseDir << "\n";
  std::string InDataDir(baseDir); InDataDir += "/RawData";
  std::vector<std::string> dirList;
  {
    std::string str;
    int dataNo;
    int const idShift=(SampleMin>0? SampleMin: 0);
    if(SampleMin>0 && SampleMax>0) dirList.resize(SampleMax-idShift+1);
    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((SampleMin>0 || SampleMax>0) && (dataNo<SampleMin || SampleMax<dataNo)) continue;
        debug_print("# dir=" << str << ", dataNo=" << dataNo);
        if( (SampleMin<=0 || SampleMax<=0)  && dirList.size()<=dataNo) dirList.resize(dataNo+1);
        debug_print("dataNo-idShift=" << dataNo-idShift << ", dataNo=" << dataNo << ", idShift=" << idShift);
        dirList.at(dataNo-idShift) = str;
      }
    }
  }
 
  std::vector<std::vector<double>> Average(Nmax+1);
  std::vector<std::vector<double>> Variance(Nmax+1);
  for(int n = Nmax;n >= Nmin ; --n) {
     Average.at(n).resize(dirList.size());
    Variance.at(n).resize(dirList.size());
    for(size_t sample = 0;sample < dirList.size(); ++sample){
       Average.at(n).at(sample) = NAN;
      Variance.at(n).at(sample) = NAN;
    }
  }
 
 
  #pragma omp parallel for schedule(dynamic, 10)
  for(size_t sample = 0;sample < dirList.size(); ++sample) {
    Integer_t dim;
    double dtemp;
    std::vector<double> EigenEnergy, levelSpacing;
    std::string InEnergyFname, str;
    std::ifstream InEnergyFs;
    std::vector<std::string> candidateFileNames;
    std::string OutFName;
    std::string OutDir(std::regex_replace(dirList[sample], std::regex("/RawData"), "/ProcessedData"));
    filesystem::create_directories(OutDir);
    OutFName = OutDir + "/LevelSpacingRatio.txt";
    std::ofstream OutFs(OutFName); checkIsFileOpen(OutFs, OutFName);
    OutFs << "# 1.(N) 2.(Spectral Mean) 3.(Spectral Stddev) 4.(Spectral Kutosis)\n" << std::endl;
 
    std::cout << "# " << dirList[sample] << std::endl;
    for(int n = Nmax;n >= Nmin ; --n) {
      dim = 0;
      std::stringstream buff(""); buff << "_N" << n << ".txt";
      { //-------------------- Load EigenEnergies --------------------//
        candidateFileNames.resize(2);
        candidateFileNames[0] = dirList[sample] + "/EigenExpValueZ" + buff.str();
        candidateFileNames[1] = dirList[sample] + "/EigenExpValueC" + buff.str();
        if( InEnergyFs.is_open() ) { InEnergyFs.close(); InEnergyFs.clear(); }
        for(auto name : candidateFileNames) {
          InEnergyFname = name;
          InEnergyFs.open(InEnergyFname);
          if( InEnergyFs.is_open() ) break;
        }
        if( !InEnergyFs.is_open() ) continue;
        InEnergyFs.exceptions(std::ios::badbit | std::ios::failbit);
 
        EigenEnergy.resize(0);
        try{
          skip_header(InEnergyFs);
          std::stringstream ss;
          for(getline(InEnergyFs, str); !InEnergyFs.eof(); getline(InEnergyFs, str)) {
            ss.str(str); ss.clear(std::stringstream::goodbit);
            ss >> dtemp; EigenEnergy.push_back(dtemp);
          }
        } catch(std::exception& e) {
          if( !InEnergyFs.eof() )
          std::cerr << "Error(" << InEnergyFs.eof() << InEnergyFs.fail() << InEnergyFs.bad() << "):" << e.what() << std::endl;
        }
        InEnergyFs.close(); InEnergyFs.clear();
        dim = EigenEnergy.size();
      }
      #ifndef NDEBUG
        std::cout << std::scientific;
        print(EigenEnergy, EigenEnergy.size());
      #endif
 
      LevelSpacingRatio(levelSpacing, Emin, Emax, dim, EigenEnergy);
       Average.at(n).at(sample) = std::accumulate(levelSpacing.begin(), levelSpacing.end(), 0.0) / levelSpacing.size();
       double ave = Average.at(n).at(sample);
      Variance.at(n).at(sample) = std::accumulate(levelSpacing.begin(), levelSpacing.end(), 0.0, [ave](double sum, const auto& e){
                const auto temp = e - ave;
                return sum + temp * temp;
              }) / levelSpacing.size();
      dtemp = std::accumulate(levelSpacing.begin(), levelSpacing.end(), 0.0, [ave](double sum, const auto& e){
                const auto temp = e - ave;
                return sum + temp * temp * temp * temp;
              }) / levelSpacing.size();
      OutFs << n << " "
            << Average.at(n).at(sample) << " "
            << std::sqrt(Variance.at(n).at(sample)) << " "
            << dtemp/(Variance.at(n).at(sample)*Variance.at(n).at(sample))
            << std::endl;
    }
  }
 
  std::cout << "# Directory: " << baseDir << "\n";
  std::string OutDIR(baseDir); OutDIR += "/Output";
  filesystem::create_directory(OutDIR);
 
  std::stringstream buff("");
  buff << "/MeanLevelSpacingRatio_Emin" << std::setprecision(2) << Emin << "_Emax" << Emax << "_dE.txt";
  std::string   OutFName(OutDIR+buff.str());
  std::ofstream Outfp(OutFName); checkIsFileOpen(Outfp, OutFName);
  Outfp.exceptions(std::ios::badbit | std::ios::failbit);
  Outfp << "# 1.(N) 2.(Ensemble Average) 3.(Ensemble Stddev) 4.(ndata)\n" << std::endl;
  for(int n = Nmax;n >=Nmin ; --n) {
    double ave=0.0, var=0.0, dtemp;
    int ndata = 0;
    for(size_t sample = 0;sample < dirList.size(); ++sample) {
      if( isnan(Average.at(n).at(sample)) ) continue;
      ndata += 1;
      ave += Average.at(n).at(sample);
    }
    ave /= (double)ndata;
    for(size_t sample = 0;sample < dirList.size(); ++sample) {
      if( isnan(Average.at(n).at(sample)) ) continue;
      dtemp = Average.at(n).at(sample) - ave;
      var += dtemp * dtemp;
    }
    var /= (double)ndata;
    Outfp << n   << " "
          << ave << " "
          << std::sqrt(var) << " "
          << ndata
          << std::endl;
  }
 
  return 0;
}

Variable Documentation

filesystem

namespace filesystem = std::experimental::filesystem