Stat.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 != 4) {
    std::cerr << "Usage: 1.This 2.n_min 3.n_max 4.Directory\n";
    std::exit(EX_USAGE);
  }
  Integer_t const n_min   = std::atoll(argv[1]);
  Integer_t const n_max   = std::atoll(argv[2]);
  Integer_t const DataMin = 1;
 
  std::vector<Integer_t> histDShell(10000);
  Integer_t rep, ndata;
  double Fluc[2], maxE;
 
  std::stringstream buff;
 
  std::string const baseDir(argv[3]);
  std::cout << "Directory: " << baseDir << "\n";
  std::string const OutDIR(baseDir+"/Output");
  filesystem::create_directory(OutDIR);
 
  std::string   OutStatName;
  std::ofstream OutStat[2];
  OutStatName = OutDIR +"/Stat_Fluc.txt";
  OutStat[0].open(OutStatName); checkIsFileOpen(OutStat[0], OutStatName);
  OutStat[0].exceptions(std::ios::badbit | std::ios::failbit);
  OutStatName = OutDIR +"/Stat_MaxFluc.txt";
  OutStat[1].open(OutStatName); checkIsFileOpen(OutStat[1], OutStatName);
  OutStat[1].exceptions(std::ios::badbit | std::ios::failbit);
  for(int i = 0;i <= 1; ++i) OutStat[i] << "# 1.(System Size) 2.(Mean) 3.(Stddev) 4.(Stddev_err) 5.(Ndata)\n\n" << std::scientific << std::right << std::endl;
 
  for(Integer_t n = n_max;n >= n_min; --n) {
    buff.str(""); buff.clear(std::stringstream::goodbit);
    buff << "/MeasureOfETH_N" << n << ".txt";
    std::string const InFName(baseDir+buff.str());
    std::ifstream InFile(InFName); checkIsFileOpen(InFile, InFName);
    InFile.exceptions(std::ios::badbit | std::ios::eofbit | std::ios::failbit);
      try { skip_header(InFile); }
      catch(std::exception& e) {
        std::cerr << "Error(skip_header): " << e.what() << std::endl;
        std::cerr << "File: \"" << InFName << "\" is empty." << std::endl;
        continue;
      }
    std::ifstream::pos_type head = InFile.tellg();
 
    Integer_t Count=0, count[2]={0,0}, maxDShell=INT_MIN, minDShell=INT_MAX;
    double meanDShell  = 0;
    double mean[2]     = {0,0};
    double variance[2] = {0,0};
    double mu4[2]      = {0,0};
    std::fill(histDShell.begin(), histDShell.end(), 0);
 
    std::string line;
    // Calculate mean values //
    try{
      for(getline(InFile, line); !InFile.eof(); getline(InFile, line)) {
        // std::cout << line << std::endl;
        std::cout << "(n="      << std::setw(2) << std::right << n
                  << ", Count=" << std::setw(6) << std::right << Count << ") "
                  << line << "\r" << std::flush;
        std::istringstream inStream(line);
        inStream >> rep >> Fluc[0] >> Fluc[1] >> maxE >> ndata;
        if(ndata < DataMin) continue;
        minDShell   = std::min(minDShell, ndata);
        maxDShell   = std::max(maxDShell, ndata);
        meanDShell += ndata;
        Count += 1;
        if((size_t)ndata >= histDShell.size()) histDShell.resize(ndata+1);
        histDShell.at(ndata) += 1;
        for(int i = 0;i <= 1; ++i) if(!isnan(Fluc[i]) && !isinf(Fluc[i])) {
          count[i] += 1; mean[i] += Fluc[i];
        }
      }
    } catch(std::exception& e) {
      if( !InFile.eof() ) std::cerr << "Error(" << InFile.eof() << InFile.fail() << InFile.bad() << "):" << e.what() << std::endl;
    }
    meanDShell /= (double)Count;
    mean[0]/=(double)count[0]; mean[1]/=(double)count[1];
    std::cout << "\r                                                  \r";
    std::cout << "DimShell:(" << minDShell << "," << maxDShell << ") n=" << n
              << ", count=(" << count[0] << ", " << count[1] << ")\n";
 
    InFile.clear(); InFile.seekg(head);
    // Calculate standard deviation and its error //
    try{
      for(getline(InFile, line); !InFile.eof(); getline(InFile, line)) {
        std::istringstream inStream(line);
        inStream >> rep >> Fluc[0] >> Fluc[1] >> maxE >> ndata;
        if(ndata < DataMin) continue;
        for(int i = 0;i <= 1; ++i) if( !isnan(Fluc[i]) && !isinf(Fluc[i]) ) {
          variance[i] += pow(Fluc[i]  -mean[i], 2)/(double)(count[i]-1);
          mu4[i]      += pow(Fluc[i]  -mean[i], 4)/(double)count[i];
        }
      }
    } catch(std::exception& e) {
      if( !InFile.eof() ) std::cerr << "Error(" << InFile.eof() << InFile.fail() << InFile.bad() << "):" << e.what() << std::endl;
    }
 
    for(int i = 0;i <= 1; ++i) {
      double variance_err = sqrt( (mu4[i] -variance[i]*variance[i])/count[i] );
      OutStat[i] << std::setw(2)  << n << " "  << std::showpos
                 << std::setw(13) << mean[i] << " "
                 << std::setw(13) << sqrt(variance[i])   << " "
                 << std::setw(13) << 0.5*variance_err/sqrt(variance[i]) << " " << std::noshowpos
                 << count[i] << "\n";
    }
 
 
    buff.str("");
    buff.clear(std::stringstream::goodbit);
    buff << "/Hist_DimShell_n" << n << ".txt";
    std::string   OutDSName(OutDIR); OutDSName += buff.str();
    std::ofstream OutDShell(OutDSName);
      if( !OutDShell.is_open() ) {
        std::cerr << "Can't open a file " << OutDSName << std::endl;
        std::exit(EX_CANTCREAT);
      }
    OutDShell << std::scientific;
    OutDShell << "# total = " << Count << "\n";
    OutDShell << "# minDShell = " << minDShell << "; maxDShell=" << maxDShell << "; meanDShell=" << meanDShell << "\n";
    OutDShell << "# 1.(Dim. of shell) 2.(Count) 3.(Cumulative Distribution Function)\n\n";
    if(Count == 0) OutDShell << "0 0 1\n";
    else {
      Integer_t itemp = 0;
      for(Integer_t i = minDShell;i <= maxDShell; ++i) {
        itemp += histDShell.at(i);
        OutDShell << std::setw(4) << i << " "
                  << std::setw(5) << histDShell.at(i) << " "
                  << std::setw(13) << (double)itemp/(double)Count << "\n";
      }
      if(itemp != Count) std::cerr << "Warning: itemp(" << itemp << ") != Count(" << Count << ")." << std::endl;
    }
    OutDShell.close();
  }
  std::cout << std::endl;
  for(int i = 0;i <= 1; ++i) OutStat[i].close();
 
  return 0;
}

Variable Documentation

filesystem

namespace filesystem = std::experimental::filesystem