503 lignes
21 KiB
C++
503 lignes
21 KiB
C++
#include "JSC.h"
|
|
|
|
using namespace JSC;
|
|
|
|
|
|
namespace JSC {
|
|
inline complex<DP> phi(complex<DP> x){return x;}
|
|
inline complex<DP> a(complex<DP> x){return 1;}
|
|
inline complex<DP> b(complex<DP> x,complex<DP> y, complex<DP> eta){ return phi(x-y)/phi(x-y+complex<DP>(0.0,1.0)*eta);}
|
|
inline complex<DP> d(complex<DP> x, complex<DP> xi, complex<DP> eta, int N){return pow(b(x,xi,eta),N);}
|
|
|
|
|
|
inline complex<DP> ln_Fn_F (XXX_Bethe_State& B, int k, int beta, int b)
|
|
{
|
|
complex<DP> ans = 0.0;
|
|
|
|
for (int j = 0; j < B.chain.Nstrings; ++j) {
|
|
for (int alpha = 0; alpha < B.base.Nrap[j]; ++alpha) {
|
|
for (int a = 1; a <= B.chain.Str_L[j]; ++a) {
|
|
|
|
if (!((j == k) && (alpha == beta) && (a == b)))
|
|
ans += log(B.lambda[j][alpha] - B.lambda[k][beta]
|
|
+ 0.5 * II * (B.chain.Str_L[j] - B.chain.Str_L[k] - 2.0 * (a - b)));
|
|
}
|
|
}
|
|
}
|
|
|
|
return(ans);
|
|
}
|
|
|
|
inline complex<DP> ln_Fn_G (XXX_Bethe_State& A, XXX_Bethe_State& B, int k, int beta, int b)
|
|
{
|
|
complex<DP> ans = 0.0;
|
|
|
|
for (int j = 0; j < A.chain.Nstrings; ++j) {
|
|
for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha) {
|
|
for (int a = 1; a <= A.chain.Str_L[j]; ++a) {
|
|
|
|
ans += log(A.lambda[j][alpha] - B.lambda[k][beta]
|
|
+ 0.5 * II * (A.chain.Str_L[j] - B.chain.Str_L[k] - 2.0 * (a - b)));
|
|
}
|
|
}
|
|
}
|
|
|
|
return(ans);
|
|
}
|
|
|
|
inline complex<DP> Fn_K (XXX_Bethe_State& A, int j, int alpha, int a, XXX_Bethe_State& B, int k, int beta, int b)
|
|
{
|
|
return(1.0/((A.lambda[j][alpha] - B.lambda[k][beta]
|
|
+ 0.5 * II * (A.chain.Str_L[j] - B.chain.Str_L[k] - 2.0 * (a - b)))
|
|
* (A.lambda[j][alpha] - B.lambda[k][beta]
|
|
+ 0.5 * II * (A.chain.Str_L[j] - B.chain.Str_L[k] - 2.0 * (a - b - 1.0)) )));
|
|
}
|
|
|
|
inline complex<DP> Fn_L (XXX_Bethe_State& A, int j, int alpha, int a, XXX_Bethe_State& B, int k, int beta, int b)
|
|
{
|
|
return ((2.0 * (A.lambda[j][alpha] - B.lambda[k][beta]
|
|
+ 0.5 * II * (A.chain.Str_L[j] - B.chain.Str_L[k] - 2.0 * (a - b - 0.5))
|
|
))
|
|
* pow(Fn_K (A, j, alpha, a, B, k, beta, b), 2.0));
|
|
}
|
|
|
|
|
|
complex<DP> ln_Szm_p_Smz_ME (XXX_Bethe_State& A, XXX_Bethe_State& B)
|
|
{
|
|
//clock_t start_time_local = clock();
|
|
//A has to be the ground state!
|
|
|
|
// This function returns the natural log of the S^z operator matrix element.
|
|
// The A and B states can contain strings.
|
|
|
|
// Check that the two states refer to the same XXX_Chain
|
|
|
|
if (A.chain != B.chain) JSCerror("Incompatible XXX_Chains in Szm_p_Smz matrix element.");
|
|
|
|
// Check that A and B are compatible: same Mdown
|
|
|
|
if (A.base.Mdown != B.base.Mdown + 1) JSCerror("Incompatible Mdown between the two states in SzSm_p_SmSz matrix element!");
|
|
|
|
//if (B.type_id > 999999LL) return(complex<DP>(-300.0));
|
|
|
|
//add a delta to the origin of the centered strings
|
|
for (int i = 0; i < A.chain.Nstrings; ++i)
|
|
for (int alpha = 0; alpha < A.base.Nrap[i]; ++alpha)
|
|
if(abs(A.lambda[i][alpha])<5.55112e-12)A.lambda[i][alpha]=5.55112e-12;
|
|
for (int i = 0; i < B.chain.Nstrings; ++i)
|
|
for (int alpha = 0; alpha < B.base.Nrap[i]; ++alpha)
|
|
if(abs(B.lambda[i][alpha])<5.55112e-5)B.lambda[i][alpha]=5.55112e-5;
|
|
|
|
// Some convenient arrays
|
|
|
|
complex<DP> i=complex<DP>(0.0,1.0);
|
|
complex<DP> eta=-i;
|
|
complex<DP> ln_prod = complex<DP>(0.0,0.0);
|
|
complex<DP> result;
|
|
result=log(B.chain.Nsites*1.0/4.0);
|
|
|
|
int sizeA=0;
|
|
int sizeB=0;
|
|
|
|
for (int i = 0; i < A.chain.Nstrings; ++i)
|
|
sizeA+=A.base.Nrap[i]*A.chain.Str_L[i];
|
|
for (int i = 0; i < B.chain.Nstrings; ++i)
|
|
sizeB+=B.base.Nrap[i]*B.chain.Str_L[i];
|
|
|
|
complex<DP>* mu = new complex<DP>[sizeA];
|
|
complex<DP>* lam = new complex<DP>[sizeB];
|
|
int index=0;
|
|
for (int i = 0; i < A.chain.Nstrings; ++i)
|
|
for (int alpha = 0; alpha < A.base.Nrap[i]; ++alpha)
|
|
for (int a = 1; a <= A.chain.Str_L[i]; ++a)
|
|
{
|
|
// mu[index]=(A.lambda[i][alpha] + 0.5 * II * (A.chain.Str_L[i] + 1.0 - 2.0 * a));
|
|
mu[index]=(A.lambda[i][alpha] + 0.5 * -eta * (A.chain.Str_L[i] + 1.0 - 2.0 * a));
|
|
index++;
|
|
}
|
|
|
|
index=0;
|
|
for (int i = 0; i < B.chain.Nstrings; ++i)
|
|
for (int alpha = 0; alpha < B.base.Nrap[i]; ++alpha)
|
|
for (int a = 1; a <= B.chain.Str_L[i]; ++a)
|
|
{
|
|
// lam[index]=(B.lambda[i][alpha] + 0.5 * II * (B.chain.Str_L[i] + 1.0 - 2.0 * a));
|
|
lam[index]=(B.lambda[i][alpha] + 0.5 * -eta * (B.chain.Str_L[i] + 1.0 - 2.0 * a));
|
|
index++;
|
|
}
|
|
|
|
Lambda re_ln_Fn_F_B_0(B.chain, B.base);
|
|
Lambda im_ln_Fn_F_B_0(B.chain, B.base);
|
|
Lambda re_ln_Fn_G_0(B.chain, B.base);
|
|
Lambda im_ln_Fn_G_0(B.chain, B.base);
|
|
Lambda re_ln_Fn_G_2(B.chain, B.base);
|
|
Lambda im_ln_Fn_G_2(B.chain, B.base);
|
|
|
|
complex<DP> ln_prod1 = 0.0;
|
|
complex<DP> ln_prod2 = 0.0;
|
|
complex<DP> ln_prod3 = 0.0;
|
|
complex<DP> ln_prod4 = 0.0;
|
|
|
|
for (int i = 0; i < A.chain.Nstrings; ++i)
|
|
for (int alpha = 0; alpha < A.base.Nrap[i]; ++alpha)
|
|
for (int a = 1; a <= A.chain.Str_L[i]; ++a)
|
|
ln_prod1 += log(norm(A.lambda[i][alpha] + 0.5 * II * (A.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)));
|
|
|
|
for (int i = 0; i < B.chain.Nstrings; ++i)
|
|
for (int alpha = 0; alpha < B.base.Nrap[i]; ++alpha)
|
|
for (int a = 1; a <= B.chain.Str_L[i]; ++a)
|
|
if (norm(B.lambda[i][alpha] + 0.5 * II * (B.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)) > 100.0 * MACHINE_EPS_SQ)
|
|
ln_prod2 += log(norm(B.lambda[i][alpha] + 0.5 * II * (B.chain.Str_L[i] + 1.0 - 2.0 * a - 1.0)));
|
|
|
|
// Define the F ones earlier...
|
|
|
|
for (int j = 0; j < B.chain.Nstrings; ++j) {
|
|
for (int alpha = 0; alpha < B.base.Nrap[j]; ++alpha) {
|
|
re_ln_Fn_F_B_0[j][alpha] = real(ln_Fn_F(B, j, alpha, 0));
|
|
im_ln_Fn_F_B_0[j][alpha] = imag(ln_Fn_F(B, j, alpha, 0));
|
|
re_ln_Fn_G_0[j][alpha] = real(ln_Fn_G(A, B, j, alpha, 0));
|
|
im_ln_Fn_G_0[j][alpha] = imag(ln_Fn_G(A, B, j, alpha, 0));
|
|
re_ln_Fn_G_2[j][alpha] = real(ln_Fn_G(A, B, j, alpha, 2));
|
|
im_ln_Fn_G_2[j][alpha] = imag(ln_Fn_G(A, B, j, alpha, 2));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// for (int i = 0; i < A.chain.Nstrings; ++i)
|
|
// for (int alpha = 0; alpha < A.base.Nrap[i]; ++alpha)
|
|
// for (int a = 1; a <= A.chain.Str_L[i]; ++a)
|
|
// ln_prod+=log(abs(phi((A.lambda[i][alpha] + 0.5 * II * (A.chain.Str_L[i] + 1.0 - 2.0 * a))+eta*0.5)))
|
|
|
|
// for (int i = 0; i < B.chain.Nstrings; ++i)
|
|
// for (int alpha = 0; alpha < B.base.Nrap[i]; ++alpha)
|
|
// for (int a = 1; a <= B.chain.Str_L[i]; ++a)
|
|
// ln_prod+=-log(abs(phi(-(B.lambda[i][alpha] + 0.5 * II * (B.chain.Str_L[i] + 1.0 - 2.0 * a))+eta*0.5)));
|
|
|
|
// for (int i = 0; i < B.chain.Nstrings; ++i)
|
|
// for (int alpha = 0; alpha < B.base.Nrap[i]; ++alpha)
|
|
// for (int a = 1; a <= B.chain.Str_L[i]; ++a)
|
|
// for (int j = 0; j < B.chain.Nstrings; ++j)
|
|
// for (int beta = 0; beta < B.base.Nrap[j]; ++beta)
|
|
// for (int b = 1; b <= B.chain.Str_L[j]; ++b)
|
|
// if(i!=j || alpha!=beta ||a!=b)ln_prod3+=-0.5*log(abs(phi((B.lambda[i][alpha] + 0.5 * II * (B.chain.Str_L[i] + 1.0 - 2.0 * a))-(B.lambda[j][beta] + 0.5 * II * (B.chain.Str_L[j] + 1.0 - 2.0 * b))-eta)));
|
|
|
|
// for (int i = 0; i < A.chain.Nstrings; ++i)
|
|
// for (int alpha = 0; alpha < A.base.Nrap[i]; ++alpha)
|
|
// for (int a = 1; a <= A.chain.Str_L[i]; ++a)
|
|
// for (int j = 0; j < A.chain.Nstrings; ++j)
|
|
// for (int beta = 0; beta < A.base.Nrap[j]; ++beta)
|
|
// for (int b = 1; b <= A.chain.Str_L[j]; ++b)
|
|
// if(abs((A.lambda[i][alpha] + 0.5 * II * (A.chain.Str_L[i] + 1.0 - 2.0 * a))-(A.lambda[j][beta] + 0.5 * II * (A.chain.Str_L[j] + 1.0 - 2.0 * b))-eta)!=0 && (i!=j && alpha!=beta && a!=b))
|
|
// ln_prod3+=-0.5*log(abs((A.lambda[i][alpha] + 0.5 * II * (A.chain.Str_L[i] + 1.0 - 2.0 * a))-(A.lambda[j][beta] + 0.5 * II * (A.chain.Str_L[j] + 1.0 - 2.0 * b))-eta));
|
|
|
|
|
|
|
|
//mu is the ground state!
|
|
//A -> mu, B -> lam
|
|
complex<DP> prod=complex<DP>(1.0,0.0);
|
|
complex<DP> prod2=complex<DP>(1.0,0.0);
|
|
complex<DP> prod3=complex<DP>(1.0,0.0);
|
|
for(int l=0; l<sizeA;l++) prod*=phi(mu[l]+eta*0.5);
|
|
for(int l=0; l<sizeB;l++) prod/=phi(lam[l]+eta*0.5);
|
|
|
|
for(int l=0; l<sizeA;l++)
|
|
for(int m=0; m<sizeA;m++)
|
|
if(l!=m)prod2*=1.0/sqrt(abs(phi(mu[m]-mu[l]-eta)));
|
|
for(int l=0; l<sizeB;l++)
|
|
for(int m=0; m<sizeB;m++)
|
|
if(abs(lam[m]-lam[l]-eta)!=0 && l!=m)prod3*=1.0/sqrt(abs(phi(lam[m]-lam[l]-eta)));
|
|
|
|
result+=2.0*log(abs(prod))-2.0*log(prod3)+2.0*log(prod2) - A.lnnorm - B.lnnorm;// a factor prod3^2 is inserted in the determinant!
|
|
// cout<<"prod:"<<prod<<endl;
|
|
SQMat_CX Hm(0.0, A.base.Mdown);
|
|
//complex<DP> H[sizeA][sizeA];
|
|
// cout<<"mu[l]:";
|
|
// for(int l=0; l<sizeA;l++)
|
|
// cout<<mu[l]<<", ";
|
|
// cout<<endl;
|
|
// cout<<"lam[l]:";
|
|
// for(int l=0; l<sizeB;l++)
|
|
// cout<<lam[l]<<", ";
|
|
// cout<<endl;
|
|
|
|
int index_a = 0;
|
|
int index_b = 0;
|
|
complex<DP> Prod_powerN;
|
|
|
|
for (int j = 0; j < A.chain.Nstrings; ++j) {
|
|
for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha) {
|
|
for (int a = 1; a <= A.chain.Str_L[j]; ++a) {
|
|
|
|
index_b = 0;
|
|
|
|
for (int k = 0; k < B.chain.Nstrings; ++k) {
|
|
for (int beta = 0; beta < B.base.Nrap[k]; ++beta) {
|
|
for (int b = 1; b <= B.chain.Str_L[k]; ++b) {
|
|
|
|
if (B.chain.Str_L[k] == 1) {
|
|
|
|
complex<DP> prodplus= complex<DP>(1.0,0.0);
|
|
complex<DP> prodminus= complex<DP>(1.0,0.0);
|
|
|
|
// use simplified code for one-string here: original form of Hm2P matrix
|
|
|
|
prodplus = Fn_K (A, j, alpha, a, B, k, beta, 0);// 1.0/ (phi(mu[l]-lam[k]) phi(mu[l]-lam[k]+eta) )
|
|
prodplus*= exp(re_ln_Fn_G_0[k][beta] + II * im_ln_Fn_G_0[k][beta] - re_ln_Fn_F_B_0[k][beta]);//Prod phi(mu[l]-lam[k]+eta) / prod_l!=k |phi(lam[l]-lam[k]) |;
|
|
prodminus = Fn_K (A, j, alpha, a, B, k, beta, 1);// 1.0/ (phi(mu[l]-lam[k]) phi(mu[l]-lam[k]-eta) )
|
|
prodminus*= exp(re_ln_Fn_G_2[k][beta] + II * im_ln_Fn_G_2[k][beta] - re_ln_Fn_F_B_0[k][beta]);//Prod phi(mu[l]-lam[k]-eta)/ prod_l!=k | phi(lam[l]-lam[k]) |;
|
|
|
|
Prod_powerN = pow((B.lambda[k][beta] -eta*0.5) /(B.lambda[k][beta] +eta*0.5), complex<DP> (B.chain.Nsites));
|
|
|
|
Hm[index_a][index_b] =eta*(prodplus-prodminus*Prod_powerN);
|
|
|
|
} // if (B.chain.Str_L == 1)
|
|
|
|
else {
|
|
|
|
if (b > 1) Hm[index_a][index_b] = eta* Fn_K(A, j, alpha, a, B, k, beta, b-1)*exp(ln_Fn_G(A,B,k,beta,b-1))*exp(-real(ln_Fn_F(B, k, beta, b - 1)));//.../ prod_l!=k | phi(lam[l]-lam[k]) |
|
|
else if (b == 1) {
|
|
|
|
Vect_CX ln_FunctionF(B.chain.Str_L[k] + 2);
|
|
for (int i = 0; i < B.chain.Str_L[k] + 2; ++i) ln_FunctionF[i] = ln_Fn_F (B, k, beta, i);
|
|
|
|
Vect_CX ln_FunctionG(B.chain.Str_L[k] + 2);
|
|
for (int i = 0; i < B.chain.Str_L[k] + 2; ++i) ln_FunctionG[i] = ln_Fn_G (A, B, k, beta, i);
|
|
|
|
complex<DP> sum1 = complex<DP>(0.0,0.0);
|
|
|
|
sum1 += Fn_K (A, j, alpha, a, B, k, beta, 0) *exp(ln_FunctionG[0]+ ln_FunctionG[1] //sum term when i=0
|
|
- ln_FunctionF[0] - ln_FunctionF[1]);
|
|
|
|
sum1 += Fn_K (A, j, alpha, a, B, k, beta, B.chain.Str_L[k]) //sum term when i=n
|
|
* exp( ln_FunctionG[B.chain.Str_L[k]] + ln_FunctionG[B.chain.Str_L[k] + 1]
|
|
- ln_FunctionF[B.chain.Str_L[k]] - ln_FunctionF[B.chain.Str_L[k] + 1]);
|
|
|
|
for (int jsum = 1; jsum < B.chain.Str_L[k]; ++jsum)
|
|
|
|
sum1 -= Fn_L (A, j, alpha, a, B, k, beta, jsum) *
|
|
exp(ln_FunctionG[jsum] + ln_FunctionG[jsum + 1] - ln_FunctionF[jsum] - ln_FunctionF[jsum + 1]);
|
|
|
|
|
|
Hm[index_a][index_b] = eta * exp(ln_FunctionF[0]+ ln_FunctionF[1] - ln_FunctionG[1]) * sum1 * exp( - real(ln_Fn_F(B, k, beta, b - 1))); //the absolute value prod_l!=k phi(lam[l]-lam[k]) : real(ln_...)
|
|
} // else if (b == B.chain.Str_L[k])
|
|
} // else
|
|
index_b++;
|
|
}}} // sums over k, beta, b
|
|
|
|
// now define the elements Hm[a][M]
|
|
|
|
//Hm[index_a][B.base.Mdown] = one_over_A_lambda_sq_plus_1over2sq;
|
|
//Hm[index_a][B.base.Mdown] = eta/((A.lambda[j][alpha] + 0.5 * II * (A.chain.Str_L[j] + 1.0 - 2.0 * a)) *
|
|
// (A.lambda[j][alpha] + 0.5 * II * (A.chain.Str_L[j] + 1.0 - 2.0 * a)) + 0.25);
|
|
Hm[index_a][B.base.Mdown] = eta/((mu[index_a]-eta*0.5)*(mu[index_a]+eta*0.5));
|
|
index_a++;
|
|
}}} // sums over j, alpha, a
|
|
|
|
// cout<<"Hm:";
|
|
// for(int j=0; j<sizeA;j++){
|
|
// for(int k=0; k<sizeA;k++) cout<<"Hm["<<j<<"]["<<k<<"]:"<<Hm[j][k]<<", ";
|
|
// cout<<endl;
|
|
// }
|
|
|
|
complex<DP> F= complex<DP>(0.0,0.0);
|
|
|
|
complex<DP> detmatrix;
|
|
detmatrix=exp(lndet_LU_CX_dstry(Hm));
|
|
//cout<<"exp(lndet_LU_CX(Hm)):"<<abs(detmatrix)<<endl;
|
|
// cout<<"exp(i*(A.K-B.K))+1.0):"<<exp(i*(A.K-B.K))+1.0<<"det(matrix):"<<detmatrix<<endl;
|
|
//F=-(exp(-i*(A.K-B.K))+1.0)*detmatrix;
|
|
|
|
//mu is the ground state!
|
|
//A -> mu, B -> lam
|
|
SQMat_CX G(0.0, A.base.Mdown);
|
|
SQMat_CX BbDa(0.0, A.base.Mdown);
|
|
index_a = 0;
|
|
|
|
for (int j = 0; j < A.chain.Nstrings; ++j) {
|
|
for (int alpha = 0; alpha < A.base.Nrap[j]; ++alpha) {
|
|
for (int a = 1; a <= A.chain.Str_L[j]; ++a) {
|
|
|
|
index_b = 0;
|
|
|
|
complex<DP> Da;
|
|
complex<DP> Ca;
|
|
Da=eta/((mu[index_a]-eta*0.5)*(mu[index_a]+eta*0.5));
|
|
Ca=eta*((mu[index_a]-eta*0.5)+(mu[index_a]+eta*0.5))/pow(((mu[index_a]-eta*0.5)*(mu[index_a]+eta*0.5)),2.0);
|
|
|
|
|
|
for (int k = 0; k < B.chain.Nstrings; ++k) {
|
|
for (int beta = 0; beta < B.base.Nrap[k]; ++beta) {
|
|
for (int b = 1; b <= B.chain.Str_L[k]; ++b) {
|
|
|
|
/*if (B.chain.Str_L[k] == 1) {
|
|
|
|
complex<DP> Bb;
|
|
Bb=-(phi(lam[index_b]+eta*0.5)+phi(lam[index_b]-eta*0.5));
|
|
complex<DP> product=complex<DP>(1.0,0.0);
|
|
for(int o=0; o<sizeB;o++)product*=phi(lam[o]-lam[index_b]+eta);
|
|
Bb*=product;
|
|
|
|
complex<DP> prodplus= complex<DP>(1.0,0.0);
|
|
complex<DP> prodminus= complex<DP>(1.0,0.0);
|
|
|
|
// use simplified code for one-string here: original form of Hm2P matrix
|
|
prodplus = Fn_K (A, j, alpha, a, B, k, beta, 0);// 1.0/ (phi(mu[l]-lam[k]) phi(mu[l]-lam[k]+eta) )
|
|
prodplus*= exp(re_ln_Fn_G_0[k][beta] + II * im_ln_Fn_G_0[k][beta] - re_ln_Fn_F_B_0[k][beta]);//Prod phi(mu[l]-lam[k]+eta) / prod_l!=k |phi(lam[l]-lam[k]) |;
|
|
//prodplus*= exp(re_ln_Fn_G_0[k][beta] + II * im_ln_Fn_G_0[k][beta]);// - re_ln_Fn_F_B_0[k][beta]);//Prod phi(mu[l]-lam[k]+eta) / prod_l!=k |phi(lam[l]-lam[k]) |;
|
|
prodminus = Fn_K (A, j, alpha, a, B, k, beta, 1);// 1.0/ (phi(mu[l]-lam[k]) phi(mu[l]-lam[k]-eta) )
|
|
prodminus*= exp(re_ln_Fn_G_2[k][beta] + II * im_ln_Fn_G_2[k][beta] - re_ln_Fn_F_B_0[k][beta]);//Prod phi(mu[l]-lam[k]-eta)/ prod_l!=k | phi(lam[l]-lam[k]) |;
|
|
// prodminus*= exp(re_ln_Fn_G_2[k][beta] + II * im_ln_Fn_G_2[k][beta]);// - re_ln_Fn_F_B_0[k][beta]);//Prod phi(mu[l]-lam[k]-eta)/ prod_l!=k | phi(lam[l]-lam[k]) |;
|
|
|
|
Prod_powerN = pow((B.lambda[k][beta] - eta*0.5) /(B.lambda[k][beta] + eta*0.5), complex<DP> (B.chain.Nsites));
|
|
|
|
G[index_a][index_b] =eta*(prodplus-prodminus*Prod_powerN);
|
|
BbDa[index_a][index_b]=Bb*Da*exp(- re_ln_Fn_F_B_0[k][beta]);
|
|
|
|
} // if (B.chain.Str_L == 1)
|
|
|
|
else {
|
|
*/{
|
|
|
|
if (b > 1){
|
|
G[index_a][index_b] = eta* Fn_K(A, j, alpha, a, B, k, beta, b-1)*exp(ln_Fn_G(A,B,k,beta,b-1))*exp(-real(ln_Fn_F(B, k, beta, b - 1)));//.../ prod_l!=k | phi(lam[l]-lam[k]) |
|
|
BbDa[index_a][index_b] =0 ;
|
|
}
|
|
else if (b == 1) {
|
|
|
|
Vect_CX ln_FunctionF(B.chain.Str_L[k] + 2);
|
|
for (int i = 0; i < B.chain.Str_L[k] + 2; ++i) ln_FunctionF[i] = ln_Fn_F (B, k, beta, i);
|
|
|
|
Vect_CX ln_FunctionG(B.chain.Str_L[k] + 2);
|
|
for (int i = 0; i < B.chain.Str_L[k] + 2; ++i) ln_FunctionG[i] = ln_Fn_G (A, B, k, beta, i);
|
|
|
|
complex<DP> sum1 = complex<DP>(0.0,0.0);
|
|
complex<DP> sum2 = complex<DP>(0.0,0.0);
|
|
|
|
sum1 += Fn_K (A, j, alpha, a, B, k, beta, 0) *exp(ln_FunctionG[0]+ ln_FunctionG[1]
|
|
- ln_FunctionF[0] - ln_FunctionF[1]);//sum term when i=0
|
|
//sum2 doesn't have a i=0 term
|
|
|
|
sum1 += Fn_K (A, j, alpha, a, B, k, beta, B.chain.Str_L[k])
|
|
* exp( ln_FunctionG[B.chain.Str_L[k]] + ln_FunctionG[B.chain.Str_L[k] + 1]
|
|
- ln_FunctionF[B.chain.Str_L[k]] - ln_FunctionF[B.chain.Str_L[k] + 1]); //sum term when i=n
|
|
sum2 += exp(ln_FunctionG[B.chain.Str_L[k]]- ln_FunctionF[B.chain.Str_L[k]] )
|
|
* (phi((B.lambda[k][beta] + 0.5 * II * (B.chain.Str_L[k] + 1.0 - 2.0 * B.chain.Str_L[k]))-eta*0.5)
|
|
+ phi((B.lambda[k][beta] + 0.5 * II * (B.chain.Str_L[k] + 1.0 - 2.0 * B.chain.Str_L[k]))+eta*0.5) ); //sum term when i=n
|
|
|
|
for (int jsum = 1; jsum < B.chain.Str_L[k]; ++jsum) {
|
|
sum1 -= Fn_L (A, j, alpha, a, B, k, beta, jsum) *
|
|
exp(ln_FunctionG[jsum] + ln_FunctionG[jsum + 1] - ln_FunctionF[jsum] - ln_FunctionF[jsum + 1]);
|
|
sum2 += exp(ln_FunctionG[jsum]- ln_FunctionF[jsum] )
|
|
* (phi((B.lambda[k][beta] + 0.5 * II * (B.chain.Str_L[k] + 1.0 - 2.0 * jsum))-eta*0.5)
|
|
+ phi((B.lambda[k][beta] + 0.5 * II * (B.chain.Str_L[k] + 1.0 - 2.0 * jsum))+eta*0.5) );
|
|
}
|
|
|
|
G[index_a][index_b] = eta * exp(ln_FunctionF[0]+ ln_FunctionF[1] - ln_FunctionG[1]) * sum1 * exp( - real(ln_Fn_F(B, k, beta, b - 1))); //the absolute value prod_l!=k phi(lam[l]-lam[k]) : real(ln_...)
|
|
BbDa[index_a][index_b] = - Da* exp(ln_FunctionF[0]+ ln_FunctionF[1] - ln_FunctionG[1]) * sum2 * exp( - real(ln_Fn_F(B, k, beta, b - 1)));//the absolute value prod_l!=k phi(lam[l]-lam[k]) : real(ln_...)
|
|
} // else if (b == B.chain.Str_L[k])
|
|
} // else
|
|
index_b++;
|
|
}}} // sums over k, beta, b
|
|
|
|
// now define the elements Hm[a][M]
|
|
|
|
|
|
//Hm[index_a][B.base.Mdown] = eta/((A.lambda[j][alpha] + 0.5 * II * (A.chain.Str_L[j] + 1.0 - 2.0 * a)) * (A.lambda[j][alpha] + 0.5 * II * (A.chain.Str_L[j] + 1.0 - 2.0 * a)) + 0.25);
|
|
G[index_a][B.base.Mdown]=Ca;
|
|
BbDa[index_a][B.base.Mdown]=0;
|
|
index_a++;
|
|
}}} // sums over j, alpha, a
|
|
|
|
SQMat_CX matrix(0.0, A.base.Mdown);
|
|
for(int a=0; a<sizeA;a++)
|
|
for(int b=0; b<sizeA;b++)
|
|
matrix[a][b]=G[a][b]+BbDa[a][b];
|
|
|
|
// cout<<"matrix:";
|
|
// for(int j=0; j<sizeA;j++){
|
|
// for(int k=0; k<sizeA;k++) cout<<"matrix["<<j<<"]["<<k<<"]:"<<matrix[j][k]<<", ";
|
|
// cout<<endl;
|
|
// }
|
|
// cout<<"matrixtest:";
|
|
// for(int j=0; j<sizeA;j++){
|
|
// for(int k=0; k<sizeA;k++) cout<<"matrixtest["<<j<<"]["<<k<<"]:"<<matrixtest[j][k]<<", ";
|
|
// cout<<endl;
|
|
// }
|
|
|
|
// cout<<"BbDa[a][b]:";
|
|
// for(int j=0; j<sizeA;j++){
|
|
// for(int k=0; k<sizeA;k++) cout<<"BbDa["<<j<<"]["<<k<<"]:"<<BbDa[j][k]<<", ";
|
|
// cout<<endl;
|
|
// }
|
|
// cout<<"Bn[b]*Da[a]:";
|
|
// for(int j=0; j<sizeA;j++){
|
|
// for(int k=0; k<sizeA;k++) cout<<"test["<<j<<"]["<<k<<"]:"<<Bn[k]*Da[j]<<", ";
|
|
// cout<<endl;
|
|
// }
|
|
|
|
// cout<<"prod:"<<prod<<endl;
|
|
// cout<<"(exp(lndet_LU_CX_dstry(matrix))-exp(lndet_LU_CX_dstry(G))):"<<(exp(lndet_LU_CX(matrix))-exp(lndet_LU_CX(G)))<<endl;
|
|
// cout<<"(exp(lndet_LU_CX_dstry(matrix)):"<<(exp(lndet_LU_CX(matrix)))<<endl;
|
|
|
|
//cout<<" an(n):"<<an(n)<<" det(matrix):"<<det(matrix)<< " det(Gn):"<<det(Gn)<<" an(n)*(det(matrix)-det(Gn)):"<<an(n)*(det(matrix)-det(Gn))<<endl;
|
|
complex<DP> sum=prod*(exp(lndet_LU_CX_dstry(matrix))-exp(lndet_LU_CX_dstry(G)));
|
|
//sum=conj(prod)*(exp(lndet_LU_CX_dstry(matrix))-exp(lndet_LU_CX_dstry(G)));
|
|
|
|
//cout<<"an(n):"<< an(n)<< "det(matrix):"<<det(matrix)<<" det(Gn):"<<det(Gn)<<endl;
|
|
|
|
//sum_nm_test=(0.5*(lam[0]-lam[1])*(eta*eta+4.0*lam[0]*lam[1]))/pow((lam[0]-eta/2.0)*(lam[0]+eta/2.0)*(lam[1]-eta/2.0)*(lam[1]+eta/2.0),2.0)*(0.5*(mu[0]-mu[1])*(eta*eta+4.0*mu[0]*mu[1]))/pow((mu[0]-eta/2.0)*(mu[0]+eta/2.0)*(mu[1]-eta/2.0)*(mu[1]+eta/2.0),2.0);
|
|
//sum_nm_test=(0.5*(lam[0]-lam[1])*(eta*eta+4.0*lam[0]*lam[1]))*(0.5*(mu[0]-mu[1])*(eta*eta+4.0*mu[0]*mu[1]))/pow((mu[0]-eta/2.0)*(mu[0]+eta/2.0)*(mu[1]-eta/2.0)*(mu[1]+eta/2.0),2.0);
|
|
//cout<<"F1:"<<F<<endl;
|
|
// F+=4.0*pow(prod,2)*exp(i*(qlam+qmu))*sum_n;
|
|
|
|
// F+=+2.0*exp(i*(A.K-B.K))*sum;
|
|
|
|
complex<DP> F2=exp(eta*(B.K-A.K))*(-2.0*sum);
|
|
complex<DP> F3=(exp(eta*(B.K-A.K)))*(detmatrix);
|
|
F=detmatrix;
|
|
// cout<<"F1:"<<F*sqrt(exp(result))<<" F2:"<<F2*sqrt(exp(result))<<" F3:"<<F3*sqrt(exp(result))<<endl;
|
|
// cout<<"abs(F1)^2:"<<abs(F*F*(exp(result)))<<" abs(F2)^2:"<<abs(F2*F2*(exp(result)))<<" abs(F3)^2:"<<abs(F3*F3*(exp(result)))<<endl;
|
|
// cout<<"arg(F1):"<<-i*log(F*sqrt(exp(result))/abs(F*sqrt(exp(result))))/M_PI<<" arg(F2):"<<-i*log(F2*sqrt(exp(result))/abs(F2*sqrt(exp(result))))/M_PI<<" arg(F3):"<<-i*log(F3*sqrt(exp(result))/abs(F3*sqrt(exp(result))))/M_PI<<endl;
|
|
// cout<<"F:"<<(F)<<endl;
|
|
// cout<<"Smff:"<<exp(result)*4.0*abs(detmatrix*detmatrix)<<endl;
|
|
F+=exp(i*(A.K-B.K))*(2.0*sum*(-1.0)+detmatrix);
|
|
|
|
|
|
// cout<<"sum:"<<sum<<endl;
|
|
// cout<<"exp(result):"<<exp(result)<<endl;
|
|
|
|
//TEST!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
result+=2.0*log(abs(F));
|
|
result-=log(A.chain.Nsites-A.base.Mdown*2+2.0);
|
|
//result*=pow(abs((exp(i*(A.K-B.K))+1.0)*detmatrix),2);//*(exp(i*(A.K-B.K))+1.0)
|
|
//result*=pow(abs(2.0*exp(i*(A.K-B.K))*sum),2);
|
|
//result/=(B.chain.Nsites)*1/16.0;
|
|
//cout<<"TEST::::::::::::::::::::::"<<"A.Check_Admissibility('a'):"<<A.Check_Admissibility('a')<<endl;
|
|
//cout<<"mu:"<<mu<<" lam:"<<lam<<endl;
|
|
// cout<<"an(n):"<<an<<endl;
|
|
// cout<<"prod^2:"<<pow(abs(prod),2)<<endl;
|
|
// cout<<"prod3:"<<prod3<<endl;
|
|
// cout<<"prod2:"<<prod2<<endl;
|
|
|
|
|
|
// cout<<"normlam"<<"normmu:"<<(exp(A.lnnorm))<<":"<<(exp(B.lnnorm))<<endl;
|
|
// cout<<"abs(prod*prod*prod2*sum_n):"<<abs(prod*prod*prod2*sum_n)<<endl;
|
|
|
|
|
|
//cout<<"computation time for Szm:"<<clock()-start_time_local<<endl;
|
|
complex<DP> ln_ME_sq = result;
|
|
|
|
// if (real(ln_ME_sq) > 10.0) ln_ME_sq = complex<DP> (-300.0); // fix for artificial divergences
|
|
|
|
delete[] mu;
|
|
delete[] lam;
|
|
|
|
|
|
//return(ln_ME_sq);
|
|
return(0.5 * ln_ME_sq); // Return ME, not MEsq
|
|
|
|
}
|
|
|
|
} // namespace JSC
|