HPhiMain.c

Go to the documentation of this file.

/* HPhi  -  Quantum Lattice Model Simulator */
/* Copyright (C) 2015 The University of Tokyo */

/* This program is free software: you can redistribute it and/or modify */
/* it under the terms of the GNU General Public License as published by */
/* the Free Software Foundation, either version 3 of the License, or */
/* (at your option) any later version. */

/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the */
/* GNU General Public License for more details. */

/* You should have received a copy of the GNU General Public License */
/* along with this program.  If not, see <http://www.gnu.org/licenses/>. */
/*-------------------------------------------------------------*/

#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"

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

  int mode=0;
  char cFileListName[D_FileNameMax];

  stdoutMPI = stdout;
  if(JudgeDefType(argc, argv, &mode)!=0){
    FinalizeMPI();
    return 0;
  }  

  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);
    FinalizeMPI();
    return -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);
    FinalizeMPI();
    return -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);
    FinalizeMPI();
    return -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){
      FinalizeMPI();
      return -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));
      FinalizeMPI();
      return 0;
    }
    StartTimer(2000);
    diagonalcalc(&(X.Bind));
    StopTimer(2000);
      
    switch (X.Bind.Def.iCalcType) {
    case Lanczos:
      StartTimer(4000);
      if (CalcByLanczos(&X) != TRUE) {
        FinalizeMPI();
        StopTimer(4000);
        return 0;
      }
      StopTimer(4000);
      break;

    case CG:
      if (CalcByLOBPCG(&X) != TRUE) {
        FinalizeMPI();
        return 0;
      }
      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) {
          FinalizeMPI();
          StopTimer(3000);
          return 0;
        }
        StopTimer(3000);
      break;

      case TimeEvolution:
        if(CalcByTEM(X.Bind.Def.Param.ExpecInterval, &X)!=0){
          FinalizeMPI();
          return 0;
        }

    default:
      FinalizeMPI();
      StopTimer(0);
      return 0;
    }
  }
  else{
    StartTimer(6000);
    if (CalcSpectrum(&X) != TRUE) {
      FinalizeMPI();
      StopTimer(6000);
      return 0;
    }
    StopTimer(6000);
  }
  
  StopTimer(0);
  OutputTimer(&(X.Bind));
  FinalizeMPI();
  return 0;
}