mltplySpinCore.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 <bitcalc.hpp>
#include "xsetmem.hpp"
#include "wrapperMPI.hpp"
#include "mltplyCommon.hpp"
#include "mltplySpinCore.hpp"

/******************************************************************************/
//[s] GetInfo functions
/******************************************************************************/

int child_exchange_spin_GetInfo(
  int iExchange,
  struct BindStruct *X
) {
  int isite1 = X->Def.ExchangeCoupling[iExchange][0] + 1;
  int isite2 = X->Def.ExchangeCoupling[iExchange][1] + 1;
  X->Large.tmp_J = X->Def.ParaExchangeCoupling[iExchange];
  X->Large.is1_up = X->Def.Tpow[isite1 - 1];
  X->Large.is2_up = X->Def.Tpow[isite2 - 1];
  X->Large.isA_spin = X->Large.is1_up + X->Large.is2_up;
  return 0;
}/*int child_exchange_spin_GetInfo*/
int child_pairlift_spin_GetInfo(
  int iPairLift,
  struct BindStruct *X
) {
  int isite1 = X->Def.PairLiftCoupling[iPairLift][0] + 1;
  int isite2 = X->Def.PairLiftCoupling[iPairLift][1] + 1;
  X->Large.tmp_J = X->Def.ParaPairLiftCoupling[iPairLift];
  X->Large.is1_up = X->Def.Tpow[isite1 - 1];
  X->Large.is2_up = X->Def.Tpow[isite2 - 1];
  X->Large.isA_spin = X->Large.is1_up + X->Large.is2_up;
  return 0;
}/*int child_pairlift_spin_GetInfo*/
int child_general_int_spin_GetInfo(
  struct BindStruct *X,
  long int isite1,
  long int isite2,
  long int sigma1,
  long int sigma2,
  long int sigma3,
  long int sigma4,
  std::complex<double> tmp_V
) {
  X->Large.tmp_V = tmp_V;
  X->Large.isite1 = isite1;
  X->Large.isite2 = isite2;
  X->Large.is1_up = X->Def.Tpow[isite1 - 1];
  X->Large.is2_up = X->Def.Tpow[isite2 - 1];
  X->Large.is1_spin = sigma1;
  X->Large.is2_spin = sigma2;
  X->Large.is3_spin = sigma3;
  X->Large.is4_spin = sigma4;
  return 0;
}/*int child_general_int_spin_GetInfo*/

/******************************************************************************/
//[e] GetInfo functions
/******************************************************************************/

/******************************************************************************/
//[s] core routines
/******************************************************************************/

int X_Spin_CisAit(
  long int j,
  struct BindStruct *X,
  long int is1_spin,
  long int sigma2,
  long int *tmp_off
) {
  long int list_1_j;
  long int off;
  list_1_j = list_1_org[j];
  if (X_SpinGC_CisAit(list_1_j + 1, is1_spin, sigma2, &off) != 0) {
    GetOffComp(list_2_1, list_2_2, off, X->Large.irght, X->Large.ilft, X->Large.ihfbit, tmp_off);
    return 1;
  }
  else {
    *tmp_off = 0;
    return 0;
  }
}/*int X_Spin_CisAit*/
int X_Spin_CisAis(
  long int j,
  long int is1_spin,
  long int sigma1
) {
  int A_ibit_tmp;
  // off = j
  A_ibit_tmp = ((list_1[j] & is1_spin) / is1_spin) ^ (1 - sigma1);
  return A_ibit_tmp;
}/*int X_Spin_CisAis*/
int X_SpinGC_CisAis(
  long int j,
  long int is1_spin,
  long int sigma1
) {
  int A_ibit_tmp;
  long int list_1_j;
  // off = j
  list_1_j = j - 1;
  A_ibit_tmp = ((list_1_j & is1_spin) / is1_spin) ^ (1 - sigma1);
  return A_ibit_tmp;
}/*int X_SpinGC_CisAis*/
int X_SpinGC_CisAit(
  long int j,
  long int is1_spin,
  long int sigma2,
  long int *tmp_off
) {
  long int list_1_j, ibit_tmp_1;

  list_1_j = j - 1;

  ibit_tmp_1 = list_1_j & is1_spin;
  if (ibit_tmp_1 == 0 && sigma2 == 0) {    // down -> up
    *tmp_off = list_1_j + is1_spin;
    return 1;
  }
  else if (ibit_tmp_1 != 0 && sigma2 == 1) { // up -> down
    *tmp_off = list_1_j - is1_spin;
    return 1;
  }
  else {
    *tmp_off = 0;
    return 0;
  }
}/*int X_SpinGC_CisAit*/

/******************************************************************************/
//[e] core routines
/******************************************************************************/

