int tmLQCD_finalise() {
#ifdef OMP
free_omp_accumulators();
#endif
#ifdef HAVE_GPU
if(usegpu_flag){
finalize_mixedsolve();
# ifdef GPU_DOUBLE
finalize_gpu_fields();
# endif
# ifdef TEMPORALGAUGE
finalize_temporalgauge();
# endif
}
#endif
free_gauge_field();
free_geometry_indices();
free_spinor_field();
free_moment_field();
free_chi_spinor_field();
#ifdef MPI
MPI_Barrier(MPI_COMM_WORLD);
#endif
return(0);
}
int init_chi_spinor_field(const int V, const int nr) {
int i = 0;
static int _nr = 0;
if(!chi_initialised || nr > _nr) {
free_chi_spinor_field();
_nr = nr;
chi_initialised = 1;
if((void*)(sp_up = (spinor*)calloc(2*nr*V+1, sizeof(spinor))) == NULL) {
printf ("malloc errno : %d\n",errno);
errno = 0;
return(1);
}
if((void*)(g_chi_up_spinor_field = malloc(2*nr*sizeof(spinor*))) == NULL) {
printf ("malloc errno : %d\n",errno);
errno = 0;
return(2);
}
if((void*)(g_chi_dn_spinor_field = malloc(nr*sizeof(spinor*))) == NULL) {
printf ("malloc errno : %d\n",errno);
errno = 0;
return(2);
}
g_chi_up_spinor_field[0] = (spinor*)(((unsigned long int)(sp_up)+ALIGN_BASE)&~ALIGN_BASE);
for(int i = 1; i < 2*nr; i++){
g_chi_up_spinor_field[i] = g_chi_up_spinor_field[i-1]+V;
}
for(int i = 0; i < nr; i++){
g_chi_dn_spinor_field[i] = g_chi_up_spinor_field[nr+i];
}
}
return(0);
}
int init_chi_spinor_field(const int V, const int nr) {
int i = 0;
static int _nr = 0;
if(!chi_initialised || nr > _nr) {
free_chi_spinor_field();
_nr = nr;
chi_initialised = 1;
if((void*)(sp_up = (spinor*)calloc(nr*V+1, sizeof(spinor))) == NULL) {
printf ("malloc errno : %d\n",errno);
errno = 0;
return(1);
}
if((void*)(g_chi_up_spinor_field = malloc(nr*sizeof(spinor*))) == NULL) {
printf ("malloc errno : %d\n",errno);
errno = 0;
return(2);
}
if((void*)(sp_dn = (spinor*)calloc(nr*V+1, sizeof(spinor))) == NULL) {
printf ("malloc errno : %d\n",errno);
errno = 0;
return(1);
}
if((void*)(g_chi_dn_spinor_field = malloc(nr*sizeof(spinor*))) == NULL) {
printf ("malloc errno : %d\n",errno);
errno = 0;
return(2);
}
#if ( defined SSE || defined SSE2 || defined SSE3)
g_chi_up_spinor_field[0] = (spinor*)(((unsigned long int)(sp_up)+ALIGN_BASE)&~ALIGN_BASE);
g_chi_dn_spinor_field[0] = (spinor*)(((unsigned long int)(sp_dn)+ALIGN_BASE)&~ALIGN_BASE);
#else
g_chi_up_spinor_field[0] = sp_up;
g_chi_dn_spinor_field[0] = sp_dn;
#endif
for(i = 1; i < nr; i++){
g_chi_up_spinor_field[i] = g_chi_up_spinor_field[i-1]+V;
g_chi_dn_spinor_field[i] = g_chi_dn_spinor_field[i-1]+V;
}
}
return(0);
}
int main(int argc, char *argv[])
{
FILE *parameterfile = NULL;
int c, j, i, ix = 0, isample = 0, op_id = 0;
char * filename = NULL;
char datafilename[50];
char parameterfilename[50];
char conf_filename[50];
char * input_filename = NULL;
double plaquette_energy;
struct stout_parameters params_smear;
spinor **s, *s_;
#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
DUM_DERI = 8;
DUM_MATRIX = DUM_DERI + 5;
#if ((defined BGL && defined XLC) || defined _USE_TSPLITPAR)
NO_OF_SPINORFIELDS = DUM_MATRIX + 3;
#else
NO_OF_SPINORFIELDS = DUM_MATRIX + 3;
#endif
verbose = 0;
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 = "invert.input";
}
if (filename == NULL) {
filename = "output";
}
/* Read the input file */
if( (j = read_input(input_filename)) != 0) {
fprintf(stderr, "Could not find input file: %s\nAborting...\n", input_filename);
exit(-1);
}
#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
/* this DBW2 stuff is not needed for the inversion ! */
if (g_dflgcr_flag == 1) {
even_odd_flag = 0;
}
g_rgi_C1 = 0;
if (Nsave == 0) {
Nsave = 1;
}
if (g_running_phmc) {
NO_OF_SPINORFIELDS = DUM_MATRIX + 8;
}
tmlqcd_mpi_init(argc, argv);
g_dbw2rand = 0;
/* starts the single and double precision random number */
/* generator */
start_ranlux(rlxd_level, random_seed);
/* we need to make sure that we don't have even_odd_flag = 1 */
/* if any of the operators doesn't use it */
/* in this way even/odd can still be used by other operators */
for(j = 0; j < no_operators; j++) if(!operator_list[j].even_odd_flag) even_odd_flag = 0;
#ifndef MPI
g_dbw2rand = 0;
#endif
#ifdef _GAUGE_COPY
j = init_gauge_field(VOLUMEPLUSRAND, 1);
#else
j = init_gauge_field(VOLUMEPLUSRAND, 0);
#endif
if (j != 0) {
fprintf(stderr, "Not enough memory for gauge_fields! Aborting...\n");
exit(-1);
}
j = init_geometry_indices(VOLUMEPLUSRAND);
if (j != 0) {
fprintf(stderr, "Not enough memory for geometry indices! Aborting...\n");
exit(-1);
}
if (no_monomials > 0) {
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(-1);
}
}
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(-1);
}
if (g_running_phmc) {
j = init_chi_spinor_field(VOLUMEPLUSRAND / 2, 20);
if (j != 0) {
fprintf(stderr, "Not enough memory for PHMC Chi fields! Aborting...\n");
exit(-1);
}
}
g_mu = g_mu1;
if (g_cart_id == 0) {
/*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");
write_first_messages(parameterfile, 1);
fclose(parameterfile);
}
/* define the geometry */
geometry();
/* define the boundary conditions for the fermion fields */
boundary(g_kappa);
phmc_invmaxev = 1.;
init_operators();
/* this could be maybe moved to init_operators */
#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) {
j = init_dirac_halfspinor32();
if (j != 0)
{
fprintf(stderr, "Not enough memory for 32-bit halffield! Aborting...\n");
exit(-1);
}
}
# if (defined _PERSISTENT)
if (even_odd_flag)
init_xchange_halffield();
# endif
#endif
for (j = 0; j < Nmeas; j++) {
sprintf(conf_filename, "%s.%.4d", gauge_input_filename, nstore);
if (g_cart_id == 0) {
printf("#\n# Trying to read gauge field from file %s in %s precision.\n",
conf_filename, (gauge_precision_read_flag == 32 ? "single" : "double"));
fflush(stdout);
}
if( (i = read_gauge_field(conf_filename)) !=0) {
fprintf(stderr, "Error %d while reading gauge field from %s\n Aborting...\n", i, conf_filename);
exit(-2);
}
if (g_cart_id == 0) {
printf("# Finished reading gauge field.\n");
fflush(stdout);
}
#ifdef MPI
xchange_gauge(g_gauge_field);
#endif
/*compute the energy of the gauge field*/
plaquette_energy = measure_gauge_action( (const su3**) g_gauge_field);
if (g_cart_id == 0) {
printf("# The computed plaquette value is %e.\n", plaquette_energy / (6.*VOLUME*g_nproc));
fflush(stdout);
}
if (use_stout_flag == 1){
params_smear.rho = stout_rho;
params_smear.iterations = stout_no_iter;
/* if (stout_smear((su3_tuple*)(g_gauge_field[0]), ¶ms_smear, (su3_tuple*)(g_gauge_field[0])) != 0) */
/* exit(1) ; */
g_update_gauge_copy = 1;
g_update_gauge_energy = 1;
g_update_rectangle_energy = 1;
plaquette_energy = measure_gauge_action( (const su3**) g_gauge_field);
if (g_cart_id == 0) {
printf("# The plaquette value after stouting is %e\n", plaquette_energy / (6.*VOLUME*g_nproc));
fflush(stdout);
}
}
if (reweighting_flag == 1) {
reweighting_factor(reweighting_samples, nstore);
}
/* Compute minimal eigenvalues, if wanted */
if (compute_evs != 0) {
eigenvalues(&no_eigenvalues, 5000, eigenvalue_precision,
0, compute_evs, nstore, even_odd_flag);
}
if (phmc_compute_evs != 0) {
#ifdef MPI
MPI_Finalize();
#endif
return(0);
}
/* Compute the mode number or topological susceptibility using spectral projectors, if wanted*/
if(compute_modenumber != 0 || compute_topsus !=0){
s_ = calloc(no_sources_z2*VOLUMEPLUSRAND+1, sizeof(spinor));
s = calloc(no_sources_z2, sizeof(spinor*));
if(s_ == NULL) {
printf("Not enough memory in %s: %d",__FILE__,__LINE__); exit(42);
}
if(s == NULL) {
printf("Not enough memory in %s: %d",__FILE__,__LINE__); exit(42);
}
for(i = 0; i < no_sources_z2; i++) {
#if (defined SSE3 || defined SSE2 || defined SSE)
s[i] = (spinor*)(((unsigned long int)(s_)+ALIGN_BASE)&~ALIGN_BASE)+i*VOLUMEPLUSRAND;
#else
s[i] = s_+i*VOLUMEPLUSRAND;
#endif
z2_random_spinor_field(s[i], VOLUME);
/* what is this here needed for?? */
/* spinor *aux_,*aux; */
/* #if ( defined SSE || defined SSE2 || defined SSE3 ) */
/* aux_=calloc(VOLUMEPLUSRAND+1, sizeof(spinor)); */
/* aux = (spinor *)(((unsigned long int)(aux_)+ALIGN_BASE)&~ALIGN_BASE); */
/* #else */
/* aux_=calloc(VOLUMEPLUSRAND, sizeof(spinor)); */
/* aux = aux_; */
/* #endif */
if(g_proc_id == 0) {
printf("source %d \n", i);
}
if(compute_modenumber != 0){
mode_number(s[i], mstarsq);
}
if(compute_topsus !=0) {
top_sus(s[i], mstarsq);
}
}
free(s);
free(s_);
}
/* move to operators as well */
if (g_dflgcr_flag == 1) {
/* set up deflation blocks */
init_blocks(nblocks_t, nblocks_x, nblocks_y, nblocks_z);
/* the can stay here for now, but later we probably need */
/* something like init_dfl_solver called somewhere else */
/* create set of approximate lowest eigenvectors ("global deflation subspace") */
/* g_mu = 0.; */
/* boundary(0.125); */
generate_dfl_subspace(g_N_s, VOLUME);
/* boundary(g_kappa); */
/* g_mu = g_mu1; */
/* Compute little Dirac operators */
/* alt_block_compute_little_D(); */
if (g_debug_level > 0) {
check_projectors();
check_local_D();
}
if (g_debug_level > 1) {
check_little_D_inversion();
}
}
if(SourceInfo.type == 1) {
index_start = 0;
index_end = 1;
}
g_precWS=NULL;
if(use_preconditioning == 1){
/* todo load fftw wisdom */
#if (defined HAVE_FFTW ) && !( defined MPI)
loadFFTWWisdom(g_spinor_field[0],g_spinor_field[1],T,LX);
#else
use_preconditioning=0;
#endif
}
if (g_cart_id == 0) {
fprintf(stdout, "#\n"); /*Indicate starting of the operator part*/
}
for(op_id = 0; op_id < no_operators; op_id++) {
boundary(operator_list[op_id].kappa);
g_kappa = operator_list[op_id].kappa;
g_mu = 0.;
if(use_preconditioning==1 && PRECWSOPERATORSELECT[operator_list[op_id].solver]!=PRECWS_NO ){
printf("# Using preconditioning with treelevel preconditioning operator: %s \n",
precWSOpToString(PRECWSOPERATORSELECT[operator_list[op_id].solver]));
/* initial preconditioning workspace */
operator_list[op_id].precWS=(spinorPrecWS*)malloc(sizeof(spinorPrecWS));
spinorPrecWS_Init(operator_list[op_id].precWS,
operator_list[op_id].kappa,
operator_list[op_id].mu/2./operator_list[op_id].kappa,
-(0.5/operator_list[op_id].kappa-4.),
PRECWSOPERATORSELECT[operator_list[op_id].solver]);
g_precWS = operator_list[op_id].precWS;
if(PRECWSOPERATORSELECT[operator_list[op_id].solver] == PRECWS_D_DAGGER_D) {
fitPrecParams(op_id);
}
}
for(isample = 0; isample < no_samples; isample++) {
for (ix = index_start; ix < index_end; ix++) {
if (g_cart_id == 0) {
fprintf(stdout, "#\n"); /*Indicate starting of new index*/
}
/* we use g_spinor_field[0-7] for sources and props for the moment */
/* 0-3 in case of 1 flavour */
/* 0-7 in case of 2 flavours */
prepare_source(nstore, isample, ix, op_id, read_source_flag, source_location);
operator_list[op_id].inverter(op_id, index_start);
}
}
if(use_preconditioning==1 && operator_list[op_id].precWS!=NULL ){
/* free preconditioning workspace */
spinorPrecWS_Free(operator_list[op_id].precWS);
free(operator_list[op_id].precWS);
}
if(operator_list[op_id].type == OVERLAP){
free_Dov_WS();
}
}
nstore += Nsave;
}
#ifdef MPI
MPI_Finalize();
#endif
#ifdef OMP
free_omp_accumulators();
#endif
free_blocks();
free_dfl_subspace();
free_gauge_field();
free_geometry_indices();
free_spinor_field();
free_moment_field();
free_chi_spinor_field();
return(0);
#ifdef _KOJAK_INST
#pragma pomp inst end(main)
#endif
}
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 main(int argc, char *argv[])
{
FILE *parameterfile = NULL;
int j, i, ix = 0, isample = 0, op_id = 0;
char datafilename[206];
char parameterfilename[206];
char conf_filename[50];
char * input_filename = NULL;
char * filename = NULL;
double plaquette_energy;
struct stout_parameters params_smear;
#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
DUM_DERI = 8;
DUM_MATRIX = DUM_DERI + 5;
NO_OF_SPINORFIELDS = DUM_MATRIX + 4;
//4 extra fields (corresponding to DUM_MATRIX+0..5) for deg. and ND matrix mult.
NO_OF_SPINORFIELDS_32 = 6;
verbose = 0;
g_use_clover_flag = 0;
process_args(argc,argv,&input_filename,&filename);
set_default_filenames(&input_filename, &filename);
init_parallel_and_read_input(argc, argv, input_filename);
/* this DBW2 stuff is not needed for the inversion ! */
if (g_dflgcr_flag == 1) {
even_odd_flag = 0;
}
g_rgi_C1 = 0;
if (Nsave == 0) {
Nsave = 1;
}
if (g_running_phmc) {
NO_OF_SPINORFIELDS = DUM_MATRIX + 8;
}
tmlqcd_mpi_init(argc, argv);
g_dbw2rand = 0;
/* starts the single and double precision random number */
/* generator */
start_ranlux(rlxd_level, random_seed^nstore);
/* we need to make sure that we don't have even_odd_flag = 1 */
/* if any of the operators doesn't use it */
/* in this way even/odd can still be used by other operators */
for(j = 0; j < no_operators; j++) if(!operator_list[j].even_odd_flag) even_odd_flag = 0;
#ifndef TM_USE_MPI
g_dbw2rand = 0;
#endif
#ifdef _GAUGE_COPY
j = init_gauge_field(VOLUMEPLUSRAND, 1);
j += init_gauge_field_32(VOLUMEPLUSRAND, 1);
#else
j = init_gauge_field(VOLUMEPLUSRAND, 0);
j += init_gauge_field_32(VOLUMEPLUSRAND, 0);
#endif
if (j != 0) {
fprintf(stderr, "Not enough memory for gauge_fields! Aborting...\n");
exit(-1);
}
j = init_geometry_indices(VOLUMEPLUSRAND);
if (j != 0) {
fprintf(stderr, "Not enough memory for geometry indices! Aborting...\n");
exit(-1);
}
if (no_monomials > 0) {
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(-1);
}
}
if (even_odd_flag) {
j = init_spinor_field(VOLUMEPLUSRAND / 2, NO_OF_SPINORFIELDS);
j += init_spinor_field_32(VOLUMEPLUSRAND / 2, NO_OF_SPINORFIELDS_32);
}
else {
j = init_spinor_field(VOLUMEPLUSRAND, NO_OF_SPINORFIELDS);
j += init_spinor_field_32(VOLUMEPLUSRAND, NO_OF_SPINORFIELDS_32);
}
if (j != 0) {
fprintf(stderr, "Not enough memory for spinor fields! Aborting...\n");
exit(-1);
}
if (g_running_phmc) {
j = init_chi_spinor_field(VOLUMEPLUSRAND / 2, 20);
if (j != 0) {
fprintf(stderr, "Not enough memory for PHMC Chi fields! Aborting...\n");
exit(-1);
}
}
g_mu = g_mu1;
if (g_cart_id == 0) {
/*construct the filenames for the observables and the parameters*/
strncpy(datafilename, filename, 200);
strcat(datafilename, ".data");
strncpy(parameterfilename, filename, 200);
strcat(parameterfilename, ".para");
parameterfile = fopen(parameterfilename, "w");
write_first_messages(parameterfile, "invert", git_hash);
fclose(parameterfile);
}
/* define the geometry */
geometry();
/* define the boundary conditions for the fermion fields */
boundary(g_kappa);
phmc_invmaxev = 1.;
init_operators();
/* list and initialize measurements*/
if(g_proc_id == 0) {
printf("\n");
for(int j = 0; j < no_measurements; j++) {
printf("# measurement id %d, type = %d\n", j, measurement_list[j].type);
}
}
init_measurements();
/* this could be maybe moved to init_operators */
#ifdef _USE_HALFSPINOR
j = init_dirac_halfspinor();
if (j != 0) {
fprintf(stderr, "Not enough memory for halffield! Aborting...\n");
exit(-1);
}
/* for mixed precision solvers, the 32 bit halfspinor field must always be there */
j = init_dirac_halfspinor32();
if (j != 0)
{
fprintf(stderr, "Not enough memory for 32-bit halffield! Aborting...\n");
exit(-1);
}
# if (defined _PERSISTENT)
if (even_odd_flag)
init_xchange_halffield();
# endif
#endif
for (j = 0; j < Nmeas; j++) {
sprintf(conf_filename, "%s.%.4d", gauge_input_filename, nstore);
if (g_cart_id == 0) {
printf("#\n# Trying to read gauge field from file %s in %s precision.\n",
conf_filename, (gauge_precision_read_flag == 32 ? "single" : "double"));
fflush(stdout);
}
if( (i = read_gauge_field(conf_filename,g_gauge_field)) !=0) {
fprintf(stderr, "Error %d while reading gauge field from %s\n Aborting...\n", i, conf_filename);
exit(-2);
}
if (g_cart_id == 0) {
printf("# Finished reading gauge field.\n");
fflush(stdout);
}
#ifdef TM_USE_MPI
xchange_gauge(g_gauge_field);
#endif
/*Convert to a 32 bit gauge field, after xchange*/
convert_32_gauge_field(g_gauge_field_32, g_gauge_field, VOLUMEPLUSRAND);
/*compute the energy of the gauge field*/
plaquette_energy = measure_plaquette( (const su3**) g_gauge_field);
if (g_cart_id == 0) {
printf("# The computed plaquette value is %e.\n", plaquette_energy / (6.*VOLUME*g_nproc));
fflush(stdout);
}
if (use_stout_flag == 1){
params_smear.rho = stout_rho;
params_smear.iterations = stout_no_iter;
/* if (stout_smear((su3_tuple*)(g_gauge_field[0]), ¶ms_smear, (su3_tuple*)(g_gauge_field[0])) != 0) */
/* exit(1) ; */
g_update_gauge_copy = 1;
plaquette_energy = measure_plaquette( (const su3**) g_gauge_field);
if (g_cart_id == 0) {
printf("# The plaquette value after stouting is %e\n", plaquette_energy / (6.*VOLUME*g_nproc));
fflush(stdout);
}
}
/* if any measurements are defined in the input file, do them here */
measurement * meas;
for(int imeas = 0; imeas < no_measurements; imeas++){
meas = &measurement_list[imeas];
if (g_proc_id == 0) {
fprintf(stdout, "#\n# Beginning online measurement.\n");
}
meas->measurefunc(nstore, imeas, even_odd_flag);
}
if (reweighting_flag == 1) {
reweighting_factor(reweighting_samples, nstore);
}
/* Compute minimal eigenvalues, if wanted */
if (compute_evs != 0) {
eigenvalues(&no_eigenvalues, 5000, eigenvalue_precision,
0, compute_evs, nstore, even_odd_flag);
}
if (phmc_compute_evs != 0) {
#ifdef TM_USE_MPI
MPI_Finalize();
#endif
return(0);
}
/* Compute the mode number or topological susceptibility using spectral projectors, if wanted*/
if(compute_modenumber != 0 || compute_topsus !=0){
invert_compute_modenumber();
}
// set up blocks if Deflation is used
if (g_dflgcr_flag)
init_blocks(nblocks_t, nblocks_x, nblocks_y, nblocks_z);
if(SourceInfo.type == SRC_TYPE_VOL || SourceInfo.type == SRC_TYPE_PION_TS || SourceInfo.type == SRC_TYPE_GEN_PION_TS) {
index_start = 0;
index_end = 1;
}
g_precWS=NULL;
if(use_preconditioning == 1){
/* todo load fftw wisdom */
#if (defined HAVE_FFTW ) && !( defined TM_USE_MPI)
loadFFTWWisdom(g_spinor_field[0],g_spinor_field[1],T,LX);
#else
use_preconditioning=0;
#endif
}
if (g_cart_id == 0) {
fprintf(stdout, "#\n"); /*Indicate starting of the operator part*/
}
for(op_id = 0; op_id < no_operators; op_id++) {
boundary(operator_list[op_id].kappa);
g_kappa = operator_list[op_id].kappa;
g_mu = operator_list[op_id].mu;
g_c_sw = operator_list[op_id].c_sw;
// DFLGCR and DFLFGMRES
if(operator_list[op_id].solver == DFLGCR || operator_list[op_id].solver == DFLFGMRES) {
generate_dfl_subspace(g_N_s, VOLUME, reproduce_randomnumber_flag);
}
if(use_preconditioning==1 && PRECWSOPERATORSELECT[operator_list[op_id].solver]!=PRECWS_NO ){
printf("# Using preconditioning with treelevel preconditioning operator: %s \n",
precWSOpToString(PRECWSOPERATORSELECT[operator_list[op_id].solver]));
/* initial preconditioning workspace */
operator_list[op_id].precWS=(spinorPrecWS*)malloc(sizeof(spinorPrecWS));
spinorPrecWS_Init(operator_list[op_id].precWS,
operator_list[op_id].kappa,
operator_list[op_id].mu/2./operator_list[op_id].kappa,
-(0.5/operator_list[op_id].kappa-4.),
PRECWSOPERATORSELECT[operator_list[op_id].solver]);
g_precWS = operator_list[op_id].precWS;
if(PRECWSOPERATORSELECT[operator_list[op_id].solver] == PRECWS_D_DAGGER_D) {
fitPrecParams(op_id);
}
}
for(isample = 0; isample < no_samples; isample++) {
for (ix = index_start; ix < index_end; ix++) {
if (g_cart_id == 0) {
fprintf(stdout, "#\n"); /*Indicate starting of new index*/
}
/* we use g_spinor_field[0-7] for sources and props for the moment */
/* 0-3 in case of 1 flavour */
/* 0-7 in case of 2 flavours */
prepare_source(nstore, isample, ix, op_id, read_source_flag, source_location, random_seed);
//randmize initial guess for eigcg if needed-----experimental
if( (operator_list[op_id].solver == INCREIGCG) && (operator_list[op_id].solver_params.eigcg_rand_guess_opt) ){ //randomize the initial guess
gaussian_volume_source( operator_list[op_id].prop0, operator_list[op_id].prop1,isample,ix,0); //need to check this
}
operator_list[op_id].inverter(op_id, index_start, 1);
}
}
if(use_preconditioning==1 && operator_list[op_id].precWS!=NULL ){
/* free preconditioning workspace */
spinorPrecWS_Free(operator_list[op_id].precWS);
free(operator_list[op_id].precWS);
}
if(operator_list[op_id].type == OVERLAP){
free_Dov_WS();
}
}
nstore += Nsave;
}
#ifdef TM_USE_OMP
free_omp_accumulators();
#endif
free_blocks();
free_dfl_subspace();
free_gauge_field();
free_gauge_field_32();
free_geometry_indices();
free_spinor_field();
free_spinor_field_32();
free_moment_field();
free_chi_spinor_field();
free(filename);
free(input_filename);
free(SourceInfo.basename);
free(PropInfo.basename);
#ifdef TM_USE_QUDA
_endQuda();
#endif
#ifdef TM_USE_MPI
MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
#endif
return(0);
#ifdef _KOJAK_INST
#pragma pomp inst end(main)
#endif
}