HPhiMain.cpp

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

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

  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;
}