int X_child_exchange_spin_element(
  long int j,
  struct BindStruct *X,
  long int isA_up,
  long int isB_up,
  long int sigmaA,
  long int sigmaB,
  long int *tmp_off
) {
  long int iexchg, off;
  long int irght = X->Large.irght;
  long int ilft = X->Large.ilft;
  long int ihfbit = X->Large.ihfbit;
  long int ibit_tmp_A, ibit_tmp_B;

  ibit_tmp_A = ((list_1[j] & isA_up) / isA_up);
  ibit_tmp_B = ((list_1[j] & isB_up) / isB_up);
  if (ibit_tmp_A == sigmaA && ibit_tmp_B == sigmaB) {
    iexchg = list_1[j] ^ (isA_up + isB_up);
    GetOffComp(list_2_1, list_2_2, iexchg, irght, ilft, ihfbit, &off);
    *tmp_off = off;
    return 1;
  }
  else {
    *tmp_off = 0; // just tentative
    return 0;
  }
}/*int X_child_exchange_spin_element*/
void child_exchange_spin_element(
  long int j,
  int nstate, std::complex<double> **tmp_v0,
  std::complex<double> **tmp_v1,
  struct BindStruct *X,
  long int *tmp_off
) {
  long int off;
  long int iexchg;
  long int is_up = X->Large.isA_spin;
  long int irght = X->Large.irght;
  long int ilft = X->Large.ilft;
  long int ihfbit = X->Large.ihfbit;
  std::complex<double> tmp_J = X->Large.tmp_J;
  long int ibit_tmp;
  int one = 1;

  ibit_tmp = (list_1[j] & is_up);
  if (ibit_tmp == 0 || ibit_tmp == is_up) {
    return;
  }
  else {
    iexchg = list_1[j] ^ is_up;
    GetOffComp(list_2_1, list_2_2, iexchg, irght, ilft, ihfbit, &off);
    *tmp_off = off;
    zaxpy_(&nstate, &tmp_J, &tmp_v1[j][0], &one, &tmp_v0[off][0], &one);
  }
}/*std::complex<double> child_exchange_spin_element*/
void GC_child_exchange_spin_element(
  long int j,
  int nstate, std::complex<double> **tmp_v0,
  std::complex<double> **tmp_v1,
  struct BindStruct *X,
  long int *tmp_off
) {
  long int is_up = X->Large.isA_spin;
  std::complex<double> tmp_J = X->Large.tmp_J;
  long int list_1_j, list_1_off;
  int one = 1;

  list_1_j = j - 1;

  long int ibit_tmp;
  ibit_tmp = (list_1_j & is_up);
  if (ibit_tmp == 0 || ibit_tmp == is_up) {
    return;
  }
  else {
    list_1_off = list_1_j ^ is_up;
    *tmp_off = list_1_off;
    zaxpy_(&nstate, &tmp_J, &tmp_v1[j][0], &one, &tmp_v0[list_1_off + 1][0], &one);
  }
}/*std::complex<double> GC_child_exchange_spin_element*/
void GC_child_pairlift_spin_element(
  long int j,
  int nstate, std::complex<double> **tmp_v0,
  std::complex<double> **tmp_v1,
  struct BindStruct *X,
  long int *tmp_off
) {
  long int is_up = X->Large.isA_spin;
  std::complex<double> tmp_J = X->Large.tmp_J;
  int one = 1;
  long int list_1_off;
  long int list_1_j = j - 1;
  long int ibit_tmp;
  //ibit_tmp = ((list_1_j & is1_up) / is1_up) ^ ((list_1_j & is2_up) / is2_up);
  ibit_tmp = (list_1_j & is_up);
  if (ibit_tmp == 0 || ibit_tmp == is_up) {
    list_1_off = list_1_j ^ is_up; //Change: ++ -> -- or -- -> ++
    *tmp_off = list_1_off;
    zaxpy_(&nstate, &tmp_J, &tmp_v1[j][0], &one, &tmp_v0[list_1_off + 1][0], &one);
  }
}/*std::complex<double> GC_child_pairlift_spin_element*/
//[s]Spin
void child_CisAisCisAis_spin_element(
  long int j,
  long int isA_up,
  long int isB_up,
  long int org_sigma2,
  long int org_sigma4,
  std::complex<double> tmp_V,
  int nstate, std::complex<double> **tmp_v0,
  std::complex<double> **tmp_v1
) {
  int tmp_sgn;
  std::complex<double> dmv;
  int one = 1;

  tmp_sgn = X_Spin_CisAis(j, isB_up, org_sigma4);
  tmp_sgn *= X_Spin_CisAis(j, isA_up, org_sigma2);
  dmv = (std::complex<double>)tmp_sgn * tmp_V;
  zaxpy_(&nstate, &dmv, &tmp_v1[j][0], &one, &tmp_v0[j][0], &one);
}/*std::complex<double> child_CisAisCisAis_spin_element*/

//[e]Spin

//[s]GC Spin
void GC_child_CisAisCisAis_spin_element(
  long int j,
  long int isA_up,
  long int isB_up,
  long int org_sigma2,
  long int org_sigma4,
  std::complex<double> tmp_V,
  int nstate, std::complex<double> **tmp_v0,
  std::complex<double> **tmp_v1
) {
  int tmp_sgn;
  std::complex<double> dmv = 0;
  int one = 1;

  tmp_sgn = X_SpinGC_CisAis(j, isB_up, org_sigma4);
  tmp_sgn *= X_SpinGC_CisAis(j, isA_up, org_sigma2);
  if (tmp_sgn != 0) {
    dmv = (std::complex<double>)tmp_sgn * tmp_V;
    zaxpy_(&nstate, &dmv, &tmp_v1[j][0], &one, &tmp_v0[j][0], &one);
  }
}/*std::complex<double> GC_child_CisAisCisAis_spin_element*/
void GC_child_CisAisCitAiu_spin_element(
  long int j,
  long int org_sigma2,
  long int org_sigma4,
  long int isA_up,
  long int isB_up,
  std::complex<double> tmp_V,
  int nstate, std::complex<double> **tmp_v0,
  std::complex<double> **tmp_v1,
  long int *tmp_off
) {
  int tmp_sgn;
  std::complex<double> dmv;
  int one = 1;
  tmp_sgn = X_SpinGC_CisAit(j, isB_up, org_sigma4, tmp_off);
  if (tmp_sgn != 0) {
    tmp_sgn *= X_SpinGC_CisAis((*tmp_off + 1), isA_up, org_sigma2);
    if (tmp_sgn != 0) {
      dmv = (std::complex<double>)tmp_sgn * tmp_V;
      zaxpy_(&nstate, &dmv, &tmp_v1[j][0], &one, &tmp_v0[*tmp_off + 1][0], &one);
    }/*if (tmp_sgn != 0)*/
  }/*if (tmp_sgn != 0)*/
}/*std::complex<double> GC_child_CisAisCitAiu_spin_element*/
void GC_child_CisAitCiuAiu_spin_element(
  long int j,
  long int org_sigma2,
  long int org_sigma4,
  long int isA_up,
  long int isB_up,
  std::complex<double> tmp_V,
  int nstate, std::complex<double> **tmp_v0,
  std::complex<double> **tmp_v1,
  long int *tmp_off
) {
  int tmp_sgn;
  std::complex<double> dmv;
  int one = 1;
  tmp_sgn = X_SpinGC_CisAis(j, isB_up, org_sigma4);
  if (tmp_sgn != 0) {
    tmp_sgn *= X_SpinGC_CisAit(j, isA_up, org_sigma2, tmp_off);
    if (tmp_sgn != 0) {
      dmv = (std::complex<double>)tmp_sgn * tmp_V;
      zaxpy_(&nstate, &dmv, &tmp_v1[j][0], &one, &tmp_v0[*tmp_off + 1][0], &one);
    }/*if (tmp_sgn != 0)*/
  }/*if (tmp_sgn != 0)*/
}/*std::complex<double> GC_child_CisAitCiuAiu_spin_element*/
void GC_child_CisAitCiuAiv_spin_element(
  long int j,
  long int org_sigma2,
  long int org_sigma4,
  long int isA_up,
  long int isB_up,
  std::complex<double> tmp_V,
  int nstate, std::complex<double> **tmp_v0,
  std::complex<double> **tmp_v1,
  long int *tmp_off_2
) {
  int tmp_sgn;
  long int tmp_off_1;
  std::complex<double> dmv;
  int one = 1;
  tmp_sgn = X_SpinGC_CisAit(j, isB_up, org_sigma4, &tmp_off_1);
  if (tmp_sgn != 0) {
    tmp_sgn *= X_SpinGC_CisAit((tmp_off_1 + 1), isA_up, org_sigma2, tmp_off_2);
    if (tmp_sgn != 0) {
      dmv = (std::complex<double>)tmp_sgn * tmp_V;
      zaxpy_(&nstate, &dmv, &tmp_v1[j][0], &one, &tmp_v0[*tmp_off_2 + 1][0], &one);
    }/*if (tmp_sgn != 0)*/
  }/*if (tmp_sgn != 0)*/
}/*std::complex<double> GC_child_CisAitCiuAiv_spin_element*/
//[e]GC Spin