void
qopWilsonDslashInit(int *argc, char ***argv)
{
QDP_initialize(argc, argv);
QDP_verbose(0);
QDP_profcontrol(0);
}
int
main(int argc, char *argv[])
{
int i, j;
QDP_initialize(&argc, &argv);
QDP_profcontrol(0);
seed = time(NULL);
j = 0;
for(i=1; i<argc; i++) {
switch(argv[i][0]) {
case 'c' : cgtype=atoi(&argv[i][1]); break;
case 'k' : kappa=atof(&argv[i][1]); break;
case 'n' : nit=atoi(&argv[i][1]); break;
case 's' : seed=atoi(&argv[i][1]); break;
case 'S' : style=atoi(&argv[i][1]); break;
case 'x' : j=i; while((i+1<argc)&&(isdigit(argv[i+1][0]))) ++i; break;
default : usage(argv[0]);
}
}
lattice_size = (int *) malloc(ndim*sizeof(int));
if(j==0) {
for(i=0; i<ndim; ++i) lattice_size[i] = 8;
} else {
if(!isdigit(argv[j][1])) usage(argv[0]);
lattice_size[0] = atoi(&argv[j][1]);
for(i=1; i<ndim; ++i) {
if((++j<argc)&&(isdigit(argv[j][0]))) {
lattice_size[i] = atoi(&argv[j][0]);
} else {
lattice_size[i] = lattice_size[i-1];
}
}
}
if(QDP_this_node==0) {
printf("size = %i", lattice_size[0]);
for(i=1; i<ndim; i++) {
printf(" %i", lattice_size[i]);
}
printf("\n");
printf("kappa = %g\n", kappa);
printf("seed = %i\n", seed);
}
QDP_set_latsize(ndim, lattice_size);
QDP_create_layout();
rs = QDP_create_S();
seed_rand(rs, seed);
start();
QDP_finalize();
return 0;
}
int
main(int argc, char *argv[])
{
int status = 1;
int mu;
const char *g_name;
QDP_ColorMatrix *U[NDIM];
QLA_Real plaq;
/* start QDP */
QDP_initialize(&argc, &argv);
if (argc != 1 + NDIM + 1) {
printf0("ERROR: usage: %s Lx ... gauge-file\n", argv[0]);
goto end;
}
for (mu = 0; mu < NDIM; mu++)
lattice[mu] = atoi(argv[1 + mu]);
g_name = argv[1 + NDIM];
/* set lattice size and create layout */
QDP_set_latsize(NDIM, lattice);
QDP_create_layout();
/* allocate the gauge field */
create_Mvector(U, NELEMS(U));
/* read gauge field */
if (read_gauge(U, g_name) != 0) {
printf0("ERROR: read_gauge(%s)\n", g_name);
goto end;
}
/* Compute plaquette */
plaq = plaquette(U);
/* delete the gauge field */
destroy_Mvector(U, NELEMS(U));
/* Display the value */
printf0("plaquette{%s} = %g\n", argv[1],
plaq / (QDP_volume() * QDP_Nc * NDIM * (NDIM - 1) / 2 ));
status = 0;
end:
/* shutdown QDP */
QDP_finalize();
return status;
}
int
main(int argc, char *argv[])
{
int fpos[NDIM];
int c, d, ri;
int gamma;
int status = 1;
int mu;
QDP_DiracFermion *f;
QDP_DiracFermion *g;
/* start QDP */
QDP_initialize(&argc, &argv);
if (argc != 1 + 2 * NDIM + 4) {
printf0("ERROR: usage: %s Lx ... x ... c d r/i gamma\n", argv[0]);
goto end;
}
for (mu = 0; mu < NDIM; mu++)
lattice[mu] = atoi(argv[1 + mu]);
for (mu = 0; mu < NDIM; mu++)
fpos[mu] = atoi(argv[1 + NDIM + mu]);
c = atoi(argv[1 + 2 * NDIM]);
d = atoi(argv[1 + 2 * NDIM + 1]);
ri = atoi(argv[1 + 2 * NDIM + 2]);
gamma = atoi(argv[1 + 2 * NDIM + 3]);
/* set lattice size and create layout */
QDP_set_latsize(NDIM, lattice);
QDP_create_layout();
f = QDP_create_D();
g = QDP_create_D();
point_fermion(f, fpos, c, d, ri);
dump_fermion("check-gamma-f", f);
QDP_D_eq_gamma_times_D(g, f, gamma, QDP_all);
dump_fermion("check-gamma-g", g);
QDP_destroy_D(g);
QDP_destroy_D(f);
status = 0;
end:
/* shutdown QDP */
QDP_finalize();
return status;
}
int main(int argc, char *argv[]) {
int meascount,todo;
int prompt;
double dssplaq,dstplaq;
int m_iters,s_iters,avm_iters,avs_iters,avspect_iters;
#ifdef SPECTRUM
int spect_iters;
#endif
complex plp;
double dtime;
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();
/* loop over input sets */
while( readin(prompt) == 0){
/* set up loop tables */
make_loop_table2();
/* perform warmup trajectories */
dtime = -dclock();
/* call plaquette measuring process */
/* Check: compute initial plaquette (T. D.) */
d_plaquette(&dssplaq,&dstplaq);
if(this_node==0)printf("START %e %e %e\n",
dssplaq,dstplaq,
dssplaq+dstplaq);
for(todo=warms; todo > 0; --todo ){
update();
}
if(this_node==0)printf("WARMUPS COMPLETED\n");
/* perform measuring trajectories, reunitarizing and measuring */
meascount=0; /* number of measurements */
plp = cmplx(99.9,99.9);
avspect_iters = avm_iters = avs_iters = 0;
for(todo=trajecs; todo > 0; --todo ){
/* do the trajectories */
s_iters=update();
/* Do "local" measurements every trajectory! */
/* The action from the RG trans */
gauge_action(&dssplaq);
if(this_node==0)printf("ACTION_V %e %e\n",
dssplaq,(dssplaq)/(double)(volume*6));
/* call plaquette measuring process */
d_plaquette(&dssplaq,&dstplaq);
/* call the Polyakov loop measuring program */
plp = ploop();
/* generate a pseudofermion configuration */
boundary_flip(MINUS);
m_iters = f_measure_cl();
boundary_flip(PLUS);
++meascount;
avm_iters += m_iters;
avs_iters += s_iters;
if(this_node==0)printf("GMES %e %e %e %e %e\n",
(double)plp.real,(double)plp.imag,(double)m_iters,
dssplaq,dstplaq);
/* Re(Polyakov) Im(Poyakov) cg_iters ss_plaq st_plaq */
/* measure other stuff every "propinterval" trajectories */
if(((todo-1)%propinterval) == 0){
fixflag = NO_GAUGE_FIX;
#ifdef SPECTRUM
#ifdef SCREEN
gaugefix(ZUP,(Real)1.5,500,(Real)GAUGE_FIX_TOL);
invalidate_this_clov(gen_clov);
fixflag = COULOMB_GAUGE_FIX;
boundary_flip(MINUS);
spect_iters = s_props_cl();
avspect_iters += spect_iters;
boundary_flip(PLUS);
#else /* spectrum in time direction */
gaugefix(TUP,(Real)1.5,500,(Real)GAUGE_FIX_TOL);
invalidate_this_clov(gen_clov);
fixflag = COULOMB_GAUGE_FIX;
/* commented 15 OCT 95, MBW....we'll use periodic b.c. for spect. */
/* boundary_flip(MINUS); */
/* Don't need t_props if we are doing w_spectrum - C. DeTar */
/* spect_iters = t_props_cl();
avspect_iters += spect_iters; */
spect_iters = w_spectrum_cl();
avspect_iters += spect_iters;
/* boundary_flip(PLUS); */
#endif /* end ifndef SCREEN */
#endif /* end ifdef SPECTRUM */
}
fflush(stdout);
} /* end loop over trajectories */
if(this_node==0)printf("RUNNING COMPLETED\n");
/* Check: compute final plaquette (T. D.) */
d_plaquette(&dssplaq,&dstplaq);
if(this_node==0)printf("STOP %e %e %e\n",
dssplaq,dstplaq,
dssplaq+dstplaq);
if(meascount>0) {
if(this_node==0)printf("average cg iters for step= %e\n",
(double)avs_iters/meascount);
if(this_node==0)printf("average cg iters for measurement= %e\n",
(double)avm_iters/meascount);
#ifdef SPECTRUM
if(this_node==0)printf("average cg iters for spectrum = %e\n",
(double)avspect_iters/meascount);
#endif
}
dtime += dclock();
if(this_node==0){
printf("Time = %e seconds\n",dtime);
printf("total_iters = %d\n",total_iters);
}
fflush(stdout);
dtime = -dclock();
/* save lattice if requested */
if( saveflag != FORGET ){
save_lattice( saveflag, savefile, stringLFN );
}
}
return 0;
}
int main(int argc, char *argv[])
{
int ndim,dims[4];
gauge_file *gf;
gauge_header *gh;
FILE *fp;
char *filename_milc,*filename_scidac;
QIO_Layout layout;
QIO_Reader *infile;
QIO_RecordInfo rec_info;
char *datatype;
int status;
int datum_size;
int input_prec;
int count = 4;
int word_size;
int typesize;
w_serial_site_writer state;
if(argc < 3)
{
fprintf(stderr,"Usage %s <SciDAC file> <MILC file>\n",argv[0]);
exit(1);
}
filename_scidac = argv[1];
filename_milc = argv[2];
if(this_node == 0)printf("Converting file %s to MILC v5 file %s\n",
filename_scidac, filename_milc);
initialize_machine(&argc,&argv);
#ifdef HAVE_QDP
QDP_initialize(&argc, &argv);
#endif
this_node = mynode();
number_of_nodes = numnodes();
if(number_of_nodes != 1){
printf("This is single-processor code. Please rebuild as such.\n");
terminate(1);
}
/* Open the SciDAC file and discover the lattice dimensions. Then
close. */
status = read_lat_dim_scidac(filename_scidac, &ndim, dims);
if(status)terminate(1);
if(ndim != 4){
printf("Wanted ndims = 4 in %s but got %d\n",filename_scidac,ndim);
terminate(1);
}
nx = dims[0]; ny = dims[1]; nz = dims[2]; nt = dims[3];
volume = nx*ny*nz*nt;
/* Finish setting up, now we know the dimensions */
setup();
/* Build the QIO layout */
build_qio_layout(&layout);
/* Open the SciDAC file for reading */
infile = open_scidac_input(filename_scidac, &layout, 0, QIO_SERIAL);
if(infile == NULL)terminate(1);
/* Open the MILC v5 file for writing */
fp = fopen(filename_milc, "wb");
if(fp == NULL)
{
printf("Can't open file %s, error %d\n",
filename_milc,errno);fflush(stdout);
terminate(1);
}
gf = setup_output_gauge_file();
gh = gf->header;
/* Read the SciDAC record header. */
xml_record_in = QIO_string_create();
status = QIO_read_record_info(infile, &rec_info, xml_record_in);
if(status != QIO_SUCCESS)terminate(1);
node0_printf("Record info \n\"%s\"\n",QIO_string_ptr(xml_record_in));
/* Make sure this is a lattice field */
datatype = QIO_get_datatype(&rec_info);
typesize = QIO_get_typesize(&rec_info);
if(strcmp(datatype, "QDP_F3_ColorMatrix") == 0 ||
strcmp(datatype, "USQCD_F3_ColorMatrix") == 0 ||
typesize == 72){
datum_size = sizeof(fsu3_matrix);
input_prec = 1;
word_size = sizeof(float);
}
else if(strcmp(datatype, "QDP_D3_ColorMatrix") == 0 ||
strcmp(datatype, "USQCD_F3_ColorMatrix") == 0 ||
typesize == 144){
datum_size = sizeof(dsu3_matrix);
input_prec = 2;
word_size = sizeof(double);
}
else {
printf("Unrecognized datatype %s\n",datatype);
terminate(1);
}
/* Copy the time stamp from the SciDAC file */
strncpy(gh->time_stamp, QIO_get_record_date(&rec_info),
MAX_TIME_STAMP);
gh->time_stamp[MAX_TIME_STAMP-1] = '\0';
/* Write the MILC v5 header */
gh->order = NATURAL_ORDER;
/* Node 0 writes the header */
swrite_gauge_hdr(fp,gh);
/* Assign values to file structure */
gf->fp = fp;
gf->filename = filename_milc;
gf->byterevflag = 0; /* Not used for writing */
gf->rank2rcv = NULL; /* Not used for writing */
gf->parallel = 0;
/* Initialize writing the lattice data */
w_serial_start_lattice(gf, &state, input_prec);
/* Read the SciDAC record data. The factory function writes the
site links to a file. */
status = QIO_read_record_data(infile, w_serial_site_links,
datum_size*count, word_size,
(void *)&state);
if(status != QIO_SUCCESS)terminate(1);
node0_printf("SciDAC checksums %x %x\n",
QIO_get_reader_last_checksuma(infile),
QIO_get_reader_last_checksumb(infile));
/* Close the SciDAC file */
QIO_close_read(infile);
/* Finish the MILC v5 file */
w_serial_finish_lattice(&state);
w_serial_f(gf);
QIO_string_destroy(xml_record_in);
#ifdef HAVE_QDP
QDP_finalize();
#endif
normal_exit(0);
return 0;
}
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 */
int
main(int argc, char *argv[])
{
const char *msg;
int status = 1;
int mu, i;
struct QOP_CLOVER_State *clover_state;
QDP_Int *I_seed;
int i_seed;
QDP_RandomState *state;
QLA_Real plaq;
QLA_Real n[NELEMS(F)];
struct QOP_CLOVER_Gauge *c_g;
struct QOP_CLOVER_Fermion *c_f[NELEMS(F)];
double kappa;
double c_sw;
double in_eps;
int in_iter;
int log_flag;
double out_eps;
int out_iter;
int cg_status;
double run_time;
long long flops, sent, received;
/* start QDP */
QDP_initialize(&argc, &argv);
if (argc != 1 + NDIM + 6) {
printf0("ERROR: usage: %s Lx ... seed kappa c_sw iter eps log?\n",
argv[0]);
goto end;
}
for (mu = 0; mu < NDIM; mu++) {
lattice[mu] = atoi(argv[1 + mu]);
}
i_seed = atoi(argv[1 + NDIM]);
kappa = atof(argv[2 + NDIM]);
c_sw = atof(argv[3 + NDIM]);
in_iter = atoi(argv[4 + NDIM]);
in_eps = atof(argv[5 + NDIM]);
log_flag = atoi(argv[6 + NDIM]) == 0? 0: QOP_CLOVER_LOG_EVERYTHING;
/* set lattice size and create layout */
QDP_set_latsize(NDIM, lattice);
QDP_create_layout();
primary = QMP_is_primary_node();
self = QMP_get_node_number();
get_vector(network, 1, QMP_get_logical_number_of_dimensions(),
QMP_get_logical_dimensions());
get_vector(node, 0, QMP_get_logical_number_of_dimensions(),
QMP_get_logical_coordinates());
printf0("network: ");
for (i = 0; i < NDIM; i++)
printf0(" %d", network[i]);
printf0("\n");
printf0("node: ");
for (i = 0; i < NDIM; i++)
printf0(" %d", node[i]);
printf0("\n");
printf0("kappa: %20.15f\n", kappa);
printf0("c_sw: %20.15f\n", c_sw);
printf0("in_iter: %d\n", in_iter);
printf0("in_eps: %15.2e\n", in_eps);
/* allocate the gauge field */
create_Mvector(U, NELEMS(U));
create_Mvector(C, NELEMS(C));
create_Dvector(F, NELEMS(F));
I_seed = QDP_create_I();
QDP_I_eq_funci(I_seed, icoord, QDP_all);
state = QDP_create_S();
QDP_S_eq_seed_i_I(state, i_seed, I_seed, QDP_all);
for (mu = 0; mu < NELEMS(U); mu++) {
QDP_M_eq_gaussian_S(U[mu], state, QDP_all);
}
for (i = 0; i < NELEMS(F); i++) {
QDP_D_eq_gaussian_S(F[i], state, QDP_all);
}
/* build the clovers */
clover(C, U);
/* initialize CLOVER */
if (QOP_CLOVER_init(&clover_state, lattice, network, node, primary,
sublattice, NULL)) {
printf0("CLOVER_init() failed\n");
goto end;
}
if (QOP_CLOVER_import_fermion(&c_f[0], clover_state, f_reader, F[0])) {
printf0("CLOVER_import_fermion(0) failed\n");
goto end;
}
if (QOP_CLOVER_allocate_fermion(&c_f[1], clover_state)) {
printf0("CLOVER_allocate_fermion(1) failed\n");
goto end;
}
if (QOP_CLOVER_allocate_fermion(&c_f[2], clover_state)) {
printf0("CLOVER_allocate_fermion(2) failed\n");
goto end;
}
if (QOP_CLOVER_allocate_fermion(&c_f[3], clover_state)) {
printf0("CLOVER_allocate_fermion(3) failed\n");
goto end;
}
if (QOP_CLOVER_import_gauge(&c_g, clover_state, kappa, c_sw,
u_reader, c_reader, NULL)) {
printf("CLOVER_import_gauge() failed\n");
goto end;
}
QOP_CLOVER_D_operator(c_f[2], c_g, c_f[0]);
cg_status = QOP_CLOVER_D_CG(c_f[3], &out_iter, &out_eps,
c_f[2], c_g, c_f[2], in_iter, in_eps,
log_flag);
msg = QOP_CLOVER_error(clover_state);
QOP_CLOVER_performance(&run_time, &flops, &sent, &received, clover_state);
QOP_CLOVER_export_fermion(f_writer, F[3], c_f[3]);
printf0("CG status: %d\n", cg_status);
printf0("CG error message: %s\n", msg? msg: "<NONE>");
printf0("CG iter: %d\n", out_iter);
printf0("CG eps: %20.10e\n", out_eps);
printf0("CG performance: runtime %e sec\n", run_time);
printf0("CG performance: flops %.3e MFlop/s (%lld)\n",
flops * 1e-6 / run_time, flops);
printf0("CG performance: snd %.3e MB/s (%lld)\n",
sent * 1e-6 / run_time, sent);
printf0("CG performance: rcv %.3e MB (%lld)/s\n",
received * 1e-6 / run_time, received);
/* free CLOVER */
QOP_CLOVER_free_gauge(&c_g);
for (i = 0; i < NELEMS(c_f); i++)
QOP_CLOVER_free_fermion(&c_f[i]);
QOP_CLOVER_fini(&clover_state);
/* Compute plaquette */
plaq = plaquette(U);
/* field norms */
for (i = 0; i < NELEMS(F); i++)
QDP_r_eq_norm2_D(&n[i], F[i], QDP_all);
/* Display the values */
printf0("plaquette = %g\n",
plaq / (QDP_volume() * QDP_Nc * NDIM * (NDIM - 1) / 2 ));
for (i = 0; i < NELEMS(F); i++)
printf0(" |f|^2 [%d] = %20.10e\n", i, (double)(n[i]));
/* Compute and display <f[1] f[0]> */
show_dot("1|orig", F[1], F[0]);
/* Compute and display <f[1] f[3]> */
show_dot("1|solv", F[1], F[3]);
QDP_destroy_S(state);
QDP_destroy_I(I_seed);
destroy_Mvector(U, NELEMS(U));
destroy_Mvector(C, NELEMS(C));
destroy_Dvector(F, NELEMS(F));
status = 0;
end:
/* shutdown QDP */
printf0("end\n");
QDP_finalize();
return status;
}
int
main(int argc, char *argv[])
{
int status = 1;
int mu, i;
struct QOP_CLOVER_State *clover_state;
QDP_Int *I_seed;
int i_seed;
QDP_RandomState *state;
QLA_Real plaq;
QLA_Real n[NELEMS(F)];
struct QOP_CLOVER_Gauge *c_g;
struct QOP_CLOVER_Fermion *c_f[NELEMS(F)];
double kappa;
double c_sw;
/* start QDP */
QDP_initialize(&argc, &argv);
if (argc != 1 + NDIM + 3) {
printf0("ERROR: usage: %s Lx ... seed kappa c_sw\n", argv[0]);
goto end;
}
for (mu = 0; mu < NDIM; mu++) {
lattice[mu] = atoi(argv[1 + mu]);
}
i_seed = atoi(argv[1 + NDIM]);
kappa = atof(argv[2 + NDIM]);
c_sw = atof(argv[3 + NDIM]);
/* set lattice size and create layout */
QDP_set_latsize(NDIM, lattice);
QDP_create_layout();
primary = QMP_is_primary_node();
self = QMP_get_node_number();
get_vector(network, 1, QMP_get_logical_number_of_dimensions(),
QMP_get_logical_dimensions());
get_vector(node, 0, QMP_get_logical_number_of_dimensions(),
QMP_get_logical_coordinates());
printf0("network: ");
for (i = 0; i < NDIM; i++)
printf0(" %d", network[i]);
printf0("\n");
printf0("node: ");
for (i = 0; i < NDIM; i++)
printf0(" %d", node[i]);
printf0("\n");
printf0("kappa: %20.15f\n", kappa);
printf0("c_sw: %20.15f\n", c_sw);
/* allocate the gauge field */
create_Mvector(U, NELEMS(U));
create_Mvector(C, NELEMS(C));
create_Dvector(F, NELEMS(F));
I_seed = QDP_create_I();
QDP_I_eq_funci(I_seed, icoord, QDP_all);
state = QDP_create_S();
QDP_S_eq_seed_i_I(state, i_seed, I_seed, QDP_all);
for (mu = 0; mu < NELEMS(U); mu++) {
QDP_M_eq_gaussian_S(U[mu], state, QDP_all);
}
for (i = 0; i < NELEMS(F); i++) {
QDP_D_eq_gaussian_S(F[i], state, QDP_all);
}
/* build the clovers */
clover(C, U);
/* initialize CLOVER */
if (QOP_CLOVER_init(&clover_state, lattice, network, node, primary,
sublattice, NULL)) {
printf0("CLOVER_init() failed\n");
goto end;
}
if (QOP_CLOVER_import_fermion(&c_f[0], clover_state, f_reader, F[0])) {
printf0("CLOVER_import_fermion(0) failed\n");
goto end;
}
if (QOP_CLOVER_import_fermion(&c_f[1], clover_state, f_reader, F[1])) {
printf0("CLOVER_import_fermion(1) failed\n");
goto end;
}
if (QOP_CLOVER_allocate_fermion(&c_f[2], clover_state)) {
printf0("CLOVER_allocate_fermion(2) failed\n");
goto end;
}
if (QOP_CLOVER_allocate_fermion(&c_f[3], clover_state)) {
printf0("CLOVER_allocate_fermion(3) failed\n");
goto end;
}
if (QOP_CLOVER_import_gauge(&c_g, clover_state, kappa, c_sw,
u_reader, c_reader, NULL)) {
printf("CLOVER_import_gauge() failed\n");
goto end;
}
QOP_CLOVER_D_operator(c_f[2], c_g, c_f[0]);
QOP_CLOVER_export_fermion(f_writer, F[2], c_f[2]);
QOP_CLOVER_D_operator_conjugated(c_f[3], c_g, c_f[1]);
QOP_CLOVER_export_fermion(f_writer, F[3], c_f[3]);
/* free CLOVER */
QOP_CLOVER_free_gauge(&c_g);
for (i = 0; i < NELEMS(c_f); i++)
QOP_CLOVER_free_fermion(&c_f[i]);
QOP_CLOVER_fini(&clover_state);
/* Compute plaquette */
plaq = plaquette(U);
/* field norms */
for (i = 0; i < NELEMS(F); i++)
QDP_r_eq_norm2_D(&n[i], F[i], QDP_all);
/* Display the values */
printf0("plaquette = %g\n",
plaq / (QDP_volume() * QDP_Nc * NDIM * (NDIM - 1) / 2 ));
for (i = 0; i < NELEMS(F); i++)
printf0(" |f|^2 [%d] = %20.10e\n", i, (double)(n[i]));
/* Compute and display <f[1] f[2]> */
show_dot("1|D0", F[1], F[2]);
/* Compute and display <f[3] f[0]> */
show_dot("X1|0", F[3], F[0]);
QDP_destroy_S(state);
QDP_destroy_I(I_seed);
destroy_Mvector(U, NELEMS(U));
destroy_Mvector(C, NELEMS(C));
destroy_Dvector(F, NELEMS(F));
status = 0;
end:
/* shutdown QDP */
printf0("end\n");
QDP_finalize();
return status;
}
int main(int argc,char *argv[])
{
int prompt , k, ns, i;
site *s;
double inv_space_vol;
int color,spin, color1, spin1;
int key[4];
int dummy[4];
FILE *corr_fp;
complex pr_tmp;
wilson_propagator *qdest;
wilson_propagator qtemp1;
wilson_vector *psi = NULL;
w_prop_file *wpf;
wilson_quark_source wqs;
key[XUP] = 1;
key[YUP] = 1;
key[ZUP] = 1;
key[TUP] = 0;
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();
prompt = setup();
setup_restrict_fourier(key, dummy);
psi = create_wv_field();
/* Initialize the source type */
init_wqs(&wqs);
while( readin(prompt) == 0){
/**************************************************************/
/*load staggered propagator*/
reload_ksprop_to_site3(ks_prop_startflag,
start_ks_prop_file, &ksqs, F_OFFSET(prop), 1);
FORALLSITES(i,s){
for(color = 0; color < 3; color++)for(k = 0; k < 3; k++)
s->stag_propagator.e[color][k] = s->prop[color].c[k];
}
/* Initialize FNAL correlator file */
corr_fp = open_fnal_meson_file(savefile_c);
/* Load Wilson propagator for each kappa */
for(k=0; k<num_kap; k++){
kappa = kap[k];
wpf = r_open_wprop(startflag_w[k], startfile_w[k]);
for(spin=0;spin<4;spin++)
for(color=0;color<3;color++){
if(reload_wprop_sc_to_field(startflag_w[k], wpf,
&wqs, spin, color, psi, 1) != 0)
terminate(1);
FORALLSITES(i,s){
copy_wvec(&psi[i],&lattice[i].quark_propagator.c[color].d[spin]);
}
}
r_close_wprop(startflag_w[k],wpf);
/*******************************************************************/
/* Rotate the heavy quark */
rotate_w_quark(F_OFFSET(quark_propagator),
F_OFFSET(quark_propagator_copy), d1[k]);
// result in quark_propagator_copy
/**************************************************************/
/*Calculate and print out the spectrum with the rotated heavy
quark propagators*/
spectrum_hl_rot(corr_fp, F_OFFSET(stag_propagator),
F_OFFSET(quark_propagator_copy), k);
/**************************************************************/
/*Smear quarks, calculate and print out the spectrum with the
smeared heavy quark propagators*/
for(color=0;color<3;color++)for(spin=0;spin<4;spin++){
restrict_fourier_site(F_OFFSET(quark_propagator.c[color].d[spin]),
sizeof(wilson_vector), FORWARDS);
}
for(ns=0; ns<num_smear;ns++){
if(strcmp(smearfile[ns],"none")==0) continue;
inv_space_vol = 1./((double)nx*ny*nz);
/* Either read a smearing file, or take it to be a point sink */
if(strlen(smearfile[ns]) != 0){
get_smearings_bi_serial(smearfile[ns]);
restrict_fourier_site(F_OFFSET(w),
sizeof(complex), FORWARDS);
FORALLSITES(i,s){
for(color=0;color<3;color++)for(spin=0;spin<4;spin++)
for(color1=0;color1<3;color1++)for(spin1=0;spin1<4;spin1++){
pr_tmp =
s->quark_propagator.c[color].d[spin].d[spin1].c[color1];
s->quark_propagator_copy.c[color].d[spin].d[spin1].c[color1].real =
pr_tmp.real * s->w.real - pr_tmp.imag * s->w.imag;
s->quark_propagator_copy.c[color].d[spin].d[spin1].c[color1].imag =
pr_tmp.real * s->w.imag + pr_tmp.imag * s->w.real;
}
}
} else { /* Point sink */
FORALLSITES(i,s){
for(color=0;color<3;color++)for(spin=0;spin<4;spin++)
for(color1=0;color1<3;color1++)for(spin1=0;spin1<4;spin1++){
pr_tmp =
s->quark_propagator.c[color].d[spin].d[spin1].c[color1];
s->quark_propagator_copy.c[color].d[spin].d[spin1].c[color1].real =
pr_tmp.real;
s->quark_propagator_copy.c[color].d[spin].d[spin1].c[color1].imag =
pr_tmp.imag;
}
}
}
for(color=0;color<3;color++)for(spin=0;spin<4;spin++){
restrict_fourier_site(F_OFFSET(quark_propagator_copy.c[color].d[spin]),
sizeof(wilson_vector), BACKWARDS);
}
FORALLSITES(i,s)
{
qdest = &(s->quark_propagator_copy);
qtemp1 = s->quark_propagator_copy;
for(spin=0;spin<4;spin++)for(color=0;color<3;color++)
for(spin1=0;spin1<4;spin1++)for(color1=0;color1<3;color1++)
{
qdest->c[color].d[spin1].d[spin].c[color1].real =
qtemp1.c[color].d[spin].d[spin1].c[color1].real;
qdest->c[color].d[spin1].d[spin].c[color1].imag =
qtemp1.c[color].d[spin].d[spin1].c[color1].imag;
}
}
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;
}
int main(int argc, char *argv[])
{
int meascount;
int todo;
int prompt;
double ssplaq;
double stplaq;
complex plp;
double dtime;
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();
make_loop_table2();
if(startflag != CONTINUE)total_sweeps = 0;
/* loop over input sets */
while ( readin(prompt) == 0 )
{
total_sweeps += sweeps;
dtime = -dclock();
/* perform smoothing sweeps, reunitarizing and measuring */
meascount = 0; /* number of measurements */
for (todo=sweeps; todo > 0; --todo )
{
/* do one smoothing sweep */
smooth();
/* measure every "measinterval" trajectories */
if ((todo%measinterval) == 0)
{
/* call plaquette measuring process */
d_plaquette(&ssplaq, &stplaq);
/* don't bother to */
/* call the Polyakov loop measuring program */
/* plp = ploop(); */
plp = cmplx(99.9, 99.9);
++meascount;
if (this_node==0)
{
/* Re(Polyakov) Im(Poyakov) cg_iters ss_plaq st_plaq */
printf("GMES %e %e %e %e %e\n",
(double)plp.real, (double)plp.imag, 99.9,
(double)ssplaq, (double)stplaq);
}
fflush(stdout);
}
} /* end loop over sweeps */
/* perform gauge fixing after smoothing if requested */
if ( fixflag == COULOMB_GAUGE_FIX )
{
if (this_node == 0)
{
printf("Fixing to Coulomb gauge\n");
}
gaugefix(TUP, (Real)1.5, 500, GAUGE_FIX_TOL);
}
else if (this_node == 0)
{
printf("GAUGE FIXING SKIPPED.\n");
}
/* measure the instanton charge on the fitted config */
instanton_density();
if (this_node==0)
{
printf("RUNNING COMPLETED\n");
}
dtime += dclock();
if (this_node==0)
{
printf("Time = %e seconds\n", dtime);
}
fflush(stdout);
/* save FFdual */
if(savetopoflag != FORGET) save_topo(topofile);
/* save lattice if requested */
if ( saveflag != FORGET )
{
save_lattice( saveflag, savefile, stringLFN );
}
}
return 0;
}
int
main( int argc, char **argv )
{
int meascount,traj_done,i;
int prompt;
int s_iters, avs_iters, avspect_iters, avbcorr_iters;
double dtime, dclock();
initialize_machine(&argc,&argv);
#ifdef HAVE_QDP
QDP_initialize(&argc, &argv);
#ifndef QDP_PROFILE
QDP_profcontrol(0);
#endif
#endif
/* Remap standard I/O */
if(remap_stdio_from_args(argc, argv) == 1)terminate(1);
g_sync();
/* set up */
prompt = setup();
/* loop over input sets */
while( readin(prompt) == 0) {
/* perform warmup trajectories */
#ifdef MILC_GLOBAL_DEBUG
global_current_time_step = 0;
#endif /* MILC_GLOBAL_DEBUG */
dtime = -dclock();
for( traj_done=0; traj_done < warms; traj_done++ ){
update();
}
node0_printf("WARMUPS COMPLETED\n"); fflush(stdout);
/* perform measuring trajectories, reunitarizing and measuring */
meascount=0; /* number of measurements */
avspect_iters = avs_iters = avbcorr_iters = 0;
for( traj_done=0; traj_done < trajecs; traj_done++ ){
#ifdef MILC_GLOBAL_DEBUG
#ifdef HISQ_REUNITARIZATION_DEBUG
{
int isite, idir;
site *s;
FORALLSITES(isite,s) {
for( idir=XUP;idir<=TUP;idir++ ) {
lattice[isite].on_step_Y[idir] = 0;
lattice[isite].on_step_W[idir] = 0;
lattice[isite].on_step_V[idir] = 0;
}
}
}
#endif /* HISQ_REUNITARIZATION_DEBUG */
#endif /* MILC_GLOBAL_DEBUG */
/* do the trajectories */
s_iters=update();
/* measure every "propinterval" trajectories */
if( (traj_done%propinterval)==(propinterval-1) ){
/* call gauge_variable fermion_variable measuring routines */
/* results are printed in output file */
rephase(OFF);
g_measure( );
rephase(ON);
#ifdef MILC_GLOBAL_DEBUG
#ifdef HISQ
g_measure_plaq( );
#endif
#ifdef MEASURE_AND_TUNE_HISQ
g_measure_tune( );
#endif /* MEASURE_AND_TUNE_HISQ */
#endif /* MILC_GLOBAL_DEBUG */
/************************************************************/
/* WARNING: The spectrum code below is under revision */
/* It works only in special cases */
/* For the asqtad spectrum, please create the lattice first */
/* and then run the appropriate executable in ks_imp_dyn. */
/************************************************************/
/* Do some fermion measurements */
#ifdef SPECTRUM
/* Fix TUP Coulomb gauge - gauge links only*/
rephase( OFF );
gaugefix(TUP,(Real)1.8,500,(Real)GAUGE_FIX_TOL);
rephase( ON );
invalidate_all_ferm_links(&fn_links);
#ifdef DM_DU0
invalidate_all_ferm_links(&fn_links_dmdu0);
#endif
#endif
for(i=0;i<n_dyn_masses;i++){
// Remake the path table if the fermion coeffs change for this mass
// DT IT CAN"T BE RIGHT TO CALL IT WITH dyn_mass
//if(make_path_table(&ks_act_paths, &ks_act_paths_dmdu0,dyn_mass[i]))
//AB: NOT SURE IF WE ARE DOING THIS RIGHT HERE
// HAVE TO THINK THROUGH HOW LINKS ARE LOADED FOR MEASUREMENTS
// AND WHERE NAIK CORRECTION CAN EVER POSSIBLY ENTER
// if(make_path_table(&ks_act_paths, &ks_act_paths_dmdu0, 0.0/*TEMP*/ ))
{
// If they change, invalidate only fat and long links
//node0_printf("INVALIDATE\n");
invalidate_all_ferm_links(&fn_links);
#ifdef DM_DU0
invalidate_all_ferm_links(&fn_links_dmdu0);
#endif
}
/* Load fat and long links for fermion measurements if needed */
#ifdef HISQ
//AB: QUICK FIX TO USE NAIK EPSILON FOR SPECTRUM MEASUREMENTS,
// WORKS ONLY IF IN THE RATIONAL FUNCTION FILE naik_term_epsilon IS NON-ZERO
// FOR LAST PSEUDO-FIELD
// IT IS ASSUMED THAT THIS CORRECTION CORRESPONDS TO LAST DYNAMICAL MASS
//AB: OLD WAY OF INITIALIZING THE LINKS: fn_links.hl.current_X_set = 0;
// INSTEAD WE DO:
//// if(n_dyn_masses-1==i) { // last dynamical mass, assumed to be c-quark
//// fn_links.hl.current_X_set = n_naiks-1;
//DT CHARM QUARK NEEDS SMALLER RESIDUAL
//// node0_printf("TEMP: reset rsqprop from %e to %e\n",rsqprop,1e-8*rsqprop);
//// rsqprop *= 1e-8;
//// }
//// else { // light quarks
fn_links.hl.current_X_set = 0;
//// }
#endif
load_ferm_links(&fn_links, &ks_act_paths);
#ifdef DM_DU0
#ifdef HISQ
fn_links_dmdu0.hl.current_X_set = 0;
#endif
load_ferm_links(&fn_links_dmdu0, &ks_act_paths_dmdu0);
#endif
f_meas_imp( F_OFFSET(phi1), F_OFFSET(xxx1), dyn_mass[i],
&fn_links, &fn_links_dmdu0);
/* Measure derivatives wrto chemical potential */
#ifdef D_CHEM_POT
Deriv_O6( F_OFFSET(phi1), F_OFFSET(xxx1), F_OFFSET(xxx2),
dyn_mass[i], &fn_links, &fn_links_dmdu0);
#endif
#ifdef SPECTRUM
// DT: At the moment spectrum_nd does only the first two masses
// this only makes sense to get the kaon, and only works if
// eps_naik is the same for both the first two quarks
if( strstr(spectrum_request,",spectrum_nd,") != NULL && i==0 )
avspect_iters += spectrum_nd( dyn_mass[0], dyn_mass[1], 1e-2, &fn_links);
// AB: spectrum() is used only for the charm quark,
// i.e., last dynamical mass
if(strstr(spectrum_request,",spectrum,") != NULL && n_dyn_masses-1==i)
avspect_iters += spectrum2( dyn_mass[i], F_OFFSET(phi1),
F_OFFSET(xxx1), &fn_links);
if(strstr(spectrum_request,",spectrum_point,") != NULL)
avspect_iters += spectrum_fzw( dyn_mass[i], F_OFFSET(phi1),
F_OFFSET(xxx1), &fn_links);
// AB: nl_spectrum is used only for strange,
// i.e., second mass
if(strstr(spectrum_request,",nl_spectrum,") != NULL && 1==i)
avspect_iters += nl_spectrum( dyn_mass[i], F_OFFSET(phi1),
F_OFFSET(xxx1),
F_OFFSET(tempmat1),
F_OFFSET(staple),
&fn_links);
// AB: spectrum_mom is used only for charm,
// i.e., last mass
if(strstr(spectrum_request,",spectrum_mom,") != NULL && n_dyn_masses-1==i)
avspect_iters += spectrum_mom( dyn_mass[i], dyn_mass[i],
F_OFFSET(phi1), 1e-1,
&fn_links);
// For now we can't do the off-diagonal spectrum if Dirac operators
// depend on masses. We need two propagators
// if(strstr(spectrum_request,",spectrum_multimom,") != NULL)
// avspect_iters += spectrum_multimom(dyn_mass[i],
// spectrum_multimom_low_mass,
// spectrum_multimom_mass_step,
// spectrum_multimom_nmasses,
// 5e-3, &fn_links);
// For now we can't do the off-diagonal spectrum if Dirac operators
// depend on masses. We need two propagators
// if(strstr(spectrum_request,",spectrum_nd,") != NULL){
// avspect_iters += spectrum_nd( mass1, mass2, 1e-1,
// &fn_links);
// AB: spectrum_nlpi2 is used only for up/down,
// i.e., first mass
if(strstr(spectrum_request,",spectrum_nlpi2,") != NULL && 0==i)
avspect_iters += spectrum_nlpi2( dyn_mass[i], dyn_mass[i],
F_OFFSET(phi1),1e-1,
&fn_links );
if(strstr(spectrum_request,",spectrum_singlets,") != NULL)
avspect_iters += spectrum_singlets(dyn_mass[i], 5e-3,
F_OFFSET(phi1), &fn_links );
// For now we can't do the off-diagonal spectrum if Dirac operators
// depend on masses. We need two propagators
// if(strstr(spectrum_request,",fpi,") != NULL)
// avspect_iters += fpi_2( fpi_mass, fpi_nmasses, 2e-3,
// &fn_links );
#ifdef HYBRIDS
if(strstr(spectrum_request,",spectrum_hybrids,") != NULL)
avspect_iters += spectrum_hybrids( dyn_mass[i], F_OFFSET(phi1),
5e-3, &fn_links);
#endif
if(strstr(spectrum_request,",hvy_pot,") != NULL){
rephase( OFF );
hvy_pot( F_OFFSET(link[XUP]) );
rephase( ON );
}
#endif
// if(n_dyn_masses-1==i) { // last dynamical mass, assumed to be c-quark
//DT CHARM QUARK NEEDS SMALLER RESIDUAL
//AB NEED TO RETURN RESIDUAL TO THE ORIGINAL VALUE
// node0_printf("TEMP: reset rsqprop from %e to %e\n",rsqprop,1e+8*rsqprop);
// rsqprop *= 1e+8;
// }
}
avs_iters += s_iters;
++meascount;
fflush(stdout);
}
} /* end loop over trajectories */
node0_printf("RUNNING COMPLETED\n"); fflush(stdout);
if(meascount>0) {
node0_printf("average cg iters for step= %e\n",
(double)avs_iters/meascount);
}
dtime += dclock();
if(this_node==0){
printf("Time = %e seconds\n",dtime);
printf("total_iters = %d\n",total_iters);
}
fflush(stdout);
/* save lattice if requested */
if( saveflag != FORGET ){
rephase( OFF );
save_lattice( saveflag, savefile, stringLFN );
rephase( ON );
}
}
#ifdef HAVE_QDP
QDP_finalize();
#endif
normal_exit(0);
return 0;
}
void
qhmc_init_qopqdp(int *argc, char ***argv)
{
QDP_initialize(argc, argv);
QDP_profcontrol(0);
}
/* the driver */
int
main(int argc, char *argv[])
{
int status = 1;
int i;
lua_State *L = NULL;
if (QDP_initialize(&argc, &argv)) {
fprintf(stderr, "QDP initialization failed\n");
return 1;
}
QDP_profcontrol(0);
double node = QDP_this_node;
QMP_min_double(&node);
qlua_master_node = node;
L = lua_open();
if (L == NULL) {
message("can not create Lua state");
goto end;
}
qlua_init(L, argc, argv); /* open libraries */
if (argc < 2) {
message("QLUA component versions:\n");
for (i = 0; versions[i].name; i++)
message(" %10s: %s\n", versions[i].name, versions[i].value);
} else {
for (i = 1; i < argc; i++) {
char *source;
if(strcmp(argv[i],"-e")==0) { // process command
const char *chunk = argv[i] + 2;
if (*chunk == '\0') {
if (++i >= argc) {
message("missing argument to -e");
goto end;
}
chunk = argv[i];
}
QLUA_ASSERT(chunk != NULL);
status = dostring(L, chunk);
source = "=(command line)";
} else {
status = dofile(L, argv[i]);
source = argv[i];
}
report(L, source, status);
if (status) {
fflush(stdout);
fflush(stderr);
QDP_abort(1);
break;
}
}
}
qlua_fini(L);
lua_close(L);
end:
QDP_finalize();
return status;
}
int main( int argc, char **argv ){
register site *s;
int i,si;
int prompt;
double dtime;
su3_vector **eigVec ;
su3_vector *tmp ;
double *eigVal ;
int total_R_iters ;
double chirality ;
initialize_machine(&argc,&argv);
#ifdef HAVE_QDP
QDP_initialize(&argc, &argv);
#ifndef QDP_PROFILE
QDP_profcontrol(0);
#endif
#endif
/* Remap standard I/O */
if(remap_stdio_from_args(argc, argv) == 1)terminate(1);
g_sync();
/* set up */
prompt = setup();
/* loop over input sets */
while( readin(prompt) == 0){
dtime = -dclock();
invalidate_all_ferm_links(&fn_links);
make_path_table(&ks_act_paths, &ks_act_paths_dmdu0);
/* Load fat and long links for fermion measurements if needed */
load_ferm_links(&fn_links, &ks_act_paths);
/* call fermion_variable measuring routines */
/* results are printed in output file */
f_meas_imp( F_OFFSET(phi), F_OFFSET(xxx), mass,
&fn_links, &fn_links_dmdu0);
eigVal = (double *)malloc(Nvecs*sizeof(double));
eigVec = (su3_vector **)malloc(Nvecs*sizeof(su3_vector*));
for(i=0;i<Nvecs;i++)
eigVec[i]=
(su3_vector*)malloc(sites_on_node*sizeof(su3_vector));
total_R_iters=Kalkreuter(eigVec, eigVal, eigenval_tol,
error_decr, Nvecs, MaxIter, Restart,
Kiters, EVEN, &fn_links) ;
tmp = (su3_vector*)malloc(sites_on_node*sizeof(su3_vector));
for(i=0;i<Nvecs;i++)
{
/* Construct to odd part of the vector. *
* Note that the true odd part of the eigenvector is *
* i/sqrt(eigVal) Dslash Psi. But since I only compute *
* the chirality the i factor is irrelevant (-i)*i=1!! */
dslash_fn_field(eigVec[i], tmp, ODD, &fn_links) ;
FORSOMEPARITY(si,s,ODD){
scalar_mult_su3_vector( &(tmp[si]),
1.0/sqrt(eigVal[i]),
&(eigVec[i][si]) ) ;
}
measure_chirality(eigVec[i], &chirality, EVENANDODD);
/* Here I divide by 2 since the EVEN vector is normalized to
* 1. The EVENANDODD vector is normalized to 2. I could have
* normalized the EVENANDODD vector to 1 and then not devide
* by to. The measure_chirality routine assumes vectors
* normalized to 1. */
node0_printf("Chirality(%i): %g\n",i,chirality/2) ;
}
free(tmp);
/**
for(i=0;i<Nvecs;i++)
{
sprintf(label,"DENSITY(%i)",i) ;
print_densities(eigVec[i], label, ny/2,nz/2,nt/2, EVEN) ;
}
**/
for(i=0;i<Nvecs;i++)
free(eigVec[i]) ;
free(eigVec) ;
free(eigVal) ;
#ifdef FN
invalidate_all_ferm_links(&fn_links);
#endif
fflush(stdout);
node0_printf("RUNNING COMPLETED\n"); fflush(stdout);
dtime += dclock();
if(this_node==0){
printf("Time = %e seconds\n",dtime);
printf("total_iters = %d\n",total_iters);
printf("total Rayleigh iters = %d\n",total_R_iters);
}
fflush(stdout);
}
int main (int argc,char **argv )
{
QDP_initialize(&argc,&argv);
/********************************************************
* Command line parsing
********************************************************
*/
if ( argc != 6 ) {
Printf("Usage: %s lx ly lz lt Ls\n All must be even\n",argv[0]);
Printf("argc is %d\n",argc);
for ( int i=0;i<argc;i++){
Printf("%d %s\n",i,argv[i]);
}
exit
(-1);
}
/********************************************************
* Setup QDP
********************************************************
*/
multi1d<int> nrow(Nd);
nrow[0] = atoi(argv[1]);
nrow[1] = atoi(argv[2]);
nrow[2] = atoi(argv[3]);
nrow[3] = atoi(argv[4]);
Layout::setLattSize(nrow);
Layout::create();
int lx = QDP::Layout::subgridLattSize()[0];
int ly = QDP::Layout::subgridLattSize()[1];
int lz = QDP::Layout::subgridLattSize()[2];
int lt = QDP::Layout::subgridLattSize()[3];
int Ls = atoi(argv[5]);
Real M5 = 1.8;
Real mass = 0.00;
Real mq = mass;
/********************************************************
* Setup DWF operator
********************************************************
*/
bfmarg dwfa;
majorityVote dwf;
dwfa.node_latt[0] = lx;
dwfa.node_latt[1] = ly;
dwfa.node_latt[2] = lz;
dwfa.node_latt[3] = lt;
multi1d<int> procs = QDP::Layout::logicalSize();
Printf("%d dim machine\n\t", procs.size());
for(int mu=0;mu<4;mu++){
Printf("%d ", procs[mu]);
// if ( procs[mu]>1 ) {
// dwfa.local_comm[mu] = 0;
// } else {
dwfa.local_comm[mu] = 1;
// }
}
Printf("\nLocal comm = ");
for(int mu=0;mu<4;mu++){
Printf("%d ", dwfa.local_comm[mu]);
}
Printf("\n");
dwfa.precon_5d = 1;
dwfa.Ls = Ls;
dwfa.M5 = toDouble(M5);
dwfa.mass = toDouble(mq);
dwfa.Csw = 0.0;
dwfa.max_iter = 1000;
dwfa.residual = 1.e-8;
Printf("Initialising bfm operator\n");
dwf.init(dwfa);
/********************************************************
* Bagel internal single checkerboard vectors
********************************************************
*/
Fermion_t psi_h[2];
psi_h[0] = dwf.allocFermion();
psi_h[1] = dwf.allocFermion();
Fermion_t chi_h[2];
chi_h[0] = dwf.allocFermion();
chi_h[1] = dwf.allocFermion();
dwf.randGauge();
/*Import this checkerboard of source field to bagel*/
Printf("Importing psi field cb %d\n",1);
dwf.randFermion(psi_h[0]);
dwf.randFermion(psi_h[1]);
// Fill the other checkerboard of result with noise
dwf.randFermion(chi_h[0]);
dwf.randFermion(chi_h[1]);
#define NITER 100
for(int i=0;i<NITER;i++) {
dwf.axpy(chi_h[0],psi_h[0],psi_h[0],0.0) ;
dwf.axpy(chi_h[1],psi_h[0],psi_h[0],0.0) ;
dwf.CGNE(chi_h,psi_h);
}
Printf("Done\n");
}
int
main( int argc, char **argv )
{
int meascount,traj_done;
int prompt;
int s_iters, avs_iters, avspect_iters, avbcorr_iters;
double dtime, dclock();
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();
// restore_random_state_scidac_to_site("randsave", F_OFFSET(site_prn));
// restore_color_vector_scidac_to_site("xxx1save", F_OFFSET(xxx1),1);
// restore_color_vector_scidac_to_site("xxx2save", F_OFFSET(xxx2),1);
/* loop over input sets */
while( readin(prompt) == 0) {
/* perform warmup trajectories */
dtime = -dclock();
for( traj_done=0; traj_done < warms; traj_done++ ){
update();
}
node0_printf("WARMUPS COMPLETED\n"); fflush(stdout);
/* perform measuring trajectories, reunitarizing and measuring */
meascount=0; /* number of measurements */
avspect_iters = avs_iters = avbcorr_iters = 0;
for( traj_done=0; traj_done < trajecs; traj_done++ ){
/* do the trajectories */
s_iters=update();
/* measure every "propinterval" trajectories */
if( (traj_done%propinterval)==(propinterval-1) ){
/* call gauge_variable fermion_variable measuring routines */
/* results are printed in output file */
rephase(OFF);
g_measure( );
rephase(ON);
/* Load fat and long links for fermion measurements */
load_ferm_links(&fn_links, &ks_act_paths);
#ifdef DM_DU0
load_ferm_links(&fn_links_dmdu0, &ks_act_paths_dmdu0);
#endif
/* Measure pbp, etc */
#ifdef ONEMASS
f_meas_imp(F_OFFSET(phi),F_OFFSET(xxx),mass, &fn_links,
&fn_links_dmdu0);
#else
f_meas_imp( F_OFFSET(phi1), F_OFFSET(xxx1), mass1,
&fn_links, &fn_links_dmdu0);
f_meas_imp( F_OFFSET(phi2), F_OFFSET(xxx2), mass2,
&fn_links, &fn_links_dmdu0);
#endif
/* Measure derivatives wrto chemical potential */
#ifdef D_CHEM_POT
#ifdef ONEMASS
Deriv_O6( F_OFFSET(phi1), F_OFFSET(xxx1), F_OFFSET(xxx2), mass,
&fn_links, &fn_links_dmdu0);
#else
Deriv_O6( F_OFFSET(phi1), F_OFFSET(xxx1), F_OFFSET(xxx2), mass1,
&fn_links, &fn_links_dmdu0);
Deriv_O6( F_OFFSET(phi1), F_OFFSET(xxx1), F_OFFSET(xxx2), mass2,
&fn_links, &fn_links_dmdu0);
#endif
#endif
#ifdef SPECTRUM
/* Fix TUP Coulomb gauge - gauge links only*/
rephase( OFF );
gaugefix(TUP,(Real)1.8,500,(Real)GAUGE_FIX_TOL);
rephase( ON );
#ifdef FN
invalidate_all_ferm_links(&fn_links);
#ifdef DM_DU0
invalidate_all_ferm_links(&fn_links_dmdu0);
#endif
#endif
/* Load fat and long links for fermion measurements */
load_ferm_links(&fn_links, &ks_act_paths);
#ifdef DM_DU0
load_ferm_links(&fn_links_dmdu0, &ks_act_paths_dmdu0);
#endif
if(strstr(spectrum_request,",spectrum,") != NULL){
#ifdef ONEMASS
avspect_iters += spectrum2(mass,F_OFFSET(phi),F_OFFSET(xxx),
&fn_links);
#else
avspect_iters += spectrum2( mass1, F_OFFSET(phi1),
F_OFFSET(xxx1), &fn_links);
avspect_iters += spectrum2( mass2, F_OFFSET(phi1),
F_OFFSET(xxx1), &fn_links);
#endif
}
if(strstr(spectrum_request,",spectrum_point,") != NULL){
#ifdef ONEMASS
avspect_iters += spectrum_fzw(mass,F_OFFSET(phi),F_OFFSET(xxx),
&fn_links);
#else
avspect_iters += spectrum_fzw( mass1, F_OFFSET(phi1),
F_OFFSET(xxx1), &fn_links);
avspect_iters += spectrum_fzw( mass2, F_OFFSET(phi1),
F_OFFSET(xxx1), &fn_links);
#endif
}
if(strstr(spectrum_request,",nl_spectrum,") != NULL){
#ifdef ONEMASS
avspect_iters += nl_spectrum(mass,F_OFFSET(phi),F_OFFSET(xxx),
F_OFFSET(tempmat1),F_OFFSET(staple),
&fn_links);
#else
avspect_iters += nl_spectrum( mass1, F_OFFSET(phi1),
F_OFFSET(xxx1), F_OFFSET(tempmat1),F_OFFSET(staple),
&fn_links);
#endif
}
if(strstr(spectrum_request,",spectrum_mom,") != NULL){
#ifdef ONEMASS
avspect_iters += spectrum_mom(mass,mass,F_OFFSET(phi),5e-3,
&fn_links);
#else
avspect_iters += spectrum_mom( mass1, mass1,
F_OFFSET(phi1), 1e-1,
&fn_links);
#endif
}
if(strstr(spectrum_request,",spectrum_multimom,") != NULL){
#ifdef ONEMASS
avspect_iters += spectrum_multimom(mass,
spectrum_multimom_low_mass,
spectrum_multimom_mass_step,
spectrum_multimom_nmasses,
5e-3, &fn_links);
#else
avspect_iters += spectrum_multimom(mass1,
spectrum_multimom_low_mass,
spectrum_multimom_mass_step,
spectrum_multimom_nmasses,
5e-3, &fn_links);
#endif
}
#ifndef ONEMASS
if(strstr(spectrum_request,",spectrum_nd,") != NULL){
avspect_iters += spectrum_nd( mass1, mass2, 1e-1,
&fn_links);
}
#endif
if(strstr(spectrum_request,",spectrum_nlpi2,") != NULL){
#ifdef ONEMASS
avspect_iters += spectrum_nlpi2(mass,mass,F_OFFSET(phi),5e-3,
&fn_links );
#else
avspect_iters += spectrum_nlpi2( mass1, mass1,
F_OFFSET(phi1),1e-1,
&fn_links );
avspect_iters += spectrum_nlpi2( mass2, mass2,
F_OFFSET(phi1),1e-1,
&fn_links );
#endif
}
if(strstr(spectrum_request,",spectrum_singlets,") != NULL){
#ifdef ONEMASS
avspect_iters += spectrum_singlets(mass, 5e-3, F_OFFSET(phi),
&fn_links);
#else
avspect_iters += spectrum_singlets(mass1, 5e-3, F_OFFSET(phi1),
&fn_links );
avspect_iters += spectrum_singlets(mass2, 5e-3, F_OFFSET(phi1),
&fn_links );
#endif
}
if(strstr(spectrum_request,",fpi,") != NULL)
{
avspect_iters += fpi_2( fpi_mass, fpi_nmasses, 2e-3,
&fn_links );
}
#ifdef HYBRIDS
if(strstr(spectrum_request,",spectrum_hybrids,") != NULL){
#ifdef ONEMASS
avspect_iters += spectrum_hybrids( mass,F_OFFSET(phi),1e-1,
&fn_links);
#else
avspect_iters += spectrum_hybrids( mass1, F_OFFSET(phi1), 5e-3,
&fn_links);
avspect_iters += spectrum_hybrids( mass2, F_OFFSET(phi1), 2e-3,
&fn_links);
#endif
}
#endif
if(strstr(spectrum_request,",hvy_pot,") != NULL){
rephase( OFF );
hvy_pot( F_OFFSET(link[XUP]) );
rephase( ON );
}
#endif /* SPECTRUM */
avs_iters += s_iters;
++meascount;
fflush(stdout);
}
} /* end loop over trajectories */
node0_printf("RUNNING COMPLETED\n"); fflush(stdout);
if(meascount>0) {
node0_printf("average cg iters for step= %e\n",
(double)avs_iters/meascount);
#ifdef SPECTRUM
node0_printf("average cg iters for spectrum = %e\n",
(double)avspect_iters/meascount);
#endif
}
dtime += dclock();
if(this_node==0){
printf("Time = %e seconds\n",dtime);
printf("total_iters = %d\n",total_iters);
}
fflush(stdout);
/* save lattice if requested */
if( saveflag != FORGET ){
rephase( OFF );
save_lattice( saveflag, savefile, stringLFN );
rephase( ON );
#ifdef HAVE_QIO
// save_random_state_scidac_from_site("randsave", "Dummy file XML",
// "Random number state", QIO_SINGLEFILE, F_OFFSET(site_prn));
// save_color_vector_scidac_from_site("xxx1save", "Dummy file XML",
// "xxx vector", QIO_SINGLEFILE, F_OFFSET(xxx1),1);
// save_color_vector_scidac_from_site("xxx2save", "Dummy file XML",
// "xxx vector", QIO_SINGLEFILE, F_OFFSET(xxx2),1);
#endif
}
}
#ifdef HAVE_QDP
QDP_finalize();
#endif
normal_exit(0);
return 0;
}
