xsetmem.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 "Common.hpp"
#include "common/setmemory.hpp"
#include "xsetmem.hpp"
#include "wrapperMPI.hpp"
#include <iostream>
void setmem_HEAD
(
 struct BindStruct *X
 )
{
  X->Def.CDataFileHead = (char*)malloc(D_FileNameMax*sizeof(char));
  X->Def.CParaFileHead = (char*)malloc(D_FileNameMax*sizeof(char));
}

void setmem_def
(
 struct BindStruct *X,
 struct BoostList *xBoost
 ) {
  X->Def.Tpow = li_1d_allocate(2 * X->Def.Nsite + 2);
  X->Def.OrgTpow = li_1d_allocate(2 * X->Def.Nsite + 2);
  X->Def.SiteToBit = li_1d_allocate(X->Def.Nsite + 1);
  X->Def.LocSpn = i_1d_allocate(X->Def.Nsite);
  X->Phys.spin_real_cor = d_1d_allocate(X->Def.Nsite * X->Def.Nsite);
  X->Phys.charge_real_cor = d_1d_allocate(X->Def.Nsite * X->Def.Nsite);
  X->Phys.loc_spin_z = d_1d_allocate(X->Def.Nsite * X->Def.Nsite);
  X->Def.EDChemi = i_1d_allocate(X->Def.NInterAll + X->Def.NTransfer);
  X->Def.EDSpinChemi = i_1d_allocate(X->Def.NInterAll + X->Def.NTransfer);
  X->Def.EDParaChemi = d_1d_allocate(X->Def.NInterAll + X->Def.NTransfer);
  X->Def.GeneralTransfer = i_2d_allocate(X->Def.NTransfer, 4);
  X->Def.ParaGeneralTransfer = cd_1d_allocate(X->Def.NTransfer);

  if (X->Def.iCalcType == TimeEvolution) {
    X->Def.EDGeneralTransfer = i_2d_allocate(X->Def.NTransfer + X->Def.NTETransferMax, 4);
    X->Def.EDParaGeneralTransfer = cd_1d_allocate(X->Def.NTransfer + X->Def.NTETransferMax);
  } else {
    X->Def.EDGeneralTransfer = i_2d_allocate(X->Def.NTransfer, 4);
    X->Def.EDParaGeneralTransfer = cd_1d_allocate(X->Def.NTransfer);
  }

  X->Def.CoulombIntra = i_2d_allocate(X->Def.NCoulombIntra, 1);
  X->Def.ParaCoulombIntra = d_1d_allocate(X->Def.NCoulombIntra);
  X->Def.CoulombInter = i_2d_allocate(X->Def.NCoulombInter + X->Def.NIsingCoupling, 2);
  X->Def.ParaCoulombInter = d_1d_allocate(X->Def.NCoulombInter + X->Def.NIsingCoupling);
  X->Def.HundCoupling = i_2d_allocate(X->Def.NHundCoupling + X->Def.NIsingCoupling, 2);
  X->Def.ParaHundCoupling = d_1d_allocate(X->Def.NHundCoupling + X->Def.NIsingCoupling);
  X->Def.PairHopping = i_2d_allocate(X->Def.NPairHopping, 2);
  X->Def.ParaPairHopping = d_1d_allocate(X->Def.NPairHopping);
  X->Def.ExchangeCoupling = i_2d_allocate(X->Def.NExchangeCoupling, 2);
  X->Def.ParaExchangeCoupling = d_1d_allocate(X->Def.NExchangeCoupling);
  X->Def.PairLiftCoupling = i_2d_allocate(X->Def.NPairLiftCoupling, 2);
  X->Def.ParaPairLiftCoupling = d_1d_allocate(X->Def.NPairLiftCoupling);

  X->Def.InterAll = i_2d_allocate(X->Def.NInterAll, 8);
  X->Def.ParaInterAll = cd_1d_allocate(X->Def.NInterAll);

  X->Def.CisAjt = i_2d_allocate(X->Def.NCisAjt, 4);
  X->Def.CisAjtCkuAlvDC = i_2d_allocate(X->Def.NCisAjtCkuAlvDC, 8);

  X->Def.NSingleExcitationOperator = i_1d_allocate(X->Def.NNSingleExcitationOperator);
  X->Def.SingleExcitationOperator = (int***)malloc(sizeof(int**)*X->Def.NNSingleExcitationOperator);
  X->Def.ParaSingleExcitationOperator = (std::complex<double>**)malloc(
    sizeof(std::complex<double>*)*X->Def.NNSingleExcitationOperator);
  X->Def.NPairExcitationOperator = i_1d_allocate(X->Def.NNPairExcitationOperator);
  X->Def.PairExcitationOperator = (int***)malloc(sizeof(int**)*X->Def.NNPairExcitationOperator);
  X->Def.ParaPairExcitationOperator = (std::complex<double>**)malloc(
    sizeof(std::complex<double>*)*X->Def.NNPairExcitationOperator);

  X->Def.ParaLaser = d_1d_allocate(X->Def.NLaser);

  xBoost->list_6spin_star = i_2d_allocate(xBoost->R0 * xBoost->num_pivot, 7);
  xBoost->list_6spin_pair = i_3d_allocate(xBoost->R0 * xBoost->num_pivot, 7, 15);
  xBoost->arrayJ = cd_3d_allocate(xBoost->NumarrayJ, 3, 3);

  int NInterAllSet;
  NInterAllSet = (X->Def.iCalcType == TimeEvolution) ? X->Def.NInterAll + X->Def.NTEInterAllMax : X->Def.NInterAll;
  X->Def.InterAll_OffDiagonal = i_2d_allocate(NInterAllSet, 8);
  X->Def.ParaInterAll_OffDiagonal = cd_1d_allocate(NInterAllSet);
  X->Def.InterAll_Diagonal = i_2d_allocate(NInterAllSet, 4);
  X->Def.ParaInterAll_Diagonal = d_1d_allocate(NInterAllSet);

  if (X->Def.iCalcType == TimeEvolution) {
    X->Def.TETime = d_1d_allocate(X->Def.NTETimeSteps);
    //Time-dependent Transfer
    X->Def.NTETransfer = i_1d_allocate(X->Def.NTETimeSteps);
    X->Def.NTETransferDiagonal = i_1d_allocate(X->Def.NTETimeSteps);
    X->Def.TETransfer = i_3d_allocate(X->Def.NTETimeSteps, X->Def.NTETransferMax, 4);
    X->Def.TETransferDiagonal = i_3d_allocate(X->Def.NTETimeSteps, X->Def.NTETransferMax, 2);
    X->Def.ParaTETransfer = cd_2d_allocate(X->Def.NTETimeSteps, X->Def.NTETransferMax);
    X->Def.ParaTETransferDiagonal = d_2d_allocate(X->Def.NTETimeSteps, X->Def.NTETransferMax);
    //Time-dependent InterAll
    X->Def.NTEInterAll = i_1d_allocate(X->Def.NTETimeSteps);
    X->Def.NTEInterAllDiagonal = i_1d_allocate(X->Def.NTETimeSteps);
    X->Def.TEInterAll = i_3d_allocate(X->Def.NTETimeSteps, X->Def.NTEInterAllMax, 8);
    X->Def.TEInterAllDiagonal = i_3d_allocate(X->Def.NTETimeSteps, X->Def.NTEInterAllMax, 4);
    X->Def.ParaTEInterAll = cd_2d_allocate(X->Def.NTETimeSteps, X->Def.NTEInterAllMax);
    X->Def.ParaTEInterAllDiagonal = d_2d_allocate(X->Def.NTETimeSteps, X->Def.NTEInterAllMax);
    X->Def.NTEInterAllOffDiagonal = i_1d_allocate(X->Def.NTETimeSteps);
    X->Def.TEInterAllOffDiagonal = i_3d_allocate(X->Def.NTETimeSteps, X->Def.NTEInterAllMax, 8);
    X->Def.ParaTEInterAllOffDiagonal = cd_2d_allocate(X->Def.NTETimeSteps, X->Def.NTEInterAllMax);
    //Time-dependent Chemi generated by InterAll diagonal components
    X->Def.NTEChemi = i_1d_allocate(X->Def.NTETimeSteps);
    X->Def.TEChemi = i_2d_allocate(X->Def.NTETimeSteps, X->Def.NTEInterAllMax);
    X->Def.SpinTEChemi = i_2d_allocate(X->Def.NTETimeSteps, X->Def.NTEInterAllMax);
    X->Def.ParaTEChemi = d_2d_allocate(X->Def.NTETimeSteps, X->Def.NTEInterAllMax);
  }
}


