int main(int argc,char *argv[])
{
int meascount;
int prompt;
Real avm_iters,avs_iters;
double starttime,endtime,dclock();
double dtime;
int MinCG,MaxCG;
Real RsdCG;
register int i;
register site *s;
int spinindex,spin,color,j,k,t,t_off;
int kh,kl;
int nr_fb;
char nr_fb_label[3][2] = { "0", "F", "B" };
int flag;
int kprop;
int num_prop;
Real space_vol;
int status;
propagator hdibar_prop[MAX_KAP][MAX_KAP][HDIPROPS];
propagator nrbar_prop[MAX_KAP][MAX_KAP][NRPROPS];
char scratch_file[MAX_KAP][MAXFILENAME];
Real norm_fac[10];
static char *mes_kind[10] = {"PION","PS505","PS055","PS0505",
"RHO33","RHO0303","SCALAR","SCALA0","PV35","B12"};
complex *pmes_prop[MAX_KAP][MAX_KAP][10];
int pmes_prop_done[MAX_KAP][MAX_KAP];
w_prop_file *fp_in_w[MAX_KAP]; /* For reading binary propagator files */
w_prop_file *fp_out_w[MAX_KAP]; /* For writing binary propagator files */
w_prop_file *fp_scr[MAX_KAP];
initialize_machine(&argc,&argv);
#ifdef HAVE_QDP
QDP_initialize(&argc, &argv);
#endif
/* Remap standard I/O */
if(remap_stdio_from_args(argc, argv) == 1)terminate(1);
g_sync();
/* set up */
prompt = setup_H_cl();
/* loop over input sets */
while( readin(prompt) == 0)
{
MaxCG = niter;
starttime=dclock();
avm_iters=0.0;
meascount=0;
/* Allocate space for relativistic meson propagator */
for(num_prop=0;num_prop<10;num_prop++)
for(i=0;i<num_kap;i++)for(j=0;j<=i;j++){
pmes_prop[i][j][num_prop] = (complex *)malloc(nt*sizeof(complex));
for(t=0;t<nt;t++){
pmes_prop[i][j][num_prop][t] = cmplx(0.0,0.0);
}
pmes_prop_done[i][j] = 0;
}
/* Allocate space for non relativistic baryon propagators */
for(kprop=0;kprop<NRPROPS;kprop++)
for(i=0;i<num_kap;i++)for(j=0;j<num_kap;j++){
nrbar_prop[i][j][kprop].c
= (complex *)malloc(nt*sizeof(complex));
if(nrbar_prop[i][j][kprop].c == NULL)
{
printf("control_H_cl: Can't malloc nrbar prop %d %d %d\n",
i,j,kprop);
terminate(1);
}
for(t=0;t<nt;t++)nrbar_prop[i][j][kprop].c[t]
= cmplx(0.0,0.0);
nrbar_prop[i][j][kprop].label
= (char *)malloc(10*sizeof(char));
if(nrbar_prop[i][j][kprop].c == NULL)
{
printf("control_H_cl: Can't malloc nrbar prop label %d %d %d\n",
i,j,kprop);
terminate(1);
}
}
/* Allocate space for H-dibaryon channel propagators */
for(kprop=0;kprop<HDIPROPS;kprop++)
for(kh=0;kh<num_kap_heavy;kh++)for(kl=0;kl<num_kap_light;kl++){
/* kappa indexing scheme is consistent with baryon propagator
even though we compute only the propagators with
one heavy (s) quark and two light (u,d) quarks */
i = kh; j = kl + num_kap_heavy;
hdibar_prop[i][j][kprop].c
= (complex *)malloc(nt*sizeof(complex));
if(hdibar_prop[i][j][kprop].c == NULL)
{
printf("control_H_cl: Can't malloc baryon prop %d %d %d\n",
i,j,kprop);
terminate(1);
}
for(t=0;t<nt;t++)hdibar_prop[i][j][kprop].c[t]
= cmplx(0.0,0.0);
hdibar_prop[i][j][kprop].label
= (char *)malloc(10*sizeof(char));
if(hdibar_prop[i][j][kprop].label == NULL)
{
printf("control_H_cl: Can't malloc baryon prop label %d %d %d\n",
i,j,kprop);
terminate(1);
}
}
if( fixflag == COULOMB_GAUGE_FIX)
{
if(this_node == 0)
printf("Fixing to Coulomb gauge\n");
STARTIOTIME;
gaugefix(TUP,(Real)1.5,500,GAUGE_FIX_TOL);
STOPIOTIME("gauge fix");
invalidate_this_clov(gen_clov);
}
else
if(this_node == 0)printf("COULOMB GAUGE FIXING SKIPPED.\n");
/* save lattice if requested */
if( saveflag != FORGET ){
/* Note: beta, kappa are kept only for save_old_binary */
STARTIOTIME;
savelat_p = save_lattice( saveflag, savefile, stringLFN );
STOPIOTIME("save lattice");
}
if(this_node==0)printf("END OF HEADER\n");
/* Loop over all kappas to compute and store quark propagator */
for(k=0;k<num_kap;k++){
kappa = kap[k];
source_r0=wqs[k].r0;
RsdCG=resid[k];
if(this_node==0)printf("Kappa=%e r0=%e residue=%e\n",
(double)kappa,(double)source_r0,(double)RsdCG);
/* open file for kth wilson propagator */
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[k].type);
/* Open scratch file and write header */
sprintf(scratch_file[k],"%s_%02d",scratchstem_w,k);
if(scratchflag == SAVE_CHECKPOINT)
{
fp_scr[k] = w_checkpoint_w_i(scratch_file[k]);
/* Close, temporarily */
w_checkpoint_w_c(fp_scr[k]);
}
else
/* If serial, write header and leave it open */
fp_scr[k] = w_serial_w_i(scratch_file[k]);
/* Loop over source colors */
for(color=0;color<3;color++){
for(spinindex=0;spinindex<n_spins;spinindex++){
spin = spins[spinindex];
meascount ++;
if(this_node==0)printf("color=%d spin=%d\n",color,spin);
if(startflag_w[k] == CONTINUE)
{
if(k == 0)
{
node0_printf("Can not continue propagator here! Zeroing it instead\n");
startflag_w[k] = FRESH;
}
else
{
FORALLSITES(i,s)
copy_wvec(&(s->quark_propagator.c[color].d[spin]),
&(s->psi));
}
}
/* Saves one multiplication by zero in cgilu */
if(startflag_w[k] == FRESH)flag = 0;
else
flag = 1;
/* load psi if requested */
#ifdef IOTIME
status = reload_wprop_sc_to_site( startflag_w[k], fp_in_w[k],
spin, color, F_OFFSET(psi),1);
#else
status = reload_wprop_sc_to_site( startflag_w[k], fp_in_w[k],
spin, color, F_OFFSET(psi),0);
#endif
if(status != 0)
{
node0_printf("control_H_cl: Recovering from error by resetting initial guess to zero\n");
reload_wprop_sc_to_site( FRESH, fp_in_w[k],
spin, color, F_OFFSET(psi),0);
flag = 0;
}
/* Invert to find propagator */
/* Complete the source structure */
wqs[k].color = color;
wqs[k].spin = spin;
/* For clover_info */
wqstmp = wqs[k];
/* If we are starting afresh, we set a minimum number
of iterations */
if(startflag_w[k] == FRESH || status != 0)MinCG = nt;
else MinCG = 0;
/* Load inversion control structure */
qic.prec = PRECISION;
qic.min = MinCG;
qic.max = MaxCG;
qic.nrestart = nrestart;
qic.resid = RsdCG;
qic.start_flag = flag;
/* Load Dirac matrix parameters */
dcp.Kappa = kappa;
dcp.Clov_c = clov_c;
dcp.U0 = u0;
#ifdef BI
/* compute the propagator. Result in psi. */
avs_iters
= (Real)wilson_invert_site_wqs(F_OFFSET(chi),F_OFFSET(psi),
w_source,&wqs[k],
bicgilu_cl_site,&qic,(void *)&dcp);
#else
/* compute the propagator. Result in psi. */
avs_iters =
(Real)wilson_invert_site_wqs(F_OFFSET(chi),F_OFFSET(psi),
w_source,&wqs[k],
cgilu_cl_site,&qic,(void *)&dcp);
#endif
avm_iters += avs_iters;
FORALLSITES(i,s)
copy_wvec(&(s->psi),
&(s->quark_propagator.c[color].d[spin]));
STARTIOTIME;
/* Write psi to scratch disk */
if(scratchflag == SAVE_CHECKPOINT)
{
w_checkpoint_w_o(fp_scr[k]);
w_checkpoint_w(fp_scr[k],spin,color,F_OFFSET(psi));
w_checkpoint_w_c(fp_scr[k]);
}
else
w_serial_w(fp_scr[k],spin,color,F_OFFSET(psi));
STOPIOTIME("do fast quark dump");
/* save psi if requested */
#ifdef IOTIME
save_wprop_sc_from_site( saveflag_w[k],fp_out_w[k],
spin,color,F_OFFSET(psi),1);
#else
save_wprop_sc_from_site( saveflag_w[k],fp_out_w[k],
spin,color,F_OFFSET(psi),0);
#endif
} /* source spins */
} /* source colors */
/* Close and release scratch file */
if(scratchflag == SAVE_CHECKPOINT)
w_checkpoint_w_f(fp_scr[k]);
else
w_serial_w_f(fp_scr[k]);
if(this_node==0)printf("Saved binary wilson_vector in file %s\n",
scratch_file[k]);
/* close files for wilson propagators */
r_close_wprop(startflag_w[k],fp_in_w[k]);
w_close_wprop(saveflag_w[k],fp_out_w[k]);
} /* kappas */
/* Loop over choice forward - backward for NR source and sink */
for(nr_fb = 1; nr_fb <= 2; nr_fb++)if(nr_fb & nr_forw_back)
{
/* Reset completion flags */
for(i=0;i<num_kap;i++)for(j=0;j<num_kap;j++){
for(kprop=0;kprop<NRPROPS;kprop++)
nrbar_prop[i][j][kprop].done = 0;
for(kprop=0;kprop<HDIPROPS;kprop++)
hdibar_prop[i][j][kprop].done = 0;
}
/* Loop over heavy kappas for the point sink spectrum */
for(k=0;k<num_kap_heavy;k++){
/* Read the kth heavy kappa propagator from the scratch file */
kappa = kappa_heavy = kap[k];
if(scratchflag == SAVE_CHECKPOINT)
fp_scr[k] = r_parallel_w_i(scratch_file[k]);
else
fp_scr[k] = r_serial_w_i(scratch_file[k]);
STARTIOTIME;
for(color=0;color<3;color++) for(spin=0;spin<4;spin++){
if(scratchflag == SAVE_CHECKPOINT)
r_parallel_w(fp_scr[k], spin, color,
F_OFFSET(quark_propagator.c[color].d[spin]));
else
r_serial_w(fp_scr[k], spin, color,
F_OFFSET(quark_propagator.c[color].d[spin]));
}
STOPIOTIME("to read 12 spin-color combinations");
if(scratchflag == SAVE_CHECKPOINT)
r_parallel_w_f(fp_scr[k]);
else
r_serial_w_f(fp_scr[k]);
/* Convert to NR propagator */
STARTPRTIME;
nr_propagator(F_OFFSET(quark_propagator),
F_OFFSET(nr_prop1), nr_fb);
diquarkprop(F_OFFSET(nr_prop1),
F_OFFSET(diquark_prop1));
STOPPRTIME("make nr and diquark");
/* Diagonal spectroscopy - not needed */
/** w_nrbaryon(F_OFFSET(nr_prop1), F_OFFSET(nr_prop1),
F_OFFSET(diquark_prop1), nrbar_prop[k][k]); **/
/** w_hdibaryon(F_OFFSET(diquark_prop1),
F_OFFSET(diquark_prop1), hdibar_prop[k][k]); **/
/* Heavy-light spectroscopy */
/* Loop over light kappas for the point sink spectrum */
for(j=num_kap_heavy;j<num_kap;j++){
/* Read the propagator from the scratch file */
kappa = kappa_light = kap[j];
if(scratchflag == SAVE_CHECKPOINT)
fp_scr[j] = r_parallel_w_i(scratch_file[j]);
else
fp_scr[j] = r_serial_w_i(scratch_file[j]);
STARTIOTIME;
for(color=0;color<3;color++) for(spin=0;spin<4;spin++){
if(scratchflag == SAVE_CHECKPOINT)
r_parallel_w(fp_scr[j], spin, color,
F_OFFSET(quark_prop2.c[color].d[spin]));
else
r_serial_w(fp_scr[j], spin, color,
F_OFFSET(quark_prop2.c[color].d[spin]));
}
STOPIOTIME("do fast quark read");
if(scratchflag == SAVE_CHECKPOINT)
r_parallel_w_f(fp_scr[j]);
else
r_serial_w_f(fp_scr[j]);
/* Convert to NR propagator */
STARTPRTIME;
nr_propagator(F_OFFSET(quark_prop2),
F_OFFSET(nr_prop2),nr_fb);
diquarkprop(F_OFFSET(nr_prop2),
F_OFFSET(diquark_prop2));
STOPPRTIME("make nr and diquark propagators");
/* Diagonal spectroscopy - baryons only - done if
any of them was not previously done */
for(kprop=0;kprop<NRPROPS;kprop++)
{
if(nrbar_prop[j][j][kprop].done == 0)
{
STARTPRTIME;
w_nrbaryon(F_OFFSET(nr_prop2), F_OFFSET(nr_prop2),
F_OFFSET(diquark_prop2), nrbar_prop[j][j]);
STOPPRTIME("do diagonal baryons");
break;
}
}
/* Heavy-light spectroscopy - baryons and H */
/* We don't do baryon heavy-light if the kappa values
are the same, since the result is the same as the
diagonal light propagator */
if(kappa_heavy != kappa_light)
{
/* Relativistic meson propagator: Do only once */
if(pmes_prop_done[j][k] == 0) {
STARTPRTIME;
for(color=0;color<3;color++){
w_meson_site(F_OFFSET(quark_propagator.c[color]),
F_OFFSET(quark_prop2.c[color]), pmes_prop[j][k]);
}
pmes_prop_done[j][k] = 1;
STOPPRTIME("do off-diagonal relativistic meson");
}
STARTPRTIME;
w_nrbaryon(F_OFFSET(nr_prop2),
F_OFFSET(nr_prop1),F_OFFSET(diquark_prop1),
nrbar_prop[j][k]);
w_nrbaryon(F_OFFSET(nr_prop1),
F_OFFSET(nr_prop2),F_OFFSET(diquark_prop2),
nrbar_prop[k][j]);
STOPPRTIME("do two sets of hl baryons");
}
/* For H we do only the case prop2 = u (light) index j
and prop1 = s (heavy) index k */
STARTPRTIME;
w_hdibaryon(F_OFFSET(diquark_prop2),
F_OFFSET(diquark_prop1), hdibar_prop[k][j]);
STOPPRTIME("do one set of hl H dibaryons");
} /* light kappas */
} /* heavy kappas */
/* Stick with same convention as clover_invert/control_cl_hl.c */
space_vol = (Real)(nx*ny*nz);
for(num_prop=0;num_prop<10;num_prop++) norm_fac[num_prop] = space_vol;
norm_fac[4] *= 3.0;
norm_fac[5] *= 3.0;
norm_fac[8] *= 3.0;
norm_fac[9] *= 3.0;
/* print relativistic meson propagators */
for(num_prop=0;num_prop<10;num_prop++)
for(i=0;i<num_kap;i++)
for(j=0;j<=i;j++)
if(pmes_prop_done[i][j] == 1){
for(t = 0; t < nt; t++){
t_off = (t + source_time)%nt;
g_floatsum( &pmes_prop[i][j][num_prop][t_off].real );
pmes_prop[i][j][num_prop][t_off].real /= norm_fac[num_prop];
g_floatsum( &pmes_prop[i][j][num_prop][t_off].imag );
pmes_prop[i][j][num_prop][t_off].imag /= norm_fac[num_prop];
if(this_node == 0)
printf("POINT%s %d %d %d %e %e\n",
mes_kind[num_prop],i,j,t,
(double)pmes_prop[i][j][num_prop][t_off].real,
(double)pmes_prop[i][j][num_prop][t_off].imag);
}
}
/* Once printed, this propagator should be neither
calculated nor printed again */
for(i=0;i<num_kap;i++)
for(j=0;j<=i;j++)
if(pmes_prop_done[i][j] == 1)
pmes_prop_done[i][j] = 2;
/* print non-relativistic baryon propagators */
if(this_node == 0)
for(kprop=0;kprop<NRPROPS;kprop++)
for(i=0;i<num_kap;i++){
for(j=0;j<i;j++)
if(nrbar_prop[i][j][kprop].done==1){
for(t = 0; t < nt; t++){
t_off = (t + source_time)%nt;
/* Periodic boundary conditions - no wraparound sign */
printf("%s_NR%s %d %d %d %d %e %e\n",
nr_fb_label[nr_fb],
nrbar_prop[i][j][kprop].label,i,j,j,t,
(double)nrbar_prop[i][j][kprop].c[t_off].real,
(double)nrbar_prop[i][j][kprop].c[t_off].imag);
}
}
if(nrbar_prop[i][i][kprop].done==1)
for(t = 0; t < nt; t++){
t_off = (t + source_time)%nt;
printf("%s_NR%s %d %d %d %d %e %e\n",
nr_fb_label[nr_fb],
nrbar_prop[i][j][kprop].label,i,i,i,t,
(double)nrbar_prop[i][i][kprop].c[t_off].real,
(double)nrbar_prop[i][i][kprop].c[t_off].imag);
}
for(j=i+1;j<num_kap;j++)
if(nrbar_prop[i][j][kprop].done==1)
for(t = 0; t < nt; t++){
t_off = (t + source_time)%nt;
printf("%s_NR%s %d %d %d %d %e %e\n",
nr_fb_label[nr_fb],
nrbar_prop[i][j][kprop].label,j,j,i,t,
(double)nrbar_prop[i][j][kprop].c[t_off].real,
(double)nrbar_prop[i][j][kprop].c[t_off].imag);
}
}
/* print H-dibaryon mixed channel propagators */
if(this_node == 0)
for(kprop=0;kprop<HDIPROPS;kprop++)
for(i=0;i<num_kap;i++){
for(j=0;j<num_kap;j++)if(hdibar_prop[i][j][kprop].done==1){
for(t = 0; t < nt; t++){
t_off = (t + source_time)%nt;
printf("%s_%s %d %d %d %d %e %e\n",
nr_fb_label[nr_fb],
hdibar_prop[i][j][kprop].label,i,j,j,t,
(double)hdibar_prop[i][j][kprop].c[t_off].real,
(double)hdibar_prop[i][j][kprop].c[t_off].imag);
}
}
}
} /* Loop over nr forward - backward */
/* Cleanup */
for(kprop=0;kprop<NRPROPS;kprop++)
for(i=0;i<num_kap;i++)for(j=0;j<num_kap;j++){
free(nrbar_prop[i][j][kprop].c);
free(nrbar_prop[i][j][kprop].label);
}
for(kprop=0;kprop<HDIPROPS;kprop++)
for(kh=0;kh<num_kap_heavy;kh++)for(kl=0;kl<num_kap_light;kl++){
i = kh; j = kl + num_kap_heavy;
free(hdibar_prop[i][j][kprop].c);
free(hdibar_prop[i][j][kprop].label);
}
if(this_node==0)printf("RUNNING COMPLETED\n");
if(meascount>0){
if(this_node==0)printf("total cg iters for measurement= %e\n",
(double)avm_iters);
if(this_node==0)printf("cg iters for measurement= %e\n",
(double)avm_iters/(double)meascount);
}
endtime=dclock();
if(this_node==0){
printf("Time = %e seconds\n",(double)(endtime-starttime));
printf("total_iters = %d\n",total_iters);
}
fflush(stdout);
}
return 0;
} /* control_H_cl */
MUST COMPILE WITH QIO FOR THE SCRATCH FILE
#endif
/* Comment these out if you want to suppress detailed timing */
/*#define IOTIME*/
/*#define PRTIME*/
int main(int argc, char *argv[])
{
int meascount;
int prompt;
Real avm_iters,avs_iters;
double starttime,endtime;
#ifdef IOTIME
double dtime;
int iotime = 1;
#else
int iotime = 0;
#endif
int MinCG,MaxCG;
Real RsdCG, RRsdCG;
int spin,color,j,k;
int flag;
int status;
w_prop_file *fp_in_w[MAX_KAP]; /* For reading binary propagator files */
w_prop_file *fp_out_w[MAX_KAP]; /* For writing binary propagator files */
w_prop_file *fp_scr[MAX_KAP];
quark_source wqs_scr; /* scratch file */
char scratch_file[MAX_KAP][MAXFILENAME];
wilson_vector *psi = NULL;
wilson_prop_field *quark_propagator = NULL;
wilson_prop_field *quark_prop2 = NULL;
int cg_cl = CL_CG;
int source_type;
initialize_machine(&argc,&argv);
/* Remap standard I/O */
if(remap_stdio_from_args(argc, argv) == 1)terminate(1);
g_sync();
/* set up */
prompt = setup_cl();
/* loop over input sets */
psi = create_wv_field();
quark_propagator = create_wp_field(3);
quark_prop2 = create_wp_field(3);
while( readin(prompt) == 0)
{
starttime=dclock();
MaxCG=niter;
avm_iters=0.0;
meascount=0;
spectrum_cl_hl_init();
if( fixflag == COULOMB_GAUGE_FIX)
{
if(this_node == 0)
printf("Fixing to Coulomb gauge\n");
#ifdef IOTIME
dtime = -dclock();
#endif
gaugefix(TUP,(Real)1.5,500,GAUGE_FIX_TOL);
#ifdef IOTIME
dtime += dclock();
if(this_node==0)printf("Time to gauge fix = %e\n",dtime);
#endif
invalidate_this_clov(gen_clov);
}
else
if(this_node == 0)printf("COULOMB GAUGE FIXING SKIPPED.\n");
/* save lattice if requested */
if( saveflag != FORGET ){
savelat_p = save_lattice( saveflag, savefile, stringLFN );
}
if(this_node==0)printf("END OF HEADER\n");
/* if(this_node==0) printf("num_kap = %d\n", num_kap); */
/* Loop over kappas to compute and store quark propagator */
for(k=0;k<num_kap;k++){
kappa=kap[k];
RsdCG=resid[k];
RRsdCG=relresid[k];
if(this_node==0)printf("Kappa= %g r0= %g residue= %g rel= %g\n",
(double)kappa,(double)wqs.r0,(double)RsdCG,
(double)RRsdCG);
/* open files for wilson propagators */
#ifdef IOTIME
dtime = -dclock();
#endif
wqstmp = wqs; /* For clover_info.c */
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 IOTIME
dtime += dclock();
if(startflag_w[k] != FRESH)
node0_printf("Time to open prop = %e\n",dtime);
#endif
/* Open scratch file and write header */
sprintf(scratch_file[k],"%s_%02d",scratchstem_w,k);
source_type = UNKNOWN;
fp_scr[k] = w_open_wprop(scratchflag, scratch_file[k], source_type);
init_qs(&wqs_scr);
/* Loop over source spins */
for(spin=0;spin<4;spin++){
/* Loop over source colors */
for(color=0;color<3;color++){
meascount ++;
/*if(this_node==0)printf("color=%d spin=%d\n",color,spin);*/
if(startflag_w[k] == CONTINUE)
{
if(k == 0)
{
node0_printf("Can not continue propagator here! Zeroing it instead\n");
startflag_w[k] = FRESH;
}
else
{
copy_wv_from_wp(psi, quark_propagator, color, spin);
}
}
/* Saves one multiplication by zero in cgilu */
if(startflag_w[k] == FRESH)flag = 0;
else
flag = 1;
/* load psi if requested */
status = reload_wprop_sc_to_field( startflag_w[k], fp_in_w[k],
&wqs, spin, color, psi, iotime);
if(status != 0)
{
node0_printf("control_cl_hl: Recovering from error by resetting initial guess to zero\n");
reload_wprop_sc_to_field( FRESH, fp_in_w[k], &wqs,
spin, color, psi,0);
flag = 0;
}
/* Complete the source structure */
wqs.color = color;
wqs.spin = spin;
/* If we are starting afresh, we set a minimum number
of iterations */
if(startflag_w[k] == FRESH || status != 0)MinCG = nt/2;
else MinCG = 0;
/* Load inversion control structure */
qic.prec = PRECISION;
qic.min = 0;
qic.max = MaxCG;
qic.nrestart = nrestart;
qic.parity = EVENANDODD;
qic.start_flag = flag;
qic.nsrc = 1;
qic.resid = RsdCG;
qic.relresid = RRsdCG;
/* Load Dirac matrix parameters */
dcp.Kappa = kappa;
dcp.Clov_c = clov_c;
dcp.U0 = u0;
switch (cg_cl) {
case BICG:
avs_iters =
(Real)wilson_invert_field_wqs(&wqs, w_source_field, psi,
bicgilu_cl_field,
&qic,(void *)&dcp);
break;
case HOP:
avs_iters =
(Real)wilson_invert_field_wqs(&wqs, w_source_field, psi,
hopilu_cl_field,
&qic,(void *)&dcp);
break;
case MR:
avs_iters =
(Real)wilson_invert_field_wqs(&wqs, w_source_field, psi,
mrilu_cl_field,
&qic,(void *)&dcp);
break;
case CG:
avs_iters =
(Real)wilson_invert_field_wqs(&wqs, w_source_field, psi,
cgilu_cl_field,
&qic,(void *)&dcp);
break;
default:
node0_printf("main(%d): Inverter choice %d not supported\n",
cg_cl, this_node);
}
avm_iters += avs_iters;
copy_wp_from_wv(quark_propagator, psi, color, spin);
/* Write psi to scratch disk */
#ifdef IOTIME
dtime = -dclock();
#endif
save_wprop_sc_from_field(scratchflag, fp_scr[k], &wqs_scr,
spin, color, psi, "Scratch record", iotime);
#ifdef IOTIME
dtime += dclock();
if(this_node==0)
printf("Time to dump prop spin %d color %d %e\n",
spin,color,dtime);
#endif
/* save psi if requested */
save_wprop_sc_from_field( saveflag_w[k],fp_out_w[k], &wqs,
spin,color,psi,"", iotime);
} /* source colors */
} /* source spins */
/* Close and release scratch file */
w_close_wprop(scratchflag, fp_scr[k]);
/*if(this_node==0)printf("Dumped prop to file %s\n",
scratch_file[k]); */
/* close files for wilson propagators */
#ifdef IOTIME
dtime = -dclock();
#endif
r_close_wprop(startflag_w[k],fp_in_w[k]);
w_close_wprop(saveflag_w[k],fp_out_w[k]);
#ifdef IOTIME
dtime += dclock();
if(saveflag_w[k] != FORGET)
node0_printf("Time to close prop = %e\n",dtime);
#endif
} /* kappas */
/* Loop over heavy kappas for the point sink spectrum */
for(k=0;k<num_kap;k++){
/* Read the propagator from the scratch file */
#ifdef IOTIME
dtime = -dclock();
#endif
kappa=kap[k];
init_qs(&wqs_scr);
reload_wprop_to_wp_field(scratchflag, scratch_file[k], &wqs_scr,
quark_propagator, iotime);
#ifdef IOTIME
dtime += dclock();
if(this_node==0)
{
printf("Time to read 12 spin,color combinations %e\n",dtime);
fflush(stdout);
}
#endif
/*if(this_node==0)
printf("Closed scratch file %s\n",scratch_file[k]);
fflush(stdout); */
/* Diagonal spectroscopy */
spectrum_cl_hl_diag_baryon(quark_propagator, k);
spectrum_cl_hl_diag_meson(quark_propagator, k);
spectrum_cl_hl_diag_rot_meson(quark_propagator, k);
if(strstr(spectrum_request,",sink_smear,") != NULL){
spectrum_cl_hl_diag_smeared_meson(quark_propagator, k);
}
/* Heavy-light spectroscopy */
/* Loop over light kappas for the point sink spectrum */
for(j=k+1;j<num_kap;j++){
#ifdef IOTIME
dtime = -dclock();
#endif
/* Read the propagator from the scratch file */
kappa=kap[j];
init_qs(&wqs_scr);
reload_wprop_to_wp_field(scratchflag, scratch_file[j], &wqs_scr,
quark_prop2, iotime);
#ifdef IOTIME
dtime += dclock();
if(this_node==0)
{
printf("Time to read 12 spin,color combinations %e\n",dtime);
fflush(stdout);
}
#endif
#ifdef PRTIME
dtime = -dclock();
#endif
spectrum_cl_hl_offdiag_baryon( quark_propagator, quark_prop2,
j, k);
spectrum_cl_hl_offdiag_meson( quark_propagator, quark_prop2,
j, k);
spectrum_cl_hl_offdiag_rot_meson( quark_propagator, quark_prop2,
j, k);
#ifdef PRTIME
dtime = -dclock();
#endif
} /* light kappas */
/* Smear the heavy propagator in place */
sink_smear_prop( quark_propagator );
/* Write the smeared propagator to the scratch file (overwriting)*/
kappa=kap[k];
#ifdef IOTIME
dtime = -dclock();
#endif
save_wprop_from_wp_field(scratchflag, scratch_file[k], &wqs_scr,
quark_propagator, "Scratch propagator",
iotime);
#ifdef IOTIME
dtime += dclock();
if(this_node==0)
{
printf("Time to dump convolution %d %e\n",k,dtime);
fflush(stdout);
}
#endif
} /* heavy kappas */
/* Loop over heavy kappas for the shell sink spectrum */
if(strstr(spectrum_request,",sink_smear,") != NULL)
for(k=0;k<num_kap;k++){
#ifdef IOTIME
dtime = -dclock();
#endif
/* Read the propagator from the scratch file */
kappa=kap[k];
init_qs(&wqs_scr);
reload_wprop_to_wp_field(scratchflag, scratch_file[k], &wqs_scr,
quark_propagator, iotime);
#ifdef IOTIME
dtime += dclock();
if(this_node==0)
{
printf("Time to read convolution %d %e\n",k,dtime);
fflush(stdout);
}
#endif
/* Diagonal spectroscopy */
spectrum_cl_hl_diag_smeared_meson(quark_propagator, k);
/* Heavy-light spectroscopy */
/* Loop over light kappas for the shell sink spectrum */
for(j=k+1;j<num_kap;j++){
#ifdef PRTIME
dtime = -dclock();
#endif
/* Read the propagator from the scratch file */
kappa=kap[j];
init_qs(&wqs_scr);
reload_wprop_to_wp_field(scratchflag, scratch_file[j], &wqs_scr,
quark_prop2, iotime);
/* Compute the spectrum */
spectrum_cl_hl_offdiag_smeared_meson( quark_propagator,
quark_prop2, j, k);
#ifdef PRTIME
dtime += dclock();
if(this_node==0)
{
printf("Time to read and do off diagonal mesons %d %d %e\n",
j,k,dtime);
fflush(stdout);
}
#endif
} /* light kappas */
} /* heavy kappas */
spectrum_cl_hl_print(wqs.t0);
spectrum_cl_hl_cleanup();
if(this_node==0)printf("RUNNING COMPLETED\n");
if(meascount>0){
if(this_node==0)printf("total cg iters for measurement= %e\n",
(double)avm_iters);
if(this_node==0)printf("cg iters for measurement= %e\n",
(double)avm_iters/(double)meascount);
}
endtime=dclock();
if(this_node==0){
printf("Time = %e seconds\n",(double)(endtime-starttime));
printf("total_iters = %d\n",total_iters);
}
fflush(stdout);
}
destroy_wv_field(psi);
destroy_wp_field(quark_propagator);
return 0;
}
int main(int argc, char *argv[])
{
int meascount;
int prompt;
Real avm_iters,avs_iters;
double starttime,endtime;
#ifdef IOTIME
double dtime;
int iotime = 1;
#else
int iotime = 0;
#endif
int MaxCG;
Real RsdCG, RRsdCG;
int spin,color,k;
int flag;
int status;
int cl_cg = CL_CG;
w_prop_file *fp_in_w[MAX_KAP]; /* For propagator files */
w_prop_file *fp_out_w[MAX_KAP]; /* For propagator files */
wilson_vector *psi = NULL;
wilson_prop_field quark_propagator = NULL;
initialize_machine(&argc,&argv);
#ifdef HAVE_QDP
QDP_initialize(&argc, &argv);
#endif
/* Remap standard I/O */
if(remap_stdio_from_args(argc, argv) == 1)terminate(1);
g_sync();
/* set up */
prompt = setup_cl();
/* loop over input sets */
psi = create_wv_field();
quark_propagator = create_wp_field();
while( readin(prompt) == 0)
{
starttime=dclock();
MaxCG=niter;
wqstmp = wqs; /* For clover_info.c */
avm_iters=0.0;
meascount=0;
if( fixflag == COULOMB_GAUGE_FIX)
{
if(this_node == 0)
printf("Fixing to Coulomb gauge\n");
#ifdef IOTIME
dtime = -dclock();
#endif
gaugefix(TUP,(Real)1.5,500,GAUGE_FIX_TOL);
#ifdef IOTIME
dtime += dclock();
if(this_node==0)printf("Time to gauge fix = %e\n",dtime);
#endif
invalidate_this_clov(gen_clov);
}
else
if(this_node == 0)printf("COULOMB GAUGE FIXING SKIPPED.\n");
/* save lattice if requested */
if( saveflag != FORGET ){
savelat_p = save_lattice( saveflag, savefile, stringLFN );
}
if(this_node==0)printf("END OF HEADER\n");
/* if(this_node==0) printf("num_kap = %d\n", num_kap); */
/* Loop over kappas */
for(k=0;k<num_kap;k++){
kappa=kap[k];
RsdCG=resid[k];
RRsdCG=relresid[k];
if(this_node==0)printf("Kappa= %g r0= %g residue= %g rel= %g\n",
(double)kappa,(double)wqs.r0,(double)RsdCG,
(double)RRsdCG);
/* open files for wilson propagators */
#ifdef IOTIME
dtime = -dclock();
#endif
fp_in_w[k] = r_open_wprop(startflag_w[k], startfile_w[k]);
#ifdef IOTIME
dtime += dclock();
if(startflag_w[k] != FRESH)
node0_printf("Time to open prop = %e\n",dtime);
#endif
fp_out_w[k] = w_open_wprop(saveflag_w[k], savefile_w[k],
wqs.type);
/* Loop over source spins */
for(spin=0;spin<4;spin++){
/* Loop over source colors */
for(color=0;color<3;color++){
meascount ++;
/*if(this_node==0)printf("color=%d spin=%d\n",color,spin); */
if(startflag_w[k] == CONTINUE)
{
node0_printf("Can not continue propagator here! Zeroing it instead\n");
startflag_w[k] = FRESH;
}
/* Saves one multiplication by zero in cgilu */
if(startflag_w[k] == FRESH)flag = 0;
else
flag = 1;
/* load psi if requested */
status = reload_wprop_sc_to_field( startflag_w[k], fp_in_w[k],
&wqs, spin, color, psi, iotime);
if(status != 0)
{
node0_printf("control_cl: Recovering from error by resetting initial guess to zero\n");
reload_wprop_sc_to_field( FRESH, fp_in_w[k], &wqs,
spin, color, psi, 0);
flag = 0;
}
/* Complete the source structure */
wqs.color = color;
wqs.spin = spin;
/* Load inversion control structure */
qic.prec = PRECISION;
qic.max = MaxCG;
qic.nrestart = nrestart;
qic.resid = RsdCG;
qic.relresid = RRsdCG;
qic.start_flag = flag;
/* Load Dirac matrix parameters */
dcp.Kappa = kappa;
dcp.Clov_c = clov_c;
dcp.U0 = u0;
/* compute the propagator. Result in psi. */
switch (cl_cg) {
case BICG:
avs_iters =
(Real)wilson_invert_field_wqs(&wqs, w_source_field, psi,
bicgilu_cl_field,
&qic,(void *)&dcp);
break;
case HOP:
avs_iters =
(Real)wilson_invert_field_wqs(&wqs, w_source_field, psi,
hopilu_cl_field,
&qic,(void *)&dcp);
break;
case MR:
avs_iters =
(Real)wilson_invert_field_wqs(&wqs, w_source_field, psi,
mrilu_cl_field,
&qic,(void *)&dcp);
break;
case CG:
avs_iters =
(Real)wilson_invert_field_wqs(&wqs, w_source_field, psi,
cgilu_cl_field,
&qic,(void *)&dcp);
break;
default:
node0_printf("main(%d): Inverter choice %d not supported\n",
this_node,cl_cg);
}
avm_iters += avs_iters;
copy_wp_from_wv(quark_propagator, psi, color, spin);
/* save psi if requested */
save_wprop_sc_from_field( saveflag_w[k],fp_out_w[k], &wqs,
spin,color,psi,"Fill in record info here",iotime);
} /* source spins */
} /* source colors */
/* close files for wilson propagators */
r_close_wprop(startflag_w[k],fp_in_w[k]);
#ifdef IOTIME
dtime = -dclock();
#endif
w_close_wprop(saveflag_w[k],fp_out_w[k]);
#ifdef IOTIME
dtime += dclock();
if(saveflag_w[k] != FORGET)
node0_printf("Time to close prop = %e\n",dtime);
#endif
/* spectrum, if requested */
if(strstr(spectrum_request,",spectrum,") != NULL)
spectrum_cl(quark_propagator, wqs.t0, k);
} /* kappas */
if(this_node==0)printf("RUNNING COMPLETED\n");
if(meascount>0){
if(this_node==0)printf("total cg iters for measurement= %e\n",
(double)avm_iters);
if(this_node==0)printf("cg iters for measurement= %e\n",
(double)avm_iters/(double)meascount);
}
endtime=dclock();
if(this_node==0){
printf("Time = %e seconds\n",(double)(endtime-starttime));
printf("total_iters = %d\n",total_iters);
}
fflush(stdout);
}
destroy_wv_field(psi);
destroy_wp_field(quark_propagator);
return 0;
}
void calc_heavy_light_form()
{
int color , spin ;
int k_sequential ;
int p_insert ;
int k_spectator , k_zonked_light , k_zonked_heavy ;
int HH3_corr_dim , HH3_corr_stride ;
int HL3_corr_dim , HL3_corr_stride ;
complex *HH3_corr ; /*** The heavy-heavy 3pt correlators *****/
complex *HL3_corr ; /*** The heavy-light 3pt correlators *****/
complex *HL2_GE_corr ; /*** The heavy-light 2pt correlators *****/
complex *LL2_GG_corr ; /*** The light-light 2pt correlators *****/
complex *HL2_GG_corr ; /*** The sequential correlators *****/
complex *HL2_GL_corr ; /*** The local-sink correlators required for fB *****/
int HL2_GE_corr_dim ;
int LL2_GG_corr_dim ;
int HL2_GG_corr_dim ;
int HL2_GL_corr_dim , HL2_GL_corr_stride ;
w_prop_file *zonked_light_ssink_fp[MAX_KAPPA] ; /*** Quark propagator IO stuff **/
w_prop_file *zonked_heavy_fp[MAX_KAPPA] ; /*** Quark propagator IO stuff **/
w_prop_file *zonked_heavy_ssink_fp[MAX_KAPPA] ; /*** Quark propagator IO stuff **/
int t_source = wqs_zonked_heavy[0].t0 ; /** assume all the kappa start from the same point **/
field_offset null_argument = 0 ;
int do_heavy_heavy;
int change_mom_smear;
int exists_zonked_light_ssink[MAX_KAPPA];
int exists_zonked_heavy_ssink[MAX_KAPPA];
int exists_zonked_heavy[MAX_KAPPA];
/**********----------------------------------------**********/
setup_w_meson_store();
setup_HL3_corr( &HL3_corr, &HL3_corr_dim, &HL3_corr_stride );
setup_HH3_corr( &HH3_corr, &HH3_corr_dim, &HH3_corr_stride);
setup_LL2_corr(&LL2_GG_corr , &LL2_GG_corr_dim );
setup_HL2_corr(&HL2_GE_corr, &HL2_GE_corr_dim);
setup_HL2_corr(&HL2_GG_corr, &HL2_GG_corr_dim) ;
setup_HL2_corr_with_rotations(&HL2_GL_corr , &HL2_GL_corr_dim , &HL2_GL_corr_stride) ;
set_zonked_save_intermediate();
/*** Generate heavy quark propagators
Gaussian smear the propagators at the sink
Calculate the light-light and heavy-light smeared sink
2 pt function
Calculate heavy-heavy local sink 2 pt function
*****/
/* Figure out what needs to be done and open any needed and available
sink-smeared LIGHT quark propagator output files */
for(k_zonked_light=0 ; k_zonked_light < no_zonked_light ;
++k_zonked_light)
{
exists_zonked_light_ssink[k_zonked_light] =
file_exists_broadcast(qfile_zonked_light_ssink[k_zonked_light]);
kappa = kappa_zonked_light[k_zonked_light];
/* If it doesn't exist and we are computing two pt functions
that use it, we will create it, so open the file for writing */
wqstmp = wqs_zonked_light[k_zonked_light]; /* For clover_info */
strcat(wqstmp.descrp,"; SMEARED SINK.");
if(!exists_zonked_light_ssink[k_zonked_light] &&
((saveflag_HL2_GG != FORGET) || (saveflag_LL2_GG != FORGET) ))
zonked_light_ssink_fp[k_zonked_light]
= w_open_wprop(saveflag_zonked_light_ssink,
qfile_zonked_light_ssink[k_zonked_light],
wqs_zonked_light[k_zonked_light].type);
}
/* See if the heavy-heavy correlators need to be computed */
do_heavy_heavy = !file_exists_broadcast(filename_HH2_GL);
/* Figure out what needs to be done and open any needed and available
sink-smeared HEAVY quark propagator output files */
for(k_zonked_heavy=0 ; k_zonked_heavy < no_zonked_heavy ;
++k_zonked_heavy)
{
exists_zonked_heavy[k_zonked_heavy] =
file_exists_broadcast(qfile_zonked_heavy[k_zonked_heavy]);
exists_zonked_heavy_ssink[k_zonked_heavy] =
file_exists_broadcast(qfile_zonked_heavy_ssink[k_zonked_heavy]);
/* We (re)compute the heavy_heavy 2 pt function if any of the
heavy local propagator files is missing */
if(!exists_zonked_heavy[k_zonked_heavy])do_heavy_heavy = 1;
kappa = kappa_zonked_heavy[k_zonked_heavy];
/* If it doesn't exist, we will write, so open the file for writing */
wqstmp = wqs_zonked_heavy[k_zonked_heavy]; /* For clover_info */
if(!exists_zonked_heavy[k_zonked_heavy])
zonked_heavy_fp[k_zonked_heavy]
= w_open_wprop(saveflag_zonked_heavy[k_zonked_heavy],
qfile_zonked_heavy[k_zonked_heavy],
wqs_zonked_heavy[k_zonked_heavy].type);
/* If it doesn't exist and we need it for the HL2_GG correlator,
we will write, so open the file for writing */
wqstmp = wqs_zonked_heavy[k_zonked_heavy]; /* For clover_info */
strcat(wqstmp.descrp,"; SMEARED SINK.");
if(!exists_zonked_heavy_ssink[k_zonked_heavy] &&
(saveflag_HL2_GG != FORGET))
zonked_heavy_ssink_fp[k_zonked_heavy]
= w_open_wprop(saveflag_zonked_heavy_ssink,
qfile_zonked_heavy_ssink[k_zonked_heavy],
wqs_zonked_heavy[k_zonked_heavy].type);
}
/* We will compute the heavy_heavy spectrum if any one of the heavy
local-sink propagator files is missing or if the correlator file
doesn't exist. Call to initialize the calculation */
if(do_heavy_heavy)
meson_spectrum(null_argument , t_source, 0 , no_zonked_heavy,
SETUP_CORR,filename_HH2_GL) ;
/* Calculate the local and smeared two-point functions HL2_GL HL2_GG
and LL2_GG */
for(color=0 ; color < 3 ; ++color)
{
node0_printf("\nSTARTING SMEARED COLOR %d\n",color);
fflush(stdout);
/*** generate smeared light quark propagators ***/
/* We don't load the light propagators and don't calculate the
smeared sink two-point functions unless a flag is set (see
setup_form) */
if((saveflag_HL2_GG != FORGET) || (saveflag_LL2_GG != FORGET) ){
for(k_zonked_light=0 ; k_zonked_light < no_zonked_light ;
++k_zonked_light)
{
/* If the smeared light quark prop file exists, use it */
if(exists_zonked_light_ssink[k_zonked_light])
{
/* Load the smeared sink propagator */
node0_printf("REUSING previous zonked light tmp file %s\n",
qfile_zonked_light_ssink[k_zonked_light]);
fflush(stdout);
for(spin=0; spin < 4 ; ++spin )
load_in_zonked_light_ssink(color,spin,k_zonked_light,
F_OFFSET(quark_zonked_light[k_zonked_light].d[spin]));
} /* end if exists */
else
{
/* Load the local sink propagator and smear at sink */
for(spin=0; spin < 4 ; ++spin )
load_in_zonked_light2(color,spin,k_zonked_light,
F_OFFSET(quark_zonked_light[k_zonked_light].d[spin]));
/*** smear the light zonked quarks at the sink ****/
/* NOTE: WE ARE ASSUMING THE SHELL SMEARING FUNCTIONS
ARE THE SAME FOR ZONKED AND SPECTATOR QUARKS */
M_SINK_SMEAR(quark_zonked_light[k_zonked_light],
heavy_smear_func_mom[0] ) ;
/** write the light ssink quark props to disk ***/
for(spin=0; spin < 4 ; ++spin )
save_wprop_sc_from_site(saveflag_zonked_light_ssink,
zonked_light_ssink_fp[k_zonked_light],
spin, color,
F_OFFSET(quark_zonked_light[k_zonked_light].d[spin]),
1) ;
} /* end if file doesn't exist */
} /* k_zonked_light */
} /* end if (saveflag_HL2_GG != FORGET) || (saveflag_LL2_GG != FORGET) */
/*** generate the heavy zonked local sink propagators if they
don't already exist. We'll need them for the 3 pt functions even
if we aren't calculating the smeared two pt functions. ***/
for(k_zonked_heavy=0 ; k_zonked_heavy < no_zonked_heavy ;
++k_zonked_heavy)
{
if(!exists_zonked_heavy[k_zonked_heavy])
{
for(spin = 0 ; spin < 4 ; ++spin)
generate_heavy_zonked(color,spin,
kappa_zonked_heavy[k_zonked_heavy],
inverter_type_zonked_heavy[k_zonked_heavy],
F_OFFSET(quark_zonked_heavy[k_zonked_heavy].d[spin])) ;
/*** store the heavy quark propagator to disk ****/
for(spin=0; spin < 4 ; ++spin )
save_wprop_sc_from_site(saveflag_zonked_heavy[k_zonked_heavy],
zonked_heavy_fp[k_zonked_heavy],
spin, color,
F_OFFSET(quark_zonked_heavy[k_zonked_heavy].d[spin]),
1) ;
} /* end if doesn't exist */
else if(do_heavy_heavy)
{
/* Load heavy zonked local from existing tmp now if we
need it for the heavy_heavy prop */
for(spin=0; spin < 4 ; ++spin )
load_in_zonked_heavy_local(color,spin,k_zonked_heavy,
F_OFFSET(quark_zonked_heavy[k_zonked_heavy].d[spin]));
} /* end else if exists but do_heavy_heavy */
} /* k_zonked_heavy */
/** Calculate the heavy degenerate spectrum (HH2_GL) **/
if(do_heavy_heavy)
{
for(k_zonked_heavy=0 ; k_zonked_heavy < no_zonked_heavy ;
++k_zonked_heavy)
meson_spectrum(F_OFFSET(quark_zonked_heavy[k_zonked_heavy]),
t_source ,k_zonked_heavy ,
no_zonked_heavy, CALCULATE_SPECTRUM,
filename_HH2_GL) ;
}
/*** generate the smeared zonked local sink propagators if they
don't already exist and if we need them for two point functions ***/
if(saveflag_HL2_GG != FORGET){
for(k_zonked_heavy=0 ; k_zonked_heavy < no_zonked_heavy ;
++k_zonked_heavy)
{
/* If the sink smeared heavy quark prop file exists, use it */
if(exists_zonked_heavy_ssink[k_zonked_heavy])
{
node0_printf("REUSING previous zonked heavy tmp file %s\n",
qfile_zonked_heavy_ssink[k_zonked_heavy]);
fflush(stdout);
for(spin=0; spin < 4 ; ++spin )
load_in_zonked_heavy_smear(color,spin,k_zonked_heavy,
F_OFFSET(quark_zonked_heavy[k_zonked_heavy].d[spin]));
} /* end if exists */
else
{
/* Load local heavy quark prop unless we just computed
or loaded it */
if(exists_zonked_heavy[k_zonked_heavy] &&
!do_heavy_heavy)
{
node0_printf("REUSING previous zonked heavy file %s\n",
qfile_zonked_heavy[k_zonked_heavy]);
fflush(stdout);
for(spin=0; spin < 4 ; ++spin )
load_in_zonked_heavy_local(color,spin,k_zonked_heavy,
F_OFFSET(quark_zonked_heavy[k_zonked_heavy].d[spin]));
}
/* smear heavy zonked quark at sink */
M_SINK_SMEAR(quark_zonked_heavy[k_zonked_heavy],
heavy_smear_func_mom[0]);
/*** store the smeared--smeared quark propagator to disk ***/
for(spin=0; spin < 4 ; ++spin )
save_wprop_sc_from_site(saveflag_zonked_heavy_ssink,
zonked_heavy_ssink_fp[k_zonked_heavy],
spin, color,
F_OFFSET(quark_zonked_heavy[k_zonked_heavy].d[spin]), 1) ;
} /* end if doesn't exist */
} /* k_zonked_heavy */
} /* if(saveflag_HL2_GG != FORGET) */
/** Calculate the source- and sink-smeared 2 pt functions **/
if((saveflag_HL2_GG != FORGET) || (saveflag_LL2_GG != FORGET)) {
for(k_spectator = 0 ; k_spectator < no_spectator ; ++k_spectator)
{
/** generate or copy sink smeared spectator quark propagator **/
/* If the spectator quark is the same as one of the zonked light
quarks, copy the preloaded smeared zonked light quark instead
NOTE: WE ARE ASSUMING THE SMEARING FUNCTIONS ARE THE SAME
FOR ZONKED AND SPECTATOR QUARKS */
restore_smeared_spectator(color,k_spectator);
/****-----
light-light two-pt (LL2_GG)
(symmetric source and sink smearing)
-----*****/
/* Skip this calculation if flag is set (see setup_form) */
if(saveflag_LL2_GG != FORGET){
node0_printf("Computing LL2_GG correlator\n");
fflush(stdout);
for(k_zonked_light=0 ; k_zonked_light < no_zonked_light ;
++k_zonked_light)
{
/*** calculate the light-light two point functions
(LL2_GG) (shell smearing functions) *****/
contract_LL2(LL2_GG_corr,
F_OFFSET(quark_zonked_light[k_zonked_light]) ,
F_OFFSET(quark_spectator ) ,
k_zonked_light, k_spectator) ;
} /*** end of the loop over the zonked light quark reads ***/
} /* end of if(saveflag_LL2_GG != FORGET) */
/****-----
heavy-light two pt (HL2_GG) (shell smeared source and sink)
-----*****/
/* Skip this calculation if flag is set (see setup_form) */
if(saveflag_HL2_GG != FORGET){
node0_printf("Computing HL2_GG correlator\n");
fflush(stdout);
for(k_zonked_heavy=0 ; k_zonked_heavy < no_zonked_heavy ;
++k_zonked_heavy)
{
/*** contract the heavy-light two point function
(HL2_GG) (BAG SMEARING AT THE SINK) ******/
contract_HL2(HL2_GG_corr ,
F_OFFSET(quark_zonked_heavy[k_zonked_heavy]) ,
F_OFFSET(quark_spectator),
k_zonked_heavy, k_spectator) ;
} /*** end of the loop over the zonked heavy quarks ***/
} /* End of if(saveflag_HL2_GG != FORGET) */
} /* k_spectator */
} /* End of if((saveflag_HL2_GG != FORGET) || (saveflag_LL2_GG != FORGET) ) */
} /* color */
/* Write heavy-heavy spectrum */
if(do_heavy_heavy)
meson_spectrum(null_argument ,t_source ,0 ,no_zonked_heavy,
WRITE_RESULTS,filename_HH2_GL) ;
/*** write the sink-smeared 2 pt correlators to disk ****/
finish_LL2_GG_corr(LL2_GG_corr, LL2_GG_corr_dim ) ;
finish_HL2_GG_corr(HL2_GG_corr, HL2_GG_corr_dim ) ;
free(LL2_GG_corr);
free(HL2_GG_corr) ;
/* Close the temporary propagator output files if we opened them before */
for(k_zonked_light=0 ; k_zonked_light < no_zonked_light ;
++k_zonked_light)
{
if(!exists_zonked_light_ssink[k_zonked_light] &&
((saveflag_HL2_GG != FORGET) || (saveflag_LL2_GG != FORGET) ))
w_close_wprop(saveflag_zonked_light_ssink,
zonked_light_ssink_fp[k_zonked_light]);
}
for(k_zonked_heavy=0 ; k_zonked_heavy < no_zonked_heavy ;
++k_zonked_heavy)
{
if(!exists_zonked_heavy[k_zonked_heavy])
w_close_wprop(saveflag_zonked_heavy[k_zonked_heavy],
zonked_heavy_fp[k_zonked_heavy]);
if(!exists_zonked_heavy_ssink[k_zonked_heavy] &&
(saveflag_HL2_GG != FORGET))
w_close_wprop(saveflag_zonked_heavy_ssink,
zonked_heavy_ssink_fp[k_zonked_heavy]);
}
/*** Calculate the heavy to heavy and heavy to light 3 pt functions
Calculate the heavy-light 2 pt functions requiring local-sink quark
propagators ***/
for(color=0 ; color < 3 ; ++color)
{
node0_printf("\nSTARTING LOCAL COLOR %d\n",color);
fflush(stdout);
if((saveflag_HL2_GL != FORGET) ||
(saveflag_HL2_GE != FORGET) ||
(saveflag_HH3 != FORGET) ||
(saveflag_HL3 != FORGET))
{
/*** reload all the light zonked quark propagators for this color,
smeared at the source only **/
for(k_zonked_light=0 ; k_zonked_light < no_zonked_light ;
++k_zonked_light)
for(spin=0; spin < 4 ; ++spin )
load_in_zonked_light2(color,spin,k_zonked_light,
F_OFFSET(quark_zonked_light[k_zonked_light].d[spin]));
/*** reload all the heavy zonked quark propagators for this color,
smeared at the source only **/
for(k_zonked_heavy=0 ; k_zonked_heavy < no_zonked_heavy ;
++k_zonked_heavy)
for(spin=0; spin < 4 ; ++spin )
load_in_zonked_heavy_local(color,spin,k_zonked_heavy,
F_OFFSET(quark_zonked_heavy[k_zonked_heavy].d[spin]));
}
for(k_spectator = 0 ; k_spectator < no_spectator ; ++k_spectator)
{
/** restore spectator quark propagator to "quark_spectator" **/
restore_local_spectator(color, k_spectator);
/****-----
heavy-light two-pt (HL2_GL) (shell smeared sources, local sink)
-----*****/
/* Skip this calculation if flag is set (see setup_form) */
if(saveflag_HL2_GL != FORGET){
for(k_zonked_heavy=0 ; k_zonked_heavy < no_zonked_heavy ;
++k_zonked_heavy)
{
node0_printf("Computing HL2_GL correlator\n");
fflush(stdout);
/*** contract the heavy-light two point function
(HL2_GL) (smeared-source local-sink) */
contract_HL2_with_rotations(HL2_GL_corr,
F_OFFSET(quark_zonked_heavy[k_zonked_heavy]) ,
F_OFFSET(quark_spectator),
F_OFFSET(quark_rot ),
k_zonked_heavy, k_spectator) ;
} /*** end of the loop over the zonked heavy inversions ***/
} /* End of if(saveflag_HL2_GL != FORGET) */
for(p_insert = 0 ; p_insert < no_p_values ; ++p_insert)
{
node0_printf("\nStarting momentum insertion %d\n",p_insert);
fflush(stdout);
/**** sink smear the spectator quark
with the sequential smearing function ****/
/* If the smearing function did not change, retain the
previous result */
if(p_insert == 0 ||
strcmp(seq_smear_file[p_insert],
seq_smear_file[p_insert-1]) != 0)
{
node0_printf("Sequential smearing for momentum insertion %d\n",p_insert);
fflush(stdout);
restore_local_spectator(color, k_spectator);
M_SINK_SMEAR(quark_spectator,seq_smear_func[ p_insert ] ) ;
change_mom_smear = 1;
}
else
{
node0_printf("REUSING sequentially smeared spectator from previous momentum insertion\n");
fflush(stdout);
change_mom_smear = 0;
}
/****-----
heavy-light two pt (HL2_GE) (shell source, relative sink)
-----*****/
/* Skip this calculation if flag is set (see setup_form) */
/* Note: We may, in the future, want to distiguish
smearing functions for different B meson momenta.
However, at present we have not made any provision
for such a distinction in the relative-smeared
two-point function. So we do the calculation only
for the first momentum in the list! CD */
if((saveflag_HL2_GE != FORGET) && p_insert > 0 && change_mom_smear)
node0_printf("WARNING: HL2_GE correlator is computed only for the first smearing function in the list\n");
fflush(stdout);
if((saveflag_HL2_GE != FORGET) && p_insert == 0){
node0_printf("Computing HL2_GE correlator\n");
fflush(stdout);
for(k_zonked_heavy=0 ; k_zonked_heavy < no_zonked_heavy ;
++k_zonked_heavy)
{
/*** contract the heavy-light two point functiion
(HL2_GE) (RELATIVE SMEARING AT THE SINK) */
contract_HL2(
HL2_GE_corr,
F_OFFSET(quark_zonked_heavy[k_zonked_heavy]) ,
F_OFFSET(quark_spectator),
k_zonked_heavy, k_spectator) ;
} /*** end of the loop over the zonked heavy inversions ***/
}
if( (saveflag_HH3 != FORGET) || (saveflag_HL3 != FORGET))
for(k_sequential = 0 ; k_sequential < no_sequential ; ++k_sequential )
{
copy_site_spin_wilson_vector(F_OFFSET(quark_spectator) ,
F_OFFSET(quark_sequential) );
if( this_node == 0 )
printf("Computing form factors for k_sequential = %g k_spectator = %g p = %d,%d,%d \n",
kappa_sequential[k_sequential], kappa_spectator[k_spectator] ,
p_momstore[p_insert ][0] , p_momstore[p_insert ][1] , p_momstore[p_insert ][2] ) ;
fflush(stdout);
/*** generate the sequential source propagator ****/
for(spin = 0 ; spin < 4 ; ++spin )
{
/*** do the sequential source inversion ****/
kappa = kappa_sequential[k_sequential] ;
sequential_source(
F_OFFSET(quark_sequential.d[spin] ),
F_OFFSET(psi),
p_momstore[p_insert ][0] ,
p_momstore[p_insert ][1] ,
p_momstore[p_insert ][2] ,
tf, color,spin,
kappa_sequential[k_sequential] ,
inverter_type_sequential[k_sequential],
niter_zonked_heavy,
nrestart_zonked_heavy,
resid_zonked_heavy,
p_insert ) ;
} /*** end of the loop over spin ***/
/****-----
heavy to light form factor
-----*****/
if( (saveflag_HL3 != FORGET) ) {
for(k_zonked_light=0 ; k_zonked_light < no_zonked_light ;
++k_zonked_light)
{
/*** tie the propagators together to calculate
the three point function *****/
contract_HL3(
HL3_corr,
F_OFFSET(quark_zonked_light[k_zonked_light]),
F_OFFSET(quark_sequential) ,
F_OFFSET(quark_rot ),
p_insert, k_sequential,
k_zonked_light, k_spectator ) ;
} /*** end of the loop over the zonked light
quark reads ***/
} /* End of if(saveflag_HL3 != FORGET) */
/****-----
heavy to heavy form factor
-----*****/
if( (saveflag_HH3 != FORGET) ) {
for(k_zonked_heavy=0 ; k_zonked_heavy < no_zonked_heavy ;
++k_zonked_heavy)
{
/*** tie the propagators together *****/
contract_HH3(
HH3_corr,
F_OFFSET(quark_zonked_heavy[k_zonked_heavy]),
F_OFFSET(quark_sequential ),
F_OFFSET(quark_rot ),
p_insert, k_sequential,
k_zonked_heavy, k_spectator ) ;
} /*** end of the loop over the zonked heavy quarks ***/
} /* End of if(saveflag_HH3 != FORGET) */
} /*** end of the loop over p_insert ****/
} /*** end of the loop over k_sequential ****/
} /*** end of the loop over k_spectator ****/
} /*** end the loop over the source colour *****/
/*** write the correlators to disk ****/
finish_HL3_corr(HL3_corr, HL3_corr_dim , HL3_corr_stride) ;
finish_HH3_corr(HH3_corr, HH3_corr_dim , HH3_corr_stride) ;
finish_HL2_GE_corr(HL2_GE_corr, HL2_GE_corr_dim ) ;
finish_HL2_GL_corr(HL2_GL_corr,
HL2_GL_corr_dim, HL2_GL_corr_stride );
/**** free up the memory used in this code *****/
free(HH3_corr) ;
free(HL3_corr) ;
free(HL2_GE_corr);
free(HL2_GL_corr);
} /***** end of calc_heavy_light_form ****/
int main(int argc, char **argv)
{
int meascount[MAX_NKAP];
int prompt, count1, count2;
Real avm_iters[MAX_NKAP];
double starttime, endtime;
int MaxMR, restart_flag;
Real RsdMR; /******/
int spin, color, nk; /******/
int max_prop;
int cl_cg = CL_CG;
double ssplaq, stplaq;
FILE *fp_m_out = NULL; /*** meson IO stuff **/
int fb_m_out = 0; /*** meson IO stuff **/
w_prop_file *fp_in_w[MAX_NKAP]; /* For propagator files */
w_prop_file *fp_out_w[MAX_NKAP]; /* For propagator files */
double g_time ;
int i ;
int MinMR;
/*** variables required for the static variational code ***/
int nodata = 0 ;
complex *meson = NULL;
/****** start of the execution of the code ************/
initialize_machine(&argc, &argv);
/* Remap standard I/O */
if(remap_stdio_from_args(argc, argv) == 1)terminate(1);
g_sync();
/* set up */
prompt = setup_h();
/**DEBUG***/
#ifdef DEBUGDEF
light_quark_pion(0) ;
#endif
/* loop over input sets */
while( readin(prompt) == 0)
{
if( fixflag == COULOMB_GAUGE_FIX)
{
if(this_node == 0)
printf("Fixing to Coulomb gauge\n");
g_time = -dclock();
gaugefix(TUP,(Real)1.5,500,GAUGE_FIX_TOL);
g_time += dclock();
if(this_node==0)printf("Time to gauge fix = %e\n",g_time);
invalidate_this_clov(gen_clov);
}
else
if(this_node == 0)printf("COULOMB GAUGE FIXING SKIPPED.\n");
/* save lattice if requested */
if( saveflag != FORGET )
{
save_lattice( saveflag, savefile, stringLFN );
}
/* call plaquette measuring process */
d_plaquette(&ssplaq, &stplaq);
if (this_node == 0)
printf("START %e %e\n",(double) ssplaq, (double) stplaq);
/******* set up code for the static variational calculation *****/
if( nkap == 1 )
{
nodata = nt*nosmear*144 ;
/** reserve memory for the smeared meson correlators on each node ****/
if( ( meson = (complex *) calloc( (size_t) nodata, sizeof(complex) ) ) == NULL )
{
printf("ERROR: could not reserve buffer space for the meson smearing functions\n");
terminate(1);
}
/** call a number of set up routines for the static variational code ***/
setup_vary(meson, nodata);
} /*** end of set up section for the static-variational calculation ***/
/***DEBUG check_calc_matrix() ; ****/
starttime=dclock();
MaxMR = niter;
RsdMR = (Real) sqrt((double) rsqprop);
if (this_node == 0)
printf("Residue=%e\n",(double) RsdMR);
for (nk = 0; nk < nkap; nk++)
{
avm_iters[nk] = 0.0;
meascount[nk] = 0;
}
max_prop = 12;
count1 = 0;
count2 = 0;
for (spin = start_spin; spin < 4; spin++)
{
for (color = 0; color < 3; color++)
{
count1++;
if (count1 == 1)
color += start_color;
for (nk = 0; nk < nkap; nk++)
{
count2++;
if (count2 == 1)
nk += start_kap;
kappa = cappa[nk];
meascount[nk]++;
/* open file for wilson propagators */
fp_in_w[nk] = r_open_wprop(startflag_w[nk], startfile_w[nk]);
if ((spin + color) == 0)
{
/*** first pass of the code **/
fp_out_w[nk] = w_open_wprop(saveflag_w[nk], savefile_w[nk],
wqs.type);
/* open file for meson output and write the header */
if (saveflag_m == SAVE_MESON_ASCII)
{
fp_m_out = w_ascii_m_i(savefile_m[nk], max_prop);
fb_m_out = -1; /* i.e. file is NOT binary */
}
else if (saveflag_m == SAVE_MESON_BINARY)
{
fb_m_out = w_binary_m_i(savefile_m[nk], max_prop);
fp_m_out = NULL; /* i.e. file is NOT ascii */
}
else
{
if( this_node == 0 )
printf("ERROR in main saveflag_m = %d is out of range in initial opening\n",saveflag_m) ;
terminate(1);
}
} /*** end of spin =0 && color == 0 **/
else
{
fp_out_w[nk] = w_open_wprop(saveflag_w[nk], savefile_w[nk],
wqs.type);
/* open file for meson output for appending output*/
if (saveflag_m == SAVE_MESON_ASCII)
{
fp_m_out = a_ascii_m_i(savefile_m[nk], max_prop);
fb_m_out = -1; /* i.e. file is NOT binary */
}
if (saveflag_m == SAVE_MESON_BINARY)
{
fb_m_out = a_binary_m_i(savefile_m[nk], max_prop);
fp_m_out = NULL; /* i.e. file is NOT ascii */
}
else
{
if( this_node == 0 )
printf("ERROR in main saveflag_m = %d is out of range in appending opening\n",saveflag_m) ;
terminate(1);
}
} /*** end of spin && color not equal to zero ***/
if (this_node == 0)
printf("color=%d spin=%d kappa=%f nk=%d\n", color, spin, (double) kappa, nk);
/* load psi if requested */
init_qs(&wqstmp2);
reload_wprop_sc_to_site(startflag_w[nk], fp_in_w[nk],&wqstmp2,
spin, color, F_OFFSET(psi),1);
if (nk == 0 || count2 == 1)
restart_flag = flag;
else
restart_flag = 1;
/* Conjugate gradient inversion uses site structure
temporary"chi" */
/* Complete the source structure */
wqs.color = color;
wqs.spin = spin;
wqs.parity = EVENANDODD;
/* For wilson_info */
wqstmp = wqs;
/* If we are starting fresh, we want to set a mininum number of
iterations */
if(startflag_w[nk] == FRESH)MinMR = nt/2; else MinMR = 0;
/* Load inversion control structure */
qic.prec = PRECISION;
qic.min = MinMR;
qic.max = MaxMR;
qic.nrestart = nrestart;
qic.parity = EVENANDODD;
qic.start_flag = restart_flag;
qic.nsrc = 1;
qic.resid = RsdMR;
qic.relresid = 0;
/* Load Dirac matrix parameters */
dwp.Kappa = kappa;
switch (cl_cg) {
case CG:
/* Load temporaries specific to inverter */
/* compute the propagator. Result in psi. */
avm_iters[nk] +=
(Real)wilson_invert_site_wqs(F_OFFSET(chi),F_OFFSET(psi),
w_source_h,&wqs,
cgilu_w_site,&qic,(void *)&dwp);
break;
case MR:
/* Load temporaries specific to inverter */
/* compute the propagator. Result in psi. */
avm_iters[nk] +=
(Real)wilson_invert_site_wqs(F_OFFSET(chi),F_OFFSET(psi),
w_source_h,&wqs,
mrilu_w_site,&qic,(void *)&dwp);
break;
default:
node0_printf("main(%d): Inverter choice %d not supported\n",
this_node,cl_cg);
}
/* save psi if requested */
save_wprop_sc_from_site( saveflag_w[nk],fp_out_w[nk], &wqstmp2,
spin,color,F_OFFSET(psi),1);
light_meson(F_OFFSET(psi), color, spin, wqs.type, fp_m_out, fb_m_out);
if (this_node == 0)
printf("Light mesons found\n");
/*** calculate the correlators required for the static variational code **/
if( nkap == 1 )
{
/** calculate the smeared meson correlators required for Bparam **/
calc_smeared_meson(meson, F_OFFSET(psi) , F_OFFSET(mp), color, spin);
/** calculate the object required for the 2-pt variational calculation ***/
buildup_strip(F_OFFSET(psi) , color, spin);
} /** end of the partial calculations for the variationl project ***/
/*
* find source again since mrilu overwrites it; for hopping
* expansion
*/
/* source must be of definite parity */
wqs.parity = source_parity;
w_source_h(F_OFFSET(chi), &wqs);
hopping(F_OFFSET(chi), F_OFFSET(mp), F_OFFSET(psi), nhop,
kappa_c, wqs.parity, color, spin, wqs.type,
fp_m_out, fb_m_out);
/* close files */
r_close_wprop(startflag_w[nk], fp_in_w[nk]);
w_close_wprop(saveflag_w[nk],fp_out_w[nk]);
if (saveflag_m == SAVE_MESON_ASCII)
w_ascii_m_f(fp_m_out, savefile_m[nk]);
else if (saveflag_m == SAVE_MESON_BINARY)
w_binary_m_f(fb_m_out, savefile_m[nk]);
if (spin == end_spin && color == end_color && nk == end_kap)
goto end_of_loops;
}
}
} /* end of loop over spin, color, kappa */
end_of_loops:
if (this_node == 0)
printf("RUNNING COMPLETED\n");
/**DEBUG***/
#ifdef DEBUGDEF
light_quark_pion(2) ;
#endif
for (nk = 0; nk < nkap; nk++)
{
if (meascount[nk] > 0)
{
if (this_node == 0)
printf("total mr iters for measurement= %e\n",
(double) avm_iters[nk]);
if (this_node == 0)
printf("average mr iters per spin-color= %e\n",
(double) avm_iters[nk] / (double) meascount[nk]);
}
}
endtime=dclock();
node0_printf("Time = %e seconds\n", (double) (endtime - starttime));
fflush(stdout);
/*** calculation section for the variational code *****/
if( nkap == 1 )
{
/** sum up the smeared meson correlators over all the nodes ***/
for(i=0 ; i < nodata ;++i)
{
g_complexsum(meson + i) ;
}
/* write the smeared correlators to a single disk file ***/
IF_MASTER
write_smear_mesonx(meson);
free(meson); /*** free up the memory for the b-parameter correlators ***/
calc_vary_matrix() ; /** calculate the static variational matrix **/
node0_printf(">> The end of the static variational code <<<<\n");
}/** end of the final static variational code *****/
node0_printf("Time = %e seconds\n",(double)(endtime-starttime));
fflush(stdout);
} /* end of while(prompt) */
return 0;
} /* end of main() */
