xsetmem.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 "Common.h"
#include "common/setmemory.h"
#include "xsetmem.h"
#include "wrapperMPI.h"
static unsigned long int mfint[7];/*for malloc*/

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
 ) {
  unsigned long int i = 0;
  unsigned long int j = 0;
  unsigned long int k = 0;
  X->Def.Tpow = lui_1d_allocate(2 * X->Def.Nsite + 2);
  X->Def.OrgTpow = lui_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.EDNChemi + X->Def.NInterAll + X->Def.NTransfer);
  X->Def.EDSpinChemi = i_1d_allocate(X->Def.EDNChemi + X->Def.NInterAll + X->Def.NTransfer);
  X->Def.EDParaChemi = d_1d_allocate(X->Def.EDNChemi + 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.SingleExcitationOperator = i_2d_allocate(X->Def.NSingleExcitationOperator, 3);
  X->Def.ParaSingleExcitationOperator = cd_1d_allocate(X->Def.NSingleExcitationOperator);
  X->Def.PairExcitationOperator = i_2d_allocate(X->Def.NPairExcitationOperator, 5);
  X->Def.ParaPairExcitationOperator = cd_1d_allocate(X->Def.NPairExcitationOperator);

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

  unsigned int ipivot, iarrayJ, ispin;
  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 = ui_1d_allocate(X->Def.NTETimeSteps);
    X->Def.NTETransferDiagonal = ui_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 = ui_1d_allocate(X->Def.NTETimeSteps);
    X->Def.NTEInterAllDiagonal = ui_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 = ui_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 = ui_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
 ) {

  unsigned long int j = 0;
  unsigned long int idim_maxMPI;

  idim_maxMPI = MaxMPI_li(X->Check.idim_max);

  if (GetlistSize(X) == TRUE) {
      list_1 = lui_1d_allocate(X->Check.idim_max + 1);
#ifdef MPI
      list_1buf = lui_1d_allocate(idim_maxMPI + 1);
#endif // MPI
      list_2_1 = lui_1d_allocate(X->Large.SizeOflist_2_1);
      list_2_2 = lui_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);
    v0 = cd_1d_allocate(X->Check.idim_max + 1);
    v1 = cd_1d_allocate(X->Check.idim_max + 1);
  if (X->Def.iCalcType == TimeEvolution) {
      v2 = cd_1d_allocate(X->Check.idim_max + 1);
  } else {
      v2 = cd_1d_allocate(1);
  }
#ifdef MPI
    v1buf = cd_1d_allocate(idim_maxMPI + 1);
#endif // MPI
  if (X->Def.iCalcType == TPQCalc) {
      vg = cd_1d_allocate(1);
  } else {
      vg = cd_1d_allocate(X->Check.idim_max + 1);
  }
    alpha = d_1d_allocate(X->Def.Lanczos_max + 1);
    beta = d_1d_allocate(X->Def.Lanczos_max + 1);

  if (
          list_Diagonal == NULL
          || v0 == NULL
          || v1 == NULL
          || vg == NULL
          ) {
    return -1;
  }

  if (X->Def.iCalcType == TPQCalc || X->Def.iFlgCalcSpec != CALCSPEC_NOT) {
      vec = cd_2d_allocate(X->Def.Lanczos_max + 1, X->Def.Lanczos_max + 1);
  } else if (X->Def.iCalcType == Lanczos || X->Def.iCalcType == CG) {
    if (X->Def.LanczosTarget > X->Def.nvec) {
        vec = cd_2d_allocate(X->Def.LanczosTarget + 1, X->Def.Lanczos_max + 1);
    } else {
        vec = cd_2d_allocate(X->Def.nvec + 1, X->Def.Lanczos_max + 1);
    }
  }

  if (X->Def.iCalcType == FullDiag) {
      X->Phys.all_num_down = d_1d_allocate(X->Check.idim_max + 1);
      X->Phys.all_num_up = d_1d_allocate( X->Check.idim_max + 1);
      X->Phys.all_energy = d_1d_allocate(X->Check.idim_max + 1);
      X->Phys.all_doublon = d_1d_allocate(X->Check.idim_max + 1);
      X->Phys.all_sz = d_1d_allocate(X->Check.idim_max + 1);
      X->Phys.all_s2 = d_1d_allocate(X->Check.idim_max + 1);
      Ham = cd_2d_allocate(X->Check.idim_max + 1, X->Check.idim_max + 1);
      L_vec = cd_2d_allocate(X->Check.idim_max + 1, X->Check.idim_max + 1);

    if (X->Phys.all_num_down == NULL
        || X->Phys.all_num_up == NULL
        || X->Phys.all_energy == NULL
        || X->Phys.all_doublon == NULL
        || X->Phys.all_s2 == NULL
            ) {
      return -1;
    }
    for (j = 0; j < X->Check.idim_max + 1; j++) {
      if (Ham[j] == NULL || L_vec[j] == NULL) {
        return -1;
      }
    }
  } else if (X->Def.iCalcType == CG) {
      X->Phys.all_num_down = d_1d_allocate(X->Def.k_exct);
      X->Phys.all_num_up = d_1d_allocate(X->Def.k_exct);
      X->Phys.all_energy = d_1d_allocate(X->Def.k_exct);
      X->Phys.all_doublon = d_1d_allocate(X->Def.k_exct);
      X->Phys.all_sz = d_1d_allocate(X->Def.k_exct);
      X->Phys.all_s2 = d_1d_allocate( X->Def.k_exct);
  }
  fprintf(stdoutMPI, "%s", cProFinishAlloc);
  return 0;
}

  void setmem_IntAll_Diagonal
          (
                  int **InterAllOffDiagonal,
                  double complex *ParaInterAllOffDiagonal,
                  int **InterAllDiagonal,
                  double *ParaInterAllDiagonal,
                  const int NInterAll
          ) {
    InterAllOffDiagonal = i_2d_allocate(NInterAll, 8);
    ParaInterAllOffDiagonal = cd_1d_allocate(NInterAll);
    InterAllDiagonal = i_2d_allocate(NInterAll, 4);
    ParaInterAllDiagonal = d_1d_allocate(NInterAll);
  }


  int GetlistSize
          (
                  struct BindStruct *X
          ) {
    // unsigned int idim_maxMPI;

//    idim_maxMPI = MaxMPI_li(X->Check.idim_max);

    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:
        return FALSE;
    }
    return TRUE;
}