HPhiMain.c File Reference

#include <sz.h>
#include <HPhiTrans.h>
#include <output_list.h>
#include <diagonalcalc.h>
#include <CalcByLanczos.h>
#include <CalcByLOBPCG.h>
#include <CalcByFullDiag.h>
#include <CalcByTPQ.h>
#include <CalcSpectrum.h>
#include <check.h>
#include "CalcByTEM.h"
#include "readdef.h"
#include "StdFace_main.h"
#include "wrapperMPI.h"
#include "splash.h"
#include "CalcTime.h"

Include dependency graph for HPhiMain.c:

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.c.

References EDMainCalStruct::Bind, BindStruct::Boost, CalcByFullDiag(), CalcByLanczos(), CalcByLOBPCG(), CalcByTEM(), CalcByTPQ(), CalcSpectrum(), cErrDefFile, cErrIndices, cErrLargeMem, cErrnvec, cErrnvecShow, cErrOutput, cFileNameTimeKeep, check(), cParentOutputFolder, cProFinishDefCheck, cProFinishDefFiles, cReadDefFinish, cReadDefStart, D_FileNameMax, BindStruct::Def, diagonalcalc(), exitMPI(), ParamList::ExpecInterval, FinalizeMPI(), HPhiTrans(), DefineList::iCalcType, iErrCodeMem, DefineList::iFlgCalcSpec, DefineList::iFlgScaLAPACK, InitializeMPI(), InitTimer(), JudgeDefType(), DefineList::k_exct, list_1, list_2_1, list_2_2, MPIFALSE, 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(), TRUE, DefineList::WRITE, and X.

                                {

  int mode=0;
  char cFileListName[D_FileNameMax];

  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(cParentOutputFolder, &tmpst) != 0) {
      if (mkdir(cParentOutputFolder, 0777) != 0) {
        fprintf(stdoutMPI, "%s", cErrOutput);
        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", cErrDefFile);
    exitMPI(-1);
  }

  if (X.Bind.Def.nvec < X.Bind.Def.k_exct){
    fprintf(stdoutMPI, "%s", cErrnvec);
    fprintf(stdoutMPI, cErrnvecShow, X.Bind.Def.nvec, X.Bind.Def.k_exct);
    exitMPI(-1);
  }
  fprintf(stdoutMPI, "%s", cProFinishDefFiles);
  
  /*ALLOCATE-------------------------------------------*/
  setmem_def(&X.Bind, &X.Bind.Boost);
  /*-----------------------------------------------------*/

  /*Read Def files.*/
  TimeKeeper(&(X.Bind), cFileNameTimeKeep, cReadDefStart, "w");
  if(ReadDefFileIdxPara(&(X.Bind.Def), &(X.Bind.Boost))!=0){
    fprintf(stdoutMPI, "%s", cErrIndices);
    exitMPI(-1);
  }
  TimeKeeper(&(X.Bind), cFileNameTimeKeep, cReadDefFinish, "a");
  fprintf(stdoutMPI, "%s", cProFinishDefCheck);

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

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

  //Start Calculation
  if(X.Bind.Def.iFlgCalcSpec == CALCSPEC_NOT) {
    
    if(check(&(X.Bind))==MPIFALSE){
     exitMPI(-1);
    }
    
    /*LARGE VECTORS ARE ALLOCATED*/
    if (setmem_large(&X.Bind) != 0) {
      fprintf(stdoutMPI, cErrLargeMem, iErrCodeMem);
      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 Lanczos:
      StartTimer(4000);
      if (CalcByLanczos(&X) != TRUE) {
        StopTimer(4000);
        exitMPI(-3);
      }
      StopTimer(4000);
      break;

    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);
    }
  }
  else{
    StartTimer(6000);
    if (CalcSpectrum(&X) != TRUE) {
      StopTimer(6000);
      exitMPI(-3);
    }
    StopTimer(6000);
  }
  
  StopTimer(0);
  OutputTimer(&(X.Bind));
  FinalizeMPI();
  return 0;
}

Here is the call graph for this function: