mltply.c File Reference

Multiplying the wavefunction by the Hamiltonian. \( H v_1\). More...

#include <bitcalc.h>
#include "mltply.h"
#include "mltplySpin.h"
#include "mltplyHubbard.h"
#include "wrapperMPI.h"
#include "CalcTime.h"
#include "mltplyCommon.h"
#include "diagonalcalc.h"

Go to the source code of this file.

Functions
int	mltply (struct BindStruct *X, double complex *tmp_v0, double complex *tmp_v1)
	Parent function of multiplying the wavefunction by the Hamiltonian. \( H v_1\). First, the calculation of diagonal term is done by using the list \( \verb|list_diaognal| \). Next, the calculation of off-diagonal term is done. . More...

Detailed Description

Multiplying the wavefunction by the Hamiltonian. \( H v_1\).

Version

0.2

add function to treat the case of generalspin

Version

0.1

Author

Takahiro Misawa (The University of Tokyo)

Kazuyoshi Yoshimi (The University of Tokyo)

Definition in file mltply.c.

Function Documentation

mltply()

int mltply	(	struct BindStruct *	X,
		double complex *	tmp_v0,
		double complex *	tmp_v1
	)

Parent function of multiplying the wavefunction by the Hamiltonian. \( H v_1\).
First, the calculation of diagonal term is done by using the list \( \verb|list_diaognal| \).
Next, the calculation of off-diagonal term is done.
.

Note

If \( \verb|mode| \) in BindStruct X is \( \verb|M_CORR| \), the wave function is not updated. The expected values are only calculated.
Otherwise, the wavefunction \( v_0 \) is updated as \( v_0 += H v_1\).

Parameters

X	[in] Struct for getting the information of the operators.
tmp_v0	[in, out]
tmp_v1	[in]

Returns

Author

Takahiro Misawa (The University of Tokyo)

Kazuyoshi Yoshimi (The University of Tokyo)

Definition at line 56 of file mltply.c.

References diagonalcalcForTE(), FALSE, GetSplitBitByModel(), GetSplitBitForGeneralSpin(), list_Diagonal, mltplyHubbard(), mltplyHubbardGC(), mltplySpin(), mltplySpinGC(), StartTimer(), step_i, StopTimer(), SumMPI_dc(), and X.

Referenced by CalcSpectrumByBiCG(), CG_EigenVector(), expec_energy_flct(), Lanczos_EigenValue(), Lanczos_EigenVector(), Lanczos_GetTridiagonalMatrixComponents(), LOBPCG_Main(), MultiplyForTEM(), and PowerLanczos().

                                                                                {
  long unsigned int j=0;
  long unsigned int irght=0;
  long unsigned int ilft=0;
  long unsigned int ihfbit=0;

  double complex dam_pr;

  long unsigned int i_max;

  StartTimer(1);
  i_max = X->Check.idim_max;
  X->Large.prdct = 0.0;
  dam_pr = 0.0;

  if(i_max!=0){
    if (X->Def.iFlgGeneralSpin == FALSE) {
      if (GetSplitBitByModel(X->Def.Nsite, X->Def.iCalcModel, &irght, &ilft, &ihfbit) != 0) {
        return -1;
      }
    }
    else{
      if(X->Def.iCalcModel==Spin){
        if (GetSplitBitForGeneralSpin(X->Def.Nsite, &ihfbit, X->Def.SiteToBit) != 0) {
          return -1;
        }
      }
    }
  }
  else{
    irght=0;
    ilft=0;
    ihfbit=0;
  }
  X->Large.i_max = i_max;
  X->Large.irght = irght;
  X->Large.ilft = ilft;
  X->Large.ihfbit = ihfbit;
  X->Large.mode = M_MLTPLY;

  StartTimer(100);
#pragma omp parallel for default(none) reduction(+:dam_pr) firstprivate(i_max) shared(tmp_v0, tmp_v1, list_Diagonal)
  for (j = 1; j <= i_max; j++) {
    tmp_v0[j] += (list_Diagonal[j]) * tmp_v1[j];
    dam_pr += (list_Diagonal[j]) * conj(tmp_v1[j]) * tmp_v1[j];
  }
  X->Large.prdct += dam_pr;
  StopTimer(100);
  if (X->Def.iCalcType == TimeEvolution) diagonalcalcForTE(step_i, X, tmp_v0, tmp_v1);
  
  switch (X->Def.iCalcModel) {
  case HubbardGC:
    mltplyHubbardGC(X, tmp_v0, tmp_v1);
    break;
      
  case KondoGC:
  case Hubbard:
  case Kondo:
    mltplyHubbard(X, tmp_v0, tmp_v1);
    break;
      
  case Spin:
    mltplySpin(X, tmp_v0, tmp_v1);
    break;
      
  case SpinGC:
    mltplySpinGC(X, tmp_v0, tmp_v1);
    break;
      
  default:
    return -1;
  }
  
  X->Large.prdct = SumMPI_dc(X->Large.prdct);  
  StopTimer(1);
  return 0;
}