/**
*
*
* @param X
*
* @author Takahiro Misawa (The University of Tokyo)
* @author Kazuyoshi Yoshimi (The University of Tokyo)
* @return
*/
int lapack_diag(struct BindStruct *X){
FILE *fp;
char sdt[D_FileNameMax]="";
int i,j,i_max,xMsize;
i_max=X->Check.idim_max;
for(i=0;i<i_max;i++){
for(j=0;j<i_max;j++){
Ham[i][j] =Ham[i+1][j+1];
}
}
xMsize = i_max;
//DSEVvector(xMsize, Ham, v0, L_vec);
ZHEEVall(xMsize, Ham, v0, L_vec);
strcpy(sdt,cFileNameEigenvalue_Lanczos);
if(childfopenMPI(sdt,"w",&fp)!=0){
return -1;
}
for(i=0;i<i_max;i++){
fprintf(fp," %d %.10lf \n",i, creal(v0[i]));
}
fclose(fp);
return 0;
}
/**
*
*
* @param X
*
* @author Takahiro Misawa (The University of Tokyo)
* @author Kazuyoshi Yoshimi (The University of Tokyo)
*
* @return
*/
int HPhiTrans(struct BindStruct *X){
FILE *fp_err;
char sdt_err[D_FileNameMax];
int i,k;
int cnt_trans;
strcpy(sdt_err, cFileNameWarningOnTransfer);
if(childfopenMPI(sdt_err, "w", &fp_err)!=0){
return -1;
}
fclose(fp_err);
//Transefer
cnt_trans=0;
for(i=0;i<X->Def.EDNTransfer;i++){
// eliminate double counting
for(k=0;k<cnt_trans;k++){
if( X->Def.EDGeneralTransfer[i][1] == X->Def.EDGeneralTransfer[k][1]
&& X->Def.EDGeneralTransfer[i][3] == X->Def.EDGeneralTransfer[k][3]){
if(X->Def.EDGeneralTransfer[i][0] == X->Def.EDGeneralTransfer[k][0]
&& X->Def.EDGeneralTransfer[i][2] == X->Def.EDGeneralTransfer[k][2]){
sprintf(sdt_err,"%s",cErrTransfer);
childfopenMPI(sdt_err,"a", &fp_err);
fprintf(fp_err,cErrDoubleCounting, X->Def.EDGeneralTransfer[k][0] ,X->Def.EDGeneralTransfer[k][2], X->Def.EDGeneralTransfer[k][1], X->Def.EDGeneralTransfer[k][3]);
fclose(fp_err);
// return -1;
}
}
}
cnt_trans+=1;
}
//fprintf(stdoutMPI, cProEDNTrans, cnt_trans);
//fprintf(stdoutMPI, cProEDNChemi, cnt_chemi);
return 0;
}
int OutputTMComponents(
struct EDMainCalStruct *X,
double *_alpha,
double *_beta,
double _dnorm,
int liLanczosStp
)
{
char sdt[D_FileNameMax];
unsigned long int i;
FILE *fp;
sprintf(sdt, cFileNameTridiagonalMatrixComponents, X->Bind.Def.CDataFileHead);
childfopenMPI(sdt,"w", &fp);
fprintf(fp, "%d \n",liLanczosStp);
fprintf(fp, "%.10lf \n",_dnorm);
for( i = 1 ; i <= liLanczosStp; i++){
fprintf(fp,"%.10lf %.10lf \n", alpha[i], beta[i]);
}
fclose(fp);
return TRUE;
}
int ReadTMComponents(
struct EDMainCalStruct *X,
double *_dnorm,
unsigned long int *_i_max
){
char sdt[D_FileNameMax];
char ctmp[256];
unsigned long int idx;
unsigned long int i_max;
double dnorm;
FILE *fp;
idx=1;
sprintf(sdt, cFileNameTridiagonalMatrixComponents, X->Bind.Def.CDataFileHead);
childfopenMPI(sdt,"r", &fp);
fgetsMPI(ctmp, sizeof(ctmp)/sizeof(char), fp);
sscanf(ctmp,"%ld \n", &i_max);
if(X->Bind.Def.iFlgCalcSpec == RECALC_INOUT_TMComponents_VEC||
X->Bind.Def.iFlgCalcSpec == RECALC_FROM_TMComponents_VEC) {
alpha=(double*)realloc(alpha, sizeof(double)*(i_max + X->Bind.Def.Lanczos_max + 1));
beta=(double*)realloc(beta, sizeof(double)*(i_max + X->Bind.Def.Lanczos_max + 1));
}
else if(X->Bind.Def.iFlgCalcSpec==RECALC_FROM_TMComponents){
alpha=(double*)realloc(alpha, sizeof(double)*(i_max + 1));
beta=(double*)realloc(beta, sizeof(double)*(i_max + 1));
}
fgetsMPI(ctmp, sizeof(ctmp)/sizeof(char), fp);
sscanf(ctmp,"%lf \n", &dnorm);
while(fgetsMPI(ctmp, sizeof(ctmp)/sizeof(char), fp) != NULL){
sscanf(ctmp,"%lf %lf \n", &alpha[idx], &beta[idx]);
idx++;
}
fclose(fp);
*_dnorm=dnorm;
*_i_max=i_max;
return TRUE;
}
/**
* @brief A main function to calculate eigenvalues and eigenvectors by Lanczos method
*
* @param[in,out] X CalcStruct list for getting and pushing calculation information
* @retval 0 normally finished
* @retval -1 unnormally finished
*
* @version 0.2
* @date 2015/10/20 add function of using a flag of iCalcEigenVec
* @version 0.1
* @author Takahiro Misawa (The University of Tokyo)
* @author Kazuyoshi Yoshimi (The University of Tokyo)
*
*/
int CalcByLanczos(
struct EDMainCalStruct *X
)
{
char sdt[D_FileNameMax];
double diff_ene,var;
long int i;
long int i_max=0;
FILE *fp;
if(X->Bind.Def.iInputEigenVec==FALSE){
// this part will be modified
switch(X->Bind.Def.iCalcModel){
case HubbardGC:
case SpinGC:
case KondoGC:
case SpinlessFermionGC:
initial_mode = 1; // 1 -> random initial vector
break;
case Hubbard:
case Kondo:
case Spin:
case SpinlessFermion:
if(X->Bind.Def.iFlgGeneralSpin ==TRUE){
initial_mode=1;
}
else{
if(X->Bind.Def.initial_iv>0){
initial_mode = 0; // 0 -> only v[iv] = 1
}else{
initial_mode = 1; // 1 -> random initial vector
}
}
break;
default:
//fclose(fp);
exitMPI(-1);
}
if(Lanczos_EigenValue(&(X->Bind))!=0){
fprintf(stderr, " Lanczos Eigenvalue is not converged in this process.\n");
return(FALSE);
}
if(X->Bind.Def.iCalcEigenVec==CALCVEC_NOT){
fprintf(stdoutMPI, " Lanczos EigenValue = %.10lf \n ",X->Bind.Phys.Target_energy);
return(TRUE);
}
fprintf(stdoutMPI, cLogLanczos_EigenVecStart);
// printf("debug: X->Bind.Check.idim_maxMPI=%d\n", X->Bind.Check.idim_maxMPI);
if(X->Bind.Check.idim_maxMPI != 1){
Lanczos_EigenVector(&(X->Bind));
expec_energy(&(X->Bind));
//check for the accuracy of the eigenvector
var = fabs(X->Bind.Phys.var-X->Bind.Phys.energy*X->Bind.Phys.energy)/fabs(X->Bind.Phys.var);
diff_ene = fabs(X->Bind.Phys.Target_energy-X->Bind.Phys.energy)/fabs(X->Bind.Phys.Target_energy);
fprintf(stdoutMPI, "\n");
fprintf(stdoutMPI, " Accuracy check !!!\n");
fprintf(stdoutMPI, " LanczosEnergy = %.14e \n EnergyByVec = %.14e \n diff_ene = %.14e \n var = %.14e \n",X->Bind.Phys.Target_energy,X->Bind.Phys.energy,diff_ene,var);
if(diff_ene < eps_Energy && var< eps_Energy){
fprintf(stdoutMPI, " Accuracy of Lanczos vectors is enough.\n");
fprintf(stdoutMPI, "\n");
}
/*
else{
Comment out: Power Lanczos method
fprintf(stdoutMPI, " Accuracy of Lanczos vectors is NOT enough\n");
iconv=1;
fprintf(stdoutMPI, "Eigenvector is improved by power Lanczos method \n");
fprintf(stdoutMPI, "Power Lanczos starts\n");
flag=PowerLanczos(&(X->Bind));
fprintf(stdoutMPI, "Power Lanczos ends\n");
if(flag==1){
var = fabs(X->Bind.Phys.var-X->Bind.Phys.energy*X->Bind.Phys.energy)/fabs(X->Bind.Phys.var);
diff_ene = fabs(X->Bind.Phys.Target_energy-X->Bind.Phys.energy)/fabs(X->Bind.Phys.Target_energy);
fprintf(stdoutMPI,"\n");
fprintf(stdoutMPI,"Power Lanczos Accuracy check !!!\n");
fprintf(stdoutMPI,"%.14e %.14e: diff_ene=%.14e var=%.14e \n ",X->Bind.Phys.Target_energy,X->Bind.Phys.energy,diff_ene,var);
fprintf(stdoutMPI,"\n");
}
else if(X->Bind.Def.iCalcEigenVec==CALCVEC_LANCZOSCG && iconv==1){
*/
else if(X->Bind.Def.iCalcEigenVec==CALCVEC_LANCZOSCG){
fprintf(stdoutMPI, " Accuracy of Lanczos vectors is NOT enough\n\n");
X->Bind.Def.St=1;
CG_EigenVector(&(X->Bind));
expec_energy(&(X->Bind));
var = fabs(X->Bind.Phys.var-X->Bind.Phys.energy*X->Bind.Phys.energy)/fabs(X->Bind.Phys.var);
diff_ene = fabs(X->Bind.Phys.Target_energy-X->Bind.Phys.energy)/fabs(X->Bind.Phys.Target_energy);
fprintf(stdoutMPI, "\n");
fprintf(stdoutMPI, " CG Accuracy check !!!\n");
fprintf(stdoutMPI, " LanczosEnergy = %.14e\n EnergyByVec = %.14e\n diff_ene = %.14e\n var = %.14e \n ",X->Bind.Phys.Target_energy,X->Bind.Phys.energy,diff_ene,var);
fprintf(stdoutMPI, "\n");
//}
}
}
else{//idim_max=1
v0[1]=1;
expec_energy(&(X->Bind));
}
}
else{// X->Bind.Def.iInputEigenVec=false :input v1:
fprintf(stdoutMPI, "An Eigenvector is inputted.\n");
sprintf(sdt, cFileNameInputEigen, X->Bind.Def.CDataFileHead, X->Bind.Def.k_exct-1, myrank);
childfopenALL(sdt, "rb", &fp);
if(fp==NULL){
fprintf(stderr, "Error: A file of Inputvector does not exist.\n");
exitMPI(-1);
}
fread(&i_max, sizeof(long int), 1, fp);
if(i_max != X->Bind.Check.idim_max){
fprintf(stderr, "Error: A file of Inputvector is incorrect.\n");
exitMPI(-1);
}
fread(v1, sizeof(complex double),X->Bind.Check.idim_max+1, fp);
fclose(fp);
}
fprintf(stdoutMPI, cLogLanczos_EigenVecEnd);
// v1 is eigen vector
if(!expec_cisajs(&(X->Bind), v1)==0){
fprintf(stderr, "Error: calc OneBodyG.\n");
exitMPI(-1);
}
if(!expec_cisajscktaltdc(&(X->Bind), v1)==0){
fprintf(stderr, "Error: calc TwoBodyG.\n");
exitMPI(-1);
}
/* For ver.1.0
if(!expec_totalspin(&(X->Bind), v1)==0){
fprintf(stderr, "Error: calc TotalSpin.\n");
exitMPI(-1);
}
*/
if(!expec_totalSz(&(X->Bind), v1)==0){
fprintf(stderr, "Error: calc TotalSz.\n");
exitMPI(-1);
}
if(X->Bind.Def.St==0){
sprintf(sdt, cFileNameEnergy_Lanczos, X->Bind.Def.CDataFileHead);
}else if(X->Bind.Def.St==1){
sprintf(sdt, cFileNameEnergy_CG, X->Bind.Def.CDataFileHead);
}
if(childfopenMPI(sdt, "w", &fp)!=0){
exitMPI(-1);
}
fprintf(fp,"Energy %.16lf \n",X->Bind.Phys.energy);
fprintf(fp,"Doublon %.16lf \n",X->Bind.Phys.doublon);
fprintf(fp,"Sz %.16lf \n",X->Bind.Phys.sz);
// fprintf(fp,"total S^2 %.10lf \n",X->Bind.Phys.s2);
fclose(fp);
if(X->Bind.Def.iOutputEigenVec==TRUE){
sprintf(sdt, cFileNameOutputEigen, X->Bind.Def.CDataFileHead, X->Bind.Def.k_exct-1, myrank);
if(childfopenALL(sdt, "wb", &fp)!=0){
exitMPI(-1);
}
fwrite(&X->Bind.Check.idim_max, sizeof(X->Bind.Check.idim_max),1,fp);
fwrite(v1, sizeof(complex double),X->Bind.Check.idim_max+1, fp);
fclose(fp);
}
return TRUE;
}
/**
*
*
* @param X
*
* @author Takahiro Misawa (The University of Tokyo)
* @author Kazuyoshi Yoshimi (The University of Tokyo)
* @return
*/
int Lanczos_EigenValue(struct BindStruct *X)
{
fprintf(stdoutMPI, "%s", cLogLanczos_EigenValueStart);
FILE *fp;
char sdt[D_FileNameMax],sdt_2[D_FileNameMax];
int stp, iproc;
long int i,iv,i_max;
unsigned long int i_max_tmp, sum_i_max;
int k_exct,Target;
int iconv=-1;
double beta1,alpha1; //beta,alpha1 should be real
double complex temp1,temp2;
double complex cbeta1;
double E[5],ebefor;
int mythread;
// for GC
double dnorm;
double complex cdnorm;
long unsigned int u_long_i;
dsfmt_t dsfmt;
#ifdef lapack
double **tmp_mat;
double *tmp_E;
int int_i,int_j,mfint[7];
#endif
sprintf(sdt_2, cFileNameLanczosStep, X->Def.CDataFileHead);
i_max=X->Check.idim_max;
k_exct = X->Def.k_exct;
if(initial_mode == 0){
sum_i_max = SumMPI_li(X->Check.idim_max);
X->Large.iv = (sum_i_max / 2 + X->Def.initial_iv) % sum_i_max + 1;
iv=X->Large.iv;
fprintf(stdoutMPI, " initial_mode=%d normal: iv = %ld i_max=%ld k_exct =%d \n\n",initial_mode,iv,i_max,k_exct);
#pragma omp parallel for default(none) private(i) shared(v0, v1) firstprivate(i_max)
for(i = 1; i <= i_max; i++){
v0[i]=0.0;
v1[i]=0.0;
}
sum_i_max = 0;
for (iproc = 0; iproc < nproc; iproc++) {
i_max_tmp = BcastMPI_li(iproc, i_max);
if (sum_i_max <= iv && iv < sum_i_max + i_max_tmp) {
if (myrank == iproc) {
v1[iv - sum_i_max+1] = 1.0;
if (X->Def.iInitialVecType == 0) {
v1[iv - sum_i_max+1] += 1.0*I;
v1[iv - sum_i_max+1] /= sqrt(2.0);
}
}/*if (myrank == iproc)*/
}/*if (sum_i_max <= iv && iv < sum_i_max + i_max_tmp)*/
sum_i_max += i_max_tmp;
}/*for (iproc = 0; iproc < nproc; iproc++)*/
}/*if(initial_mode == 0)*/
else if(initial_mode==1){
iv = X->Def.initial_iv;
fprintf(stdoutMPI, " initial_mode=%d (random): iv = %ld i_max=%ld k_exct =%d \n\n",initial_mode,iv,i_max,k_exct);
#pragma omp parallel default(none) private(i, u_long_i, mythread, dsfmt) \
shared(v0, v1, iv, X, nthreads, myrank) firstprivate(i_max)
{
#pragma omp for
for (i = 1; i <= i_max; i++) {
v0[i] = 0.0;
}
/*
Initialise MT
*/
#ifdef _OPENMP
mythread = omp_get_thread_num();
#else
mythread = 0;
#endif
u_long_i = 123432 + labs(iv) + mythread + nthreads * myrank;
dsfmt_init_gen_rand(&dsfmt, u_long_i);
if (X->Def.iInitialVecType == 0) {
#pragma omp for
for (i = 1; i <= i_max; i++)
v1[i] = 2.0*(dsfmt_genrand_close_open(&dsfmt) - 0.5) + 2.0*(dsfmt_genrand_close_open(&dsfmt) - 0.5)*I;
}
else {
#pragma omp for
for (i = 1; i <= i_max; i++)
v1[i] = 2.0*(dsfmt_genrand_close_open(&dsfmt) - 0.5);
}
}/*#pragma omp parallel*/
cdnorm=0.0;
#pragma omp parallel for default(none) private(i) shared(v1, i_max) reduction(+: cdnorm)
for(i=1;i<=i_max;i++){
cdnorm += conj(v1[i])*v1[i];
}
cdnorm = SumMPI_dc(cdnorm);
dnorm=creal(cdnorm);
dnorm=sqrt(dnorm);
#pragma omp parallel for default(none) private(i) shared(v1) firstprivate(i_max, dnorm)
for(i=1;i<=i_max;i++){
v1[i] = v1[i]/dnorm;
}
}/*else if(initial_mode==1)*/
//Eigenvalues by Lanczos method
TimeKeeper(X, cFileNameTimeKeep, cLanczos_EigenValueStart, "a");
mltply(X, v0, v1);
stp=1;
TimeKeeperWithStep(X, cFileNameTimeKeep, cLanczos_EigenValueStep, "a", stp);
alpha1=creal(X->Large.prdct) ;// alpha = v^{\dag}*H*v
alpha[1]=alpha1;
cbeta1=0.0;
#pragma omp parallel for reduction(+:cbeta1) default(none) private(i) shared(v0, v1) firstprivate(i_max, alpha1)
for(i = 1; i <= i_max; i++){
cbeta1+=conj(v0[i]-alpha1*v1[i])*(v0[i]-alpha1*v1[i]);
}
cbeta1 = SumMPI_dc(cbeta1);
beta1=creal(cbeta1);
beta1=sqrt(beta1);
beta[1]=beta1;
ebefor=0;
/*
Set Maximum number of loop to the dimention of the Wavefunction
*/
i_max_tmp = SumMPI_li(i_max);
if(i_max_tmp < X->Def.Lanczos_max){
X->Def.Lanczos_max = i_max_tmp;
}
if(i_max_tmp < X->Def.LanczosTarget){
X->Def.LanczosTarget = i_max_tmp;
}
if(i_max_tmp == 1){
E[1]=alpha[1];
vec12(alpha,beta,stp,E,X);
X->Large.itr=stp;
X->Phys.Target_energy=E[k_exct];
iconv=0;
fprintf(stdoutMPI," LanczosStep E[1] \n");
fprintf(stdoutMPI," stp=%d %.10lf \n",stp,E[1]);
}
else{
#ifdef lapack
fprintf(stdoutMPI, " LanczosStep E[1] E[2] E[3] E[4] E_Max/Nsite\n");
#else
fprintf(stdoutMPI, " LanczosStep E[1] E[2] E[3] E[4] \n");
#endif
for(stp = 2; stp <= X->Def.Lanczos_max; stp++){
#pragma omp parallel for default(none) private(i,temp1, temp2) shared(v0, v1) firstprivate(i_max, alpha1, beta1)
for(i=1;i<=i_max;i++){
temp1 = v1[i];
temp2 = (v0[i]-alpha1*v1[i])/beta1;
v0[i] = -beta1*temp1;
v1[i] = temp2;
}
mltply(X, v0, v1);
TimeKeeperWithStep(X, cFileNameTimeKeep, cLanczos_EigenValueStep, "a", stp);
alpha1=creal(X->Large.prdct);
alpha[stp]=alpha1;
cbeta1=0.0;
#pragma omp parallel for reduction(+:cbeta1) default(none) private(i) shared(v0, v1) firstprivate(i_max, alpha1)
for(i=1;i<=i_max;i++){
cbeta1+=conj(v0[i]-alpha1*v1[i])*(v0[i]-alpha1*v1[i]);
}
cbeta1 = SumMPI_dc(cbeta1);
beta1=creal(cbeta1);
beta1=sqrt(beta1);
beta[stp]=beta1;
Target = X->Def.LanczosTarget;
if(stp==2){
#ifdef lapack
d_malloc2(tmp_mat,stp,stp);
d_malloc1(tmp_E,stp+1);
for(int_i=0;int_i<stp;int_i++){
for(int_j=0;int_j<stp;int_j++){
tmp_mat[int_i][int_j] = 0.0;
}
}
tmp_mat[0][0] = alpha[1];
tmp_mat[0][1] = beta[1];
tmp_mat[1][0] = beta[1];
tmp_mat[1][1] = alpha[2];
DSEVvalue(stp,tmp_mat,tmp_E);
E[1] = tmp_E[0];
E[2] = tmp_E[1];
E[3] = tmp_E[2];
E[4] = tmp_E[3];
d_free1(tmp_E,stp+1);
d_free2(tmp_mat,stp,stp);
#else
bisec(alpha,beta,stp,E,4,eps_Bisec);
#endif
ebefor=E[Target];
childfopenMPI(sdt_2,"w", &fp);
#ifdef lapack
fprintf(stdoutMPI, " stp = %d %.10lf %.10lf xxxxxxxxxx xxxxxxxxx xxxxxxxxx \n",stp,E[1],E[2]);
fprintf(fp, "LanczosStep E[1] E[2] E[3] E[4] E_Max/Nsite\n");
fprintf(fp, "stp = %d %.10lf %.10lf xxxxxxxxxx xxxxxxxxx xxxxxxxxx \n",stp,E[1],E[2]);
#else
fprintf(stdoutMPI, " stp = %d %.10lf %.10lf xxxxxxxxxx xxxxxxxxx \n",stp,E[1],E[2]);
fprintf(fp, "LanczosStep E[1] E[2] E[3] E[4] \n");
fprintf(fp,"stp = %d %.10lf %.10lf xxxxxxxxxx xxxxxxxxx \n",stp,E[1],E[2]);
#endif
fclose(fp);
}
if(stp>2 && stp%2==0){
childfopenMPI(sdt_2,"a", &fp);
#ifdef lapack
d_malloc2(tmp_mat,stp,stp);
d_malloc1(tmp_E,stp+1);
for(int_i=0;int_i<stp;int_i++){
for(int_j=0;int_j<stp;int_j++){
tmp_mat[int_i][int_j] = 0.0;
}
}
tmp_mat[0][0] = alpha[1];
tmp_mat[0][1] = beta[1];
for(int_i=1;int_i<stp-1;int_i++){
tmp_mat[int_i][int_i] = alpha[int_i+1];
tmp_mat[int_i][int_i+1] = beta[int_i+1];
tmp_mat[int_i][int_i-1] = beta[int_i];
}
tmp_mat[int_i][int_i] = alpha[int_i+1];
tmp_mat[int_i][int_i-1] = beta[int_i];
DSEVvalue(stp,tmp_mat,tmp_E);
E[1] = tmp_E[0];
E[2] = tmp_E[1];
E[3] = tmp_E[2];
E[4] = tmp_E[3];
E[0] = tmp_E[stp-1];
d_free1(tmp_E,stp+1);
d_free2(tmp_mat,stp,stp);
fprintf(stdoutMPI, " stp = %d %.10lf %.10lf %.10lf %.10lf %.10lf\n",stp,E[1],E[2],E[3],E[4],E[0]/(double)X->Def.NsiteMPI);
fprintf(fp,"stp=%d %.10lf %.10lf %.10lf %.10lf %.10lf\n",stp,E[1],E[2],E[3],E[4],E[0]/(double)X->Def.NsiteMPI);
#else
bisec(alpha,beta,stp,E,4,eps_Bisec);
fprintf(stdoutMPI, " stp = %d %.10lf %.10lf %.10lf %.10lf \n",stp,E[1],E[2],E[3],E[4]);
fprintf(fp,"stp=%d %.10lf %.10lf %.10lf %.10lf\n",stp,E[1],E[2],E[3],E[4]);
#endif
fclose(fp);
if(fabs((E[Target]-ebefor)/E[Target])<eps_Lanczos || fabs(beta[stp])<pow(10.0, -14)){
vec12(alpha,beta,stp,E,X);
X->Large.itr=stp;
X->Phys.Target_energy=E[k_exct];
iconv=0;
break;
}
ebefor=E[Target];
}
}
}
sprintf(sdt,cFileNameTimeKeep,X->Def.CDataFileHead);
if(iconv!=0){
sprintf(sdt, cLogLanczos_EigenValueNotConverged);
return -1;
}
TimeKeeper(X, cFileNameTimeKeep, cLanczos_EigenValueFinish, "a");
fprintf(stdoutMPI, "%s", cLogLanczos_EigenValueEnd);
return 0;
}
/**
* @brief Parent function to calculate two-body green's functions
*
* @param X data list for calculation
* @param vec eigenvectors
*
* @retval 0 normally finished
* @retval -1 unnormally finished
* @note the origin of function's name cisajscktalt comes from c=creation, i=ith site, s=spin, a=annihiration, j=jth site and so on.
*
* @version 0.2
* @details add function to treat the case of general spin
*
* @version 0.1
* @author Takahiro Misawa (The University of Tokyo)
* @author Kazuyoshi Yoshimi (The University of Tokyo)
*/
int expec_cisajscktaltdc
(
struct BindStruct *X,
double complex *vec
)
{
FILE *fp;
char sdt[D_FileNameMax];
long unsigned int i,j;
long unsigned int irght,ilft,ihfbit;
long unsigned int isite1,isite2,isite3,isite4;
long unsigned int org_isite1,org_isite2,org_isite3,org_isite4;
long unsigned int org_sigma1,org_sigma2,org_sigma3,org_sigma4;
long unsigned int tmp_org_isite1,tmp_org_isite2,tmp_org_isite3,tmp_org_isite4;
long unsigned int tmp_org_sigma1,tmp_org_sigma2,tmp_org_sigma3,tmp_org_sigma4;
long unsigned int isA_up, isB_up;
long unsigned int is1_up, is2_up;
long unsigned int Asum,Bsum,Adiff,Bdiff;
long unsigned int tmp_off=0;
long unsigned int tmp_off_2=0;
long unsigned int list1_off=0;
int tmp_sgn, num1, num2;
double complex tmp_V;
double complex dam_pr;
long int i_max;
//For TPQ
int step=0;
int rand_i=0;
//For Kond
double complex dmv;
if(X->Def.NCisAjtCkuAlvDC <1) return 0;
i_max=X->Check.idim_max;
X->Large.mode=M_CORR;
tmp_V = 1.0+0.0*I;
if(GetSplitBitByModel(X->Def.Nsite, X->Def.iCalcModel, &irght, &ilft, &ihfbit)!=0) {
return -1;
}
dam_pr=0.0;
//Make File Name for output
switch (X->Def.iCalcType) {
case Lanczos:
if(X->Def.St==0) {
sprintf(sdt, cFileName2BGreen_Lanczos, X->Def.CDataFileHead);
TimeKeeper(X, cFileNameTimeKeep, cLanczosExpecTwoBodyGStart,"a");
fprintf(stdoutMPI, "%s", cLogLanczosExpecTwoBodyGStart);
} else if(X->Def.St==1) {
sprintf(sdt, cFileName2BGreen_CG, X->Def.CDataFileHead);
TimeKeeper(X, cFileNameTimeKeep, cCGExpecTwoBodyGStart,"a");
fprintf(stdoutMPI, "%s", cLogLanczosExpecTwoBodyGStart);
}
break;
case TPQCalc:
step=X->Def.istep;
rand_i=X->Def.irand;
TimeKeeperWithRandAndStep(X, cFileNameTimeKeep, cTPQExpecTwoBodyGStart, "a", rand_i, step);
sprintf(sdt, cFileName2BGreen_TPQ, X->Def.CDataFileHead, rand_i, step);
break;
case FullDiag:
sprintf(sdt, cFileName2BGreen_FullDiag, X->Def.CDataFileHead, X->Phys.eigen_num);
break;
}
if(!childfopenMPI(sdt, "w", &fp)==0) {
return -1;
}
switch(X->Def.iCalcModel) {
case HubbardGC:
for(i=0; i<X->Def.NCisAjtCkuAlvDC; i++) {
org_isite1 = X->Def.CisAjtCkuAlvDC[i][0]+1;
org_sigma1 = X->Def.CisAjtCkuAlvDC[i][1];
org_isite2 = X->Def.CisAjtCkuAlvDC[i][2]+1;
org_sigma2 = X->Def.CisAjtCkuAlvDC[i][3];
org_isite3 = X->Def.CisAjtCkuAlvDC[i][4]+1;
org_sigma3 = X->Def.CisAjtCkuAlvDC[i][5];
org_isite4 = X->Def.CisAjtCkuAlvDC[i][6]+1;
org_sigma4 = X->Def.CisAjtCkuAlvDC[i][7];
dam_pr=0.0;
if(CheckPE(org_isite1-1, X)==TRUE || CheckPE(org_isite2-1, X)==TRUE ||
CheckPE(org_isite3-1, X)==TRUE || CheckPE(org_isite4-1, X)==TRUE) {
isite1 = X->Def.OrgTpow[2*org_isite1-2+org_sigma1] ;
isite2 = X->Def.OrgTpow[2*org_isite2-2+org_sigma2] ;
isite3 = X->Def.OrgTpow[2*org_isite3-2+org_sigma3] ;
isite4 = X->Def.OrgTpow[2*org_isite4-2+org_sigma4] ;
if(isite1 == isite2 && isite3 == isite4) {
dam_pr = X_GC_child_CisAisCjtAjt_Hubbard_MPI(org_isite1-1, org_sigma1,
org_isite3-1, org_sigma3,
1.0, X, vec, vec);
}
else if(isite1 == isite2 && isite3 != isite4) {
dam_pr = X_GC_child_CisAisCjtAku_Hubbard_MPI(org_isite1-1, org_sigma1,
org_isite3-1, org_sigma3, org_isite4-1, org_sigma4,
1.0, X, vec, vec);
}
else if(isite1 != isite2 && isite3 == isite4) {
dam_pr = X_GC_child_CisAjtCkuAku_Hubbard_MPI(org_isite1-1, org_sigma1, org_isite2-1, org_sigma2,
org_isite3-1, org_sigma3,
1.0, X, vec, vec);
}
else if(isite1 != isite2 && isite3 != isite4) {
dam_pr = X_GC_child_CisAjtCkuAlv_Hubbard_MPI(org_isite1-1, org_sigma1, org_isite2-1, org_sigma2,
org_isite3-1, org_sigma3, org_isite4-1, org_sigma4,
1.0, X, vec, vec);
}
}//InterPE
else {
child_general_int_GetInfo
(
i,
X,
org_isite1,
org_isite2,
org_isite3,
org_isite4,
org_sigma1,
org_sigma2,
org_sigma3,
org_sigma4,
tmp_V
);
i_max = X->Large.i_max;
isite1 = X->Large.is1_spin;
isite2 = X->Large.is2_spin;
Asum = X->Large.isA_spin;
Adiff = X->Large.A_spin;
isite3 = X->Large.is3_spin;
isite4 = X->Large.is4_spin;
Bsum = X->Large.isB_spin;
Bdiff = X->Large.B_spin;
if(isite1 == isite2 && isite3 == isite4) {
dam_pr = 0.0;
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, tmp_sgn, dmv) firstprivate(i_max,X,isite1,isite2,isite4,isite3,Asum,Bsum,Adiff,Bdiff,tmp_off,tmp_off_2,tmp_V) shared(vec)
for(j=1; j<=i_max; j++) {
dam_pr += GC_child_CisAisCisAis_element(j, isite1, isite3, tmp_V, vec, vec, X, &tmp_off);
}
} else if(isite1 == isite2 && isite3 != isite4) {
dam_pr = 0.0;
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, tmp_sgn, dmv) firstprivate(i_max,X,isite1,isite2,isite4,isite3,Asum,Bsum,Adiff,Bdiff,tmp_off,tmp_off_2,tmp_V) shared(vec)
for(j=1; j<=i_max; j++) {
dam_pr += GC_child_CisAisCjtAku_element(j, isite1, isite3, isite4, Bsum, Bdiff, tmp_V, vec, vec, X, &tmp_off);
}
} else if(isite1 != isite2 && isite3 == isite4) {
dam_pr = 0.0;
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, tmp_sgn, dmv) firstprivate(i_max,X,isite1,isite2,isite4,isite3,Asum,Bsum,Adiff,Bdiff,tmp_off,tmp_off_2,tmp_V) shared(vec)
for(j=1; j<=i_max; j++) {
dam_pr +=GC_child_CisAjtCkuAku_element(j, isite1, isite2, isite3, Asum, Adiff, tmp_V, vec, vec, X, &tmp_off);
}
} else if(isite1 != isite2 && isite3 != isite4) {
dam_pr = 0.0;
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, tmp_sgn, dmv) firstprivate(i_max,X,isite1,isite2,isite4,isite3,Asum,Bsum,Adiff,Bdiff,tmp_off,tmp_off_2,tmp_V) shared(vec)
for(j=1; j<=i_max; j++) {
dam_pr +=GC_child_CisAjtCkuAlv_element(j, isite1, isite2, isite3, isite4, Asum, Adiff, Bsum, Bdiff, tmp_V, vec, vec, X, &tmp_off_2);
}
}
}
dam_pr = SumMPI_dc(dam_pr);
fprintf(fp," %4ld %4ld %4ld %4ld %4ld %4ld %4ld %4ld %.10lf %.10lf\n",org_isite1-1,org_sigma1, org_isite2-1,org_sigma2, org_isite3-1, org_sigma3, org_isite4-1,org_sigma4, creal(dam_pr), cimag(dam_pr));
}//Intra PE
break;
case KondoGC:
case Hubbard:
case Kondo:
for(i=0; i<X->Def.NCisAjtCkuAlvDC; i++) {
org_isite1 = X->Def.CisAjtCkuAlvDC[i][0]+1;
org_sigma1 = X->Def.CisAjtCkuAlvDC[i][1];
org_isite2 = X->Def.CisAjtCkuAlvDC[i][2]+1;
org_sigma2 = X->Def.CisAjtCkuAlvDC[i][3];
org_isite3 = X->Def.CisAjtCkuAlvDC[i][4]+1;
org_sigma3 = X->Def.CisAjtCkuAlvDC[i][5];
org_isite4 = X->Def.CisAjtCkuAlvDC[i][6]+1;
org_sigma4 = X->Def.CisAjtCkuAlvDC[i][7];
tmp_V = 1.0;
dam_pr=0.0;
if(X->Def.iFlgSzConserved ==TRUE) {
if(org_sigma1+org_sigma3 != org_sigma2+org_sigma4) {
dam_pr=SumMPI_dc(dam_pr);
fprintf(fp," %4ld %4ld %4ld %4ld %4ld %4ld %4ld %4ld %.10lf %.10lf \n",org_isite1-1, org_sigma1, org_isite2-1, org_sigma2, org_isite3-1, org_sigma3, org_isite4-1, org_sigma4, creal(dam_pr), cimag(dam_pr));
continue;
}
}
if(CheckPE(org_isite1-1, X)==TRUE || CheckPE(org_isite2-1, X)==TRUE ||
CheckPE(org_isite3-1, X)==TRUE || CheckPE(org_isite4-1, X)==TRUE) {
isite1 = X->Def.OrgTpow[2*org_isite1-2+org_sigma1] ;
isite2 = X->Def.OrgTpow[2*org_isite2-2+org_sigma2] ;
isite3 = X->Def.OrgTpow[2*org_isite3-2+org_sigma3] ;
isite4 = X->Def.OrgTpow[2*org_isite4-2+org_sigma4] ;
if(isite1 == isite2 && isite3 == isite4) {
dam_pr = X_child_CisAisCjtAjt_Hubbard_MPI(org_isite1-1, org_sigma1,
org_isite3-1, org_sigma3,
1.0, X, vec, vec);
}
else if(isite1 == isite2 && isite3 != isite4) {
dam_pr = X_child_CisAisCjtAku_Hubbard_MPI(org_isite1-1, org_sigma1,
org_isite3-1, org_sigma3, org_isite4-1, org_sigma4,
1.0, X, vec, vec);
}
else if(isite1 != isite2 && isite3 == isite4) {
dam_pr = X_child_CisAjtCkuAku_Hubbard_MPI(org_isite1-1, org_sigma1, org_isite2-1, org_sigma2,
org_isite3-1, org_sigma3,
1.0, X, vec, vec);
}
else if(isite1 != isite2 && isite3 != isite4) {
dam_pr = X_child_CisAjtCkuAlv_Hubbard_MPI(org_isite1-1, org_sigma1, org_isite2-1, org_sigma2,
org_isite3-1, org_sigma3, org_isite4-1, org_sigma4,
1.0, X, vec, vec);
}
}//InterPE
else {
child_general_int_GetInfo(
i,
X,
org_isite1,
org_isite2,
org_isite3,
org_isite4,
org_sigma1,
org_sigma2,
org_sigma3,
org_sigma4,
tmp_V
);
i_max = X->Large.i_max;
isite1 = X->Large.is1_spin;
isite2 = X->Large.is2_spin;
Asum = X->Large.isA_spin;
Adiff = X->Large.A_spin;
isite3 = X->Large.is3_spin;
isite4 = X->Large.is4_spin;
Bsum = X->Large.isB_spin;
Bdiff = X->Large.B_spin;
tmp_V = 1.0;
dam_pr = 0.0;
if(isite1 == isite2 && isite3 == isite4) {
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, tmp_sgn, dmv) firstprivate(i_max,X,isite1,isite2,isite4,isite3,Asum,Bsum,Adiff,Bdiff,tmp_off,tmp_off_2) shared(vec,tmp_V)
for(j=1; j<=i_max; j++) {
dam_pr += child_CisAisCisAis_element(j, isite1, isite3, tmp_V, vec, vec, X, &tmp_off);
}
} else if(isite1 == isite2 && isite3 != isite4) {
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, tmp_sgn, dmv) firstprivate(i_max,X,isite1,isite2,isite4,isite3,Asum,Bsum,Adiff,Bdiff,tmp_off,tmp_off_2) shared(vec,tmp_V)
for(j=1; j<=i_max; j++) {
dam_pr += child_CisAisCjtAku_element(j, isite1, isite3, isite4, Bsum, Bdiff, tmp_V, vec, vec, X, &tmp_off);
}
} else if(isite1 != isite2 && isite3 == isite4) {
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, tmp_sgn, dmv) firstprivate(i_max,X,isite1,isite2,isite4,isite3,Asum,Bsum,Adiff,Bdiff,tmp_off,tmp_off_2) shared(vec,tmp_V)
for(j=1; j<=i_max; j++) {
dam_pr +=child_CisAjtCkuAku_element(j, isite1, isite2, isite3, Asum, Adiff, tmp_V, vec, vec, X, &tmp_off);
}
} else if(isite1 != isite2 && isite3 != isite4) {
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, tmp_sgn, dmv) firstprivate(i_max,X,isite1,isite2,isite4,isite3,Asum,Bsum,Adiff,Bdiff,tmp_off,tmp_off_2) shared(vec,tmp_V)
for(j=1; j<=i_max; j++) {
dam_pr +=child_CisAjtCkuAlv_element(j, isite1, isite2, isite3, isite4, Asum, Adiff, Bsum, Bdiff, tmp_V, vec, vec, X, &tmp_off_2);
}
}
}
dam_pr = SumMPI_dc(dam_pr);
fprintf(fp," %4ld %4ld %4ld %4ld %4ld %4ld %4ld %4ld %.10lf %.10lf\n",org_isite1-1,org_sigma1, org_isite2-1,org_sigma2, org_isite3-1, org_sigma3, org_isite4-1,org_sigma4, creal(dam_pr), cimag(dam_pr));
}
break;
case Spin:
if(X->Def.iFlgGeneralSpin==FALSE) {
for(i=0; i<X->Def.NCisAjtCkuAlvDC; i++) {
tmp_org_isite1 = X->Def.CisAjtCkuAlvDC[i][0]+1;
tmp_org_sigma1 = X->Def.CisAjtCkuAlvDC[i][1];
tmp_org_isite2 = X->Def.CisAjtCkuAlvDC[i][2]+1;
tmp_org_sigma2 = X->Def.CisAjtCkuAlvDC[i][3];
tmp_org_isite3 = X->Def.CisAjtCkuAlvDC[i][4]+1;
tmp_org_sigma3 = X->Def.CisAjtCkuAlvDC[i][5];
tmp_org_isite4 = X->Def.CisAjtCkuAlvDC[i][6]+1;
tmp_org_sigma4 = X->Def.CisAjtCkuAlvDC[i][7];
if(Rearray_Interactions(i, &org_isite1, &org_isite2, &org_isite3, &org_isite4, &org_sigma1, &org_sigma2, &org_sigma3, &org_sigma4, &tmp_V, X)!=0) {
//error message will be added
fprintf(fp," %4ld %4ld %4ld %4ld %4ld %4ld %4ld %4ld %.10lf %.10lf \n",tmp_org_isite1-1, tmp_org_sigma1, tmp_org_isite2-1, tmp_org_sigma2, tmp_org_isite3-1,tmp_org_sigma3, tmp_org_isite4-1, tmp_org_sigma4,0.0,0.0);
continue;
}
dam_pr = 0.0;
if(org_isite1 >X->Def.Nsite && org_isite3>X->Def.Nsite) {
if(org_sigma1==org_sigma2 && org_sigma3==org_sigma4 ) { //diagonal
is1_up = X->Def.Tpow[org_isite1 - 1];
is2_up = X->Def.Tpow[org_isite3 - 1];
num1 = X_SpinGC_CisAis((unsigned long int)myrank + 1, X, is1_up, org_sigma1);
num2 = X_SpinGC_CisAis((unsigned long int)myrank + 1, X, is2_up, org_sigma3);
#pragma omp parallel for default(none) reduction (+:dam_pr) shared(vec) \
firstprivate(i_max, num1, num2, tmp_V) private(j)
for (j = 1; j <= i_max; j++) {
dam_pr += tmp_V*num1*num2*vec[j]*conj(vec[j]);
}
}
else if(org_isite1==org_isite3 && org_sigma1==org_sigma4 && org_sigma2==org_sigma3) {
is1_up = X->Def.Tpow[org_isite1 - 1];
num1 = X_SpinGC_CisAis((unsigned long int)myrank + 1, X, is1_up, org_sigma1);
#pragma omp parallel for default(none) reduction (+:dam_pr) shared(vec) \
firstprivate(i_max, num1, num2, tmp_V) private(j)
for (j = 1; j <= i_max; j++) {
dam_pr += tmp_V*num1*vec[j]*conj(vec[j]);
}
}
else if(org_sigma1==org_sigma4 && org_sigma2==org_sigma3) { //exchange
dam_pr += X_child_general_int_spin_MPIdouble(org_isite1-1, org_sigma1, org_sigma2, org_isite3-1, org_sigma3, org_sigma4, tmp_V, X, vec, vec);
}
else { // other process is not allowed
// error message will be added
}
}
else if(org_isite1 > X->Def.Nsite || org_isite3>X->Def.Nsite) {
if(org_sigma1==org_sigma2 && org_sigma3==org_sigma4 ) { //diagonal
is1_up = X->Def.Tpow[org_isite1 - 1];
is2_up = X->Def.Tpow[org_isite3 - 1];
num2 = X_SpinGC_CisAis((unsigned long int)myrank + 1, X, is2_up, org_sigma3);
dam_pr=0.0;
#pragma omp parallel for default(none) reduction(+:dam_pr)shared(vec) \
firstprivate(i_max, tmp_V, is1_up, org_sigma1, X, num2) private(j, num1)
for (j = 1; j <= i_max; j++) {
num1 = X_Spin_CisAis(j, X, is1_up, org_sigma1);
dam_pr += tmp_V*num1*num2*conj(vec[j])*vec[j];
}
}
else if(org_sigma1==org_sigma4 && org_sigma2==org_sigma3) { //exchange
dam_pr += X_child_general_int_spin_MPIsingle(org_isite1-1, org_sigma1, org_sigma2, org_isite3-1, org_sigma3, org_sigma4, tmp_V, X, vec, vec);
}
else { // other process is not allowed
// error message will be added
dam_pr=0.0;
}
}
else {
isA_up = X->Def.Tpow[org_isite1-1];
isB_up = X->Def.Tpow[org_isite3-1];
if(org_sigma1==org_sigma2 && org_sigma3==org_sigma4 ) { //diagonal
dam_pr = 0.0;
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j) firstprivate(i_max,X,isA_up,isB_up,org_sigma2,org_sigma4,tmp_off,tmp_off_2, tmp_V) shared(vec)
for(j=1; j<=i_max; j++) {
dam_pr +=child_CisAisCisAis_spin_element(j, isA_up, isB_up, org_sigma2, org_sigma4, tmp_V, vec, vec, X);
}
} else if(org_isite1==org_isite3 && org_sigma1==org_sigma4 && org_sigma3==org_sigma2) {
dam_pr = 0.0;
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, dmv) firstprivate(i_max,X,isA_up, tmp_V) shared(vec, list_1)
for(j=1; j<=i_max; j++) {
dmv=X_CisAis(list_1[j], X, isA_up);
dam_pr += vec[j]*tmp_V*dmv*conj(vec[j]);
}
}
else if(org_sigma1==org_sigma4 && org_sigma2==org_sigma3) { // exchange
dam_pr = 0.0;
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, tmp_sgn, dmv) firstprivate(i_max,X,isA_up,isB_up,org_sigma2,org_sigma4,tmp_off,tmp_off_2,tmp_V) shared(vec)
for(j=1; j<=i_max; j++) {
tmp_sgn = X_child_exchange_spin_element(j,X,isA_up,isB_up,org_sigma2,org_sigma4,&tmp_off);
dmv = vec[j]*tmp_sgn;
dam_pr += conj(vec[tmp_off])*dmv;
}
} else { // other process is not allowed
// error message will be added
dam_pr=0.0;
}
}
dam_pr = SumMPI_dc(dam_pr);
fprintf(fp," %4ld %4ld %4ld %4ld %4ld %4ld %4ld %4ld %.10lf %.10lf \n",tmp_org_isite1-1, tmp_org_sigma1, tmp_org_isite2-1, tmp_org_sigma2, tmp_org_isite3-1, tmp_org_sigma3, tmp_org_isite4-1, tmp_org_sigma4,creal(dam_pr),cimag(dam_pr));
}
}//iFlgGeneralSpin = FALSE
else {
for(i=0; i<X->Def.NCisAjtCkuAlvDC; i++) {
tmp_org_isite1 = X->Def.CisAjtCkuAlvDC[i][0]+1;
tmp_org_sigma1 = X->Def.CisAjtCkuAlvDC[i][1];
tmp_org_isite2 = X->Def.CisAjtCkuAlvDC[i][2]+1;
tmp_org_sigma2 = X->Def.CisAjtCkuAlvDC[i][3];
tmp_org_isite3 = X->Def.CisAjtCkuAlvDC[i][4]+1;
tmp_org_sigma3 = X->Def.CisAjtCkuAlvDC[i][5];
tmp_org_isite4 = X->Def.CisAjtCkuAlvDC[i][6]+1;
tmp_org_sigma4 = X->Def.CisAjtCkuAlvDC[i][7];
if(Rearray_Interactions(i, &org_isite1, &org_isite2, &org_isite3, &org_isite4, &org_sigma1, &org_sigma2, &org_sigma3, &org_sigma4, &tmp_V, X)!=0) {
fprintf(fp," %4ld %4ld %4ld %4ld %4ld %4ld %4ld %4ld %.10lf %.10lf \n",tmp_org_isite1-1, tmp_org_sigma1, tmp_org_isite2-1, tmp_org_sigma2, tmp_org_isite3-1,tmp_org_sigma3, tmp_org_isite4-1, tmp_org_sigma4,0.0,0.0);
continue;
}
dam_pr = 0.0;
if(org_isite1 >X->Def.Nsite && org_isite3>X->Def.Nsite) {
if(org_sigma1==org_sigma2 && org_sigma3==org_sigma4 ) { //diagonal
dam_pr=X_child_CisAisCjuAju_GeneralSpin_MPIdouble(org_isite1-1, org_sigma1, org_isite3-1, org_sigma3, tmp_V, X, vec, vec);
}
else if(org_sigma1 != org_sigma2 && org_sigma3 != org_sigma4) {
dam_pr=X_child_CisAitCjuAjv_GeneralSpin_MPIdouble(org_isite1-1, org_sigma1, org_sigma2, org_isite3-1, org_sigma3, org_sigma4,tmp_V, X, vec, vec);
}
else {
dam_pr=0.0;
}
}
else if(org_isite3 > X->Def.Nsite || org_isite1 > X->Def.Nsite) {
if(org_sigma1==org_sigma2 && org_sigma3==org_sigma4 ) { //diagonal
dam_pr=X_child_CisAisCjuAju_GeneralSpin_MPIsingle(org_isite1-1, org_sigma1, org_isite3-1, org_sigma3, tmp_V, X, vec, vec);
}
else if(org_sigma1 != org_sigma2 && org_sigma3 != org_sigma4) {
dam_pr=X_child_CisAitCjuAjv_GeneralSpin_MPIsingle(org_isite1-1, org_sigma1, org_sigma2, org_isite3-1, org_sigma3, org_sigma4,tmp_V, X, vec, vec);
}
else {
dam_pr=0.0;
}
}
else {
if(org_sigma1==org_sigma2 && org_sigma3==org_sigma4 ) { //diagonal
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, num1) firstprivate(i_max,X,org_isite1, org_sigma1,org_isite3, org_sigma3, tmp_V) shared(vec,list_1)
for(j=1; j<=i_max; j++) {
num1=BitCheckGeneral(list_1[j], org_isite1, org_sigma1, X->Def.SiteToBit, X->Def.Tpow);
if(num1 != FALSE) {
num1=BitCheckGeneral(list_1[j], org_isite3, org_sigma3, X->Def.SiteToBit, X->Def.Tpow);
if(num1 != FALSE) {
dam_pr += tmp_V*conj(vec[j])*vec[j];
}
}
}
}
else if(org_sigma1 != org_sigma2 && org_sigma3 != org_sigma4) {
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, num1) firstprivate(i_max,X, org_isite1, org_isite3, org_sigma1, org_sigma2, org_sigma3, org_sigma4, tmp_off, tmp_off_2, list1_off, tmp_V) shared(vec, list_1)
for(j=1; j<=i_max; j++) {
num1 = num1*GetOffCompGeneralSpin(list_1[j], org_isite3, org_sigma4, org_sigma3, &tmp_off, X->Def.SiteToBit, X->Def.Tpow);
if(num1 != FALSE) {
num1 = GetOffCompGeneralSpin(tmp_off, org_isite1, org_sigma2, org_sigma1, &tmp_off_2, X->Def.SiteToBit, X->Def.Tpow);
ConvertToList1GeneralSpin(tmp_off_2, X->Check.sdim, &list1_off);
if(num1 != FALSE) {
dam_pr += tmp_V*conj(vec[list1_off])*vec[j];
}
}
}
}
else {
dam_pr=0.0;
}
}
dam_pr = SumMPI_dc(dam_pr);
fprintf(fp," %4ld %4ld %4ld %4ld %4ld %4ld %4ld %4ld %.10lf %.10lf \n",tmp_org_isite1-1, tmp_org_sigma1, tmp_org_isite2-1, tmp_org_sigma2, tmp_org_isite3-1, tmp_org_sigma3, tmp_org_isite4-1, tmp_org_sigma4, creal(dam_pr),cimag(dam_pr));
}
}
break;
case SpinGC:
if(X->Def.iFlgGeneralSpin==FALSE) {
for(i=0; i<X->Def.NCisAjtCkuAlvDC; i++) {
tmp_org_isite1 = X->Def.CisAjtCkuAlvDC[i][0]+1;
tmp_org_sigma1 = X->Def.CisAjtCkuAlvDC[i][1];
tmp_org_isite2 = X->Def.CisAjtCkuAlvDC[i][2]+1;
tmp_org_sigma2 = X->Def.CisAjtCkuAlvDC[i][3];
tmp_org_isite3 = X->Def.CisAjtCkuAlvDC[i][4]+1;
tmp_org_sigma3 = X->Def.CisAjtCkuAlvDC[i][5];
tmp_org_isite4 = X->Def.CisAjtCkuAlvDC[i][6]+1;
tmp_org_sigma4 = X->Def.CisAjtCkuAlvDC[i][7];
if(Rearray_Interactions(i, &org_isite1, &org_isite2, &org_isite3, &org_isite4, &org_sigma1, &org_sigma2, &org_sigma3, &org_sigma4, &tmp_V, X)!=0) {
//error message will be added
fprintf(fp," %4ld %4ld %4ld %4ld %4ld %4ld %4ld %4ld %.10lf %.10lf \n",tmp_org_isite1-1, tmp_org_sigma1, tmp_org_isite2-1, tmp_org_sigma2, tmp_org_isite3-1,tmp_org_sigma3, tmp_org_isite4-1, tmp_org_sigma4,0.0,0.0);
continue;
}
dam_pr=0.0;
if(org_isite1>X->Def.Nsite && org_isite3>X->Def.Nsite) { //org_isite3 >= org_isite1 > Nsite
if(org_sigma1==org_sigma2 && org_sigma3==org_sigma4 ) { //diagonal
dam_pr += X_GC_child_CisAisCjuAju_spin_MPIdouble( (org_isite1-1), org_sigma1, (org_isite3-1), org_sigma3, tmp_V, X, vec, vec);
}
else if(org_isite1 ==org_isite3 && org_sigma1 ==org_sigma4 && org_sigma2 ==org_sigma3) { //diagonal (for spin: cuadcdau=cuau)
dam_pr += X_GC_child_CisAis_spin_MPIdouble((org_isite1-1), org_sigma1, tmp_V, X, vec, vec);
}
else if(org_sigma1 == org_sigma2 && org_sigma3 != org_sigma4) {
dam_pr += X_GC_child_CisAisCjuAjv_spin_MPIdouble(org_isite1-1, org_sigma1, org_isite3-1, org_sigma3, org_sigma4, tmp_V, X, vec, vec);
}
else if(org_sigma1 != org_sigma2 && org_sigma3 == org_sigma4) {
dam_pr += X_GC_child_CisAitCjuAju_spin_MPIdouble(org_isite1-1, org_sigma1, org_sigma2, org_isite3-1, org_sigma3, tmp_V, X, vec, vec);
}
else if(org_sigma1 != org_sigma2 && org_sigma3 != org_sigma4) {
dam_pr += X_GC_child_CisAitCiuAiv_spin_MPIdouble(org_isite1-1, org_sigma1, org_sigma2, org_isite3-1, org_sigma3, org_sigma4, tmp_V, X, vec, vec);
}
}
else if(org_isite3>X->Def.Nsite || org_isite1>X->Def.Nsite) { //org_isite3 > Nsite >= org_isite1
if(org_sigma1==org_sigma2 && org_sigma3==org_sigma4 ) { //diagonal
dam_pr += X_GC_child_CisAisCjuAju_spin_MPIsingle( (org_isite1-1), org_sigma1, (org_isite3-1), org_sigma3, tmp_V, X, vec, vec);
}
else if(org_sigma1 == org_sigma2 && org_sigma3 != org_sigma4) {
dam_pr += X_GC_child_CisAisCjuAjv_spin_MPIsingle(org_isite1-1, org_sigma1, org_isite3-1, org_sigma3, org_sigma4, tmp_V, X, vec, vec);
}
else if(org_sigma1 != org_sigma2 && org_sigma3 == org_sigma4) {
dam_pr += X_GC_child_CisAitCjuAju_spin_MPIsingle(org_isite1-1, org_sigma1, org_sigma2, org_isite3-1, org_sigma3, tmp_V, X, vec, vec);
}
else if(org_sigma1 != org_sigma2 && org_sigma3 != org_sigma4) {
dam_pr += X_GC_child_CisAitCiuAiv_spin_MPIsingle(org_isite1-1, org_sigma1, org_sigma2, org_isite3-1, org_sigma3, org_sigma4, tmp_V, X, vec, vec);
}
}
else {
if(org_isite1==org_isite2 && org_isite3==org_isite4) {
isA_up = X->Def.Tpow[org_isite2-1];
isB_up = X->Def.Tpow[org_isite4-1];
if(org_sigma1==org_sigma2 && org_sigma3==org_sigma4 ) { //diagonal
dam_pr = 0.0;
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, tmp_sgn, dmv) firstprivate(i_max,X,isA_up,isB_up,org_sigma2,org_sigma4,tmp_off,tmp_off_2,tmp_V) shared(vec)
for(j=1; j<=i_max; j++) {
dam_pr +=GC_child_CisAisCisAis_spin_element(j, isA_up, isB_up, org_sigma2, org_sigma4, tmp_V, vec, vec, X);
}
} else if(org_sigma1 == org_sigma2 && org_sigma3 != org_sigma4) {
dam_pr = 0.0;
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, tmp_sgn, dmv) firstprivate(i_max,X,isA_up,isB_up,org_sigma2,org_sigma4,tmp_off,tmp_off_2,tmp_V) shared(vec)
for(j=1; j<=i_max; j++) {
dam_pr += GC_child_CisAisCitAiu_spin_element(j, org_sigma2, org_sigma4, isA_up, isB_up, tmp_V, vec, vec, X, &tmp_off);
}
} else if(org_sigma1 != org_sigma2 && org_sigma3 == org_sigma4) {
dam_pr = 0.0;
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, tmp_sgn, dmv) firstprivate(i_max,X,isA_up,isB_up,org_sigma2,org_sigma4,tmp_off,tmp_off_2,tmp_V) shared(vec)
for(j=1; j<=i_max; j++) {
dam_pr += GC_child_CisAitCiuAiu_spin_element(j, org_sigma2, org_sigma4, isA_up, isB_up, tmp_V, vec, vec, X, &tmp_off);
}
} else if(org_sigma1 != org_sigma2 && org_sigma3 != org_sigma4) {
dam_pr = 0.0;
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, tmp_sgn, dmv) firstprivate(i_max,X,isA_up,isB_up,org_sigma2,org_sigma4,tmp_off,tmp_off_2,tmp_V) shared(vec)
for(j=1; j<=i_max; j++) {
dam_pr += GC_child_CisAitCiuAiv_spin_element(j, org_sigma2, org_sigma4, isA_up, isB_up, tmp_V, vec, vec, X, &tmp_off);
}
}
}
}
dam_pr = SumMPI_dc(dam_pr);
fprintf(fp," %4ld %4ld %4ld %4ld %4ld %4ld %4ld %4ld %.10lf %.10lf \n",tmp_org_isite1-1, tmp_org_sigma1, tmp_org_isite2-1, tmp_org_sigma2, tmp_org_isite3-1, tmp_org_sigma3, tmp_org_isite4-1, tmp_org_sigma4,creal(dam_pr),cimag(dam_pr));
}
}
else {
for(i=0; i<X->Def.NCisAjtCkuAlvDC; i++) {
tmp_org_isite1 = X->Def.CisAjtCkuAlvDC[i][0]+1;
tmp_org_sigma1 = X->Def.CisAjtCkuAlvDC[i][1];
tmp_org_isite2 = X->Def.CisAjtCkuAlvDC[i][2]+1;
tmp_org_sigma2 = X->Def.CisAjtCkuAlvDC[i][3];
tmp_org_isite3 = X->Def.CisAjtCkuAlvDC[i][4]+1;
tmp_org_sigma3 = X->Def.CisAjtCkuAlvDC[i][5];
tmp_org_isite4 = X->Def.CisAjtCkuAlvDC[i][6]+1;
tmp_org_sigma4 = X->Def.CisAjtCkuAlvDC[i][7];
if(Rearray_Interactions(i, &org_isite1, &org_isite2, &org_isite3, &org_isite4, &org_sigma1, &org_sigma2, &org_sigma3, &org_sigma4, &tmp_V, X)!=0) {
//error message will be added
fprintf(fp," %4ld %4ld %4ld %4ld %4ld %4ld %4ld %4ld %.10lf %.10lf \n",tmp_org_isite1-1, tmp_org_sigma1, tmp_org_isite2-1, tmp_org_sigma2, tmp_org_isite3-1,tmp_org_sigma3, tmp_org_isite4-1, tmp_org_sigma4,0.0,0.0);
continue;
}
dam_pr = 0.0;
if(org_isite1 > X->Def.Nsite && org_isite3 > X->Def.Nsite) {
if(org_sigma1==org_sigma2 && org_sigma3==org_sigma4 ) { //diagonal
dam_pr=X_GC_child_CisAisCjuAju_GeneralSpin_MPIdouble(org_isite1-1, org_sigma1, org_isite3-1, org_sigma3, tmp_V, X, vec, vec);
}
else if(org_sigma1 == org_sigma2 && org_sigma3 != org_sigma4) {
dam_pr=X_GC_child_CisAisCjuAjv_GeneralSpin_MPIdouble(org_isite1-1, org_sigma1, org_isite3-1, org_sigma3, org_sigma4, tmp_V, X, vec, vec);
}
else if(org_sigma1 != org_sigma2 && org_sigma3 == org_sigma4) {
dam_pr=X_GC_child_CisAitCjuAju_GeneralSpin_MPIdouble(org_isite1-1, org_sigma1, org_sigma2, org_isite3-1, org_sigma3, tmp_V, X, vec, vec);
}
else if(org_sigma1 != org_sigma2 && org_sigma3 != org_sigma4) {
dam_pr=X_GC_child_CisAitCjuAjv_GeneralSpin_MPIdouble(org_isite1-1, org_sigma1, org_sigma2, org_isite3-1, org_sigma3, org_sigma4,tmp_V, X, vec, vec);
}
}
else if(org_isite3 > X->Def.Nsite || org_isite1 > X->Def.Nsite) {
if(org_sigma1==org_sigma2 && org_sigma3==org_sigma4 ) { //diagonal
dam_pr=X_GC_child_CisAisCjuAju_GeneralSpin_MPIsingle(org_isite1-1, org_sigma1, org_isite3-1, org_sigma3, tmp_V, X, vec, vec);
}
else if(org_sigma1 == org_sigma2 && org_sigma3 != org_sigma4) {
dam_pr=X_GC_child_CisAisCjuAjv_GeneralSpin_MPIsingle(org_isite1-1, org_sigma1, org_isite3-1, org_sigma3, org_sigma4, tmp_V, X, vec, vec);
}
else if(org_sigma1 != org_sigma2 && org_sigma3 == org_sigma4) {
dam_pr=X_GC_child_CisAitCjuAju_GeneralSpin_MPIsingle(org_isite1-1, org_sigma1, org_sigma2, org_isite3-1, org_sigma3, tmp_V, X, vec, vec);
}
else if(org_sigma1 != org_sigma2 && org_sigma3 != org_sigma4) {
dam_pr=X_GC_child_CisAitCjuAjv_GeneralSpin_MPIsingle(org_isite1-1, org_sigma1, org_sigma2, org_isite3-1, org_sigma3, org_sigma4,tmp_V, X, vec, vec);
}
}
else {
if(org_sigma1==org_sigma2 && org_sigma3==org_sigma4 ) { //diagonal
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, num1) firstprivate(i_max,X,org_isite1, org_sigma1,org_isite3, org_sigma3, tmp_V) shared(vec)
for(j=1; j<=i_max; j++) {
num1=BitCheckGeneral(j-1, org_isite1, org_sigma1, X->Def.SiteToBit, X->Def.Tpow);
if(num1 != FALSE) {
num1=BitCheckGeneral(j-1, org_isite3, org_sigma3, X->Def.SiteToBit, X->Def.Tpow);
if(num1 != FALSE) {
dam_pr += tmp_V*conj(vec[j])*vec[j];
}
}
}
} else if(org_sigma1 == org_sigma2 && org_sigma3 != org_sigma4) {
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, num1) firstprivate(i_max,X, org_isite1, org_isite3, org_sigma1,org_sigma3,org_sigma4, tmp_off, tmp_V) shared(vec)
for(j=1; j<=i_max; j++) {
num1 = GetOffCompGeneralSpin(j-1, org_isite3, org_sigma4, org_sigma3, &tmp_off, X->Def.SiteToBit, X->Def.Tpow);
if(num1 != FALSE) {
num1=BitCheckGeneral(tmp_off, org_isite1, org_sigma1, X->Def.SiteToBit, X->Def.Tpow);
if(num1 != FALSE) {
dam_pr += tmp_V*conj(vec[tmp_off+1])*vec[j];
}
}
}
} else if(org_sigma1 != org_sigma2 && org_sigma3 == org_sigma4) {
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, num1) firstprivate(i_max,X, org_isite1, org_isite3, org_sigma1,org_sigma2, org_sigma3, tmp_off, tmp_V) shared(vec)
for(j=1; j<=i_max; j++) {
num1 = BitCheckGeneral(j-1, org_isite3, org_sigma3, X->Def.SiteToBit, X->Def.Tpow);
if(num1 != FALSE) {
num1 = GetOffCompGeneralSpin(j-1, org_isite1, org_sigma2, org_sigma1, &tmp_off, X->Def.SiteToBit, X->Def.Tpow);
if(num1 != FALSE) {
dam_pr += tmp_V*conj(vec[tmp_off+1])*vec[j];
}
}
}
} else if(org_sigma1 != org_sigma2 && org_sigma3 != org_sigma4) {
#pragma omp parallel for default(none) reduction(+:dam_pr) private(j, num1) firstprivate(i_max,X, org_isite1, org_isite3, org_sigma1, org_sigma2, org_sigma3, org_sigma4, tmp_off, tmp_off_2, tmp_V) shared(vec)
for(j=1; j<=i_max; j++) {
num1 = GetOffCompGeneralSpin(j-1, org_isite3, org_sigma4, org_sigma3, &tmp_off, X->Def.SiteToBit, X->Def.Tpow);
if(num1 != FALSE) {
num1 = GetOffCompGeneralSpin(tmp_off, org_isite1, org_sigma2, org_sigma1, &tmp_off_2, X->Def.SiteToBit, X->Def.Tpow);
if(num1 != FALSE) {
dam_pr += tmp_V*conj(vec[tmp_off_2+1])*vec[j];
}
}
}
}
}
dam_pr = SumMPI_dc(dam_pr);
fprintf(fp," %4ld %4ld %4ld %4ld %4ld %4ld %4ld %4ld %.10lf %.10lf \n",tmp_org_isite1-1, tmp_org_sigma1, tmp_org_isite2-1, tmp_org_sigma2, tmp_org_isite3-1, tmp_org_sigma3, tmp_org_isite4-1, tmp_org_sigma4, creal(dam_pr),cimag(dam_pr));
}
}
break;
default:
return -1;
}
fclose(fp);
if(X->Def.iCalcType==Lanczos) {
if(X->Def.St==0) {
TimeKeeper(X, cFileNameTimeKeep, cLanczosExpecTwoBodyGFinish,"a");
fprintf(stdoutMPI, "%s", cLogLanczosExpecTwoBodyGFinish);
} else if(X->Def.St==1) {
TimeKeeper(X, cFileNameTimeKeep, cCGExpecTwoBodyGFinish,"a");
fprintf(stdoutMPI, "%s", cLogCGExpecTwoBodyGFinish);
}
}
else if(X->Def.iCalcType==TPQCalc) {
TimeKeeperWithRandAndStep(X, cFileNameTimeKeep, cTPQExpecTwoBodyGFinish, "a", rand_i, step);
}
//[s] this part will be added
/* For FullDiag, it is convinient to calculate the total spin for each vector.
Such functions will be added
if(X->Def.iCalcType==FullDiag){
if(X->Def.iCalcModel==Spin){
expec_cisajscktaltdc_alldiag_spin(X,vec);
}else if(X->Def.iCalcModel==Hubbard || X->Def.iCalcModel==Kondo){
expec_cisajscktaltdc_alldiag(X,vec);
}else{//
X->Phys.s2=0.0;
}
}
*/
//[e]
return 0;
}
/**
* @brief A program to check size of dimension for hirbert-space.
*
* @param[in,out] X Common data set used in HPhi.
*
* @retval TRUE normally finished
* @retval FALSE unnormally finished
* @retval MPIFALSE CheckMPI unormally finished
* @version 0.2
* @details add function of calculating hirbert space for canonical ensemble.
*
* @version 0.1
* @author Takahiro Misawa (The University of Tokyo)
* @author Kazuyoshi Yoshimi (The University of Tokyo)
*/
int check(struct BindStruct *X){
FILE *fp;
long unsigned int i,tmp_sdim;
int NLocSpn,NCond,Nup,Ndown;
long unsigned int u_tmp;
long unsigned int tmp;
long unsigned int Ns,comb_1,comb_2,comb_3,comb_sum, comb_up, comb_down;
int u_loc;
int mfint[7];
long int **comb;
long unsigned int idimmax=0;
long unsigned int idim=0;
long unsigned int isite=0;
int tmp_sz=0;
int iMinup=0;
int iAllup=X->Def.Ne;
/*
Set Site number per MPI process
*/
if(CheckMPI(X)!=TRUE){
return MPIFALSE;
}
Ns = X->Def.Nsite;
li_malloc2(comb, Ns+1,Ns+1);
//idim_max
switch(X->Def.iCalcModel){
case HubbardGC:
//comb_sum = 2^(2*Ns)=4^Ns
comb_sum = 1;
for(i=0;i<2*X->Def.Nsite;i++){
comb_sum= 2*comb_sum;
}
break;
case SpinGC:
//comb_sum = 2^(Ns)
comb_sum = 1;
if(X->Def.iFlgGeneralSpin ==FALSE){
for(i=0;i<X->Def.Nsite;i++){
comb_sum= 2*comb_sum;
}
}
else{
for(i=0; i<X->Def.Nsite;i++){
comb_sum=comb_sum*X->Def.SiteToBit[i];
}
}
break;
case Hubbard:
comb_up= Binomial(Ns, X->Def.Nup, comb, Ns);
comb_down= Binomial(Ns, X->Def.Ndown, comb, Ns);
comb_sum=comb_up*comb_down;
break;
case HubbardNConserved:
comb_sum=0;
if(X->Def.Ne > X->Def.Nsite){
iMinup = X->Def.Ne-X->Def.Nsite;
iAllup = X->Def.Nsite;
}
for(i=iMinup; i<= iAllup; i++){
comb_up= Binomial(Ns, i, comb, Ns);
comb_down= Binomial(Ns, X->Def.Ne-i, comb, Ns);
comb_sum +=comb_up*comb_down;
}
break;
case Kondo:
//idim_max
// calculation of dimension
// Nup = u_loc+u_cond
// Ndown = d_loc+d_cond
// NLocSpn = u_loc+d_loc
// Ncond = Nsite-NLocSpn
// idim_max = \sum_{u_loc=0}^{u_loc=Nup}
// Binomial(NLocSpn,u_loc)
// *Binomial(NCond,Nup-u_loc)
// *Binomial(NCond,Ndown+u_loc-NLocSpn)
//comb_1 = Binomial(NLocSpn,u_loc)
//comb_2 = Binomial(NCond,Nup-u_loc)
//comb_3 = Binomial(NCond,Ndown+u_loc-NLocSpn)
Nup = X->Def.Nup;
Ndown = X->Def.Ndown;
NCond = X->Def.Nsite-X->Def.NLocSpn;
NLocSpn = X->Def.NLocSpn;
comb_sum = 0;
for(u_loc=0;u_loc<=X->Def.Nup;u_loc++){
comb_1 = Binomial(NLocSpn,u_loc,comb,Ns);
comb_2 = Binomial(NCond,Nup-u_loc,comb,Ns);
comb_3 = Binomial(NCond,Ndown+u_loc-NLocSpn,comb,Ns);
comb_sum += comb_1*comb_2*comb_3;
}
break;
case KondoGC:
comb_sum = 1;
NCond = X->Def.Nsite-X->Def.NLocSpn;
NLocSpn = X->Def.NLocSpn;
//4^Nc*2^Ns
for(i=0;i<(2*NCond+NLocSpn);i++){
comb_sum= 2*comb_sum;
}
break;
case Spin:
if(X->Def.iFlgGeneralSpin ==FALSE){
if(X->Def.Nup+X->Def.Ndown != X->Def.Nsite){
fprintf(stderr, " 2Sz is incorrect.\n");
return FALSE;
}
comb_sum= Binomial(Ns, X->Def.Ne, comb, Ns);
}
else{
idimmax = 1;
X->Def.Tpow[0]=idimmax;
for(isite=0; isite<X->Def.Nsite;isite++){
idimmax=idimmax*X->Def.SiteToBit[isite];
X->Def.Tpow[isite+1]=idimmax;
}
comb_sum=0;
#pragma omp parallel for default(none) reduction(+:comb_sum) private(tmp_sz, isite) firstprivate(idimmax, X)
for(idim=0; idim<idimmax; idim++){
tmp_sz=0;
for(isite=0; isite<X->Def.Nsite;isite++){
tmp_sz += GetLocal2Sz(isite+1,idim, X->Def.SiteToBit, X->Def.Tpow );
}
if(tmp_sz == X->Def.Total2Sz){
comb_sum +=1;
}
}
}
break;
default:
fprintf(stderr, cErrNoModel, X->Def.iCalcModel);
i_free2(comb, Ns+1, Ns+1);
return FALSE;
}
if(comb_sum==0){
fprintf(stderr, "%s", cErrNoHilbertSpace);
// return FALSE;
}
//fprintf(stdoutMPI, "comb_sum= %ld \n",comb_sum);
X->Check.idim_max = comb_sum;
switch(X->Def.iCalcType){
case Lanczos:
switch(X->Def.iCalcModel){
case Hubbard:
case HubbardNConserved:
case Kondo:
case KondoGC:
case Spin:
X->Check.max_mem=5.5*X->Check.idim_max*8.0/(pow(10,9));
break;
case HubbardGC:
case SpinGC:
X->Check.max_mem=4.5*X->Check.idim_max*8.0/(pow(10,9));
break;
}
break;
case TPQCalc:
switch(X->Def.iCalcModel){
case Hubbard:
case HubbardNConserved:
case Kondo:
case KondoGC:
case Spin:
if(X->Def.iFlgCalcSpec != CALCSPEC_NOT){
X->Check.max_mem=(2)*X->Check.idim_max*16.0/(pow(10,9));
}
else {
X->Check.max_mem = 4.5 * X->Check.idim_max * 16.0 / (pow(10, 9));
}
break;
case HubbardGC:
case SpinGC:
if(X->Def.iFlgCalcSpec != CALCSPEC_NOT){
X->Check.max_mem=(2)*X->Check.idim_max*16.0/(pow(10,9));
}
else {
X->Check.max_mem = 3.5 * X->Check.idim_max * 16.0 / (pow(10, 9));
}
break;
}
break;
case FullDiag:
X->Check.max_mem=X->Check.idim_max*8.0*X->Check.idim_max*8.0/(pow(10,9));
break;
default:
return FALSE;
//break;
}
//fprintf(stdoutMPI, " MAX DIMENSION idim_max=%ld \n",X->Check.idim_max);
//fprintf(stdoutMPI, " APPROXIMATE REQUIRED MEMORY max_mem=%lf GB \n",X->Check.max_mem);
unsigned long int li_dim_max=MaxMPI_li(X->Check.idim_max);
fprintf(stdoutMPI, " MAX DIMENSION idim_max=%ld \n",li_dim_max);
double dmax_mem=MaxMPI_d(X->Check.max_mem);
fprintf(stdoutMPI, " APPROXIMATE REQUIRED MEMORY max_mem=%lf GB \n",dmax_mem);
if(childfopenMPI(cFileNameCheckMemory,"w", &fp)!=0){
i_free2(comb, Ns+1, Ns+1);
return FALSE;
}
fprintf(fp," MAX DIMENSION idim_max=%ld \n", li_dim_max);
fprintf(fp," APPROXIMATE REQUIRED MEMORY max_mem=%lf GB \n", dmax_mem);
/*
fprintf(fp," MAX DIMENSION idim_max=%ld \n",X->Check.idim_max);
fprintf(fp," APPROXIMATE REQUIRED MEMORY max_mem=%lf GB \n",X->Check.max_mem);
*/
fclose(fp);
//sdim
tmp=1;
tmp_sdim=1;
switch(X->Def.iCalcModel){
case HubbardGC:
case KondoGC:
case HubbardNConserved:
case Hubbard:
case Kondo:
while(tmp <= X->Def.Nsite){
tmp_sdim=tmp_sdim*2;
tmp+=1;
}
break;
case Spin:
case SpinGC:
if(X->Def.iFlgGeneralSpin==FALSE){
while(tmp <= X->Def.Nsite/2){
tmp_sdim=tmp_sdim*2;
tmp+=1;
}
}
else{
GetSplitBitForGeneralSpin(X->Def.Nsite, &tmp_sdim, X->Def.SiteToBit);
}
break;
default:
fprintf(stdoutMPI, cErrNoModel, X->Def.iCalcModel);
i_free2(comb, Ns+1, Ns+1);
return FALSE;
}
X->Check.sdim=tmp_sdim;
if(childfopenMPI(cFileNameCheckSdim,"w", &fp)!=0){
i_free2(comb, Ns+1, Ns+1);
return FALSE;
}
switch(X->Def.iCalcModel){
case HubbardGC:
case KondoGC:
case HubbardNConserved:
case Hubbard:
case Kondo:
//fprintf(stdoutMPI, "sdim=%ld =2^%d\n",X->Check.sdim,X->Def.Nsite);
fprintf(fp,"sdim=%ld =2^%d\n",X->Check.sdim,X->Def.Nsite);
break;
case Spin:
case SpinGC:
if(X->Def.iFlgGeneralSpin==FALSE){
//fprintf(stdoutMPI, "sdim=%ld =2^%d\n",X->Check.sdim,X->Def.Nsite/2);
fprintf(fp,"sdim=%ld =2^%d\n",X->Check.sdim,X->Def.Nsite/2);
}
break;
default:
break;
}
i_free2(comb, Ns+1, Ns+1);
u_tmp=1;
X->Def.Tpow[0]=u_tmp;
switch(X->Def.iCalcModel){
case HubbardGC:
case KondoGC:
for(i=1;i<=2*X->Def.Nsite;i++){
u_tmp=u_tmp*2;
X->Def.Tpow[i]=u_tmp;
fprintf(fp,"%ld %ld \n",i,u_tmp);
}
break;
case HubbardNConserved:
case Hubbard:
case Kondo:
for(i=1;i<=2*X->Def.Nsite-1;i++){
u_tmp=u_tmp*2;
X->Def.Tpow[i]=u_tmp;
fprintf(fp,"%ld %ld \n",i,u_tmp);
}
break;
case SpinGC:
if(X->Def.iFlgGeneralSpin==FALSE){
for(i=1;i<=X->Def.Nsite;i++){
u_tmp=u_tmp*2;
X->Def.Tpow[i]=u_tmp;
fprintf(fp,"%ld %ld \n",i,u_tmp);
}
}
else{
X->Def.Tpow[0]=u_tmp;
fprintf(fp,"%d %ld \n", 0, u_tmp);
for(i=1;i<X->Def.Nsite;i++){
u_tmp=u_tmp*X->Def.SiteToBit[i-1];
X->Def.Tpow[i]=u_tmp;
fprintf(fp,"%ld %ld \n",i,u_tmp);
}
}
break;
case Spin:
if(X->Def.iFlgGeneralSpin==FALSE){
for(i=1;i<=X->Def.Nsite-1;i++){
u_tmp=u_tmp*2;
X->Def.Tpow[i]=u_tmp;
fprintf(fp,"%ld %ld \n",i,u_tmp);
}
}
else{
for(i=0;i<X->Def.Nsite;i++){
fprintf(fp,"%ld %ld \n",i,X->Def.Tpow[i]);
}
}
break;
default:
fprintf(stdoutMPI, cErrNoModel, X->Def.iCalcModel);
i_free2(comb, Ns+1, Ns+1);
return FALSE;
}
fclose(fp);
/*
Print MPI-site information and Modify Tpow
in the inter process region.
*/
CheckMPI_Summary(X);
return TRUE;
}
void OutputTimer(struct BindStruct *X) {
char fileName[D_FileNameMax];
FILE *fp;
sprintf(fileName, "CalcTimer.dat"); //TBC
childfopenMPI(fileName,"w", &fp);
//fp = fopen(fileName, "w");
//fp = childfopenMPI(fileName, "w");
StampTime(fp, "All", 0);
StampTime(fp, " sz", 1000);
StampTime(fp, " diagonalcalc", 2000);
if(X->Def.iFlgCalcSpec == CALCSPEC_NOT){
if(X->Def.iCalcType==TPQCalc) {
StampTime(fp, " CalcByTPQ", 3000);
StampTime(fp, " FirstMultiply", 3100);
StampTime(fp, " rand in FirstMultiply", 3101);
StampTime(fp, " mltply in FirstMultiply", 3102);
StampTime(fp, " expec_energy_flct ", 3200);
StampTime(fp, " calc flctuation in expec_energy_flct ", 3201);
StampTime(fp, " mltply in expec_energy_flct ", 3202);
StampTime(fp, " expec_onebody ", 3300);
StampTime(fp, " expec_twobody ", 3400);
StampTime(fp, " Multiply ", 3500);
StampTime(fp, " FileIO ", 3600);
}
else if(X->Def.iCalcType==Lanczos){
StampTime(fp, " CalcByLanczos", 4000);
StampTime(fp, " LanczosEigenValue", 4100);
StampTime(fp, " mltply in LanczosEigenValue", 4101);
StampTime(fp, " vec12 in LanczosEigenValue", 4102);
StampTime(fp, " DSEVvalue in LanczosEigenValue", 4103);
StampTime(fp, " LanczosEigenVector", 4200);
StampTime(fp, " mltply in LanczosEigenVector", 4201);
StampTime(fp, " expec_energy_flct", 4300);
StampTime(fp, " calc flctuation in expec_energy_flct ", 4301);
StampTime(fp, " mltply in expec_energy_flct ", 4302);
StampTime(fp, " CGEigenVector", 4400);
StampTime(fp, " mltply in CGEigenVector ", 4401);
StampTime(fp, " expec_onebody ", 4500);
StampTime(fp, " expec_twobody ", 4600);
StampTime(fp, " expec_TotalSz ", 4700);
StampTime(fp, " FileIO ", 4800);
StampTime(fp, " Read Input Eigenvec ", 4801);
}
else if(X->Def.iCalcType==FullDiag){
StampTime(fp, " CalcByFullDiag", 5000);
StampTime(fp, " MakeHam", 5100);
StampTime(fp, " LapackDiag", 5200);
StampTime(fp, " CalcPhys", 5300);
StampTime(fp, " calc flctuation in expec_energy_flct ", 5301);
StampTime(fp, " mltply in expec_energy_flct ", 5302);
StampTime(fp, " Output", 5400);
StampTime(fp, " OutputHam", 5500);
}
}
else{
StampTime(fp, " CalcSpectrum by Lanczos method", 6000);
StampTime(fp, " Make excited state", 6100);
StampTime(fp, " Read origin state", 6101);
StampTime(fp, " Multiply excited operator", 6102);
StampTime(fp, " Calculate spectrum", 6200);
if(X->Def.iCalcType==Lanczos){
StampTime(fp, " Read vector for recalculation", 6201);
StampTime(fp, " Read tridiagonal components for recalculation", 6202);
StampTime(fp, " Calculate tridiagonal components", 6203);
StampTime(fp, " Output tridiagonal components", 6204);
StampTime(fp, " Calculate spectrum by Lanczos method", 6205);
StampTime(fp, " Output vectors for recalculation", 6206);
}
else if(X->Def.iCalcType==FullDiag){
StampTime(fp, " MakeHam", 6301);
StampTime(fp, " lapackdiag", 6302);
StampTime(fp, " Calculate v1", 6303);
StampTime(fp, " Calculate spectrum", 6304);
}
}
fprintf(fp,"================================================\n");
StampTime(fp,"All mltply",1);
StampTime(fp," diagonal", 100);
switch(X->Def.iCalcModel){
case HubbardGC:
StampTime(fp," HubbardGC", 200);
StampTime(fp," trans in HubbardGC", 210);
StampTime(fp," double", 211);
StampTime(fp," single", 212);
StampTime(fp," inner", 213);
StampTime(fp," interall in HubbardGC", 220);
StampTime(fp," interPE", 221);
StampTime(fp," inner", 222);
StampTime(fp," pairhopp in HubbardGC", 230);
StampTime(fp," interPE", 231);
StampTime(fp," inner", 232);
StampTime(fp," exchange in HubbardGC", 240);
StampTime(fp," interPE", 241);
StampTime(fp," inner", 242);
break;
case Hubbard:
StampTime(fp," Hubbard", 300);
StampTime(fp," trans in Hubbard", 310);
StampTime(fp," double", 311);
StampTime(fp," single", 312);
StampTime(fp," inner", 313);
StampTime(fp," interall in Hubbard", 320);
StampTime(fp," interPE", 321);
StampTime(fp," inner", 322);
StampTime(fp," pairhopp in Hubbard", 330);
StampTime(fp," interPE", 331);
StampTime(fp," inner", 332);
StampTime(fp," exchange in Hubbard", 340);
StampTime(fp," interPE", 341);
StampTime(fp," inner", 342);
break;
case Spin:
fprintf(fp,"\n");
StampTime(fp," Spin", 400);
StampTime(fp," interall in Spin", 410);
StampTime(fp," double", 411);
StampTime(fp," single1", 412);
StampTime(fp," single2", 413);
StampTime(fp," inner", 414);
StampTime(fp," exchange in Spin", 420);
StampTime(fp," double", 421);
StampTime(fp," single1", 422);
StampTime(fp," single2", 423);
StampTime(fp," inner", 424);
break;
case SpinGC:
StampTime(fp," SpinGC", 500);
StampTime(fp," trans in SpinGC", 510);
StampTime(fp," double", 511);
StampTime(fp," inner", 512);
StampTime(fp," interall in SpinGC", 520);
StampTime(fp," double", 521);
StampTime(fp," single", 522);
StampTime(fp," inner", 523);
StampTime(fp," exchange in SpinGC", 530);
StampTime(fp," double", 531);
StampTime(fp," single", 532);
StampTime(fp," inner", 533);
StampTime(fp," pairlift in SpinGC", 540);
StampTime(fp," double", 541);
StampTime(fp," single", 542);
StampTime(fp," inner", 543);
break;
default:
break;
}
fprintf(fp,"================================================\n");
fclose(fp);
free(Timer);
free(TimerStart);
}
/**
* @fn function for calculating diagonal components
*
* @param X
*
* @author Takahiro Misawa (The University of Tokyo)
* @author Kazuyoshi Yoshimi (The University of Tokyo)
* @return
*/
int diagonalcalc
(
struct BindStruct *X
){
FILE *fp;
long unsigned int i,j;
long unsigned int isite1,isite2;
long unsigned int spin;
double tmp_V;
/*[s] For InterAll*/
long unsigned int A_spin,B_spin;
/*[e] For InterAll*/
long unsigned int i_max=X->Check.idim_max;
fprintf(stdoutMPI, "%s", cProStartCalcDiag);
#pragma omp parallel for default(none) private(j) shared(list_Diagonal) firstprivate(i_max)
for(j = 1;j <= i_max; j++){
list_Diagonal[j]=0.0;
}
if(X->Def.NCoulombIntra>0){
if(childfopenMPI(cFileNameCheckCoulombIntra, "w", &fp)!=0){
return -1;
}
for(i = 0; i < X->Def.NCoulombIntra; i++){
isite1 = X->Def.CoulombIntra[i][0]+1;
tmp_V = X->Def.ParaCoulombIntra[i];
fprintf(fp,"i=%ld isite1=%ld tmp_V=%lf \n",i,isite1,tmp_V);
SetDiagonalCoulombIntra(isite1, tmp_V, X);
}
fclose(fp);
}
if(X->Def.EDNChemi>0){
if(childfopenMPI(cFileNameCheckChemi,"w", &fp)!=0){
return -1;
}
for(i = 0; i < X->Def.EDNChemi; i++){
isite1 = X->Def.EDChemi[i]+1;
spin = X->Def.EDSpinChemi[i];
tmp_V = -X->Def.EDParaChemi[i];
fprintf(fp,"i=%ld spin=%ld isite1=%ld tmp_V=%lf \n",i,spin,isite1,tmp_V);
if(SetDiagonalChemi(isite1, tmp_V,spin, X) !=0){
return -1;
}
}
fclose(fp);
}
if(X->Def.NCoulombInter>0){
if(childfopenMPI(cFileNameCheckInterU,"w", &fp)!=0){
return -1;
}
for(i = 0; i < X->Def.NCoulombInter; i++){
isite1 = X->Def.CoulombInter[i][0]+1;
isite2 = X->Def.CoulombInter[i][1]+1;
tmp_V = X->Def.ParaCoulombInter[i];
fprintf(fp,"i=%ld isite1=%ld isite2=%ld tmp_V=%lf \n",i,isite1,isite2,tmp_V);
if(SetDiagonalCoulombInter(isite1, isite2, tmp_V, X) !=0){
return -1;
}
}
fclose(fp);
}
if(X->Def.NHundCoupling>0){
if(childfopenMPI(cFileNameCheckHund,"w", &fp) !=0){
return -1;
}
for(i = 0; i < X->Def.NHundCoupling; i++){
isite1 = X->Def.HundCoupling[i][0]+1;
isite2 = X->Def.HundCoupling[i][1]+1;
tmp_V = -X->Def.ParaHundCoupling[i];
if(SetDiagonalHund(isite1, isite2, tmp_V, X) !=0){
return -1;
}
fprintf(fp,"i=%ld isite1=%ld isite2=%ld tmp_V=%lf \n",i,isite1,isite2,tmp_V);
}
fclose(fp);
}
if(X->Def.NInterAll_Diagonal>0){
if(childfopenMPI(cFileNameCheckInterAll,"w", &fp) !=0){
return -1;
}
for(i = 0; i < X->Def.NInterAll_Diagonal; i++){
isite1=X->Def.InterAll_Diagonal[i][0]+1;
A_spin=X->Def.InterAll_Diagonal[i][1];
isite2=X->Def.InterAll_Diagonal[i][2]+1;
B_spin=X->Def.InterAll_Diagonal[i][3];
tmp_V = X->Def.ParaInterAll_Diagonal[i];
fprintf(fp,"i=%ld isite1=%ld A_spin=%ld isite2=%ld B_spin=%ld tmp_V=%lf \n", i, isite1, A_spin, isite2, B_spin, tmp_V);
SetDiagonalInterAll(isite1, isite2, A_spin, B_spin, tmp_V, X);
}
fclose(fp);
}
TimeKeeper(X, cFileNameTimeKeep, cDiagonalCalcFinish, "w");
fprintf(stdoutMPI, "%s", cProEndCalcDiag);
return 0;
}
