HPhiMain.cpp File Reference

#include <sz.hpp>
#include <HPhiTrans.hpp>
#include <output_list.hpp>
#include <diagonalcalc.hpp>
#include <CalcByLOBPCG.hpp>
#include <CalcByFullDiag.hpp>
#include <CalcByTPQ.hpp>
#include <CalcSpectrum.hpp>
#include <check.hpp>
#include "CalcByTEM.hpp"
#include "readdef.hpp"
#include "StdFace_main.hpp"
#include "wrapperMPI.hpp"
#include "splash.hpp"
#include "CalcTime.hpp"
#include "common/setmemory.hpp"

Go to the source code of this file.

Functions
int	main (int argc, char *argv[])
	Main program for HPhi. More...

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

Main program for HPhi.

Parameters

argc	[in] argument count
argv	[in] argument vector

Version

2.1 Add Time evolution mode.

1.2 Add calculation spectrum mode.

1.0

Author

Takahiro Misawa (The University of Tokyo)

Kazuyoshi Yoshimi (The University of Tokyo)

Return values

-1	fail the calculation.
0	succeed the calculation.

Definition at line 177 of file HPhiMain.cpp.

References EDMainCalStruct::Bind, BindStruct::Boost, CalcByFullDiag(), CalcByLOBPCG(), CalcByTEM(), CalcByTPQ(), CalcSpectrum(), check(), BindStruct::Def, diagonalcalc(), exitMPI(), ParamList::ExpecInterval, FinalizeMPI(), HPhiTrans(), DefineList::iCalcType, DefineList::iFlgCalcSpec, DefineList::iFlgScaLAPACK, InitializeMPI(), InitTimer(), JudgeDefType(), DefineList::k_exct, list_1, list_2_1, list_2_2, myrank, nproc, NumAve, DefineList::nvec, output_list(), OutputTimer(), DefineList::Param, ReadDefFileIdxPara(), ReadDefFileNInt(), SetConvergenceFactor(), setmem_def(), setmem_HEAD(), setmem_large(), splash(), StartTimer(), StdFace_main(), stdoutMPI, StopTimer(), sz(), TimeKeeper(), and DefineList::WRITE.

                                {

  int mode=0;
  char cFileListName[D_FileNameMax];
  struct EDMainCalStruct X;

  stdoutMPI = stdout;
  if(JudgeDefType(argc, argv, &mode)!=0){
      exitMPI(-1);
  }

  if (mode == STANDARD_DRY_MODE) {
    myrank = 0;
    nproc = 1;
    stdoutMPI = stdout;
    splash();
  }
  else InitializeMPI(argc, argv);

  //Timer
  InitTimer();
  if (mode != STANDARD_DRY_MODE) StartTimer(0);
 
  //MakeDirectory for output
  struct stat tmpst;
  if (myrank == 0) {
    if (stat("./output/", &tmpst) != 0) {
      if (mkdir("./output/", 0777) != 0) {
        fprintf(stdoutMPI, "%s", "Error: Fail to make output folder in current directory. \n");
        exitMPI(-1);
      }
    }
  }/*if (myrank == 0)*/

  strcpy(cFileListName, argv[2]);
  
  if(mode==STANDARD_MODE || mode == STANDARD_DRY_MODE){
    if (myrank == 0) StdFace_main(argv[2]);
    strcpy(cFileListName, "namelist.def");
    if (mode == STANDARD_DRY_MODE){
      fprintf(stdout, "Dry run is Finished. \n\n");
      return 0;
    }
  }

  setmem_HEAD(&X.Bind);
  if(ReadDefFileNInt(cFileListName, &(X.Bind.Def), &(X.Bind.Boost))!=0){
    fprintf(stdoutMPI, "%s", "Error: Definition files(*.def) are incomplete.\n");
    exitMPI(-1);
  }

  if (X.Bind.Def.nvec < X.Bind.Def.k_exct){
    fprintf(stdoutMPI, "%s", "Error: nvec should be smaller than exct are incorrect.\n");
    fprintf(stdoutMPI, "Error: nvec = %d, exct=%d.\n",
            X.Bind.Def.nvec, X.Bind.Def.k_exct);
    exitMPI(-1);
  }
  fprintf(stdoutMPI, "%s", "\n######  Definition files are correct.  ######\n\n");
  
  /*ALLOCATE-------------------------------------------*/
  setmem_def(&X.Bind, &X.Bind.Boost);
  /*-----------------------------------------------------*/

  /*Read Def files.*/
  TimeKeeper(&(X.Bind), "%s_TimeKeeper.dat", "Read File starts:   %s", "w");
  if(ReadDefFileIdxPara(&(X.Bind.Def), &(X.Bind.Boost))!=0){
    fprintf(stdoutMPI,
            "Error: Indices and Parameters of Definition files(*.def) are incomplete.\n");
    exitMPI(-1);
  }
  TimeKeeper(&(X.Bind), "%s_TimeKeeper.dat", "Read File finishes: %s", "a");
  fprintf(stdoutMPI, "%s", "\n######  Indices and Parameters of Definition files(*.def) are complete.  ######\n\n");

  /*Set convergence Factor*/
  SetConvergenceFactor(&(X.Bind.Def));

  /*---------------------------*/
  if(HPhiTrans(&(X.Bind))!=0) {
    exitMPI(-1);
  }

  //Start Calculation
  if(X.Bind.Def.iFlgCalcSpec == CALCSPEC_NOT ||
     X.Bind.Def.iFlgCalcSpec == CALCSPEC_SCRATCH) {
    
    if(check(&(X.Bind))==MPIFALSE){
     exitMPI(-1);
    }
    
    /*LARGE VECTORS ARE ALLOCATED*/
    if (setmem_large(&X.Bind) != 0) {
      fprintf(stdoutMPI, "Error: Fail for memory allocation.");
      exitMPI(-1);
    }
    
    StartTimer(1000);
    if(sz(&(X.Bind), list_1, list_2_1, list_2_2)!=0){
      exitMPI(-1);
    }

    StopTimer(1000);
    if(X.Bind.Def.WRITE==1){
      output_list(&(X.Bind));
      exitMPI(-2);
    }
    StartTimer(2000);
    diagonalcalc(&(X.Bind));
    StopTimer(2000);
      
    switch (X.Bind.Def.iCalcType) {
    case CG:
      if (CalcByLOBPCG(&X) != TRUE) {
          exitMPI(-3);
      }
      break;

    case FullDiag:
      StartTimer(5000);
      if (X.Bind.Def.iFlgScaLAPACK == 0 && nproc != 1) {
        fprintf(stdoutMPI, "Error: Full Diagonalization by LAPACK is only allowed for one process.\n");
        FinalizeMPI();
      }
      if (CalcByFullDiag(&X) != TRUE) {
        FinalizeMPI();
      }
      StopTimer(5000);
      break;

    case TPQCalc:
      StartTimer(3000);
      if (CalcByTPQ(NumAve, X.Bind.Def.Param.ExpecInterval, &X) != TRUE) {
        StopTimer(3000);
        exitMPI(-3);
      }
      StopTimer(3000);
      break;

    case TimeEvolution:
      if (CalcByTEM(X.Bind.Def.Param.ExpecInterval, &X) != 0) {
        exitMPI(-3);
      }
      break;

    default:
      StopTimer(0);
      exitMPI(-3);
    }
  }

  if(X.Bind.Def.iFlgCalcSpec != CALCSPEC_NOT){
    StartTimer(6000);
    if (CalcSpectrum(&X) != TRUE) {
      StopTimer(6000);
      exitMPI(-3);
    }
    StopTimer(6000);
  }
  
  StopTimer(0);
  OutputTimer(&(X.Bind));
  FinalizeMPI();
  return 0;
}