ParticipationRatio.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.Type (Op1).SampleMin (Op2).SampleMax" << std::endl;
    std::cerr << "     : Type should be either (a)vsOp, (b)MF, or (c)btw2samples." << std::endl;
    std::exit(EX_USAGE);
  }
  constexpr int MaxDeg = 8;
     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.05);
  double const Emin = 0.5-dE;
  double const Emax = 0.5+dE;
     int const SampleMin = (argc>=7 ? std::stod(argv[6]) :-1);
     int const SampleMax = (argc>=8 ? std::stod(argv[7]) :-1);
  std::string const Type(argv[5]);
 
  int const n_max = Nmax;
  int const n_min = Nmin;
  int const dim_loc = 2;
  //******************** Translation invariance ********************
  debug_print("# Calculating translation-invariant sectors.");
  #include "PBC_TI/Framework/Fragments/TranslationInvariantSectors.cpp"
  //******************** (END)Translation invariance ********************
 
  std::string const baseDir(argv[1]);
  std::cout << "# Directory: " << baseDir << "\n";
  std::string const InDataDir(baseDir+"/ProcessedData");
  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<std::vector<double>>> FractalDimension(Nmax+1, std::vector<std::vector<double>>(MaxDeg+1, std::vector<double>(dirList.size(), NAN)));
  #pragma omp parallel for schedule(dynamic, 10)
  for(size_t sample = 0;sample < dirList.size(); ++sample) {
    double dtemp;
    std::string InFname, str;
    std::ifstream InFs;
    std::vector<std::string> candidateFileNames;
    bool flag = false;
    #pragma omp critical
    std::cout << "# " << dirList[sample] << std::endl;
    for(int n = Nmax;n >= Nmin ; --n) {
      std::stringstream buff(""); buff << "_N" << n << ".txt";
      { //-------------------- Load EigenEnergies --------------------//
        candidateFileNames.resize(3);
        candidateFileNames[0] = dirList[sample] + "/MultiFractalZ_" + Type + buff.str();
        candidateFileNames[1] = dirList[sample] + "/MultiFractalC_" + Type + buff.str();
        candidateFileNames[2] = dirList[sample] + "/MultiFractal_"  + Type + buff.str();
        if( InFs.is_open() ) { InFs.close(); InFs.clear(); }
        for(auto name : candidateFileNames) {
          InFname = name;
          InFs.open(InFname);
          if( InFs.is_open() ) break;
        }
        if( !InFs.is_open() ) continue;
        InFs.exceptions(std::ios::badbit);
        flag = true;
        std::stringstream ss;
        double MinEigenEnergy=NAN, MaxEigenEnergy=NAN;
        try{
          skip_header(InFs);
          for(getline(InFs, str); !InFs.eof(); getline(InFs, str)) {
            ss.str(str); ss.clear(std::stringstream::goodbit);
            ss >> dtemp;
            MinEigenEnergy = std::fmin(dtemp, MinEigenEnergy);
            MaxEigenEnergy = std::fmax(dtemp, MaxEigenEnergy);
          }
        } catch(std::exception& e) {
          if( !InFs.eof() )
          std::cerr << "Error(" << InFs.eof() << InFs.fail() << InFs.bad() << "):" << e.what() << std::endl;
        }
        double EnergyRange=MaxEigenEnergy-MinEigenEnergy;
        // #pragma omp critical
        // std::cout << "# " << dirList[sample] << ", EnergyRange=" << EnergyRange << std::endl;
        InFs.clear(); InFs.seekg(0, std::ios::beg);
        try {
          skip_header(InFs);
          for(getline(InFs, str); !InFs.eof(); getline(InFs, str)) {
            ss.str(str); ss.clear(std::stringstream::goodbit);
            ss >> dtemp; dtemp = (dtemp-MinEigenEnergy)/EnergyRange;
            if(dtemp<Emin || Emax<dtemp) continue;
            for(int deg=2;deg <= MaxDeg; ++deg) {
              ss >> dtemp;
              FractalDimension[n][deg][sample] = std::fmin(dtemp, FractalDimension[n][deg][sample]);
            }
          }
        } catch(std::exception& e) {
          if( !InFs.eof() )
          std::cerr << "Error(" << InFs.eof() << InFs.fail() << InFs.bad() << "):" << e.what() << std::endl;
        }
        InFs.close(); InFs.clear();
      }
    }
 
    if(!flag) continue;
    {
      std::string OutDIR(dirList[sample]);
      std::filesystem::create_directories(OutDIR);
      std::stringstream buff("");
      buff << "/InverseParticipationRatio_" +Type+  "_dE" << std::setprecision(2) << dE << ".txt";
      std::string OutFName(OutDIR + buff.str());
      std::ofstream OutFs(OutFName); checkIsFileOpen(OutFs, OutFName);
      OutFs << "# 1.(N) 2.(deg 2) 3.(deg 3) 4.(deg 4) 5.(deg 5) 6.(deg 6) 7.(deg 7) 8.(deg 8) 9.(deg 9)" << std::endl;
      OutFs << std::scientific;
      for(int n = Nmax;n >= Nmin ; --n) {
        OutFs << n << " ";
        for(int deg=2;deg <= MaxDeg; ++deg) {
          FractalDimension[n][deg][sample] = std::exp( -std::log((double)SectorDimension(Sector[n]))*(deg-1)*(-1+FractalDimension[n][deg][sample]) );
          OutFs << FractalDimension[n][deg][sample] << " ";
        }
        OutFs << std::endl;
      }
    }
  }
 
  std::string OutDIR(baseDir+"/Output");
  std::filesystem::create_directories(OutDIR);
  std::cout << "# OutDIR: " << OutDIR << "\n";
 
  #pragma omp parallel for
  for(int deg=2; deg<=MaxDeg; ++deg) {
    std::stringstream buff("");
    buff << "/AverageIPR_"+Type+"_dE" << std::setprecision(2) << dE << "_deg" << deg << ".txt";
    std::string   OutFName(OutDIR+buff.str());
    std::ofstream OutFs(OutFName); checkIsFileOpen(OutFs, OutFName);
    OutFs.exceptions(std::ios::badbit);
    OutFs << "# 1.(N) 2.(Ensemble Average) 3.(Ensemble Stddev) 4.(ndata)\n" << std::endl;
    OutFs << std::scientific;
    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(FractalDimension[n][deg][sample]) || isinf(FractalDimension[n][deg][sample]) ) continue;
        ndata += 1;
        ave += FractalDimension[n][deg][sample];
      }
      ave /= (double)ndata;
      for(size_t sample = 0;sample < dirList.size(); ++sample) {
        if( isnan(FractalDimension[n][deg][sample]) || isinf(FractalDimension[n][deg][sample]) ) continue;
        dtemp = FractalDimension[n][deg][sample] - ave;
        var += dtemp * dtemp;
      }
      var /= (double)ndata;
      OutFs << n   << " "
            << ave << " "
            << std::sqrt(var) << " "
            << ndata
            << std::endl;
    }
  }
 
 
  return 0;
}

Variable Documentation

filesystem

namespace filesystem = std::experimental::filesystem