SrednickiAnsatz_EigenExpValue.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
	)

                                {
  #include "PBC_TI/Framework/Fragments/setVariablesForEnsemble.cpp"
 
  Integer_t dim_sub; //全ヒルベルト空間の次元
  Integer_t info, failed=0; // カウンタ
  double gE, EnergyRange, dtemp;
 
  if( !Initialize(argc, argv, Nargs_common) ) {
    std::cerr << "Error: Initialization failed." << std::endl;
    std::exit(EX_USAGE);
  }
  debug_print("# Successfully initialized.");
 
  //******************** Check for the directory structure ********************
  debug_print("# Checking for the directory structure.");
  std::ofstream OutFs;
  //******************** (END) Check for the directory structure ********************
 
  //***************************************************************************
  //******************** Allocation & Initialization **************************
  //***************************************************************************
#ifdef GPU
  magma_init();
  magma_queue_t queue = NULL;
  magma_int_t     dev = 0;
  magma_getdevice( &dev );
  magma_queue_create( dev, &queue );
#else
  void* GPUconf = nullptr;
#endif
 
  //******************** Translation invariance ********************
  debug_print("# Calculating translation-invariant sectors.");
  #include "PBC_TI/Framework/Fragments/TranslationInvariantSectors.cpp"
  //******************** (END)Translation invariance ********************
 
  //********** Allocate CPU memories **********//
  debug_print("# Allocating CPU memories.");
  Integer_t const dim_max = SectorDimension(Sector[n_max]);
  std::vector<double>         eigenEnergy(dim_max);
  std::vector<double>            EXPvalue(dim_max);
  //********** (END) Allocate CPU memories **********//
 
  double start, t_int, end, temp_t;
  double T_diag=0, T_post=0, T_pre=0;
  init_genrand(SEED);
  start = getETtime();
  end = getETtime();
  std::cout << "(init_genrand): time=" << std::fixed << (end-start) << std::endl;
  //***************************************************************************
  //******************** (END) Allocation & Initialization ********************
  //***************************************************************************
 
  start = getETtime();
  end   = start;
  for(Integer_t repetition = repMin;repetition <= repMax; ++repetition) {
    // 局所ハミルトニアンと局所物理量をランダムにとる ******************************//
    std::string outDirName(baseDirName);
    {
      std::stringstream buff;
      buff << "/RawData/Sample_No" << repetition;
      outDirName += buff.str();
      outDirName = std::regex_replace(outDirName, std::regex("//"), "/");
      filesystem::create_directories(outDirName);
    }
 
    int sign = (Gaussian()>0 ? +1: -1);
    for(size_t n = n_max;n >= n_min; --n) {
      debug_print("# (rep,n)=(" << repetition << "," << n << ")");
      dim_sub = Sector.at(n).dim();
 
 
      temp_t = getETtime();
      {
        eigenEnergy.resize(dim_sub);
        for(Integer_t j = 0;j < dim_sub; ++j) eigenEnergy[j] = Gaussian()/sqrt((double)n);
        std::sort(eigenEnergy.begin(), eigenEnergy.end());
        EnergyRange = eigenEnergy[dim_sub-1] - eigenEnergy[0];
        gE = eigenEnergy[0];
        for(Integer_t j = 0;j < dim_sub; ++j) eigenEnergy[j] = (eigenEnergy[j]-gE)/EnergyRange;
        EXPvalue.resize(dim_sub);
        for(Integer_t j = 0;j < dim_sub; ++j) {
          EXPvalue[j] = sign*4*(eigenEnergy[j]-0.5)*(eigenEnergy[j]-0.5);
          dtemp = (eigenEnergy[j]*EnergyRange + gE)*sqrt((double)n);
          EXPvalue[j] += Gaussian()/sqrt(dim_sub*0.1*std::exp( -dtemp*dtemp/2.0 ));
        }
      }
      T_diag += getETtime() -temp_t;
 
      temp_t  = getETtime();
      {
        debug_print("# Writing results to a file.");
        std::stringstream buff("");
        buff << "/EigenExpValue" << PRECISION << "_N" << n << ".txt";
        std::string filename(outDirName); filename += buff.str();
        OutFs.open(filename); checkIsFileOpen(OutFs, filename);
        OutFs << std::right << std::showpos << std::scientific << std::setprecision(6);
        OutFs << "# OpRange= " << 1.0 << "\n"
              << "# 1.(Normalized energy) 2.(Energy) 3.(Exp value)" << "\n\n";
        for(size_t j = 0;j < dim_sub; ++j) {
          OutFs << eigenEnergy[j] << " "
                << eigenEnergy[j]*EnergyRange + gE << " "
                << EXPvalue[j] << std::endl;
        }
        OutFs.close();
      }
      T_post += getETtime() -temp_t;
    }
    if(repetition%10 == 9) {
      t_int = end; end = getETtime();
      std::cerr << "(total=" << std::setw(6) << repetition+1
                << "): timeINT="    << std::setprecision(6)  << std::setw(8)  << (end-t_int)
                << ", timeTOT="     << std::setprecision(6)  << std::setw(8)  << (end-start)
                << ", T_construct=" << std::setprecision(6)  << std::setw(10) << T_pre  << "(" << std::setprecision(1) << 100*T_pre /(end-start) << "%)"
                << ", T_diag="      << std::setprecision(6)  << std::setw(8)  << T_diag << "(" << std::setprecision(1) << 100*T_diag/(end-start) << "%)"
                << ", T_process="   << std::setprecision(6)  << std::setw(8)  << T_post << "(" << std::setprecision(1) << 100*T_post/(end-start) << "%)"
                << std::endl;
    }
  }
 
  Finalize(argc, argv);
  #ifdef GPU
    magma_finalize();
  #endif
  return 0;
}

Variable Documentation

filesystem

namespace filesystem = std::experimental::filesystem