int setmem_large
(
  struct BindStruct *X
) {
  int nstate;

  if (GetlistSize(X) == TRUE) {
    list_1 = li_1d_allocate(X->Check.idim_max + 1);
    list_2_1 = li_1d_allocate(X->Large.SizeOflist_2_1);
    list_2_2 = li_1d_allocate(X->Large.SizeOflist_2_2);
    if (list_1 == NULL
      || list_2_1 == NULL
      || list_2_2 == NULL
      ) {
      return -1;
    }
  }

  list_Diagonal = d_1d_allocate(X->Check.idim_max + 1);

  if (X->Def.iCalcType == FullDiag) {
    nstate = X->Check.idim_max;
  }
  else if (X->Def.iCalcType == CG) {
    nstate = X->Def.k_exct;
  }
  else if (X->Def.iCalcType == TPQCalc) {
    nstate = NumAve;
  }
  else {
    nstate = 1;
  }
  v0 = cd_2d_allocate(X->Check.idim_max + 1, nstate);
  v1 = cd_2d_allocate(X->Check.idim_max + 1, nstate);
#ifdef __MPI
  long int MAXidim_max;
  MAXidim_max = MaxMPI_li(X->Check.idim_max);
  if (GetlistSize(X) == TRUE) list_1buf = li_1d_allocate(MAXidim_max + 1);
  v1buf = cd_2d_allocate(MAXidim_max + 1, nstate);
#else
  if (X->Def.iCalcType == CG) v1buf = cd_2d_allocate(X->Check.idim_max + 1, nstate);
#endif // MPI

  X->Phys.num_down = d_1d_allocate(nstate);
  X->Phys.num_up = d_1d_allocate(nstate);
  X->Phys.num = d_1d_allocate(nstate);
  X->Phys.num2 = d_1d_allocate(nstate);
  X->Phys.energy = d_1d_allocate(nstate);
  X->Phys.var = d_1d_allocate(nstate);
  X->Phys.doublon = d_1d_allocate(nstate);
  X->Phys.doublon2 = d_1d_allocate(nstate);
  X->Phys.Sz = d_1d_allocate(nstate);
  X->Phys.Sz2 = d_1d_allocate(nstate);
  X->Phys.s2 = d_1d_allocate(nstate);

  fprintf(stdoutMPI, "%s", "\n######  LARGE ALLOCATE FINISH !  ######\n\n");
  return 0;
}
int GetlistSize(
  struct BindStruct *X
) {
  switch (X->Def.iCalcModel) {
  case Spin:
  case Hubbard:
  case HubbardNConserved:
  case Kondo:
  case KondoGC:
    if (X->Def.iFlgGeneralSpin == FALSE) {
      if (X->Def.iCalcModel == Spin && X->Def.Nsite % 2 == 1) {
        X->Large.SizeOflist_2_1 = X->Check.sdim * 2 + 2;
      }
      else {
        X->Large.SizeOflist_2_1 = X->Check.sdim + 2;
      }
      X->Large.SizeOflist_2_2 = X->Check.sdim + 2;
      X->Large.SizeOflistjb = X->Check.sdim + 2;
    }
    else {//for spin-canonical general spin
      X->Large.SizeOflist_2_1 = X->Check.sdim + 2;
      X->Large.SizeOflist_2_2 =
        X->Def.Tpow[X->Def.Nsite - 1] * X->Def.SiteToBit[X->Def.Nsite - 1] / X->Check.sdim + 2;
      X->Large.SizeOflistjb =
        X->Def.Tpow[X->Def.Nsite - 1] * X->Def.SiteToBit[X->Def.Nsite - 1] / X->Check.sdim + 2;
    }
    break;
  default:
    X->Large.SizeOflistjb = 1;
    return FALSE;
  }
  return TRUE;
}