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() */