int main(int argc, char **argv) {
char linebuf[MAXLINE];
char input_file[MAXLINE];
system_t *system;
time_t t = time(NULL);
struct tm tm = *localtime(&t);
/* set the default rank */
rank = 0; size = 1;
/* check args */
if(argc < 2) usage(argv[0]);
/* start up the MPI chain */
#ifdef MPI
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
#endif /* MPI */
if( !rank ) {
sprintf(linebuf, "MPMC (Massively Parallel Monte Carlo) r%d - 2012-2017 GNU Public License\n", VERSION);
output(linebuf);
sprintf(linebuf, "MAIN: processes started on %d cores @ %d-%d-%d %d:%d:%d\n", size, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
output(linebuf);
}
#ifndef MPI
FILE *procfile;
FILE *host;
char nodename[MAXLINE];
char cpu[MAXLINE];
struct stat info;
// These system calls were causing a fork() that does not play nice with some
// MPI implementations (causing some processes to never end... )
/* Collect and output hostname & processor info */
if(access("/proc/cpuinfo",R_OK)!=-1) { // Linux
host = popen("hostname","r");
fgets(nodename, MAXLINE, host);
sprintf(linebuf, "MAIN: Job running on node -> %s", nodename);
output(linebuf);
pclose(host);
procfile = fopen("/proc/cpuinfo", "r");
while (!feof(procfile)) {
fgets(cpu, MAXLINE, procfile);
if(strncasecmp(cpu,"model name",10)==0) {
sprintf(linebuf, "MAIN: CPU -> %s", cpu);
output(linebuf);
break;
}
}
fclose(procfile);
} else if (stat("/Applications",&info)==0) { // Mac OS
output("MAIN: Mac OS detected\n");
host = popen("hostname", "r");
fgets(nodename, MAXLINE, host);
sprintf(linebuf, "MAIN: Job running on node -> %s", nodename);
output(linebuf);
pclose(host);
procfile = popen("sysctl -n machdep.cpu.brand_string","r");
fgets(cpu, MAXLINE, procfile);
sprintf(linebuf, "MAIN: CPU -> %s", cpu);
output(linebuf);
pclose(procfile);
}
#endif // !MPI
/* get the config file arg */
strcpy(input_file, argv[1]);
sprintf(linebuf, "MAIN: running parameters found in %s\n", input_file);
output(linebuf);
/* read the input files and setup the simulation */
system = setup_system(input_file);
if(!system) {
error("MAIN: could not initialize the simulation\n");
die(1);
} else {
output("MAIN: the simulation has been initialized\n");
}
/* install the signal handler to catch SIGTERM cleanly */
terminate_handler(-1, system);
signal(SIGTERM, ((void *)(terminate_handler)));
signal(SIGUSR1, ((void *)(terminate_handler)));
signal(SIGUSR2, ((void *)(terminate_handler)));
output("MAIN: signal handler installed\n");
/* allocate space for the statistics */
system->nodestats = calloc(1, sizeof(nodestats_t));
memnullcheck(system->nodestats,sizeof(nodestats_t), __LINE__-1, __FILE__);
system->avg_nodestats = calloc(1, sizeof(avg_nodestats_t));
memnullcheck(system->avg_nodestats,sizeof(avg_nodestats_t), __LINE__-1, __FILE__);
system->observables = calloc(1, sizeof(observables_t));
memnullcheck(system->observables,sizeof(observables_t), __LINE__-1, __FILE__);
system->avg_observables = calloc(1, sizeof(avg_observables_t));
memnullcheck(system->avg_observables,sizeof(avg_observables_t), __LINE__-1, __FILE__);
system->checkpoint = calloc(1, sizeof(checkpoint_t));
memnullcheck(system->checkpoint,sizeof(checkpoint_t), __LINE__-1, __FILE__);
system->checkpoint->observables = calloc(1, sizeof(observables_t));
memnullcheck(system->checkpoint->observables,sizeof(observables_t), __LINE__-1, __FILE__);
system->grids = calloc(1,sizeof(grid_t));
memnullcheck(system->grids,sizeof(grid_t), __LINE__-1, __FILE__);
system->grids->histogram = calloc(1,sizeof(histogram_t));
memnullcheck(system->grids->histogram,sizeof(histogram_t), __LINE__-1, __FILE__);
system->grids->avg_histogram = calloc(1,sizeof(histogram_t));
memnullcheck(system->grids->avg_histogram,sizeof(histogram_t), __LINE__-1, __FILE__);
/* if polarization active, allocate the necessary matrices */
if(system->polarization && !system->cuda && !system->polar_zodid)
thole_resize_matrices(system);
/* if histogram calculation flag is set, allocate grid */
if(system->calc_hist){
setup_histogram(system);
allocate_histogram_grid(system);
}
/* seed the rng if neccessary */
if ( system->ensemble != ENSEMBLE_TE && system->ensemble != ENSEMBLE_REPLAY )
seed_rng(system, rank);
#ifdef MPI
MPI_Barrier(MPI_COMM_WORLD);
sprintf(linebuf, "MAIN: all %d cores are in sync\n", size);
output(linebuf);
#endif /* MPI */
/* start the MC simulation */
if(system->ensemble == ENSEMBLE_UVT) {
output("MAIN: *******************************************************\n");
output("MAIN: *** starting Grand Canonical Monte Carlo simulation ***\n");
output("MAIN: *******************************************************\n");
} else if(system->ensemble == ENSEMBLE_NVT) {
output("MAIN: *************************************************\n");
output("MAIN: *** starting Canonical Monte Carlo simulation ***\n");
output("MAIN: *************************************************\n");
} else if(system->ensemble == ENSEMBLE_NVE) {
output("MAIN: ******************************************************\n");
output("MAIN: *** starting Microcanonical Monte Carlo simulation ***\n");
output("MAIN: ******************************************************\n");
} else if(system->ensemble == ENSEMBLE_SURF) { /* surface run */
output("MAIN: *****************************************************\n");
output("MAIN: *** starting potential energy surface calculation ***\n");
output("MAIN: *****************************************************\n");
} else if(system->ensemble == ENSEMBLE_REPLAY) { /* surface fitting run */
output("MAIN: **********************************\n");
output("MAIN: *** starting trajectory replay ***\n");
output("MAIN: **********************************\n");
} else if(system->ensemble == ENSEMBLE_SURF_FIT) { /* surface fitting run */
output("MAIN: *************************************************************\n");
output("MAIN: *** starting potential energy surface fitting calculation ***\n");
output("MAIN: *************************************************************\n");
} else if(system->ensemble == ENSEMBLE_TE) { /* surface fitting run */
output("MAIN: *************************************************\n");
output("MAIN: *** starting single-point energy calculation ***\n");
output("MAIN: *************************************************\n");
}
if(system->ensemble == ENSEMBLE_SURF) { /* surface */
if(surface(system) < 0) {
error("MAIN: surface module failed on error, exiting\n");
die(1);
}
}
else if(system->ensemble == ENSEMBLE_SURF_FIT) { /* surface fitting */
if( system->surf_fit_arbitrary_configs ) {
if( surface_fit_arbitrary( system ) < 0 ) {
error("MAIN: surface fitting module (for arbitrary configurations) failed on error, exiting\n");
die(1);
}
}
else if(surface_fit(system) < 0) {
error("MAIN: surface fitting module failed on error, exiting\n");
die(1);
}
}
else if(system->ensemble == ENSEMBLE_REPLAY) { /* replay trajectory and recalc energies, etc. */
if(replay_trajectory(system) < 0) {
error("MAIN: trajectory replay failed, exiting\n");
die(1);
}
}
else if(system->ensemble == ENSEMBLE_TE) {
if(calculate_te(system) < 0) {
error("MAIN: single-point energy calculation failed, exiting\n");
die(1);
}
}
else { //else run monte carlo
if(mc(system) < 0) {
error("MAIN: MC failed on error, exiting\n");
die(1);
}
}
/* cleanup */
output("MAIN: freeing all data structures....");
cleanup(system);
output("...done\n");
output("MAIN: simulation exiting successfully\n\n");
die(0);
return 0;
}
/* was geo_fxyd */
static int
geo_fit_xy(
geomap_fit_t* const fit,
surface_t* const sf1,
surface_t* const sf2,
const size_t ncoord,
const int xfit,
const coord_t* const input,
const coord_t* const ref,
/* Output */
int* has_secondary,
double* const weights,
double* const residual,
stimage_error_t* error) {
bbox_t bbox;
double* zfit = NULL;
const double* const z = (double*)input + (xfit ? 0 : 1);
surface_t savefit;
surface_fit_error_e fit_error = surface_fit_error_ok;
size_t i = 0;
int status = 1;
assert(fit);
assert(sf1);
assert(sf2);
assert(ref);
assert(weights);
assert(residual);
assert(has_secondary);
assert(error);
surface_new(&savefit);
surface_free(sf1);
surface_free(sf2);
*has_secondary = 1;
zfit = malloc_with_error(ncoord * sizeof(double), error);
if (zfit == NULL) goto exit;
bbox_copy(&fit->bbox, &bbox);
bbox_make_nonsingular(&bbox);
if (xfit) {
switch(fit->fit_geometry) {
case geomap_fit_shift:
if (surface_init(
&savefit, fit->function, 2, 2, xterms_none, &bbox,
error)) goto exit;
surface_free(sf1);
if (surface_init(
sf1, fit->function, 1, 1, xterms_none, &bbox,
error)) goto exit;
for (i = 0; i < ncoord; ++i) {
zfit[i] = z[i<<1] - ref[i].x;
}
if (surface_fit(
sf1, ncoord, ref, zfit, weights,
surface_fit_weight_user, &fit_error, error)) goto exit;
if (fit->function == surface_type_polynomial) {
savefit.coeff[0] = sf1->coeff[0];
savefit.coeff[1] = 1.0;
savefit.coeff[2] = 0.0;
} else {
savefit.coeff[0] = sf1->coeff[0] + (bbox.max.x + bbox.min.x) / 2.0;
savefit.coeff[1] = (bbox.max.x - bbox.min.x) / 2.0;
savefit.coeff[2] = 0.0;
}
surface_free(sf1);
if (surface_copy(&savefit, sf1, error)) goto exit;
*has_secondary = 0;
break;
case geomap_fit_xyscale:
if (surface_init(
sf1, fit->function, 2, 1, xterms_none, &bbox,
error)) goto exit;
if (surface_fit(
sf1, ncoord, ref, z, weights,
surface_fit_weight_user, &fit_error, error)) goto exit;
*has_secondary = 0;
break;
default:
if (surface_init(
sf1, fit->function, 2, 2, xterms_none, &bbox,
error)) goto exit;
if (surface_fit(
sf1, ncoord, ref, z, weights,
surface_fit_weight_user, &fit_error, error)) goto exit;
if (fit->xxorder > 2 || fit->xyorder > 2 ||
fit->xxterms == xterms_full) {
if (surface_init(
sf2, fit->function, fit->xxorder, fit->xyorder,
fit->xxterms, &fit->bbox, error)) {
surface_free(sf1);
goto exit;
}
} else {
*has_secondary = 0;
}
break;
}
} else {
switch(fit->fit_geometry) {
case geomap_fit_shift:
if (surface_init(
&savefit, fit->function, 2, 2, xterms_none, &bbox,
error)) goto exit;
surface_free(sf1);
if (surface_init(
sf1, fit->function, 1, 1, xterms_none, &bbox,
error)) goto exit;
for (i = 0; i < ncoord; ++i) {
zfit[i] = z[i<<1] - ref[i].y;
}
if (surface_fit(
sf1, ncoord, ref, zfit, weights,
surface_fit_weight_user, &fit_error, error)) goto exit;
if (fit->function == surface_type_polynomial) {
savefit.coeff[0] = sf1->coeff[0];
savefit.coeff[1] = 0.0;
savefit.coeff[2] = 1.0;
} else {
savefit.coeff[0] = sf1->coeff[0] + (bbox.min.y + bbox.max.y) / 2.0;
savefit.coeff[1] = 0.0;
savefit.coeff[2] = (bbox.max.y - bbox.min.y) / 2.0;
}
surface_free(sf1);
if (surface_copy(&savefit, sf1, error)) goto exit;
*has_secondary = 0;
break;
case geomap_fit_xyscale:
if (surface_init(
sf1, fit->function, 1, 2, xterms_none, &bbox,
error)) goto exit;
if (surface_fit(
sf1, ncoord, ref, z, weights,
surface_fit_weight_user, &fit_error, error)) goto exit;
*has_secondary = 0;
break;
default:
if (surface_init(
sf1, fit->function, 2, 2, xterms_none, &bbox,
error)) goto exit;
if (surface_fit(
sf1, ncoord, ref, z, weights,
surface_fit_weight_user, &fit_error, error)) goto exit;
if (fit->yxorder > 2 || fit->yyorder > 2 ||
fit->yxterms == xterms_full) {
if (surface_init(
sf2, fit->function, fit->yxorder, fit->yyorder,
fit->yxterms, &bbox, error)) goto exit;
} else {
*has_secondary = 0;
}
break;
}
}
if (_geo_fit_xy_validate_fit_error(
fit_error, xfit, fit->projection, error)) goto exit;
if (surface_vector(sf1, ncoord, ref, residual, error)) goto exit;
for (i = 0; i < ncoord; ++i) {
residual[i] = z[i<<1] - residual[i];
}
/* Calculate the higher-order fit */
if (*has_secondary) {
if (surface_fit(
sf2, ncoord, ref, residual, weights,
surface_fit_weight_user, &fit_error, error)) goto exit;
if (_geo_fit_xy_validate_fit_error(
fit_error, xfit, fit->projection, error)) goto exit;
if (surface_vector(sf2, ncoord, ref, zfit, error)) goto exit;
for (i = 0; i < ncoord; ++i) {
residual[i] = zfit[i] - residual[i];
}
}
/* Compute the number of zero weighted points */
fit->n_zero_weighted = count_zero_weighted(ncoord, weights);
/* Calculate the RMS of the fit */
if (xfit) {
fit->xrms = 0.0;
for (i = 0; i < ncoord; ++i) {
fit->xrms += weights[i] * residual[i] * residual[i];
}
} else {
fit->yrms = 0.0;
for (i = 0; i < ncoord; ++i) {
fit->yrms += weights[i] * residual[i] * residual[i];
}
}
fit->ncoord = ncoord;
status = 0;
exit:
surface_free(&savefit);
free(zfit);
return status;
}
