double gauge_acc(const int id, hamiltonian_field_t * const hf) {
monomial * mnl = &monomial_list[id];
mnl->energy1 = g_beta*(mnl->c0 * measure_gauge_action(hf->gaugefield));
if(mnl->use_rectangles) {
mnl->energy1 += g_beta*(mnl->c1 * measure_rectangles(hf->gaugefield));
}
if(g_proc_id == 0 && g_debug_level > 3) {
printf("called gauge_acc for id %d %d dH = %1.4e\n",
id, mnl->even_odd_flag, mnl->energy0 - mnl->energy1);
}
return(mnl->energy0 - mnl->energy1);
}
void gauge_heatbath(const int id, hamiltonian_field_t * const hf) {
monomial * mnl = &monomial_list[id];
if(mnl->use_rectangles) mnl->c0 = 1. - 8.*mnl->c1;
mnl->energy0 = g_beta*(mnl->c0 * measure_gauge_action(hf->gaugefield));
if(mnl->use_rectangles) {
mnl->energy0 += g_beta*(mnl->c1 * measure_rectangles(hf->gaugefield));
}
if(g_proc_id == 0 && g_debug_level > 3) {
printf("called gauge_heatbath for id %d %d\n", id, mnl->even_odd_flag);
}
}
void sf_gauge_heatbath( const int id )
{
monomial* mnl = &(monomial_list[id]);
if( mnl->use_rectangles ){ mnl->c0 = 1. - 8.*mnl->c1; }
mnl->energy0 = g_beta * ( mnl->c0 * measure_gauge_action() );
if(mnl->use_rectangles) {
mnl->energy0 += g_beta*(mnl->c1 * measure_rectangles());
}
if(g_proc_id == 0 && g_debug_level > 3) {
printf("called gauge_heatbath for id %d %d\n", id, mnl->even_odd_flag);
}
}
double gauge_acc(const int id, hamiltonian_field_t * const hf) {
monomial * mnl = &monomial_list[id];
double atime, etime;
atime = gettime();
mnl->energy1 = g_beta*(mnl->c0 * measure_gauge_action( (const su3**) hf->gaugefield));
if(mnl->use_rectangles) {
mnl->energy1 += g_beta*(mnl->c1 * measure_rectangles( (const su3**) hf->gaugefield));
}
etime = gettime();
if(g_proc_id == 0) {
if(g_debug_level > 1) {
printf("# Time for %s monomial acc step: %e s\n", mnl->name, etime-atime);
}
if(g_debug_level > 3) {
printf("called gauge_acc for id %d dH = %1.10e\n",
id, mnl->energy0 - mnl->energy1);
}
}
return(mnl->energy0 - mnl->energy1);
}
void gauge_heatbath(const int id, hamiltonian_field_t * const hf) {
monomial * mnl = &monomial_list[id];
double atime, etime;
atime = gettime();
if(mnl->use_rectangles) mnl->c0 = 1. - 8.*mnl->c1;
mnl->energy0 = g_beta*(mnl->c0 * measure_gauge_action( (const su3**) hf->gaugefield));
if(mnl->use_rectangles) {
mnl->energy0 += g_beta*(mnl->c1 * measure_rectangles( (const su3**) hf->gaugefield));
}
etime = gettime();
if(g_proc_id == 0) {
if(g_debug_level > 1) {
printf("# Time for %s monomial heatbath: %e s\n", mnl->name, etime-atime);
}
if(g_debug_level > 3) {
printf("called gauge_heatbath for id %d energy %f\n", id, mnl->energy0);
}
}
return;
}
int main(int argc,char *argv[]) {
FILE *parameterfile=NULL,*rlxdfile=NULL, *countfile=NULL;
char * filename = NULL;
char datafilename[50];
char parameterfilename[50];
char gauge_filename[50];
char * nstore_filename = ".nstore_counter";
char * input_filename = NULL;
int rlxd_state[105];
int j,ix,mu;
int k;
struct timeval t1;
int g_nev, max_iter_ev;
double stop_prec_ev;
/* Energy corresponding to the Gauge part */
double eneg = 0., plaquette_energy = 0., rectangle_energy = 0.;
/* Acceptance rate */
int Rate=0;
/* Do we want to perform reversibility checks */
/* See also return_check_flag in read_input.h */
int return_check = 0;
/* For getopt */
int c;
/* For the Polyakov loop: */
int dir = 2;
_Complex double pl, pl4;
verbose = 0;
g_use_clover_flag = 0;
g_nr_of_psf = 1;
#ifndef XLC
signal(SIGUSR1,&catch_del_sig);
signal(SIGUSR2,&catch_del_sig);
signal(SIGTERM,&catch_del_sig);
signal(SIGXCPU,&catch_del_sig);
#endif
while ((c = getopt(argc, argv, "h?f:o:")) != -1) {
switch (c) {
case 'f':
input_filename = calloc(200, sizeof(char));
strcpy(input_filename,optarg);
break;
case 'o':
filename = calloc(200, sizeof(char));
strcpy(filename,optarg);
break;
case 'h':
case '?':
default:
usage();
break;
}
}
if(input_filename == NULL){
input_filename = "hmc.input";
}
if(filename == NULL){
filename = "output";
}
/* Read the input file */
read_input(input_filename);
mpi_init(argc, argv);
if(Nsave == 0){
Nsave = 1;
}
if(nstore == -1) {
countfile = fopen(nstore_filename, "r");
if(countfile != NULL) {
fscanf(countfile, "%d\n", &nstore);
fclose(countfile);
}
else {
nstore = 0;
}
}
if(g_rgi_C1 == 0.) {
g_dbw2rand = 0;
}
#ifndef TM_USE_MPI
g_dbw2rand = 0;
#endif
/* Reorder the mu parameter and the number of iterations */
if(g_mu3 > 0.) {
g_mu = g_mu1;
g_mu1 = g_mu3;
g_mu3 = g_mu;
j = int_n[1];
int_n[1] = int_n[3];
int_n[3] = j;
j = g_csg_N[0];
g_csg_N[0] = g_csg_N[4];
g_csg_N[4] = j;
g_csg_N[6] = j;
if(fabs(g_mu3) > 0) {
g_csg_N[6] = 0;
}
g_nr_of_psf = 3;
}
else if(g_mu2 > 0.) {
g_mu = g_mu1;
g_mu1 = g_mu2;
g_mu2 = g_mu;
int_n[3] = int_n[1];
int_n[1] = int_n[2];
int_n[2] = int_n[3];
/* For chronological inverter */
g_csg_N[4] = g_csg_N[0];
g_csg_N[0] = g_csg_N[2];
g_csg_N[2] = g_csg_N[4];
if(fabs(g_mu2) > 0) {
g_csg_N[4] = 0;
}
g_csg_N[6] = 0;
g_nr_of_psf = 2;
}
else {
g_csg_N[2] = g_csg_N[0];
if(fabs(g_mu2) > 0) {
g_csg_N[2] = 0;
}
g_csg_N[4] = 0;
g_csg_N[6] = 0;
}
for(j = 0; j < g_nr_of_psf+1; j++) {
if(int_n[j] == 0) int_n[j] = 1;
}
if(g_nr_of_psf == 3) {
g_eps_sq_force = g_eps_sq_force1;
g_eps_sq_force1 = g_eps_sq_force3;
g_eps_sq_force3 = g_eps_sq_force;
g_eps_sq_acc = g_eps_sq_acc1;
g_eps_sq_acc1 = g_eps_sq_acc3;
g_eps_sq_acc3 = g_eps_sq_acc;
}
if(g_nr_of_psf == 2) {
g_eps_sq_force = g_eps_sq_force1;
g_eps_sq_force1 = g_eps_sq_force2;
g_eps_sq_force2 = g_eps_sq_force;
g_eps_sq_acc = g_eps_sq_acc1;
g_eps_sq_acc1 = g_eps_sq_acc2;
g_eps_sq_acc2 = g_eps_sq_acc;
}
g_mu = g_mu1;
g_eps_sq_acc = g_eps_sq_acc1;
g_eps_sq_force = g_eps_sq_force1;
#ifdef _GAUGE_COPY
j = init_gauge_field(VOLUMEPLUSRAND + g_dbw2rand, 1);
#else
j = init_gauge_field(VOLUMEPLUSRAND + g_dbw2rand, 0);
#endif
if ( j!= 0) {
fprintf(stderr, "Not enough memory for gauge_fields! Aborting...\n");
exit(0);
}
j = init_geometry_indices(VOLUMEPLUSRAND + g_dbw2rand);
if ( j!= 0) {
fprintf(stderr, "Not enough memory for geometry_indices! Aborting...\n");
exit(0);
}
j = init_spinor_field(VOLUMEPLUSRAND/2, NO_OF_SPINORFIELDS);
if ( j!= 0) {
fprintf(stderr, "Not enough memory for spinor fields! Aborting...\n");
exit(0);
}
j = init_bispinor_field(VOLUME/2, NO_OF_SPINORFIELDS);
j = init_csg_field(VOLUMEPLUSRAND/2, g_csg_N);
if ( j!= 0) {
fprintf(stderr, "Not enough memory for csg fields! Aborting...\n");
exit(0);
}
j = init_moment_field(VOLUME, VOLUMEPLUSRAND);
if ( j!= 0) {
fprintf(stderr, "Not enough memory for moment fields! Aborting...\n");
exit(0);
}
zero_spinor_field(g_spinor_field[DUM_DERI+4],VOLUME/2);
zero_spinor_field(g_spinor_field[DUM_DERI+5],VOLUME/2);
zero_spinor_field(g_spinor_field[DUM_DERI+6],VOLUME/2);
if(g_proc_id == 0){
/* fscanf(fp6,"%s",filename); */
/*construct the filenames for the observables and the parameters*/
strcpy(datafilename,filename); strcat(datafilename,".data");
strcpy(parameterfilename,filename); strcat(parameterfilename,".para");
parameterfile=fopen(parameterfilename, "w");
printf("# This is the hmc code for twisted Mass Wilson QCD\n\nVersion %s\n", Version);
#ifdef SSE
printf("# The code was compiled with SSE instructions\n");
#endif
#ifdef SSE2
printf("# The code was compiled with SSE2 instructions\n");
#endif
#ifdef SSE3
printf("# The code was compiled with SSE3 instructions\n");
#endif
#ifdef P4
printf("# The code was compiled for Pentium4\n");
#endif
#ifdef OPTERON
printf("# The code was compiled for AMD Opteron\n");
#endif
#ifdef _NEW_GEOMETRY
printf("# The code was compiled with -D_NEW_GEOMETRY\n");
#endif
#ifdef _GAUGE_COPY
printf("# The code was compiled with -D_GAUGE_COPY\n");
#endif
printf("# The lattice size is %d x %d x %d x %d\n",
(int)(T*g_nproc_t), (int)(LX*g_nproc_x), (int)(LY), (int)(LZ));
printf("# The local lattice size is %d x %d x %d x %d\n",
(int)(T), (int)(LX), (int)(LY),(int) LZ);
printf("# beta = %f , kappa= %f\n", g_beta, g_kappa);
printf("# mus = %f, %f, %f\n", g_mu1, g_mu2, g_mu3);
printf("# int_n_gauge = %d, int_n_ferm1 = %d, int_n_ferm2 = %d, int_n_ferm3 = %d\n",
int_n[0], int_n[1], int_n[2], int_n[3]);
printf("# g_rgi_C0 = %f, g_rgi_C1 = %f\n", g_rgi_C0, g_rgi_C1);
printf("# Number of pseudo-fermion fields: %d\n", g_nr_of_psf);
printf("# g_eps_sq_force = %e, g_eps_sq_acc = %e\n", g_eps_sq_force, g_eps_sq_acc);
printf("# Integration scheme: ");
if(integtyp == 1) printf("leap-frog (single time scale)\n");
if(integtyp == 2) printf("Sexton-Weingarten (single time scale)\n");
if(integtyp == 3) printf("leap-frog (multiple time scales)\n");
if(integtyp == 4) printf("Sexton-Weingarten (multiple time scales)\n");
if(integtyp == 5) printf("higher order and leap-frog (multiple time scales)\n");
printf("# Using %s precision for the inversions!\n",
g_relative_precision_flag ? "relative" : "absolute");
printf("# Using in chronological inverter for spinor_field 1,2,3 a history of %d, %d, %d, respectively\n",
g_csg_N[0], g_csg_N[2], g_csg_N[4]);
fprintf(parameterfile, "The lattice size is %d x %d x %d x %d\n", (int)(g_nproc_t*T), (int)(g_nproc_x*LX), (int)(LY), (int)(LZ));
fprintf(parameterfile, "The local lattice size is %d x %d x %d x %d\n", (int)(T), (int)(LX), (int)(LY), (int)(LZ));
fprintf(parameterfile, "g_beta = %f , g_kappa= %f, c_sw = %f \n",g_beta,g_kappa,g_c_sw);
fprintf(parameterfile, "boundary of fermion fields (t,x,y,z): %f %f %f %f \n",X0,X1,X2,X3);
fprintf(parameterfile, "EPS_SQ0=%e, EPS_SQ1=%e EPS_SQ2=%e, EPS_SQ3=%e \n"
,EPS_SQ0,EPS_SQ1,EPS_SQ2,EPS_SQ3);
fprintf(parameterfile, "g_eps_sq_force = %e, g_eps_sq_acc = %e\n", g_eps_sq_force, g_eps_sq_acc);
fprintf(parameterfile, "dtau=%f, Nsteps=%d, Nmeas=%d, Nsave=%d, integtyp=%d, nsmall=%d \n",
dtau,Nsteps,Nmeas,Nsave,integtyp,nsmall);
fprintf(parameterfile, "mu = %f, mu2=%f, mu3=%f\n ", g_mu, g_mu2, g_mu3);
fprintf(parameterfile, "int_n_gauge = %d, int_n_ferm1 = %d, int_n_ferm2 = %d, int_n_ferm3 = %d\n ",
int_n[0], int_n[1], int_n[2], int_n[3]);
fprintf(parameterfile, "g_rgi_C0 = %f, g_rgi_C1 = %f\n", g_rgi_C0, g_rgi_C1);
fprintf(parameterfile, "# Number of pseudo-fermion fields: %d\n", g_nr_of_psf);
fprintf(parameterfile, "# Integration scheme: ");
if(integtyp == 1) fprintf(parameterfile, "leap-frog (single time scale)\n");
if(integtyp == 2) fprintf(parameterfile, "Sexton-Weingarten (single time scale)\n");
if(integtyp == 3) fprintf(parameterfile, "leap-frog (multiple time scales)\n");
if(integtyp == 4) fprintf(parameterfile, "Sexton-Weingarten (multiple time scales)\n");
if(integtyp == 5) fprintf(parameterfile, "higher order and leap-frog (multiple time scales)\n");
fprintf(parameterfile, "Using %s precision for the inversions!\n",
g_relative_precision_flag ? "relative" : "absolute");
fprintf(parameterfile, "Using in chronological inverter for spinor_field 1,2,3 a history of %d, %d, %d, respectively\n",
g_csg_N[0], g_csg_N[2], g_csg_N[4]);
fflush(stdout); fflush(parameterfile);
}
/* define the geometry */
geometry();
/* define the boundary conditions for the fermion fields */
boundary();
check_geometry();
if(g_proc_id == 0) {
#if defined GEOMETRIC
if(g_proc_id==0) fprintf(parameterfile,"The geometric series is used as solver \n\n");
#else
if(g_proc_id==0) fprintf(parameterfile,"The BICG_stab is used as solver \n\n");
#endif
fflush(parameterfile);
}
/* Continue */
if(startoption == 3){
rlxdfile = fopen(rlxd_input_filename,"r");
if(rlxdfile != NULL) {
if(g_proc_id == 0) {
fread(rlxd_state,sizeof(rlxd_state),1,rlxdfile);
}
}
else {
if(g_proc_id == 0) {
printf("%s does not exist, switching to restart...\n", rlxd_input_filename);
}
startoption = 2;
}
fclose(rlxdfile);
if(startoption != 2) {
if(g_proc_id == 0) {
rlxd_reset(rlxd_state);
printf("Reading Gauge field from file %s\n", gauge_input_filename); fflush(stdout);
}
read_gauge_field_time_p(gauge_input_filename,g_gauge_field);
}
}
if(startoption != 3){
/* Initialize random number generator */
if(g_proc_id == 0) {
rlxd_init(1, random_seed);
/* hot */
if(startoption == 1) {
random_gauge_field();
}
rlxd_get(rlxd_state);
#ifdef TM_USE_MPI
MPI_Send(&rlxd_state[0], 105, MPI_INT, 1, 99, MPI_COMM_WORLD);
MPI_Recv(&rlxd_state[0], 105, MPI_INT, g_nproc-1, 99, MPI_COMM_WORLD, &status);
rlxd_reset(rlxd_state);
#endif
}
#ifdef TM_USE_MPI
else {
MPI_Recv(&rlxd_state[0], 105, MPI_INT, g_proc_id-1, 99, MPI_COMM_WORLD, &status);
rlxd_reset(rlxd_state);
/* hot */
if(startoption == 1) {
random_gauge_field();
}
k=g_proc_id+1;
if(k==g_nproc){
k=0;
}
rlxd_get(rlxd_state);
MPI_Send(&rlxd_state[0], 105, MPI_INT, k, 99, MPI_COMM_WORLD);
}
#endif
/* Cold */
if(startoption == 0) {
unit_g_gauge_field();
}
/* Restart */
else if(startoption == 2) {
if (g_proc_id == 0){
printf("Reading Gauge field from file %s\n", gauge_input_filename); fflush(stdout);
}
read_gauge_field_time_p(gauge_input_filename,g_gauge_field);
}
}
/*For parallelization: exchange the gaugefield */
#ifdef TM_USE_MPI
xchange_gauge(g_gauge_field);
#endif
#ifdef _GAUGE_COPY
update_backward_gauge();
#endif
/*compute the energy of the gauge field*/
plaquette_energy=measure_gauge_action();
if(g_rgi_C1 > 0. || g_rgi_C1 < 0.) {
rectangle_energy = measure_rectangles();
if(g_proc_id==0){
fprintf(parameterfile,"#First rectangle value: %14.12f \n",rectangle_energy/(12.*VOLUME*g_nproc));
}
}
eneg = g_rgi_C0 * plaquette_energy + g_rgi_C1 * rectangle_energy;
/* Measure and print the Polyakov loop: */
polyakov_loop(&pl, dir);
if(g_proc_id==0){
fprintf(parameterfile,"#First plaquette value: %14.12f \n", plaquette_energy/(6.*VOLUME*g_nproc));
fprintf(parameterfile,"#First Polyakov loop value in %d-direction |L(%d)|= %14.12f \n",
dir, dir, cabs(pl));
}
dir=3;
polyakov_loop(&pl, dir);
if(g_proc_id==0){
fprintf(parameterfile,"#First Polyakov loop value in %d-direction |L(%d)|= %14.12f \n",
dir, dir, cabs(pl));
fclose(parameterfile);
}
/* set ddummy to zero */
for(ix = 0; ix < VOLUME+RAND; ix++){
for(mu=0; mu<4; mu++){
ddummy[ix][mu].d1=0.;
ddummy[ix][mu].d2=0.;
ddummy[ix][mu].d3=0.;
ddummy[ix][mu].d4=0.;
ddummy[ix][mu].d5=0.;
ddummy[ix][mu].d6=0.;
ddummy[ix][mu].d7=0.;
ddummy[ix][mu].d8=0.;
}
}
if(g_proc_id == 0) {
gettimeofday(&t1,NULL);
countfile = fopen("history_hmc_tm", "a");
fprintf(countfile, "!!! Timestamp %ld, Nsave = %d, g_mu = %e, g_mu1 = %e, g_mu_2 = %e, g_mu3 = %e, beta = %f, kappa = %f, C1 = %f, int0 = %d, int1 = %d, int2 = %d, int3 = %d, g_eps_sq_force = %e, g_eps_sq_acc = %e, ",
t1.tv_sec, Nsave, g_mu, g_mu1, g_mu2, g_mu3, g_beta, g_kappa, g_rgi_C1,
int_n[0], int_n[1], int_n[2], int_n[3], g_eps_sq_force, g_eps_sq_acc);
fprintf(countfile, "Nsteps = %d, dtau = %e, tau = %e, integtyp = %d, rel. prec. = %d\n",
Nsteps, dtau, tau, integtyp, g_relative_precision_flag);
fclose(countfile);
}
/* HERE THE CALLS FOR SOME EIGENVALUES */
/* for lowest
g_nev = 10;
*/
/* for largest
*/
g_nev = 10;
max_iter_ev = 1000;
stop_prec_ev = 1.e-10;
if(g_proc_id==0) {
printf(" Values of mu = %e mubar = %e eps = %e precision = %e \n \n", g_mu, g_mubar, g_epsbar, stop_prec_ev);
}
eigenvalues(&g_nev, operator_flag, max_iter_ev, stop_prec_ev);
g_nev = 4;
max_iter_ev = 200;
stop_prec_ev = 1.e-03;
max_eigenvalues(&g_nev, operator_flag, max_iter_ev, stop_prec_ev);
if(g_proc_id==0) {
printf(" Values of mu = %e mubar = %e eps = %e precision = %e \n \n", g_mu, g_mubar, g_epsbar, stop_prec_ev);
/*
printf(" Values of mu = %e precision = %e \n \n", g_mu, stop_prec_ev);
*/
}
/* END OF EIGENVALUES CALLS */
if(g_proc_id==0) {
rlxd_get(rlxd_state);
rlxdfile=fopen("last_state","w");
fwrite(rlxd_state,sizeof(rlxd_state),1,rlxdfile);
fclose(rlxdfile);
printf("Acceptance Rate was: %e Prozent\n", 100.*(double)Rate/(double)Nmeas);
fflush(stdout);
parameterfile = fopen(parameterfilename, "a");
fprintf(parameterfile, "Acceptance Rate was: %e Prozent\n", 100.*(double)Rate/(double)Nmeas);
fclose(parameterfile);
}
#ifdef TM_USE_MPI
MPI_Finalize();
#endif
free_gauge_tmp();
free_gauge_field();
free_geometry_indices();
free_spinor_field();
free_bispinor_field();
free_moment_field();
return(0);
}
int main(int argc,char *argv[]) {
FILE *parameterfile=NULL, *countfile=NULL;
char *filename = NULL;
char datafilename[50];
char parameterfilename[50];
char gauge_filename[50];
char nstore_filename[50];
char tmp_filename[50];
char *input_filename = NULL;
int status = 0, accept = 0;
int j,ix,mu, trajectory_counter=1;
struct timeval t1;
/* Energy corresponding to the Gauge part */
double plaquette_energy = 0., rectangle_energy = 0.;
/* Acceptance rate */
int Rate=0;
/* Do we want to perform reversibility checks */
/* See also return_check_flag in read_input.h */
int return_check = 0;
/* For getopt */
int c;
paramsXlfInfo *xlfInfo;
/* For online measurements */
measurement * meas;
int imeas;
#ifdef _KOJAK_INST
#pragma pomp inst init
#pragma pomp inst begin(main)
#endif
#if (defined SSE || defined SSE2 || SSE3)
signal(SIGILL,&catch_ill_inst);
#endif
strcpy(gauge_filename,"conf.save");
strcpy(nstore_filename,".nstore_counter");
strcpy(tmp_filename, ".conf.tmp");
verbose = 1;
g_use_clover_flag = 0;
#ifdef MPI
# ifdef OMP
int mpi_thread_provided;
MPI_Init_thread(&argc, &argv, MPI_THREAD_SERIALIZED, &mpi_thread_provided);
# else
MPI_Init(&argc, &argv);
# endif
MPI_Comm_rank(MPI_COMM_WORLD, &g_proc_id);
#else
g_proc_id = 0;
#endif
while ((c = getopt(argc, argv, "h?vVf:o:")) != -1) {
switch (c) {
case 'f':
input_filename = calloc(200, sizeof(char));
strcpy(input_filename,optarg);
break;
case 'o':
filename = calloc(200, sizeof(char));
strcpy(filename,optarg);
break;
case 'v':
verbose = 1;
break;
case 'V':
fprintf(stdout,"%s %s\n",PACKAGE_STRING,git_hash);
exit(0);
break;
case 'h':
case '?':
default:
usage();
break;
}
}
if(input_filename == NULL){
input_filename = "hmc.input";
}
if(filename == NULL){
filename = "output";
}
/* Read the input file */
if( (status = read_input(input_filename)) != 0) {
fprintf(stderr, "Could not find input file: %s\nAborting...\n", input_filename);
exit(-1);
}
/* set number of omp threads to be used */
#ifdef OMP
if(omp_num_threads > 0)
{
omp_set_num_threads(omp_num_threads);
}
else {
if( g_proc_id == 0 )
printf("# No value provided for OmpNumThreads, running in single-threaded mode!\n");
omp_num_threads = 1;
omp_set_num_threads(omp_num_threads);
}
init_omp_accumulators(omp_num_threads);
#endif
DUM_DERI = 4;
DUM_SOLVER = DUM_DERI+1;
DUM_MATRIX = DUM_SOLVER+6;
if(g_running_phmc) {
NO_OF_SPINORFIELDS = DUM_MATRIX+8;
}
else {
NO_OF_SPINORFIELDS = DUM_MATRIX+6;
}
DUM_BI_DERI = 6;
DUM_BI_SOLVER = DUM_BI_DERI+7;
DUM_BI_MATRIX = DUM_BI_SOLVER+6;
NO_OF_BISPINORFIELDS = DUM_BI_MATRIX+6;
tmlqcd_mpi_init(argc, argv);
if(nstore == -1) {
countfile = fopen(nstore_filename, "r");
if(countfile != NULL) {
j = fscanf(countfile, "%d %d %s\n", &nstore, &trajectory_counter, gauge_input_filename);
if(j < 1) nstore = 0;
if(j < 2) trajectory_counter = 0;
fclose(countfile);
}
else {
nstore = 0;
trajectory_counter = 0;
}
}
#ifndef MPI
g_dbw2rand = 0;
#endif
g_mu = g_mu1;
#ifdef _GAUGE_COPY
status = init_gauge_field(VOLUMEPLUSRAND + g_dbw2rand, 1);
#else
status = init_gauge_field(VOLUMEPLUSRAND + g_dbw2rand, 0);
#endif
if (status != 0) {
fprintf(stderr, "Not enough memory for gauge_fields! Aborting...\n");
exit(0);
}
j = init_geometry_indices(VOLUMEPLUSRAND + g_dbw2rand);
if (j != 0) {
fprintf(stderr, "Not enough memory for geometry_indices! Aborting...\n");
exit(0);
}
if(even_odd_flag) {
j = init_spinor_field(VOLUMEPLUSRAND/2, NO_OF_SPINORFIELDS);
}
else {
j = init_spinor_field(VOLUMEPLUSRAND, NO_OF_SPINORFIELDS);
}
if (j != 0) {
fprintf(stderr, "Not enough memory for spinor fields! Aborting...\n");
exit(0);
}
if(even_odd_flag) {
j = init_csg_field(VOLUMEPLUSRAND/2);
}
else {
j = init_csg_field(VOLUMEPLUSRAND);
}
if (j != 0) {
fprintf(stderr, "Not enough memory for csg fields! Aborting...\n");
exit(0);
}
j = init_moment_field(VOLUME, VOLUMEPLUSRAND + g_dbw2rand);
if (j != 0) {
fprintf(stderr, "Not enough memory for moment fields! Aborting...\n");
exit(0);
}
if(g_running_phmc) {
j = init_bispinor_field(VOLUME/2, NO_OF_BISPINORFIELDS);
if (j!= 0) {
fprintf(stderr, "Not enough memory for bi-spinor fields! Aborting...\n");
exit(0);
}
}
/* list and initialize measurements*/
if(g_proc_id == 0) {
printf("\n");
for(j = 0; j < no_measurements; j++) {
printf("# measurement id %d, type = %d: Frequency %d\n", j, measurement_list[j].type, measurement_list[j].freq);
}
}
init_measurements();
/*construct the filenames for the observables and the parameters*/
strcpy(datafilename,filename);
strcat(datafilename,".data");
strcpy(parameterfilename,filename);
strcat(parameterfilename,".para");
if(g_proc_id == 0){
parameterfile = fopen(parameterfilename, "a");
write_first_messages(parameterfile, "hmc", git_hash);
}
/* define the geometry */
geometry();
/* define the boundary conditions for the fermion fields */
boundary(g_kappa);
status = check_geometry();
if (status != 0) {
fprintf(stderr, "Checking of geometry failed. Unable to proceed.\nAborting....\n");
exit(1);
}
#ifdef _USE_HALFSPINOR
j = init_dirac_halfspinor();
if (j!= 0) {
fprintf(stderr, "Not enough memory for halffield! Aborting...\n");
exit(-1);
}
if(g_sloppy_precision_flag == 1) {
init_dirac_halfspinor32();
}
# if (defined _PERSISTENT)
init_xchange_halffield();
# endif
#endif
/* Initialise random number generator */
start_ranlux(rlxd_level, random_seed^nstore );
/* Set up the gauge field */
/* continue and restart */
if(startoption==3 || startoption == 2) {
if(g_proc_id == 0) {
printf("# Trying to read gauge field from file %s in %s precision.\n",
gauge_input_filename, (gauge_precision_read_flag == 32 ? "single" : "double"));
fflush(stdout);
}
if( (status = read_gauge_field(gauge_input_filename)) != 0) {
fprintf(stderr, "Error %d while reading gauge field from %s\nAborting...\n", status, gauge_input_filename);
exit(-2);
}
if (g_proc_id == 0){
printf("# Finished reading gauge field.\n");
fflush(stdout);
}
}
else if (startoption == 1) {
/* hot */
random_gauge_field(reproduce_randomnumber_flag, g_gauge_field);
}
else if(startoption == 0) {
/* cold */
unit_g_gauge_field();
}
/*For parallelization: exchange the gaugefield */
#ifdef MPI
xchange_gauge(g_gauge_field);
#endif
if(even_odd_flag) {
j = init_monomials(VOLUMEPLUSRAND/2, even_odd_flag);
}
else {
j = init_monomials(VOLUMEPLUSRAND, even_odd_flag);
}
if (j != 0) {
fprintf(stderr, "Not enough memory for monomial pseudo fermion fields! Aborting...\n");
exit(0);
}
init_integrator();
if(g_proc_id == 0) {
for(j = 0; j < no_monomials; j++) {
printf("# monomial id %d type = %d timescale %d\n", j, monomial_list[j].type, monomial_list[j].timescale);
}
}
plaquette_energy = measure_gauge_action( (const su3**) g_gauge_field);
if(g_rgi_C1 > 0. || g_rgi_C1 < 0.) {
rectangle_energy = measure_rectangles( (const su3**) g_gauge_field);
if(g_proc_id == 0){
fprintf(parameterfile,"# Computed rectangle value: %14.12f.\n",rectangle_energy/(12.*VOLUME*g_nproc));
}
}
//eneg = g_rgi_C0 * plaquette_energy + g_rgi_C1 * rectangle_energy;
if(g_proc_id == 0) {
fprintf(parameterfile,"# Computed plaquette value: %14.12f.\n", plaquette_energy/(6.*VOLUME*g_nproc));
printf("# Computed plaquette value: %14.12f.\n", plaquette_energy/(6.*VOLUME*g_nproc));
fclose(parameterfile);
}
/* set ddummy to zero */
for(ix = 0; ix < VOLUMEPLUSRAND; ix++){
for(mu=0; mu<4; mu++){
ddummy[ix][mu].d1=0.;
ddummy[ix][mu].d2=0.;
ddummy[ix][mu].d3=0.;
ddummy[ix][mu].d4=0.;
ddummy[ix][mu].d5=0.;
ddummy[ix][mu].d6=0.;
ddummy[ix][mu].d7=0.;
ddummy[ix][mu].d8=0.;
}
}
if(g_proc_id == 0) {
gettimeofday(&t1,NULL);
countfile = fopen("history_hmc_tm", "a");
fprintf(countfile, "!!! Timestamp %ld, Nsave = %d, g_mu = %e, g_mu1 = %e, g_mu_2 = %e, g_mu3 = %e, beta = %f, kappa = %f, C1 = %f, ",
t1.tv_sec, Nsave, g_mu, g_mu1, g_mu2, g_mu3, g_beta, g_kappa, g_rgi_C1);
for(j = 0; j < Integrator.no_timescales; j++) {
fprintf(countfile, "n_int[%d] = %d ", j, Integrator.no_mnls_per_ts[j]);
}
fprintf(countfile, "\n");
fclose(countfile);
}
/* Loop for measurements */
for(j = 0; j < Nmeas; j++) {
if(g_proc_id == 0) {
printf("#\n# Starting trajectory no %d\n", trajectory_counter);
}
return_check = return_check_flag && (trajectory_counter%return_check_interval == 0);
accept = update_tm(&plaquette_energy, &rectangle_energy, datafilename,
return_check, Ntherm<trajectory_counter, trajectory_counter);
Rate += accept;
/* Save gauge configuration all Nsave times */
if((Nsave !=0) && (trajectory_counter%Nsave == 0) && (trajectory_counter!=0)) {
sprintf(gauge_filename,"conf.%.4d", nstore);
if(g_proc_id == 0) {
countfile = fopen("history_hmc_tm", "a");
fprintf(countfile, "%.4d, measurement %d of %d, Nsave = %d, Plaquette = %e, trajectory nr = %d\n",
nstore, j, Nmeas, Nsave, plaquette_energy/(6.*VOLUME*g_nproc),
trajectory_counter);
fclose(countfile);
}
nstore ++;
}
else {
sprintf(gauge_filename,"conf.save");
}
if(((Nsave !=0) && (trajectory_counter%Nsave == 0) && (trajectory_counter!=0)) || (write_cp_flag == 1) || (j >= (Nmeas - 1))) {
/* If a reversibility check was performed this trajectory, and the trajectory was accepted,
* then the configuration is currently stored in .conf.tmp, written out by update_tm.
* In that case also a readback was performed, so no need to test .conf.tmp
* In all other cases the gauge configuration still needs to be written out here. */
if (!(return_check && accept)) {
xlfInfo = construct_paramsXlfInfo(plaquette_energy/(6.*VOLUME*g_nproc), trajectory_counter);
if (g_proc_id == 0) {
fprintf(stdout, "# Writing gauge field to %s.\n", tmp_filename);
}
if((status = write_gauge_field( tmp_filename, gauge_precision_write_flag, xlfInfo) != 0 )) {
/* Writing the gauge field failed directly */
fprintf(stderr, "Error %d while writing gauge field to %s\nAborting...\n", status, tmp_filename);
exit(-2);
}
if (!g_disable_IO_checks) {
#ifdef HAVE_LIBLEMON
/* Read gauge field back to verify the writeout */
if (g_proc_id == 0) {
fprintf(stdout, "# Write completed, verifying write...\n");
}
if( (status = read_gauge_field(tmp_filename)) != 0) {
fprintf(stderr, "WARNING, writeout of %s returned no error, but verification discovered errors.\n", tmp_filename);
fprintf(stderr, "Potential disk or MPI I/O error. Aborting...\n");
exit(-3);
}
if (g_proc_id == 0) {
fprintf(stdout, "# Write successfully verified.\n");
}
#else
if (g_proc_id == 0) {
fprintf(stdout, "# Write completed successfully.\n");
}
#endif
}
free(xlfInfo);
}
/* Now move .conf.tmp into place */
if(g_proc_id == 0) {
fprintf(stdout, "# Renaming %s to %s.\n", tmp_filename, gauge_filename);
if (rename(tmp_filename, gauge_filename) != 0) {
/* Errno can be inspected here for more descriptive error reporting */
fprintf(stderr, "Error while trying to rename temporary file %s to %s. Unable to proceed.\n", tmp_filename, gauge_filename);
exit(-2);
}
countfile = fopen(nstore_filename, "w");
fprintf(countfile, "%d %d %s\n", nstore, trajectory_counter+1, gauge_filename);
fclose(countfile);
}
}
/* online measurements */
for(imeas = 0; imeas < no_measurements; imeas++){
meas = &measurement_list[imeas];
if(trajectory_counter%meas->freq == 0){
if (g_proc_id == 0) {
fprintf(stdout, "#\n# Beginning online measurement.\n");
}
meas->measurefunc(trajectory_counter, imeas, even_odd_flag);
}
}
if(g_proc_id == 0) {
verbose = 1;
}
ix = reread_input("hmc.reread");
if(g_proc_id == 0) {
verbose = 0;
}
#ifdef MPI
MPI_Barrier(MPI_COMM_WORLD);
#endif
if(ix == 0 && g_proc_id == 0) {
countfile = fopen("history_hmc_tm", "a");
fprintf(countfile, "# Changed input parameters according to hmc.reread: measurement %d of %d\n", j, Nmeas);
fclose(countfile);
printf("# Changed input parameters according to hmc.reread (see stdout): measurement %d of %d\n", j, Nmeas);
remove("hmc.reread");
}
trajectory_counter++;
} /* end of loop over trajectories */
if(g_proc_id == 0 && Nmeas != 0) {
printf("# Acceptance rate was %3.2f percent, %d out of %d trajectories accepted.\n", 100.*(double)Rate/(double)Nmeas, Rate, Nmeas);
fflush(stdout);
parameterfile = fopen(parameterfilename, "a");
fprintf(parameterfile, "# Acceptance rate was %3.2f percent, %d out of %d trajectories accepted.\n", 100.*(double)Rate/(double)Nmeas, Rate, Nmeas);
fclose(parameterfile);
}
#ifdef MPI
MPI_Finalize();
#endif
#ifdef OMP
free_omp_accumulators();
#endif
free_gauge_tmp();
free_gauge_field();
free_geometry_indices();
free_spinor_field();
free_moment_field();
free_monomials();
if(g_running_phmc) {
free_bispinor_field();
free_chi_spinor_field();
}
return(0);
#ifdef _KOJAK_INST
#pragma pomp inst end(main)
#endif
}
int update_tm(double *plaquette_energy, double *rectangle_energy,
char * filename, const int return_check, const int acctest,
const int traj_counter) {
su3 *v, *w;
static int ini_g_tmp = 0;
int accept, i=0, j=0, iostatus=0;
double yy[1];
double dh, expmdh, ret_dh=0., ret_gauge_diff=0., tmp;
double atime=0., etime=0.;
double ks = 0., kc = 0., ds, tr, ts, tt;
char tmp_filename[50];
/* Energy corresponding to the Gauge part */
double new_plaquette_energy=0., new_rectangle_energy = 0.;
/* Energy corresponding to the Momenta part */
double enep=0., enepx=0., ret_enep = 0.;
/* Energy corresponding to the pseudo fermion part(s) */
FILE * datafile=NULL, * ret_check_file=NULL;
hamiltonian_field_t hf;
paramsXlfInfo *xlfInfo;
hf.gaugefield = g_gauge_field;
hf.momenta = moment;
hf.derivative = df0;
hf.update_gauge_copy = g_update_gauge_copy;
hf.update_gauge_energy = g_update_gauge_energy;
hf.update_rectangle_energy = g_update_rectangle_energy;
hf.traj_counter = traj_counter;
integrator_set_fields(&hf);
strcpy(tmp_filename, ".conf.tmp");
if(ini_g_tmp == 0) {
ini_g_tmp = init_gauge_tmp(VOLUME);
if(ini_g_tmp != 0) {
exit(-1);
}
ini_g_tmp = 1;
}
atime = gettime();
/*
* here the momentum and spinor fields are initialized
* and their respective actions are calculated
*/
/*
* copy the gauge field to gauge_tmp
*/
#ifdef OMP
#pragma omp parallel for private(w,v)
#endif
for(int ix=0;ix<VOLUME;ix++) {
for(int mu=0;mu<4;mu++) {
v=&hf.gaugefield[ix][mu];
w=&gauge_tmp[ix][mu];
_su3_assign(*w,*v);
}
}
/* heatbath for all monomials */
for(i = 0; i < Integrator.no_timescales; i++) {
for(j = 0; j < Integrator.no_mnls_per_ts[i]; j++) {
monomial_list[ Integrator.mnls_per_ts[i][j] ].hbfunction(Integrator.mnls_per_ts[i][j], &hf);
}
}
if(Integrator.monitor_forces) monitor_forces(&hf);
/* initialize the momenta */
enep = random_su3adj_field(reproduce_randomnumber_flag, hf.momenta);
g_sloppy_precision = 1;
/* run the trajectory */
if(Integrator.n_int[Integrator.no_timescales-1] > 0) {
Integrator.integrate[Integrator.no_timescales-1](Integrator.tau,
Integrator.no_timescales-1, 1);
}
g_sloppy_precision = 0;
/* compute the final energy contributions for all monomials */
dh = 0.;
for(i = 0; i < Integrator.no_timescales; i++) {
for(j = 0; j < Integrator.no_mnls_per_ts[i]; j++) {
dh += monomial_list[ Integrator.mnls_per_ts[i][j] ].accfunction(Integrator.mnls_per_ts[i][j], &hf);
}
}
enepx = moment_energy(hf.momenta);
if (!bc_flag) { /* if PBC */
new_plaquette_energy = measure_gauge_action( (const su3**) hf.gaugefield);
if(g_rgi_C1 > 0. || g_rgi_C1 < 0.) {
new_rectangle_energy = measure_rectangles( (const su3**) hf.gaugefield);
}
}
if(g_proc_id == 0 && g_debug_level > 3) printf("called moment_energy: dh = %1.10e\n", (enepx - enep));
/* Compute the energy difference */
dh = dh + (enepx - enep);
if(g_proc_id == 0 && g_debug_level > 3) {
printf("called momenta_acc dH = %e\n", (enepx - enep));
}
expmdh = exp(-dh);
/* the random number is only taken at node zero and then distributed to
the other sites */
ranlxd(yy,1);
if(g_proc_id==0) {
#ifdef MPI
for(i = 1; i < g_nproc; i++) {
MPI_Send(&yy[0], 1, MPI_DOUBLE, i, 31, MPI_COMM_WORLD);
}
#endif
}
#ifdef MPI
else{
MPI_Recv(&yy[0], 1, MPI_DOUBLE, 0, 31, MPI_COMM_WORLD, &status);
}
#endif
accept = (!acctest | (expmdh > yy[0]));
if(g_proc_id == 0) {
fprintf(stdout, "# Trajectory is %saccepted.\n", (accept ? "" : "not "));
}
/* Here a reversibility test is performed */
/* The trajectory is integrated back */
if(return_check) {
if(g_proc_id == 0) {
fprintf(stdout, "# Performing reversibility check.\n");
}
if(accept) {
/* save gauge file to disk before performing reversibility check */
xlfInfo = construct_paramsXlfInfo((*plaquette_energy)/(6.*VOLUME*g_nproc), -1);
// Should write this to temporary file first, and then check
if(g_proc_id == 0 && g_debug_level > 0) {
fprintf(stdout, "# Writing gauge field to file %s.\n", tmp_filename);
}
if((iostatus = write_gauge_field( tmp_filename, 64, xlfInfo) != 0 )) {
/* Writing failed directly */
fprintf(stderr, "Error %d while writing gauge field to %s\nAborting...\n", iostatus, tmp_filename);
exit(-2);
}
/* There is double writing of the gauge field, also in hmc_tm.c in this case */
/* No reading back check needed here, as reading back is done further down */
if(g_proc_id == 0 && g_debug_level > 0) {
fprintf(stdout, "# Writing done.\n");
}
free(xlfInfo);
}
g_sloppy_precision = 1;
/* run the trajectory back */
Integrator.integrate[Integrator.no_timescales-1](-Integrator.tau,
Integrator.no_timescales-1, 1);
g_sloppy_precision = 0;
/* compute the energy contributions from the pseudo-fermions */
ret_dh = 0.;
for(i = 0; i < Integrator.no_timescales; i++) {
for(j = 0; j < Integrator.no_mnls_per_ts[i]; j++) {
ret_dh += monomial_list[ Integrator.mnls_per_ts[i][j] ].accfunction(Integrator.mnls_per_ts[i][j], &hf);
}
}
ret_enep = moment_energy(hf.momenta);
/* Compute the energy difference */
ret_dh += ret_enep - enep ;
/* Compute Differences in the fields */
ks = 0.;
kc = 0.;
#ifdef OMP
#pragma omp parallel private(w,v,tt,tr,ts,ds,ks,kc)
{
int thread_num = omp_get_thread_num();
#endif
su3 ALIGN v0;
#ifdef OMP
#pragma omp for
#endif
for(int ix = 0; ix < VOLUME; ++ix)
{
for(int mu = 0; mu < 4; ++mu)
{
v=&hf.gaugefield[ix][mu];
w=&gauge_tmp[ix][mu];
_su3_minus_su3(v0, *v, *w);
_su3_square_norm(ds, v0);
tr = sqrt(ds) + kc;
ts = tr + ks;
tt = ts-ks;
ks = ts;
kc = tr-tt;
}
}
kc=ks+kc;
#ifdef OMP
g_omp_acc_re[thread_num] = kc;
} /* OpenMP parallel section closing brace */
/* sum up contributions from thread-local kahan summations */
for(int k = 0; k < omp_num_threads; ++k)
ret_gauge_diff += g_omp_acc_re[k];
#else
ret_gauge_diff = kc;
#endif
#ifdef MPI
tmp = ret_gauge_diff;
MPI_Reduce(&tmp, &ret_gauge_diff, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
#endif
/* compute the total H */
tmp = enep;
for(i = 0; i < Integrator.no_timescales; i++) {
for(j = 0; j < Integrator.no_mnls_per_ts[i]; j++) {
tmp += monomial_list[ Integrator.mnls_per_ts[i][j] ].energy0;
}
}
/* Output */
if(g_proc_id == 0) {
ret_check_file = fopen("return_check.data","a");
fprintf(ret_check_file,"ddh = %1.4e ddU= %1.4e ddh/H = %1.4e\n",
ret_dh, ret_gauge_diff/4./((double)(VOLUME*g_nproc))/3., ret_dh/tmp);
fclose(ret_check_file);
}
if(accept) {
/* Read back gauge field */
if(g_proc_id == 0 && g_debug_level > 0) {
fprintf(stdout, "# Trying to read gauge field from file %s.\n", tmp_filename);
}
if((iostatus = read_gauge_field(tmp_filename) != 0)) {
fprintf(stderr, "Error %d while reading gauge field from %s\nAborting...\n", iostatus, tmp_filename);
exit(-2);
}
if(g_proc_id == 0 && g_debug_level > 0) {
fprintf(stdout, "# Reading done.\n");
}
}
if(g_proc_id == 0) {
fprintf(stdout, "# Reversibility check done.\n");
}
} /* end of reversibility check */
if(accept) {
*plaquette_energy = new_plaquette_energy;
*rectangle_energy = new_rectangle_energy;
/* put the links back to SU(3) group */
if (!bc_flag) { /* periodic boundary conditions */
#ifdef OMP
#pragma omp parallel for private(v)
#endif
for(int ix=0;ix<VOLUME;ix++) {
for(int mu=0;mu<4;mu++) {
v=&hf.gaugefield[ix][mu];
restoresu3_in_place(v);
}
}
}
}
else { /* reject: copy gauge_tmp to hf.gaugefield */
#ifdef OMP
#pragma omp parallel for private(w) private(v)
#endif
for(int ix=0;ix<VOLUME;ix++) {
for(int mu=0;mu<4;mu++){
v=&hf.gaugefield[ix][mu];
w=&gauge_tmp[ix][mu];
_su3_assign(*v,*w);
}
}
}
hf.update_gauge_copy = 1;
g_update_gauge_copy = 1;
hf.update_gauge_energy = 1;
g_update_gauge_energy = 1;
hf.update_rectangle_energy = 1;
g_update_rectangle_energy = 1;
#ifdef MPI
xchange_gauge(hf.gaugefield);
#endif
etime=gettime();
/* printing data in the .data file */
if(g_proc_id==0) {
datafile = fopen(filename, "a");
if (!bc_flag) { /* if Periodic Boundary Conditions */
fprintf(datafile, "%.8d %14.12f %14.12f %e ", traj_counter,
(*plaquette_energy)/(6.*VOLUME*g_nproc), dh, expmdh);
}
for(i = 0; i < Integrator.no_timescales; i++) {
for(j = 0; j < Integrator.no_mnls_per_ts[i]; j++) {
if(monomial_list[ Integrator.mnls_per_ts[i][j] ].type != GAUGE
&& monomial_list[ Integrator.mnls_per_ts[i][j] ].type != SFGAUGE
&& monomial_list[ Integrator.mnls_per_ts[i][j] ].type != NDPOLY
&& monomial_list[ Integrator.mnls_per_ts[i][j] ].type != NDCLOVER
&& monomial_list[ Integrator.mnls_per_ts[i][j] ].type != CLOVERNDTRLOG
&& monomial_list[ Integrator.mnls_per_ts[i][j] ].type != CLOVERTRLOG ) {
fprintf(datafile,"%d %d ", monomial_list[ Integrator.mnls_per_ts[i][j] ].iter0,
monomial_list[ Integrator.mnls_per_ts[i][j] ].iter1);
}
}
}
fprintf(datafile, "%d %e", accept, etime-atime);
if(g_rgi_C1 > 0. || g_rgi_C1 < 0) {
fprintf(datafile, " %e", (*rectangle_energy)/(12*VOLUME*g_nproc));
}
fprintf(datafile, "\n");
fflush(datafile);
fclose(datafile);
}
return(accept);
}
double sf_gauge_acc( const int id, hamiltonian_field_t * const hf)
{
monomial* mnl = &(monomial_list[id]);
double sq_plaq = 0;
double sq_bulk_plaq = 0;
double sq_boundary_space_space_plaq = 0;
double sq_boundary_space_time_plaq = 0;
double sq_wrapped_plaq = 0;
double rect_plaq = 0;
sq_plaq = calc_sq_plaq();
sq_bulk_plaq = calc_bulk_sq_plaq();
sq_boundary_space_space_plaq = calc_boundary_space_space_sq_plaq();
sq_boundary_space_time_plaq = calc_boundary_space_time_sq_plaq();
sq_wrapped_plaq = calc_wrapped_sq_plaq();
rect_plaq = calc_rect_plaq();
#if 1
{
fprintf( stderr, "sq_plaq = %e\n", sq_plaq );
fprintf( stderr, "beta * c0 * sq_plaq = %e\n", g_beta * mnl->c0 * sq_plaq );
fprintf( stderr, "sq_bulk_plaq = %e\n", sq_bulk_plaq );
fprintf( stderr, "beta * c0 * sq_bulk_plaq = %e\n", g_beta * mnl->c0 * sq_bulk_plaq );
fprintf( stderr, "sq_wrapped_plaq = %e\n", sq_wrapped_plaq );
fprintf( stderr, "beta * c0 * sq_wrapped_plaq = %e\n", g_beta * mnl->c0 * sq_wrapped_plaq );
fprintf( stderr, "rect_plaq = %e\n", rect_plaq );
fprintf( stderr, "beta * c1 * rect_plaq = %e\n", g_beta * mnl->c1 * rect_plaq );
fprintf( stderr, "bulk + bound(ss) + bound(st) + wrapped = %e + %e + %e + %e = %e =?= %e = total\n",
sq_bulk_plaq, sq_boundary_space_space_plaq, sq_boundary_space_time_plaq, sq_wrapped_plaq,
sq_bulk_plaq + sq_boundary_space_space_plaq + sq_boundary_space_time_plaq + sq_wrapped_plaq, sq_plaq );
fprintf( stderr, "my energy = %e\n", g_beta * ( mnl->c0 * sq_plaq + mnl->c1 * rect_plaq ) );
}
#endif
/*mnl->energy1 = g_beta*( mnl->c0 * measure_gauge_action() );*/
/* The bulk contribution is the same. */
mnl->energy1 = g_beta * mnl->c0 * sq_bulk_plaq;
/* The space-time boundary contribution must be weighted differently. */
fprintf( stderr, "mnl->ct = %e\n", mnl->ct );
mnl->energy1 += g_beta * mnl->c0 * mnl->ct * sq_boundary_space_time_plaq;
/* The space-space boundary contribution must be weighted differently. */
fprintf( stderr, "mnl->cs = %e\n", mnl->cs );
mnl->energy1 += g_beta * mnl->c0 * mnl->cs * sq_boundary_space_space_plaq;
/* Include the missing plaquettes if requested. */
if( g_sf_inc_wrap_sq == 1 ){ mnl->energy1 += g_beta * mnl->c0 * sq_wrapped_plaq; }
if( mnl->use_rectangles )
{
mnl->energy1 += g_beta*( mnl->c1 * measure_rectangles(hf->gaugefield) );
}
fprintf( stderr, "mnl->energy1 = %e\n", mnl->energy1 );
if( ( g_proc_id == 0 ) & ( g_debug_level > 3 ) )
{
printf( "called sf_gauge_acc for id %d %d dH = %1.4e\n",
id, mnl->even_odd_flag, mnl->energy0 - mnl->energy1 );
}
return ( mnl->energy0 - mnl->energy1 );
}
