Sample_t.cu 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"
 
  IntType_t dim_sub; //全ヒルベルト空間の次元
  IntType_t info, failed=0; // カウンタ
  double gE, EnergyRange, OpRange, OpMin;
 
  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.");
  //******************** (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.");
  IntType_t const dim_max = SectorDimension(Sector[n_max]);
  std::vector<IntType_t>   NdataInShell(dim_max);
  std::vector<double>         eigenEnergy(dim_max);
  std::vector<double>            EXPvalue(dim_max);
  matrix<ComplexType_t>        h(dloc_h , dloc_h );
  matrix<ComplexType_t>      loc(dloc_op, dloc_op);
#ifndef GPU
  matrix<ComplexType_t>    h_tot(dim_max, dim_max);
  matrix<ComplexType_t>  loc_tot(dim_max, dim_max);
  #define   dh_tot   h_tot
  #define dloc_tot loc_tot
#endif
  //********** (END) Allocate CPU memories **********//
 
#ifdef GPU
  //********** Allocate GPU memories **********//
  debug_print("# Allocating GPU memories.");
  constexpr IntType_t GPU_UNIT = 32;
  IntType_t const LDT = magma_roundup(dim_max, GPU_UNIT);
  matrix_gpu<ComplexType_t>       dh(dloc_h , dloc_h );
  matrix_gpu<ComplexType_t>     dloc(dloc_op, dloc_op);
  matrix_gpu<ComplexType_t>   dh_tot(LDT, dim_max);
  matrix_gpu<ComplexType_t> dloc_tot(LDT, dim_max);
  //********** (END) Allocate GPU memories **********//
 
  //********** Determine GPU configuration **********//
  #include "PBC_TI/Framework/Fragments/getAttributesOfMatrixElementsInSector.cpp"
  //********** (END) Determine GPU configuration **********//
#endif // #ifdef GPU
 
  double start, t_int, end, temp_t;
  double T_diag=0, T_post=0, T_pre=0;
  init_genrand(SEED);
  start = getETtime();
  for(IntType_t repetition = 0;repetition < repMin; ++repetition) {
    generateLocal_h( h,   dloc_h,  -1);
    generateLocal_op(loc, dloc_op, -1);
  }
  end = getETtime();
  std::cout << "(init_genrand): time=" << std::fixed << (end-start) << std::endl;
  //***************************************************************************
  //******************** (END) Allocation & Initialization ********************
  //***************************************************************************
 
  FILE* pipe = popen("hostname", "r");
  char hostname[256];
  fgets(&(hostname[0]), 255, pipe);
  pclose(pipe);
  char* cpos = strchr(hostname, '\n'); *cpos = '\0';
  debug_print("Hostname = " << hostname);
 
  start = getETtime();
  end   = start;
  for(IntType_t repetition = repMin;repetition <= repMax; ++repetition) {
    // 局所ハミルトニアンと局所物理量をランダムにとる ******************************//
    generateLocal_h( h,   dloc_h,  -1);
    generateLocal_op(loc, dloc_op, -1);
 
    std::string filename(baseDirName);
    {
      std::stringstream buff("");
      buff << "/Sample_No" << repetition << "_" << hostname << ".txt";
      filename += buff.str();
      filename = std::regex_replace(filename, std::regex("//"), "/");
    }
    debug_print("# filename = " << filename);
    std::ofstream OutFs(filename); checkIsFileOpen(OutFs, filename);
      h.print(OutFs, dloc_h , dloc_h , "Lower");
    OutFs << "\n";
    loc.print(OutFs, dloc_op, dloc_op, "Lower");
    OutFs.close();
 
    if(repetition%10 == 9) {
      std::cerr << "(Sample=" << std::setw(6) << repetition+1 << ")" << std::endl;
    }
  }
 
  Finalize(argc, argv);
  #ifdef GPU
    magma_finalize();
  #endif
  return 0;
}

Variable Documentation

filesystem

namespace filesystem = std::experimental::filesystem