/* do measurements: load density, ploop, etc. and phases onto lattice */
void measure() {
register int i,j,k, c, is_even;
register site *s;
int dx,dy,dz; /* separation for correlated observables */
int dir; /* direction of separation */
msg_tag *tag;
register complex cc,dd; /*scratch*/
complex ztr, zcof, znum, zdet, TC, zd, density, zphase;
complex p[4]; /* probabilities of n quarks at a site */
complex np[4]; /* probabilities at neighbor site */
complex pp[4][4]; /* joint probabilities of n here and m there */
complex zplp, plp_even, plp_odd;
Real locphase, phase;
/* First make T (= timelike P-loop) from s->ploop_t
T stored in s->tempmat1
*/
ploop_less_slice(nt-1,EVEN);
ploop_less_slice(nt-1,ODD);
phase = 0.;
density = plp_even = plp_odd = cmplx(0.0, 0.0);
for(j=0;j<4;j++){
p[j]=cmplx(0.0,0.0);
for(k=0;k<4;k++)pp[j][k]=cmplx(0.0,0.0);
}
FORALLSITES(i,s) {
if(s->t != nt-1) continue;
if( ((s->x+s->y+s->z)&0x1)==0 ) is_even=1; else is_even=0;
mult_su3_nn(&(s->link[TUP]), &(s->ploop_t), &(s->tempmat1));
zplp = trace_su3(&(s->tempmat1));
if( is_even){CSUM(plp_even, zplp)}
else {CSUM(plp_odd, zplp)}
ztr = trace_su3(&(s->tempmat1));
CONJG(ztr, zcof);
if(is_even){
for(c=0; c<3; ++c) s->tempmat1.e[c][c].real += C;
zdet = det_su3(&(s->tempmat1));
znum = numer(C, ztr, zcof);
CDIV(znum, zdet, zd);
CSUM(density, zd);
/* store n_quark probabilities at this site in lattice variable
qprob[], accumulate sum over lattice in p[] */
cc= cmplx(C*C*C,0.0); CDIV(cc,zdet,s->qprob[0]); CSUM(p[0],s->qprob[0]);
CMULREAL(ztr,C*C,cc); CDIV(cc,zdet,s->qprob[1]); CSUM(p[1],s->qprob[1]);
CMULREAL(zcof,C,cc); CDIV(cc,zdet,s->qprob[2]); CSUM(p[2],s->qprob[2]);
cc = cmplx(1.0,0.0); CDIV(cc,zdet,s->qprob[3]); CSUM(p[3],s->qprob[3]);
locphase = carg(&zdet);
phase += locphase;
}
}
FORALLUPDIRBUT(gauge_dir,dir)
{
/* Upward link matrix */
m1 = &(s->link[dir]);
sub_su3_matrix( &diffmatp[i], m1, &diffmatp[i]);
for(j=0;j<3;j++)CSUM( sumvecp[i].c[j],m1->e[j][j]);
}
void mult_su3_na( su3_matrix *a, su3_matrix *b, su3_matrix *c ){
int i,j,k;
complex x,y;
// Warm up the cache to ensure fair comparison.
float sum = 0.0f;
for(i=0;i<3;i++){
for(j=0;j<3;j++){
sum += a->e[i][j].real + a->e[i][j].imag;
sum += b->e[i][j].real + b->e[i][j].imag;
sum += c->e[i][j].real + c->e[i][j].imag;
}
}
double tick = clock();
for(i=0;i<3;i++) {
for(j=0;j<3;j++){
x.real=x.imag=0.0;
for(k=0;k<3;k++){
CMUL_J( a->e[i][k] , b->e[j][k] , y );
CSUM( x , y );
}
c->e[i][j] = x;
}
}
mat_time += (clock() - tick);
}
void mult_su3_na( su3_matrix *a, su3_matrix *b, su3_matrix *c ){
int i,j,k;
complex x,y;
su3_matrix_mod am = su3_matrix_to_su3_matrix_mod(a);
su3_matrix_mod bm = su3_matrix_to_su3_matrix_mod(b);
su3_matrix_mod cm = su3_matrix_to_su3_matrix_mod(c);
double tick = clock();
#pragma simd
for(i=0;i<3;i++) {
for(j=0;j<3;j++){
x.real=x.imag=0.0;
for(k=0;k<3;k++){
MCMULJ_( am.real[i][k], am.imag[i][k] , bm.real[j][k], bm.imag[j][k], y );
CSUM( x , y );
}
cm.real[i][j] = x.real;
cm.imag[i][j] = x.imag;
}
}
mat_time += (clock() - tick);
*a = su3_matrix_mod_to_su3_matrix(am);
*b = su3_matrix_mod_to_su3_matrix(bm);
*c = su3_matrix_mod_to_su3_matrix(cm);
}
void flip_source_re(field_offset quark_prop)
{
register int i ;
register site *s;
static int flag_call = 0 ;
complex change_rep[4][4] ;
complex z ;
spin_wilson_vector quark_flip; /* temporary storage for quark */
int si , cf , sf ;
int k ;
/**** trick to print out some titles only on the first call ****/
if( flag_call == 0 )
{
IF_MASTER
printf("\nRotation of the source gamma representation has been set up\n");
flag_call = 1 ;
}
define_change_rep( change_rep );
FORALLSITES(i,s)
{
for(si=0;si<4;si++)
for(sf=0;sf<4;sf++)
for(cf=0;cf<3;cf++)
{
quark_flip.d[si].d[sf].c[cf].real = 0.0 ;
quark_flip.d[si].d[sf].c[cf].imag = 0.0 ;
for(k = 0 ; k < 4 ; ++k)
{
/** CMUL(((spin_wilson_vector *)F_PT(s,quark_prop))->d[k].d[sf].c[cf] , change_rep[sf][k] ,z) ; *** still wrong ***/
CMUL_J(((spin_wilson_vector *)F_PT(s,quark_prop))->d[k].d[sf].c[cf] , change_rep[si][k] ,z) ;
CSUM(quark_flip.d[si].d[sf].c[cf] ,z) ;
}
} /*** end the loop over colour and spin *****/
*((spin_wilson_vector *)F_PT(s,quark_prop)) = quark_flip ;
} /**** end of the loop over lattice sites ******/
/**** flip the action convention for forwards and backwards *****/
/** gammafive_sandwich(quark_prop) ; ***/
} /* end of the flip function */
complex numer(Real c, complex T, complex cof) {
complex z1, z2;
CMULREAL(T, c*c, z1);
CMULREAL(cof, 2.*c, z2);
CSUM(z1,z2);
z1.real += 3.;
return(z1);
}
// -----------------------------------------------------------------
// Modified to return total number of iterations
int f_meas_imp(field_offset chi_off, field_offset psi_off, Real mass) {
register int i;
register site *s;
int jpbp_reps, tot_iters = 0, miters, npbp_reps = 1;
Real r_pbp_even, i_pbp_even, r_pbp_odd, i_pbp_odd, r_ferm_action;
double rfaction;
complex tc;
double_complex pbp_e, pbp_o;
#ifdef NPBP_REPS
double pbp_pbp;
npbp_reps = NPBP_REPS; // Number of stochastic estimations
#endif
for (jpbp_reps = 0; jpbp_reps < npbp_reps; jpbp_reps++) {
rfaction = 0;
pbp_e = dcmplx(0, 0);
pbp_o = dcmplx(0, 0);
// Make random source and do inversion
// Generate (one-mass) g_rand; chi_off = M g_rand
grsource_imp(chi_off, mass, EVENANDODD);
// chi_off = M g_rand (still)
// psi_off = M^{-1} g_rand
clear_latvec(psi_off, EVENANDODD);
miters = mat_invert_uml(F_OFFSET(g_rand), psi_off, chi_off, mass);
tot_iters += miters;
// Fermion action = chi.psi
// pbp on even sites = g_rand.psi
FOREVENSITES(i, s) {
tc = su3_dot((vector *)F_PT(s, chi_off),
(vector *)F_PT(s, psi_off));
rfaction += tc.real;
tc = su3_dot(&(s->g_rand), (vector *)F_PT(s, psi_off));
CSUM(pbp_e, tc);
}
// pbp on odd sites
FORODDSITES(i, s) {
tc = su3_dot(&(s->g_rand), (vector *)F_PT(s, psi_off));
CSUM(pbp_o, tc);
}
void mult_su3_mat_vec( su3_matrix *a, su3_vector *b, su3_vector *c ){
register int i,j;
register complex x,y;
for(i=0;i<3;i++){
x.real=x.imag=0.0;
for(j=0;j<3;j++){
CMUL( a->e[i][j] , b->c[j] , y )
CSUM( x , y );
}
c->c[i] = x;
}
}
/******************************************************************************
FUNCTION:
check_unitarity
******************************************************************************/
void check_unitarity(su2_matrix *psub)
{
complex sum;
complex conj;
complex prod;
Real tol;
tol = 0.0001;
sum.real = 0.0;
sum.imag = 0.0;
CONJG(psub->e[0][0], conj);
CMUL(psub->e[0][0], conj, prod);
CSUM(sum, prod);
CONJG(psub->e[1][0], conj);
CMUL(psub->e[1][0], conj, prod);
CSUM(sum, prod);
if (sum.real < 1.0 - tol || sum.real > 1.0 + tol
|| sum.imag < -tol || sum.imag > tol)
{
printf("%g\t%g\n", sum.real, sum.imag);
}
}
void
llfat_mult_su3_na( su3_matrix *a, su3_matrix *b, su3_matrix *c )
{
int i,j,k;
typeof(a->e[0][0]) x,y;
for(i=0; i<3; i++)for(j=0; j<3; j++) {
x.real=x.imag=0.0;
for(k=0; k<3; k++) {
CMUL_J( a->e[i][k] , b->e[j][k] , y );
CSUM( x , y );
}
c->e[i][j] = x;
}
}
FORSOMEPARITY(i,s,parity)
{
//FORALLUPDIRBUT(gauge_dir,dir)
//{
/* Downward link matrix */
m2 = (complex *)gen_pt[TUP][i];
//CADD(diffmatp[i], *m2, diffmatp[i]);
CSUM(sumvecp[i], *m2);
//add_su3_matrix( &diffmatp[i], m2, &diffmatp[i]);
//for(j=0;j<3;j++)CSUM( sumvecp[i].c[j], m2->e[j][j]);
/* Add diagonal elements to sumvec */
//}
}
void mult_su3_na(su3_matrix *a, su3_matrix *b, su3_matrix *c) {
register int i, j, k;
register complex x, y;
for (i = 0; i < NCOL; i++) {
for (j = 0; j < NCOL; j++) {
x.real = 0.0;
x.imag = 0.0;
for (k = 0; k < NCOL; k++) {
CMUL_J(a->e[i][k], b->e[j][k], y);
CSUM(x, y);
}
c->e[i][j] = x;
}
}
}
/******************************************************************************
FUNCTION:
mult_su2
******************************************************************************/
void mult_su2(su2_matrix *pprod, su2_matrix *pmat1, su2_matrix *pmat2)
{
int p; /* index over matrix row */
int q; /* index over matrix column */
int k; /* summation index */
complex term; /* term in row times column */
for (p = 0; p < 2; p++)
{
for (q = 0; q < 2; q++)
{
pprod->e[p][q].real = 0.0;
pprod->e[p][q].imag = 0.0;
for (k = 0; k < 2; k++)
{
CMUL(pmat1->e[p][k], pmat2->e[k][q], term);
CSUM(pprod->e[p][q], term);
}
}
}
}
void accum_gauge_hit(int gauge_dir,int parity)
{
/* Accumulates sums and differences of link matrices for determining optimum */
/* hit for gauge fixing */
/* Differences are kept in diffmat and the diagonal elements of the sums */
/* in sumvec */
register int j;
register complex *m1,*m2;
register complex temp;
register int dir,i;
register site *s;
/* Clear sumvec and diffmat */
FORSOMEPARITY(i,s,parity)
{
//diffmatp[i].real = diffmatp[i].imag = 0.;
sumvecp[i].real = sumvecp[i].imag = 0.;
//clear_su3mat(&diffmatp[i]);
//clearvec(&sumvecp[i]);
}
/* Subtract upward link contributions */
FORSOMEPARITY(i,s,parity)
{
//FORALLUPDIRBUT(gauge_dir,dir)
//{
/* Upward link matrix */
m1 = &(s->link[TUP]);
CONJG(*m1, temp);
//CSUB(diffmatp[i], *m1, diffmatp[i]);
CSUM(sumvecp[i], temp);
//sub_su3_matrix( &diffmatp[i], m1, &diffmatp[i]);
//for(j=0;j<3;j++)CSUM( sumvecp[i].c[j],m1->e[j][j]);
// }
}
static void task_combuf_send()
{
switch (out_offset) {
case -1:
combuf_destroy(out_combuf);
++out_offset;
case 0:
out_combuf =
combuf_search(READY_MASK | INPUT_MASK | CREATE_MASK,
READY_MASK | CREATE_MASK);
if (out_combuf < 0)
break;
/* подсчитываем контрольную сумму. Поле можно не защищать,
* поскольку доступ только в этом месте. */
CSUM(out_combuf) = calc_csum(out_combuf);
out_xor_char = 0;
++out_offset;
uart_tx(BEGIN_MARKER);
return;
}
out_offset = -2;
}
int f_measure2(int flag) {
/* local variables for accumulators */
register int i,j,k,dir;
register site *s;
msg_tag *tag0,*tag1;
register complex cc;
complex pbp;
complex pbg5p;
int iters;
wilson_vector wv0;
int MinCG,MaxCG;
Real size_r,RsdCG;
int x,y,z,t;
MaxCG=niter;
RsdCG=resid[0];
/* gaussian random vector */
FORALLSITES(i,s){
for(k=0;k<4;k++)for(j=0;j<3;j++){
s->source.d[k].c[j] = complex_gaussian_rand_no(&node_prn);
}
}
FORALLSITES(i,s){
s->chi=s->source;
}
/* Invert, result in psi */
/* compute the propagator. Result in psi. */
#ifdef BI
iters = bicgstab(F_OFFSET(chi),F_OFFSET(psi),
MaxCG,RsdCG,&size_r,flag);
#else
iters = congrad_t(F_OFFSET(chi),F_OFFSET(psi),
MaxCG,RsdCG,&size_r,flag);
#endif
if(this_node==0)printf("size_r= %e, iters= %e\n",(double)size_r,
(double)iters);
/*Temporary*/
/* Multiply by M and see if I get source back */
/* use dir as flag*/
/**
delta0( F_OFFSET(psi), F_OFFSET(mp), PLUS);
FORALLSITES(i,s){
for(dir=0,j=0;j<4;j++)for(k=0;k<3;k++){
if(s->source.d[j].c[k].real - s->mp.d[j].c[k].real > 2e-5 )dir=1;
if(s->source.d[j].c[k].imag - s->mp.d[j].c[k].imag > 2e-5 )dir=1;
if(dir)printf("%d %d %d ( %.4e , %.4e ) ( %.4e , %.4e )\n",
i,j,k,s->source.d[j].c[k].real,s->source.d[j].c[k].imag,
s->mp.d[j].c[k].real,s->mp.d[j].c[k].imag);
}
} *End temporary **/
pbp = cmplx(0.0,0.0);
pbg5p = cmplx(0.0,0.0);
/* psi-bar-psi = source.psi */
/* psi-bar-gamma-5 psi = source. gamma-5 psi */
FORALLSITES(i,s){
cc = wvec_dot( &(s->source), &(s->psi) );
CSUM(pbp,cc);
mult_by_gamma( &(s->psi),&wv0, GAMMAFIVE);
cc = wvec_dot( &(s->source), &wv0 );
CSUM(pbg5p,cc);
}
int spectrum_nd( Real mass1, Real mass2, Real tol, ferm_links_t *fn ){
/* arguments are light and heavy quark masses, return C.G. iteration number */
int cgn;
register int i,j,x,y,z,t,t_off;
register site* s;
register complex cc;
register int t_source;
int color; /* color for source */
int src_count; /* number of source time slices used */
complex **props; /* arrays of propagators */
su3_matrix tmat;
Real finalrsq;
cgn=0; /* number of CG iterations */
/* allocate arrays to accumulate propagators */
props = (complex **)malloc(nprops*sizeof(complex *));
props[0] = (complex *)malloc(nprops*nt*sizeof(complex));
for(i=1;i<nprops;i++)props[i]=props[i-1]+nt;
/* set propagators to zero */
for(cc.real=cc.imag=0.0,i=0;i<nprops;i++)for(j=0;j<nt;j++){
props[i][j]=cc;
}
/* allocate light and heavy quark propagators for each color */
for( color=0; color<3; color++){
lightprop[color] = (su3_vector *)malloc( sizeof(su3_vector)*sites_on_node );
heavyprop[color] = (su3_vector *)malloc( sizeof(su3_vector)*sites_on_node );
}
/* loop over "source" time slice */
for(src_count=0,t_source=source_start; t_source<nt && src_count<n_sources;
t_source += source_inc,src_count++){
/* Corner wall source */
/* Use quark_source for quark source */
if(this_node==0)printf("spectrum_nd(): source time = %d\n",t_source);
for(color=0;color<3;color++){
clear_latvec( F_OFFSET(quark_source), EVENANDODD );
for(x=0;x<nx;x+=2)for(y=0;y<ny;y+=2)for(z=0;z<nz;z+=2) {
if( node_number(x,y,z,t_source) != mynode() )continue;
i=node_index(x,y,z,t_source);
lattice[i].quark_source.c[color].real = -1.0;
}
/* do a C.G. (source in quark_source, result in g_rand) */
if(t_source%2 == 0) {
cgn += ks_congrad( F_OFFSET(quark_source), F_OFFSET(g_rand),
mass1, niter, nrestart, rsqprop, PRECISION,
EVEN, &finalrsq, fn);
/* Multiply by -Madjoint */
dslash_site( F_OFFSET(g_rand), F_OFFSET(quark_prop), ODD, fn);
scalar_mult_latvec( F_OFFSET(g_rand), -2.0*mass1, F_OFFSET(quark_prop),EVEN);
}
else {
cgn += ks_congrad( F_OFFSET(quark_source), F_OFFSET(g_rand),
mass1, niter, nrestart, rsqprop, PRECISION,
ODD, &finalrsq, fn);
/* Multiply by -Madjoint */
dslash_site( F_OFFSET(g_rand), F_OFFSET(quark_prop), EVEN, fn);
scalar_mult_latvec( F_OFFSET(g_rand), -2.0*mass1, F_OFFSET(quark_prop),ODD);
}
FORALLSITES(i,s){ lightprop[color][i] = lattice[i].quark_prop; }
scalar_mult_latvec( F_OFFSET(quark_prop), -1.0, F_OFFSET(g_rand), EVENANDODD );
check_invert( F_OFFSET(g_rand), F_OFFSET(quark_source), mass1, tol, fn);
/* repeat for heavy quark */
if(t_source%2 == 0) {
cgn += ks_congrad( F_OFFSET(quark_source), F_OFFSET(g_rand),
mass2, niter, nrestart, rsqprop, PRECISION,
EVEN, &finalrsq, fn);
/* Multiply by -Madjoint */
dslash_site( F_OFFSET(g_rand), F_OFFSET(quark_prop), ODD, fn);
scalar_mult_latvec( F_OFFSET(g_rand), -2.0*mass2, F_OFFSET(quark_prop),EVEN);
}
else {
cgn += ks_congrad( F_OFFSET(quark_source), F_OFFSET(g_rand),
mass2, niter, nrestart, rsqprop, PRECISION,
ODD, &finalrsq, fn);
/* Multiply by -Madjoint */
dslash_site( F_OFFSET(g_rand), F_OFFSET(quark_prop), EVEN, fn);
scalar_mult_latvec( F_OFFSET(g_rand), -2.0*mass2, F_OFFSET(quark_prop),ODD);
}
FORALLSITES(i,s){ heavyprop[color][i] = lattice[i].quark_prop; }
/* TEMP: test inversion, */
scalar_mult_latvec( F_OFFSET(quark_prop), -1.0, F_OFFSET(g_rand), EVENANDODD );
check_invert( F_OFFSET(g_rand), F_OFFSET(quark_source), mass2, tol, fn);
} /* end color loop*/
/* add contributions into propagators */
/* measure the meson propagator */
for(t=0; t<nt; t++){
/* define the time value offset t from t_source */
t_off = (t+t_source)%nt;
for(x=0;x<nx;x++)for(y=0;y<ny;y++)for(z=0;z<nz;z++)
for(color=0;color<3;color++) {
if( node_number(x,y,z,t_off) != mynode() )continue;
i=node_index(x,y,z,t_off);
/* light-light mesons */
cc = su3_dot( &lightprop[color][i],
&lightprop[color][i] );
CSUM( props[prop_pion5_ll][t], cc )
if( (x+y)%2==0)CSUM( props[prop_rhoi0_ll][t], cc )
else CSUB( props[prop_rhoi0_ll][t], cc, props[prop_rhoi0_ll][t] )
if( (y+z)%2==0)CSUM( props[prop_rhoi0_ll][t], cc )
else CSUB( props[prop_rhoi0_ll][t], cc, props[prop_rhoi0_ll][t] )
if( (z+x)%2==0)CSUM( props[prop_rhoi0_ll][t], cc )
else CSUB( props[prop_rhoi0_ll][t], cc, props[prop_rhoi0_ll][t] )
if( x%2==0)CSUM( props[prop_rhoi_ll][t], cc )
else CSUB( props[prop_rhoi_ll][t], cc, props[prop_rhoi_ll][t] )
if( y%2==0)CSUM( props[prop_rhoi_ll][t], cc )
else CSUB( props[prop_rhoi_ll][t], cc, props[prop_rhoi_ll][t] )
if( z%2==0)CSUM( props[prop_rhoi_ll][t], cc )
else CSUB( props[prop_rhoi_ll][t], cc, props[prop_rhoi_ll][t] )
if( (x+y+z)%2==0)CSUM( props[prop_pion05_ll][t], cc )
else CSUB( props[prop_pion05_ll][t], cc, props[prop_pion05_ll][t] )
/* light-heavy mesons */
cc = su3_dot( &lightprop[color][i],
&heavyprop[color][i] );
CSUM( props[prop_pion5_lh][t], cc )
if( (x+y)%2==0)CSUM( props[prop_rhoi0_lh][t], cc )
else CSUB( props[prop_rhoi0_lh][t], cc, props[prop_rhoi0_lh][t] )
if( (y+z)%2==0)CSUM( props[prop_rhoi0_lh][t], cc )
else CSUB( props[prop_rhoi0_lh][t], cc, props[prop_rhoi0_lh][t] )
if( (z+x)%2==0)CSUM( props[prop_rhoi0_lh][t], cc )
else CSUB( props[prop_rhoi0_lh][t], cc, props[prop_rhoi0_lh][t] )
if( x%2==0)CSUM( props[prop_rhoi_lh][t], cc )
else CSUB( props[prop_rhoi_lh][t], cc, props[prop_rhoi_lh][t] )
if( y%2==0)CSUM( props[prop_rhoi_lh][t], cc )
else CSUB( props[prop_rhoi_lh][t], cc, props[prop_rhoi_lh][t] )
if( z%2==0)CSUM( props[prop_rhoi_lh][t], cc )
else CSUB( props[prop_rhoi_lh][t], cc, props[prop_rhoi_lh][t] )
if( (x+y+z)%2==0)CSUM( props[prop_pion05_lh][t], cc )
else CSUB( props[prop_pion05_lh][t], cc, props[prop_pion05_lh][t] )
/* heavy-heavy mesons */
cc = su3_dot( &heavyprop[color][i],
&heavyprop[color][i] );
CSUM( props[prop_pion5_hh][t], cc )
if( (x+y)%2==0)CSUM( props[prop_rhoi0_hh][t], cc )
else CSUB( props[prop_rhoi0_hh][t], cc, props[prop_rhoi0_hh][t] )
if( (y+z)%2==0)CSUM( props[prop_rhoi0_hh][t], cc )
else CSUB( props[prop_rhoi0_hh][t], cc, props[prop_rhoi0_hh][t] )
if( (z+x)%2==0)CSUM( props[prop_rhoi0_hh][t], cc )
else CSUB( props[prop_rhoi0_hh][t], cc, props[prop_rhoi0_hh][t] )
if( x%2==0)CSUM( props[prop_rhoi_hh][t], cc )
else CSUB( props[prop_rhoi_hh][t], cc, props[prop_rhoi_hh][t] )
if( y%2==0)CSUM( props[prop_rhoi_hh][t], cc )
else CSUB( props[prop_rhoi_hh][t], cc, props[prop_rhoi_hh][t] )
if( z%2==0)CSUM( props[prop_rhoi_hh][t], cc )
else CSUB( props[prop_rhoi_hh][t], cc, props[prop_rhoi_hh][t] )
if( (x+y+z)%2==0)CSUM( props[prop_pion05_hh][t], cc )
else CSUB( props[prop_pion05_hh][t], cc, props[prop_pion05_hh][t] )
} /* color */
} /* nt-loop */
/* measure the baryon propagator */
for(t=0; t<nt; t++) {
/* define the time value offset t from t_source */
t_off = (t+t_source)%nt;
for(x=0;x<nx;x+=2)for(y=0;y<ny;y+=2)for(z=0;z<nz;z+=2) {
if( node_number(x,y,z,t_off) != mynode() )continue;
i=node_index(x,y,z,t_off);
/* three light quarks */
for(color=0;color<3;color++){
(tmat.e[0][color]) = lightprop[0][i].c[color];
(tmat.e[1][color]) = lightprop[1][i].c[color];
(tmat.e[2][color]) = lightprop[2][i].c[color];
}
cc = det_su3( &tmat );
/* must get sign right. This looks to see if we have
wrapped around the lattice. "t" is the distance
from the source to the measurement, so we are
trying to find out if t_source+t is greater than
or equal to nt. the "-tsource/nt" is in there
so that it will work correctly with tsource=nt. */
if( (((t+t_source)/nt-t_source/nt)%2) == 0 )
CSUM( props[prop_nuc_lll][t], cc )
else /* change sign because antiperiodic b.c. sink point
should really be in a copy of the lattice */
CSUB( props[prop_nuc_lll][t], cc, props[prop_nuc_lll][t] )
/* two lights and one heavy */
for(color=0;color<3;color++){
(tmat.e[0][color]) = lightprop[0][i].c[color];
(tmat.e[1][color]) = lightprop[1][i].c[color];
(tmat.e[2][color]) = heavyprop[2][i].c[color];
}
cc = det_su3( &tmat );
if( (((t+t_source)/nt-t_source/nt)%2) == 0 )
CSUM( props[prop_nuc_llh][t], cc )
else CSUB( props[prop_nuc_llh][t], cc, props[prop_nuc_llh][t] )
/* now repeat for hhl baryon */
for(color=0;color<3;color++){
(tmat.e[0][color]) = lightprop[0][i].c[color];
(tmat.e[1][color]) = heavyprop[1][i].c[color];
(tmat.e[2][color]) = heavyprop[2][i].c[color];
}
cc = det_su3( &tmat );
if( (((t+t_source)/nt-t_source/nt)%2) == 0 )
CSUM( props[prop_nuc_lhh][t], cc )
else CSUB( props[prop_nuc_lhh][t], cc, props[prop_nuc_lhh][t] )
/* and hhh baryon (nonexistent particle!!) */
for(color=0;color<3;color++){
(tmat.e[0][color]) = heavyprop[0][i].c[color];
(tmat.e[1][color]) = heavyprop[1][i].c[color];
(tmat.e[2][color]) = heavyprop[2][i].c[color];
}
cc = det_su3( &tmat );
if( (((t+t_source)/nt-t_source/nt)%2) == 0 )
CSUM( props[prop_nuc_hhh][t], cc )
else CSUB( props[prop_nuc_hhh][t], cc, props[prop_nuc_hhh][t] )
}
} /* nt-loop */
} /* end loop on t_source */
/* Sum propagator arrays over nodes */
/* print out propagators */
g_veccomplexsum( props[0], nprops*nt );
for(i=0;i<nprops;i++)for(j=0;j<nt;j++){
CDIVREAL(props[i][j],n_sources,props[i][j]);
}
if(this_node==0){
/*meson propagators*/
printf("STARTPROP\n");
printf("MASSES: %e %e\n",mass1,mass1 );
printf("SOURCE: CORNER\n");
printf("SINKS: PION_5 PION_05 RHO_i RHO_i0 \n");
for(j=0;j<nt;j++){
printf("%d %e %e %e %e %e %e %e %e\n",j,
props[prop_pion5_ll][j].real, props[prop_pion5_ll][j].imag,
props[prop_pion05_ll][j].real, props[prop_pion05_ll][j].imag,
props[prop_rhoi_ll][j].real, props[prop_rhoi_ll][j].imag,
props[prop_rhoi0_ll][j].real, props[prop_rhoi0_ll][j].imag);
}
printf("ENDPROP\n");
printf("STARTPROP\n");
printf("MASSES: %e %e\n",mass1,mass2 );
printf("SOURCE: CORNER\n");
printf("SINKS: PION_5 PION_05 RHO_i RHO_i0 \n");
for(j=0;j<nt;j++){
printf("%d %e %e %e %e %e %e %e %e\n",j,
props[prop_pion5_lh][j].real, props[prop_pion5_lh][j].imag,
props[prop_pion05_lh][j].real, props[prop_pion05_lh][j].imag,
props[prop_rhoi_lh][j].real, props[prop_rhoi_lh][j].imag,
props[prop_rhoi0_lh][j].real, props[prop_rhoi0_lh][j].imag);
}
printf("ENDPROP\n");
printf("STARTPROP\n");
printf("MASSES: %e %e\n",mass2,mass2 );
printf("SOURCE: CORNER\n");
printf("SINKS: PION_5 PION_05 RHO_i RHO_i0 \n");
for(j=0;j<nt;j++){
printf("%d %e %e %e %e %e %e %e %e\n",j,
props[prop_pion5_hh][j].real, props[prop_pion5_hh][j].imag,
props[prop_pion05_hh][j].real, props[prop_pion05_hh][j].imag,
props[prop_rhoi_hh][j].real, props[prop_rhoi_hh][j].imag,
props[prop_rhoi0_hh][j].real, props[prop_rhoi0_hh][j].imag);
}
printf("ENDPROP\n");
/* Baryon propagators */
printf("STARTPROP\n");
printf("MASSES: %e %e %e\n",mass1,mass1,mass1);
printf("SOURCE: CORNER\n"); printf("SINKS: NUCLEON \n");
for(j=0;j<nt;j++){
printf("%d %e %e\n",j,
props[prop_nuc_lll][j].real, props[prop_nuc_lll][j].imag);
}
printf("ENDPROP\n");
printf("STARTPROP\n");
printf("MASSES: %e %e %e\n",mass1,mass1,mass2);
printf("SOURCE: CORNER\n"); printf("SINKS: NUCLEON \n");
for(j=0;j<nt;j++){
printf("%d %e %e\n",j,
props[prop_nuc_llh][j].real, props[prop_nuc_llh][j].imag);
}
printf("ENDPROP\n");
printf("STARTPROP\n");
printf("MASSES: %e %e %e\n",mass1,mass2,mass2);
printf("SOURCE: CORNER\n"); printf("SINKS: NUCLEON \n");
for(j=0;j<nt;j++){
printf("%d %e %e\n",j,
props[prop_nuc_lhh][j].real, props[prop_nuc_lhh][j].imag);
}
printf("ENDPROP\n");
printf("STARTPROP\n");
printf("MASSES: %e %e %e\n",mass2,mass2,mass2);
printf("SOURCE: CORNER\n"); printf("SINKS: NUCLEON \n");
for(j=0;j<nt;j++){
printf("%d %e %e\n",j,
props[prop_nuc_hhh][j].real, props[prop_nuc_hhh][j].imag);
}
printf("ENDPROP\n");
fflush(stdout);
} /* end if(this_node==0) */
/* free arrays */
free(props[0]); free(props);
for(color=0;color<3;color++){
free( lightprop[color] );
free( heavyprop[color] );
}
return(cgn);
} /* spectrum_nd */
complex trace(matrix *m) {
register complex tc;
CADD(m->e[0][0], m->e[1][1], tc);
CSUM(tc, m->e[2][2]);
return tc;
}
void trace_sum(matrix *m, complex *c) {
CSUM(*c, m->e[0][0]);
CSUM(*c, m->e[1][1]);
CSUM(*c, m->e[2][2]);
}
complex wvec_dot( wilson_vector *a, wilson_vector *b ){
#ifndef FAST
complex temp1,temp2;
register int i;
temp1.real = temp1.imag = 0.0;
for(i=0;i<4;i++){
CMULJ_(a->d[i].c[0],b->d[i].c[0],temp2); CSUM(temp1,temp2);
CMULJ_(a->d[i].c[1],b->d[i].c[1],temp2); CSUM(temp1,temp2);
CMULJ_(a->d[i].c[2],b->d[i].c[2],temp2); CSUM(temp1,temp2);
}
return(temp1);
#else
#ifdef NATIVEDOUBLE
register double ar,ai,br,bi,cr,ci;
#else
register Real ar,ai,br,bi,cr,ci;
#endif
register complex cc;
ar=a->d[0].c[0].real; ai=a->d[0].c[0].imag;
br=b->d[0].c[0].real; bi=b->d[0].c[0].imag;
cr = ar*br + ai*bi;
ci = ar*bi - ai*br;
ar=a->d[0].c[1].real; ai=a->d[0].c[1].imag;
br=b->d[0].c[1].real; bi=b->d[0].c[1].imag;
cr += ar*br + ai*bi;
ci += ar*bi - ai*br;
ar=a->d[0].c[2].real; ai=a->d[0].c[2].imag;
br=b->d[0].c[2].real; bi=b->d[0].c[2].imag;
cr += ar*br + ai*bi;
ci += ar*bi - ai*br;
ar=a->d[1].c[0].real; ai=a->d[1].c[0].imag;
br=b->d[1].c[0].real; bi=b->d[1].c[0].imag;
cr += ar*br + ai*bi;
ci += ar*bi - ai*br;
ar=a->d[1].c[1].real; ai=a->d[1].c[1].imag;
br=b->d[1].c[1].real; bi=b->d[1].c[1].imag;
cr += ar*br + ai*bi;
ci += ar*bi - ai*br;
ar=a->d[1].c[2].real; ai=a->d[1].c[2].imag;
br=b->d[1].c[2].real; bi=b->d[1].c[2].imag;
cr += ar*br + ai*bi;
ci += ar*bi - ai*br;
ar=a->d[2].c[0].real; ai=a->d[2].c[0].imag;
br=b->d[2].c[0].real; bi=b->d[2].c[0].imag;
cr += ar*br + ai*bi;
ci += ar*bi - ai*br;
ar=a->d[2].c[1].real; ai=a->d[2].c[1].imag;
br=b->d[2].c[1].real; bi=b->d[2].c[1].imag;
cr += ar*br + ai*bi;
ci += ar*bi - ai*br;
ar=a->d[2].c[2].real; ai=a->d[2].c[2].imag;
br=b->d[2].c[2].real; bi=b->d[2].c[2].imag;
cr += ar*br + ai*bi;
ci += ar*bi - ai*br;
ar=a->d[3].c[0].real; ai=a->d[3].c[0].imag;
br=b->d[3].c[0].real; bi=b->d[3].c[0].imag;
cr += ar*br + ai*bi;
ci += ar*bi - ai*br;
ar=a->d[3].c[1].real; ai=a->d[3].c[1].imag;
br=b->d[3].c[1].real; bi=b->d[3].c[1].imag;
cr += ar*br + ai*bi;
ci += ar*bi - ai*br;
ar=a->d[3].c[2].real; ai=a->d[3].c[2].imag;
br=b->d[3].c[2].real; bi=b->d[3].c[2].imag;
cr += ar*br + ai*bi;
ci += ar*bi - ai*br;
cc.real = cr;
cc.imag = ci;
return(cc);
#endif
}
static dirac_matrix mult_swv_na( spin_wilson_vector *a,
spin_wilson_vector *b )
{
dirac_matrix c;
#ifndef INLINE
complex temp1,temp2;
register int si,sf,s;
// flops 8*3*4*4*4 = 1536
for(si=0;si<4;si++)for(sf=0;sf<4;sf++) {
temp1.real = temp1.imag = 0.0;
for(s=0;s<4;s++){
CMUL_J(a->d[si].d[s].c[0],b->d[sf].d[s].c[0],temp2); CSUM(temp1,temp2);
CMUL_J(a->d[si].d[s].c[1],b->d[sf].d[s].c[1],temp2); CSUM(temp1,temp2);
CMUL_J(a->d[si].d[s].c[2],b->d[sf].d[s].c[2],temp2); CSUM(temp1,temp2);
}
c.d[si].d[sf] = temp1;
}
return c;
#else
#ifdef NATIVEDOUBLE
register double ar,ai,br,bi,cr,ci;
#else
register Real ar,ai,br,bi,cr,ci;
#endif
register int si,sf;
for(si=0;si<4;si++)for(sf=0;sf<4;sf++) {
ar=a->d[si].d[0].c[0].real; ai=a->d[si].d[0].c[0].imag;
br=b->d[sf].d[0].c[0].real; bi=b->d[sf].d[0].c[0].imag;
cr = br*ar + bi*ai;
ci = br*ai - bi*ar;
ar=a->d[si].d[0].c[1].real; ai=a->d[si].d[0].c[1].imag;
br=b->d[sf].d[0].c[1].real; bi=b->d[sf].d[0].c[1].imag;
cr += br*ar + bi*ai;
ci += br*ai - bi*ar;
ar=a->d[si].d[0].c[2].real; ai=a->d[si].d[0].c[2].imag;
br=b->d[sf].d[0].c[2].real; bi=b->d[sf].d[0].c[2].imag;
cr += br*ar + bi*ai;
ci += br*ai - bi*ar;
ar=a->d[si].d[1].c[0].real; ai=a->d[si].d[1].c[0].imag;
br=b->d[sf].d[1].c[0].real; bi=b->d[sf].d[1].c[0].imag;
cr += br*ar + bi*ai;
ci += br*ai - bi*ar;
ar=a->d[si].d[1].c[1].real; ai=a->d[si].d[1].c[1].imag;
br=b->d[sf].d[1].c[1].real; bi=b->d[sf].d[1].c[1].imag;
cr += br*ar + bi*ai;
ci += br*ai - bi*ar;
ar=a->d[si].d[1].c[2].real; ai=a->d[si].d[1].c[2].imag;
br=b->d[sf].d[1].c[2].real; bi=b->d[sf].d[1].c[2].imag;
cr += br*ar + bi*ai;
ci += br*ai - bi*ar;
ar=a->d[si].d[2].c[0].real; ai=a->d[si].d[2].c[0].imag;
br=b->d[sf].d[2].c[0].real; bi=b->d[sf].d[2].c[0].imag;
cr += br*ar + bi*ai;
ci += br*ai - bi*ar;
ar=a->d[si].d[2].c[1].real; ai=a->d[si].d[2].c[1].imag;
br=b->d[sf].d[2].c[1].real; bi=b->d[sf].d[2].c[1].imag;
cr += br*ar + bi*ai;
ci += br*ai - bi*ar;
ar=a->d[si].d[2].c[2].real; ai=a->d[si].d[2].c[2].imag;
br=b->d[sf].d[2].c[2].real; bi=b->d[sf].d[2].c[2].imag;
cr += br*ar + bi*ai;
ci += br*ai - bi*ar;
ar=a->d[si].d[3].c[0].real; ai=a->d[si].d[3].c[0].imag;
br=b->d[sf].d[3].c[0].real; bi=b->d[sf].d[3].c[0].imag;
cr += br*ar + bi*ai;
ci += br*ai - bi*ar;
ar=a->d[si].d[3].c[1].real; ai=a->d[si].d[3].c[1].imag;
br=b->d[sf].d[3].c[1].real; bi=b->d[sf].d[3].c[1].imag;
cr += br*ar + bi*ai;
ci += br*ai - bi*ar;
ar=a->d[si].d[3].c[2].real; ai=a->d[si].d[3].c[2].imag;
br=b->d[sf].d[3].c[2].real; bi=b->d[sf].d[3].c[2].imag;
cr += br*ar + bi*ai;
ci += br*ai - bi*ar;
c.d[si].d[sf].real = cr;
c.d[si].d[sf].imag = ci;
}
return c;
#endif
}
void f_meas_imp_field( int npbp_reps, quark_invert_control *qic, Real mass,
int naik_term_epsilon_index, fermion_links_t *fl){
imp_ferm_links_t* fn = get_fm_links(fl)[naik_term_epsilon_index];
#ifdef DM_DU0
imp_ferm_links_t* fn_du0 = get_fm_du0_links(fl)[naik_term_epsilon_index];
#endif
#if ( FERM_ACTION == HISQ || FERM_ACTION == HYPISQ ) & defined(DM_DEPS)
imp_ferm_links_t *fn_deps = get_fn_deps_links(fl);
#endif
Real r_psi_bar_psi_even, i_psi_bar_psi_even;
Real r_psi_bar_psi_odd, i_psi_bar_psi_odd;
Real r_ferm_action;
/* local variables for accumulators */
register int i;
double rfaction;
double_complex pbp_e, pbp_o;
complex cc;
int jpbp_reps;
su3_vector *gr = NULL;
su3_vector *M_gr = NULL;
su3_vector *M_inv_gr = NULL;
#ifdef DM_DU0
double r_pb_dMdu_p_even, r_pb_dMdu_p_odd;
su3_vector *dMdu_x = NULL;
#endif
#if ( FERM_ACTION == HISQ || FERM_ACTION == HYPISQ ) & defined(DM_DEPS)
double r_pb_dMdeps_p_even, r_pb_dMdeps_p_odd;
su3_vector *dMdeps_x = NULL;
#endif
#ifdef CHEM_POT
double_complex pb_dMdmu_p_e, pb_dMdmu_p_o;
double_complex pb_d2Mdmu2_p_e, pb_d2Mdmu2_p_o;
double MidM_MidM;
su3_vector *dM_M_inv_gr = NULL;
su3_vector *d2M_M_inv_gr = NULL;
su3_vector *M_inv_dM_M_inv_gr = NULL;
su3_vector *dM_M_inv_dM_M_inv_gr = NULL;
#endif
/* Loop over random sources */
for(jpbp_reps = 0; jpbp_reps < npbp_reps; jpbp_reps++){
rfaction = (double)0.0;
pbp_e = pbp_o = dcmplx((double)0.0,(double)0.0);
/* Make random source, and do inversion */
/* generate gr random; M_gr = M gr */
gr = create_v_field();
#ifndef Z2RSOURCE
grsource_plain_field( gr, EVENANDODD );
#else
z2rsource_plain_field( gr, EVENANDODD );
#endif
/* The following operation is done in the prevailing
precision. The algorithm needs to be fixed! */
M_gr = create_v_field();
ks_dirac_adj_op( gr, M_gr, mass, EVENANDODD, fn );
/* M_inv_gr = M^{-1} gr */
M_inv_gr = create_v_field();
mat_invert_uml_field( gr, M_inv_gr, qic, mass, fn );
#ifdef DM_DU0
r_pb_dMdu_p_even = r_pb_dMdu_p_odd = (double)0.0;
/* dMdu_x = dM/du0 M^{-1} gr */
dMdu_x = create_v_field();
dslash_fn_field( M_inv_gr, dMdu_x, EVENANDODD, fn_du0 );
#endif
#if ( FERM_ACTION == HISQ || FERM_ACTION == HYPISQ ) & defined(DM_DEPS)
r_pb_dMdeps_p_even = r_pb_dMdeps_p_odd = (double)0.0;
/* dMdeps_x = dM/deps0 M^{-1} gr */
dMdeps_x = create_v_field();
dslash_fn_field( M_inv_gr, dMdeps_x, EVENANDODD, fn_deps );
#endif
#ifdef CHEM_POT
pb_dMdmu_p_e = pb_dMdmu_p_o = dcmplx((double)0.0,(double)0.0);
pb_d2Mdmu2_p_e = pb_d2Mdmu2_p_o = dcmplx((double)0.0,(double)0.0);
/* dM_M_inv_gr = dM/dmu * M_inv_gr */
/* d2M_M_inv_gr = d2M/dmu2 * M_inv_gr */
dM_M_inv_gr = create_v_field();
chem_pot_tshift(fn, dM_M_inv_gr, M_inv_gr, 3., -1.);
d2M_M_inv_gr = create_v_field();
chem_pot_tshift(fn, d2M_M_inv_gr, M_inv_gr, 9., 1.);
#endif
/* fermion action = M_gr.M_inv_gr */
/* psi-bar-psi on even sites = gr.M_inv_gr */
FOREVENFIELDSITES(i){
rfaction += su3_rdot( M_gr+i, M_inv_gr+i );
cc = su3_dot( gr+i, M_inv_gr+i );
CSUM(pbp_e, cc);
#ifdef DM_DU0
/* r_pb_dMdu_p_even = gr * dM/du0 M^{-1} gr |even*/
r_pb_dMdu_p_even += su3_rdot( gr+i, dMdu_x+i );
#endif
#if ( FERM_ACTION == HISQ || FERM_ACTION == HYPISQ ) & defined(DM_DEPS)
/* r_pb_dMdu_p_even = gr * dM/du0 M^{-1} gr |even*/
r_pb_dMdeps_p_even += su3_rdot( gr+i, dMdeps_x+i );
#endif
#ifdef CHEM_POT
/* Compute pb_dMdmu_p, pb_d2Mdmu2_p and dM_M_inv on even sites */
cc = su3_dot( gr+i, dM_M_inv_gr+i);
CSUM(pb_dMdmu_p_e, cc);
cc = su3_dot( gr+i, d2M_M_inv_gr+i);
CSUM(pb_d2Mdmu2_p_e, cc);
#endif
}
/* psi-bar-psi on odd sites */
FORODDFIELDSITES(i){
cc = su3_dot( gr+i, M_inv_gr+i );
CSUM(pbp_o, cc);
#ifdef DM_DU0
/* r_pb_dMdu_p_odd = gr * dM/du0 M^{-1} gr |odd*/
r_pb_dMdu_p_odd += su3_rdot( gr+i, dMdu_x+i );
#endif
#if ( FERM_ACTION == HISQ || FERM_ACTION == HYPISQ ) & defined(DM_DEPS)
/* r_pb_dMdu_p_odd = gr * dM/du0 M^{-1} gr |odd*/
r_pb_dMdeps_p_odd += su3_rdot( gr+i, dMdeps_x+i );
#endif
#ifdef CHEM_POT
/* Compute pb_dMdmu_P, pb_d2Mdmu2_p and dM_M_inv on odd sites */
cc = su3_dot( gr+i, dM_M_inv_gr+i);
CSUM(pb_dMdmu_p_o, cc);
cc = su3_dot( gr+i, d2M_M_inv_gr+i);
CSUM(pb_d2Mdmu2_p_o, cc);
#endif
}
#ifdef CHEM_POT
destroy_v_field(d2M_M_inv_gr); d2M_M_inv_gr = NULL;
#endif
destroy_v_field(M_gr); M_gr = NULL;
g_dcomplexsum( &pbp_o );
g_dcomplexsum( &pbp_e );
g_doublesum( &rfaction );
#ifdef DM_DU0
destroy_v_field( dMdu_x ); dMdu_x = NULL;
g_doublesum( &r_pb_dMdu_p_even );
g_doublesum( &r_pb_dMdu_p_odd );
r_pb_dMdu_p_even *= (2.0/(double)volume);
r_pb_dMdu_p_odd *= (2.0/(double)volume);
node0_printf("PB_DMDU_P: mass %e %e %e ( %d of %d )\n", mass,
r_pb_dMdu_p_even, r_pb_dMdu_p_odd, jpbp_reps+1, npbp_reps);
#endif
#if ( FERM_ACTION == HISQ || FERM_ACTION == HYPISQ ) & defined(DM_DEPS)
destroy_v_field( dMdeps_x ); dMdeps_x = NULL;
g_doublesum( &r_pb_dMdeps_p_even );
g_doublesum( &r_pb_dMdeps_p_odd );
r_pb_dMdeps_p_even *= (2.0/(double)volume);
r_pb_dMdeps_p_odd *= (2.0/(double)volume);
node0_printf("PB_DMDEPS_P: mass %e %e %e ( %d of %d )\n", mass,
r_pb_dMdeps_p_even, r_pb_dMdeps_p_odd, jpbp_reps+1, npbp_reps);
#endif
r_psi_bar_psi_odd = pbp_o.real*(2.0/(double)volume) ;
i_psi_bar_psi_odd = pbp_o.imag*(2.0/(double)volume) ;
r_psi_bar_psi_even = pbp_e.real*(2.0/(double)volume) ;
i_psi_bar_psi_even = pbp_e.imag*(2.0/(double)volume) ;
r_ferm_action = rfaction*(1.0/(double)volume) ;
node0_printf("PBP: mass %e %e %e %e %e ( %d of %d )\n", mass,
r_psi_bar_psi_even, r_psi_bar_psi_odd,
i_psi_bar_psi_even, i_psi_bar_psi_odd,
jpbp_reps+1, npbp_reps);
node0_printf("FACTION: mass = %e, %e ( %d of %d )\n", mass,
r_ferm_action, jpbp_reps+1, npbp_reps);
#ifdef CHEM_POT
/* Print results for pb_dMdmu_p and pb_d2Mdmu2_p */
chem_pot_print1(pb_dMdmu_p_e, pb_dMdmu_p_o, pb_d2Mdmu2_p_e, pb_d2Mdmu2_p_o,
mass, jpbp_reps, npbp_reps);
#endif
#ifdef TR_MM_INV
if(npbp_reps > 1){
su3_vector *MM_inv_gr = create_v_field();
double pbp_pbp = 0.0;
mat_invert_uml_field( M_inv_gr, MM_inv_gr, qic, mass, fn );
FORALLFIELDSITES(i){
pbp_pbp += su3_rdot( gr+i, MM_inv_gr+i );
}
g_doublesum( &pbp_pbp );
pbp_pbp = pbp_pbp*(1.0/(double)volume) ;
node0_printf("TR_MM_INV: mass %e, %e ( %d of %d )\n", mass,
pbp_pbp, jpbp_reps+1, npbp_reps);
destroy_v_field(MM_inv_gr);
}
#endif
destroy_v_field(M_inv_gr); M_inv_gr = NULL;
#ifdef CHEM_POT
/* M_inv_dM_M_inv_gr = M^{-1} dM_M_inv_gr */
M_inv_dM_M_inv_gr = create_v_field();
mat_invert_uml_field( dM_M_inv_gr, M_inv_dM_M_inv_gr, qic, mass, fn );
destroy_v_field(dM_M_inv_gr); dM_M_inv_gr = NULL;
/* dM_M_inv_dM_M_inv_gr = dM/dmu M_inv_dM_M_inv_gr */
dM_M_inv_dM_M_inv_gr = create_v_field();
chem_pot_tshift(fn, dM_M_inv_dM_M_inv_gr, M_inv_dM_M_inv_gr, 3., -1.);
destroy_v_field(M_inv_dM_M_inv_gr); M_inv_dM_M_inv_gr = NULL;
/* Compute MidM_MidM */
MidM_MidM = (double)0.0;
FORALLFIELDSITES(i){
MidM_MidM += su3_rdot( gr+i, dM_M_inv_dM_M_inv_gr+i);
}
destroy_v_field(dM_M_inv_dM_M_inv_gr); dM_M_inv_dM_M_inv_gr = NULL;
chem_pot_print2(MidM_MidM, jpbp_reps, npbp_reps, mass);
#endif
destroy_v_field(gr); gr = NULL;
} /* jpbp_reps */
static double dirac_v_tr_gamma(complex *tr, dirac_matrix_v *src,
int gamma, int phase[], Real factor[],
int ct[], int nc, int p_index[])
{
int s2,s; /* spin indices */
int k, c, p, ph;
complex z = {0.,0.};
Real fact;
double flops = 0;
/* One value for each momentum */
for(k=0; k<nc; k++)
tr[k].real = tr[k].imag = 0;
/* For each momentum in list, multiply by gamma and take trace */
for(s=0;s<4;s++){
s2 = gamma_mat(gamma).row[s].column;
switch (gamma_mat(gamma).row[s].phase){
case 0:
for(k=0; k<nc; k++){
c = ct[k];
p = p_index[c];
z = src->d[s2].d[s].e[p];
CSUM(tr[k],z);
}
break;
case 1:
for(k=0; k<nc; k++){
c = ct[k];
p = p_index[c];
TIMESPLUSI( src->d[s2].d[s].e[p], z);
CSUM(tr[k],z);
}
break;
case 2:
for(k=0; k<nc; k++){
c = ct[k];
p = p_index[c];
TIMESMINUSONE( src->d[s2].d[s].e[p], z);
CSUM(tr[k],z);
}
break;
case 3:
for(k=0; k<nc; k++){
c = ct[k];
p = p_index[c];
TIMESMINUSI( src->d[s2].d[s].e[p], z);
CSUM(tr[k],z);
}
}
}
/* Normalization and phase */
for(k=0; k<nc; k++){
c = ct[k];
ph = phase[c];
fact = factor[c];
switch(ph){
case 0:
z = tr[k];
break;
case 1:
TIMESPLUSI( tr[k], z);
break;
case 2:
TIMESMINUSONE( tr[k], z);
break;
case 3:
TIMESMINUSI( tr[k], z);
}
CMULREAL(z,fact,tr[k]);
}
flops = 4*nc;
return flops;
} /* dirac_v_tr_gamma */
void setup_lambda() {
int i, j, k, l, count;
complex inv_sqrt = cmplx(1.0 / sqrt(2.0), 0.0);
complex i_inv_sqrt = cmplx(0.0, 1.0 / sqrt(2.0));
#ifdef DEBUG_CHECK
int a;
complex trace, tt;
node0_printf("Computing generators for U(N)\n");
#endif
// Make sure Lambda matrices are initialized
for (i = 0; i < DIMF; i++)
clear_mat(&(Lambda[i]));
// N * (N - 1) off-diagonal SU(N) generators
// (T^{ij, +})_{kl} = i * (de_{ki} de_{lj} + de_{kj} de_{li}) / sqrt(2)
// (T^{ij, -})_{kl} = (de_{ki} de_{lj} - de_{kj} de_{ki}) / sqrt(2)
// Sign in second chosen to match previous values
count = 0;
for (i = 0; i < NCOL; i++) {
for (j = i + 1; j < NCOL; j++) {
for (k = 0; k < NCOL; k++) {
for (l = 0; l < NCOL; l++) {
if (k == i && l == j) {
CSUM(Lambda[count].e[k][l], i_inv_sqrt);
CSUM(Lambda[count + 1].e[k][l], inv_sqrt);
}
else if (k == j && l == i) {
CSUM(Lambda[count].e[k][l], i_inv_sqrt);
CDIF(Lambda[count + 1].e[k][l], inv_sqrt);
}
}
}
count += 2;
}
}
if (count != NCOL * (NCOL - 1)) {
node0_printf("ERROR: Wrong number of off-diagonal generators, ");
node0_printf("%d vs. %d\n", count, NCOL * (NCOL - 1));
terminate(1);
}
// N - 1 diagonal SU(N) generators
// T^k = i * diag(1, 1, ..., -k, 0, ..., 0) / sqrt(k * (k + 1))
for (i = 0; i < NCOL - 1; i++) {
j = NCOL * (NCOL - 1) + i; // Index after +/- above
k = i + 1;
i_inv_sqrt = cmplx(0.0, 1.0 / sqrt(k * (k + 1.0)));
for (l = 0; l <= k; l++)
Lambda[j].e[l][l] = i_inv_sqrt;
CMULREAL(Lambda[j].e[k][k], -1.0 * k, Lambda[j].e[k][k]);
}
// U(1) generator i * I_N / sqrt(N)
if (DIMF == NCOL * NCOL) { // Allow SU(N) compilation for now
i_inv_sqrt = cmplx(0.0, sqrt(one_ov_N));
clear_mat(&(Lambda[DIMF - 1]));
for (i = 0; i < NCOL; i++)
Lambda[DIMF - 1].e[i][i] = i_inv_sqrt;
}
#ifdef DEBUG_CHECK
// Print Lambdas
for (i = 0; i < DIMF; i++){
node0_printf("Lambda[%d]\n",i);
if (this_node == 0)
dumpmat(&(Lambda[i]));
}
// Test group theory
node0_printf("Check group theory ");
node0_printf("Sum_a Lambda^a_{kl} Lambda^a_{ij} = -delta_kj delta_il\n");
for (i = 0; i < NCOL; i++) {
for (j = 0; j < NCOL; j++) {
for (k = 0; k < NCOL; k++) {
for (l = 0; l < NCOL; l++) {
trace = cmplx(0, 0);
for (a = 0; a < DIMF; a++) {
CMUL(Lambda[a].e[k][l], Lambda[a].e[i][j], tt);
CSUM(trace, tt);
}
if (cabs_sq(&trace) > IMAG_TOL)
node0_printf("Sum_a La^a_{%d%d} La^a_{%d%d} = (%.4g, %.4g)\n",
k, j, i, l, trace.real, trace.imag);
}
}
}
}
#endif
// Test orthogonality and compute products of Lambdas for fermion forces
#ifdef DEBUG_CHECK
for (i = 0; i < DIMF; i++) {
for (j = 0; j < DIMF; j++) {
mult_nn(&(Lambda[i]), &(Lambda[j]), &tmat);
trace = trace(&tmat);
if (trace.real * trace.real > IMAG_TOL)
node0_printf("Tr[T_%d T_%d] = (%.4g, %.4g)\n",
i, j, trace.real, trace.imag);
}
}
#endif
}
/* dest <- dest + sum_i eigVec[i]*H^{-1}*eigVec[i].resid,
resid = src - (-Dslash^2 + 4*mass^2)*dest
*/
static void initCG(su3_vector *src, su3_vector *dest, int Nvecs_curr, int Nvecs_max,
su3_vector **eigVec, double_complex *H, Real mass, int parity,
imp_ferm_links_t *fn){
/* Constants */
int ione = 1;
int otherparity = (parity == EVEN) ? ODD : EVEN;
Real msq_x4 = 4.0*mass*mass;
double dzero = (double)0.0;
double_complex zzero = dcmplx(dzero, dzero);
register int i;
int j, info;
double_complex cc;
double_complex *c, *H2;
su3_vector *resid;
c = (double_complex *)malloc(Nvecs_curr*sizeof(double_complex));
resid = (su3_vector *)malloc(sites_on_node*sizeof(su3_vector));
/* resid <- src - (-Dslash^2 + 4*mass^2)*dest */
dslash_fn_field(dest, resid, otherparity, fn);
dslash_fn_field(resid, resid, parity, fn);
FORSOMEFIELDPARITY_OMP(i, parity, default(shared)){
scalar_mult_sum_su3_vector(resid+i, dest+i, -msq_x4);
add_su3_vector(resid+i, src+i, resid+i);
} END_LOOP_OMP
/* c[i] = eigVec[i].resid */
for(j = 0; j < Nvecs_curr; j++){
// c[j] = zzero;
// FORSOMEFIELDPARITY_OMP(i, parity, private(cc) reduction(+:c[j])){
// cc = su3_dot(eigVec[j]+i, resid+i);
// CSUM(c[j], cc);
// } END_LOOP_OMP
double cctotr=0., cctoti=0.;
FORSOMEFIELDPARITY_OMP(i, parity, private(cc) reduction(+:cctotr,cctoti)){
cc = su3_dot(eigVec[j]+i, resid+i);
cctotr += cc.real;
cctoti += cc.imag;
} END_LOOP_OMP;
c[j].real = cctotr;
c[j].imag = cctoti;
}
g_vecdcomplexsum(c, Nvecs_curr);
free(resid);
H2 = (double_complex *)malloc(Nvecs_curr*Nvecs_curr*sizeof(double_complex));
/* H2 = H + 4*mass^2*I */
for(j = 0; j < Nvecs_curr; j++){
zcopy_(&Nvecs_curr, H+Nvecs_max*j, &ione, H2+Nvecs_curr*j, &ione);
CSUM(H2[(Nvecs_curr+1)*j], dcmplx(msq_x4, dzero));
}
/* Compute H^{-1}*c = H^{-1}*eigVec.resid with Cholesky decomposition */
zpotrf_("U", &Nvecs_curr, H2, &Nvecs_curr, &info);
zpotrs_("U", &Nvecs_curr, &ione, H2, &Nvecs_curr, c, &Nvecs_curr, &info);
free(H2);
/* dest <- dest + sum_j c[i]*eigVec[i] = dest + sum_i eigVec[i]*H^{-1}*eigVec[i].resid */
for(j = 0; j < Nvecs_curr; j++){
FORSOMEFIELDPARITY_OMP(i, parity, default(shared)){
c_scalar_mult_add_su3vec(dest+i, c+j, eigVec[j]+i);
} END_LOOP_OMP
}
free(c);
}
/* do measurements: load density, ploop, etc. and phases onto lattice */
void measure() {
register int i,j,k, c;
register site *s;
int dx,dy,dz; /* separation for correlated observables */
int dir; /* direction of separation */
msg_tag *tag;
register complex cc,dd; /*scratch*/
complex ztr, zcof, znum, zdet, TC, zd, density, zphase;
complex p[4]; /* probabilities of n quarks at a site */
complex np[4]; /* probabilities at neighbor site */
complex pp[4][4]; /* joint probabilities of n here and m there */
complex zplp, plp;
Real locphase, phase;
/* First make T (= timelike P-loop) from s->ploop_t
T stored in s->tempmat1
*/
ploop_less_slice(nt-1,EVEN);
ploop_less_slice(nt-1,ODD);
phase = 0.;
density = plp = cmplx(0.0, 0.0);
for(j=0;j<4;j++){
p[j]=cmplx(0.0,0.0);
for(k=0;k<4;k++)pp[j][k]=cmplx(0.0,0.0);
}
FORALLSITES(i,s) {
if(s->t != nt-1) continue;
mult_su3_nn(&(s->link[TUP]), &(s->ploop_t), &(s->tempmat1));
zplp = trace_su3(&(s->tempmat1));
CSUM(plp, zplp);
ztr = trace_su3(&(s->tempmat1));
CONJG(ztr, zcof);
for(c=0; c<3; ++c) s->tempmat1.e[c][c].real += C;
zdet = det_su3(&(s->tempmat1));
znum = numer(C, ztr, zcof);
CDIV(znum, zdet, zd);
CSUM(density, zd);
/* store n_quark probabilities at this site in lattice variable
qprob[], accumulate sum over lattice in p[] */
cc = cmplx(C*C*C,0.0); CDIV(cc,zdet,s->qprob[0]); CSUM(p[0],s->qprob[0]);
CMULREAL(ztr,C*C,cc); CDIV(cc,zdet,s->qprob[1]); CSUM(p[1],s->qprob[1]);
CMULREAL(zcof,C,cc); CDIV(cc,zdet,s->qprob[2]); CSUM(p[2],s->qprob[2]);
cc = cmplx(1.0,0.0); CDIV(cc,zdet,s->qprob[3]); CSUM(p[3],s->qprob[3]);
locphase = carg(&zdet);
phase += locphase;
}
g_floatsum( &phase );
g_complexsum( &density );
g_complexsum( &p[0] );
g_complexsum( &p[1] );
g_complexsum( &p[2] );
g_complexsum( &p[3] );
g_complexsum( &plp );
CDIVREAL(density,(Real)(nx*ny*nz),density);
CDIVREAL(p[0],(Real)(nx*ny*nz),p[0]);
CDIVREAL(p[1],(Real)(nx*ny*nz),p[1]);
CDIVREAL(p[2],(Real)(nx*ny*nz),p[2]);
CDIVREAL(p[3],(Real)(nx*ny*nz),p[3]);
CDIVREAL(plp,(Real)(nx*ny*nz),plp);
zphase = ce_itheta(phase);
if(this_node == 0) {
printf("ZMES\t%e\t%e\t%e\t%e\t%e\t%e\n", zphase.real, zphase.imag,
density.real, density.imag,
plp.real, plp.imag);
printf("PMES\t%e\t%e\t%e\t%e\t%e\t%e\t%e\t%e\n",
p[0].real, p[0].imag, p[1].real, p[1].imag,
p[2].real, p[2].imag, p[3].real, p[3].imag );
}
#ifdef PPCORR
dx=1; dy=0; dz=0; /* Temporary - right now we just do nearest neighbor */
for(dir=XUP;dir<=ZUP;dir++){
tag = start_gather_site( F_OFFSET(qprob[0]), 4*sizeof(complex), dir,
EVENANDODD, gen_pt[0] );
wait_gather(tag);
FORALLSITES(i,s)if(s->t==nt-1){
for(j=0;j<4;j++)for(k=0;k<4;k++){
CMUL( (s->qprob)[j],((complex *)gen_pt[0][i])[k],cc);
CSUM(pp[j][k],cc);
}
}
cleanup_gather(tag);
}
/* density correlation format:
PP dx dy dz n1 n2 real imag */
for(j=0;j<4;j++)for(k=0;k<4;k++){
g_complexsum( &pp[j][k] );
CDIVREAL(pp[j][k],(Real)(3*nx*ny*nz),pp[j][k]);
if(this_node==0)
printf("PP %d %d %d %d %d %e %e\n",dx,dy,dz,j,k,
pp[j][k].real,pp[j][k].imag);
}
#endif /*PPCORR*/
}
int congrad_xxx(
field_offset src, /* type wilson_vector (where source is to be created)*/
Real cgmass, /* unused here*/
int source_chirality /* chirality sector for inversion (NOT USED) */
)
{
register int i;
register site *s;
int j,k, avs_iters, avm_iters,status,flag;
int MaxCG;
int ksource, spin,color,my_chirality,chb,che,chbo,cheo,ii,jj;
Real *RsdCG;
Real size_r,one_minus_m,r02inv;
wilson_vector **psim;
void setup_multi();
w_prop_file *fp_out_w[MAX_MASSES]; /* For propagator files */
w_prop_file *fp_in_w[MAX_MASSES]; /* For propagator files */
w_prop_file *h0_out_w[MAX_MASSES]; /* For intermediate propagator files */
#ifdef EIGO
wilson_vector wproj;
complex ctmp,cd,*cproj;
int l;
int icount, ivec;
int *chiral_check;
Real cdp, cdm;
Real *ca, *cb;
Real eps, mu, denom;
#endif
double source_norm;
RsdCG=resid;
MaxCG=niter;
avs_iters=0;
r02inv= -0.5/R0;
#ifdef MINN
do_minn=1;
#endif
setup_multi();
#ifdef EIGO
if(Nvecs_hov != 0)cproj = (complex *)malloc(Nvecs_hov*sizeof(complex));
/* check chirality of your modes (to identify zero modes) */
if(Nvecs_hov != 0)chiral_check= (int *)malloc(Nvecs_hov*sizeof(int));
for(j=0;j<Nvecs_hov;j++){
cdp=0.0;
cdm=0.0;
FORALLSITES(i,s){
for(l=0;l<2;l++)for(k=0;k<3;k++){
cdp += cabs_sq(&(eigVec[j][i].d[l].c[k]));
}
for(l=2;l<4;l++)for(k=0;k<3;k++){
cdm += cabs_sq(&(eigVec[j][i].d[l].c[k]));
}
}
g_floatsum(&cdp);
g_floatsum(&cdm);
if(cdm< 1.e-6 && cdp >1.e-6)
chiral_check[j] =1;
else if (cdm >1.e-6 && cdp < 1.e-6)
chiral_check[j] = -1;
else if (cdm >1.e-6 && cdp > 1.e-6)
chiral_check[j] =0;
else{
node0_printf("eigVec0[%d] is a null vector!\n",j);
exit(1);
}
}
/* the mode propagator matrix */
/* I am stupid--how to do this in a 2-d array?? */
if(Nvecs_hov != 0){
ca= (Real *)malloc(num_masses*Nvecs_hov*sizeof(Real));
cb= (Real *)malloc(num_masses*Nvecs_hov*sizeof(Real));
}
/* initialize the coefficients of the propagator matrix for modes */
for(k=0;k<num_masses;k++)for(ivec=0;ivec<Nvecs_hov;ivec++){
icount=Nvecs_hov*k + ivec;
if(chiral_check[ivec]==0){
mu=mass[k]/(2.0*R0);
eps= sqrt(eigVal[ivec])/(2.0*R0);
denom= (mu*mu+eps*eps*(1.0-mu*mu))*2.0*R0;
ca[icount]= mu*(1.0-eps*eps)/denom;
cb[icount]= eps*sqrt(1.0-eps*eps)/denom;
}
else{
ca[icount]= 1.0/mass[k];
cb[icount]= 0.0;
}
node0_printf("mass %e mode %d %d %e %e\n",mass[k],ivec,
chiral_check[ivec],ca[icount],cb[icount]);
}
#endif
/* open the prop files */
for(k=0;k<num_masses;k++){
fp_in_w[k] = r_open_wprop(startflag_w[k], startfile_w[k]);
fp_out_w[k] = w_open_wprop(saveflag_w[k], savefile_w[k], wqs.type);
#ifdef H0INV
h0_out_w[k] = w_open_wprop(saveflag_w3[k], savefile_w3[k], wqs.type);
#endif
}
for(ksource = 0; ksource < wqs.nsource; ksource++){
spin = convert_ksource_to_spin(ksource);
color = convert_ksource_to_color(ksource);
// /* Loop over source spins */
// for(spin=0;spin<4;spin++){
// /* Loop over source colors */
// for(color=0;color<3;color++){
node0_printf("Propagator color %d spin %d\n",color,spin);
if(startflag_w[0] == FRESH){flag=0;}
else{
/* check if there's a propagator already there--Do for all masses */
flag=1;
for(k=0;k<num_masses && flag==1 ;k++){
#ifdef IOTIME
status = reload_wprop_sc_to_site( startflag_w[k], fp_in_w[k],
&wqs, spin, color, F_OFFSET(psi),1);
#else
status = reload_wprop_sc_to_site( startflag_w[k], fp_in_w[k],
&wqs, spin, color, F_OFFSET(psi),0);
#endif
if(status != 0){
node0_printf("congrad_outer_p: computing prop\n");
/*
reload_wprop_sc_to_site( FRESH, fp_in_w[k],
&wqs, spin, color, F_OFFSET(psi),0);
*/
flag = 0;
}
else{ /* status = 1--put the propagator in the new output file
so all the elements are in one place. This will fail if
the propagator generation did not write the same number of elements
for each mass value propagator */
#ifdef IOTIME
save_wprop_sc_from_site( saveflag_w[k],fp_out_w[k],
&wqs, spin,color,F_OFFSET(psi),1);
#else
save_wprop_sc_from_site( saveflag_w[k],fp_out_w[k],
&wqs, spin,color,F_OFFSET(psi),0);
#endif
}
} /* k loop */
} /*startflag_w != FRESH */
if(flag==0){ /* proceed to inversion */
if(spin<2){my_chirality=1;chb=0;che=2;chbo=2;cheo=4;}
else {my_chirality= -1;chb=2,che=4;chbo=0;cheo=2;}
chirality_flag=my_chirality;
/* Make source */
/* Complete the source structure */
/* NEEDS FIXING!! */
// wqs.color = color;
// wqs.spin = spin;
/* For wilson_info */
wqstmp = wqs;
// status = w_source_site(src,&wqs);
status = wv_source_site(src,&wqs);
/* check original source size... */
source_norm=0.0;
FORALLSITES(i,s){
source_norm += (double)magsq_wvec(((wilson_vector *)F_PT(s,src)) );
}
g_doublesum( &source_norm );
if(this_node==0){
printf("Original: source_norm = %e\n",source_norm);
fflush(stdout);
}
FORALLSITES(i,s) copy_wvec((wilson_vector *)F_PT(s,src),&(s->chi0));
#ifdef EIGO
/* project out the eigenvectors from the source */
node0_printf("removing %d modes from source\n",Nvecs_hov);
for(j=0;j<Nvecs_hov;j++){
cd=cmplx(0.0,0.0);
FORALLSITES(i,s){
/* wproj will hold the chiral projections--
recall we have ``packed'' two chiralities into eigVec */
clear_wvec(&wproj);
for(ii=chb;ii<che;ii++)for(jj=0;jj<3;jj++){
wproj.d[ii].c[jj]=eigVec[j][i].d[ii].c[jj];
}
ctmp = wvec_dot( &(wproj),(wilson_vector *)F_PT(s,src));
CSUM(cd,ctmp);
}
g_complexsum(&cd);
cproj[j]=cd;
node0_printf("projector %d %e %e\n",j,cproj[j].real,cproj[j].imag);
CMULREAL(cd,-1.0,cd);
FORALLSITES(i,s){
clear_wvec(&wproj);
for(ii=chb;ii<che;ii++)for(jj=0;jj<3;jj++){
wproj.d[ii].c[jj]=eigVec[j][i].d[ii].c[jj];
}
c_scalar_mult_add_wvec(&(s->chi0), &(wproj),
&cd, &(s->chi0) );
}
}
