Histogram.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  = (Integer_t)atoll(argv[1]);
  Integer_t const n_max  = (Integer_t)atoll(argv[2]);
  Integer_t const NMAX = n_max+1;
  constexpr Integer_t MAX  = 10000;
  constexpr double  binratio = 0.05;
 
  std::vector<double> mean(NMAX,0), stddev(NMAX,0);
  double Mean, Stddev, Fluc[2];
 
  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 const type[2] = {"Fluc", "MaxFluc"};
  for(std::string const& Type : type) {
    buff.str(""); buff.clear(std::stringstream::goodbit);
    buff << "/Stat_" << Type << ".txt";
    std::string const InStatName(OutDIR+buff.str());
    std::ifstream InStat(InStatName); checkIsFileOpen(InStat, InStatName);
    InStat.exceptions(std::ios::badbit | std::ios::failbit);
      try { skip_header(InStat); }
      catch(std::exception& e) {
        std::cerr << "Error(skip_header): " << e.what() << std::endl;
        std::cerr << "File: \"" << InStatName << "\" is empty." << std::endl;
        std::exit(EXIT_FAILURE);
      }
 
    Integer_t n, bin, rep, ndata;
    double fluc, maxE;
    std::string line;
    try{
      for(getline(InStat, line); !InStat.eof(); getline(InStat, line)) {
        std::istringstream inStream(line);
        inStream >> n >> Mean >> Stddev;
        if(n >= NMAX) {
          std::cerr << "Error: n(" << n << ") >= NMAX(" << NMAX << ")" << std::endl;
          std::exit(EX_USAGE);
        }
        mean[n]   = Mean;
        stddev[n] = Stddev;
      }
    } catch(std::exception& e) {
      if( !InStat.eof() ) std::cerr << "Error(" << InStat.eof() << InStat.fail() << InStat.bad() << "):" << e.what() << std::endl;
    }
    InStat.close();
 
    for(n = n_max;n >= n_min; --n) {
      buff.str(""); buff.clear(std::stringstream::goodbit);
      buff << "/MeasureOfETH_N" << n << ".txt";
      std::string   InFName(baseDir+buff.str());
      std::ifstream InFile(InFName);
      InFile.exceptions(std::ios::badbit | std::ios::eofbit | std::ios::failbit);
      if( !InFile.is_open() ) {
        std::cerr << "Can't open a file \"" << InFName << "\"" << std::endl;
        continue;
      }
      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;
      }
 
      double binwidth = binratio *mean[n]; if(binwidth <= 0) continue;
      Integer_t total=0, binMax=0;
      std::vector<Integer_t> count(MAX,0);
 
      try{
        for(getline(InFile, line); !InFile.eof(); getline(InFile, line)) {
          fluc = std::nan("");
          std::cout << line << "\r";
          std::istringstream inStream(line);
          inStream >> rep >> Fluc[0] >> Fluc[1] >> maxE >> ndata;
          if(Type == "Fluc") fluc = Fluc[0];
          else if(Type == "MaxFluc") fluc = Fluc[1];
          if( isnan(fluc) || isinf(fluc) ) continue;
          bin    = (Integer_t)(fluc/binwidth); if(bin >= MAX) continue;
          binMax = fmax(binMax, bin);
          total += 1;
          count[bin] += 1;
        }
      } catch(std::exception& e) {
        if( !InFile.eof() ) std::cerr << "Error(" << InFile.eof() << InFile.fail() << InFile.bad() << "):" << e.what() << std::endl;
      }
      InFile.close();
 
      buff.str("");
      buff.clear(std::stringstream::goodbit);
      buff << "/Hist_" << Type << "_n" << n << ".txt";
      std::string   OutFName(OutDIR); OutFName += buff.str();
      std::ofstream OutFile(OutFName);
        if( !OutFile.is_open() ) {
          std::cerr << "Can't open a file " << OutFName << std::endl;
          std::exit(EX_CANTCREAT);
        }
 
      std::cout << "Output file: " << OutFName;
      OutFile << std::scientific
              << "# Type="  << Type  << "\n"
              << "# total=" << total << "\n"
              << "# binwidth = " << binratio << "*mean\n"
              << "# FlucMax  = " << (binMax+0.5)*binwidth << "\n"
              << "# 1.(Fluctuation) 2.(Probability density) 3.(Cumulative distribution)\n\n";
      if(total == 0) { OutFile << "0 1 1\n"; continue; }
 
      Integer_t cumulative = 0;
      for(bin = 0;bin<=binMax && bin<MAX; ++bin) {
        cumulative += count[bin];
        OutFile << (bin+0.5)*binwidth << " " << count[bin]/(total*binwidth) << " " << (double)cumulative/(double)total << "\n";
      }
      OutFile.close();
      if(cumulative != total) std::cerr << "# Warning: cumulative(" << cumulative << ") != total(" << total << ")" << std::endl;
    }
    std::cout << "\n";
  }
 
  return 0;
}

Variable Documentation

filesystem

namespace filesystem = std::experimental::filesystem