void chk_enx(const char *fn)
{
int nre, fnr;
ener_file_t in;
gmx_enxnm_t *enm = NULL;
t_enxframe *fr;
gmx_bool bShowTStep;
gmx_bool timeSet;
real t0, old_t1, old_t2;
char buf[22];
fprintf(stderr, "Checking energy file %s\n\n", fn);
in = open_enx(fn, "r");
do_enxnms(in, &nre, &enm);
fprintf(stderr, "%d groups in energy file", nre);
snew(fr, 1);
old_t2 = -2.0;
old_t1 = -1.0;
fnr = 0;
t0 = 0;
timeSet = FALSE;
bShowTStep = TRUE;
while (do_enx(in, fr))
{
if (fnr >= 2)
{
if (fabs((fr->t-old_t1)-(old_t1-old_t2)) >
0.1*(fabs(fr->t-old_t1)+fabs(old_t1-old_t2)) )
{
bShowTStep = FALSE;
fprintf(stderr, "\nTimesteps at t=%g don't match (%g, %g)\n",
old_t1, old_t1-old_t2, fr->t-old_t1);
}
}
old_t2 = old_t1;
old_t1 = fr->t;
if (!timeSet)
{
t0 = fr->t;
timeSet = TRUE;
}
if (fnr == 0)
{
fprintf(stderr, "\rframe: %6s (index %6d), t: %10.3f\n",
gmx_step_str(fr->step, buf), fnr, fr->t);
}
fnr++;
}
fprintf(stderr, "\n\nFound %d frames", fnr);
if (bShowTStep && fnr > 1)
{
fprintf(stderr, " with a timestep of %g ps", (old_t1-t0)/(fnr-1));
}
fprintf(stderr, ".\n");
free_enxframe(fr);
free_enxnms(nre, enm);
sfree(fr);
}
void get_enx_state(const char *fn, real t, gmx_groups_t *groups, t_inputrec *ir,
t_state *state)
{
/* Should match the names in mdebin.c */
static const char *boxvel_nm[] = {
"Box-Vel-XX", "Box-Vel-YY", "Box-Vel-ZZ",
"Box-Vel-YX", "Box-Vel-ZX", "Box-Vel-ZY"
};
static const char *pcouplmu_nm[] = {
"Pcoupl-Mu-XX", "Pcoupl-Mu-YY", "Pcoupl-Mu-ZZ",
"Pcoupl-Mu-YX", "Pcoupl-Mu-ZX", "Pcoupl-Mu-ZY"
};
static const char *baro_nm[] = {
"Barostat"
};
int ind0[] = { XX,YY,ZZ,YY,ZZ,ZZ };
int ind1[] = { XX,YY,ZZ,XX,XX,YY };
int nre,nfr,i,j,ni,npcoupl;
char buf[STRLEN];
const char *bufi;
gmx_enxnm_t *enm=NULL;
t_enxframe *fr;
ener_file_t in;
in = open_enx(fn,"r");
do_enxnms(in,&nre,&enm);
snew(fr,1);
nfr = 0;
while ((nfr==0 || fr->t != t) && do_enx(in,fr)) {
nfr++;
}
close_enx(in);
fprintf(stderr,"\n");
if (nfr == 0 || fr->t != t)
gmx_fatal(FARGS,"Could not find frame with time %f in '%s'",t,fn);
npcoupl = TRICLINIC(ir->compress) ? 6 : 3;
if (ir->epc == epcPARRINELLORAHMAN) {
clear_mat(state->boxv);
for(i=0; i<npcoupl; i++) {
state->boxv[ind0[i]][ind1[i]] =
find_energy(boxvel_nm[i],nre,enm,fr);
}
fprintf(stderr,"\nREAD %d BOX VELOCITIES FROM %s\n\n",npcoupl,fn);
}
if (ir->etc == etcNOSEHOOVER)
{
for(i=0; i<state->ngtc; i++) {
ni = groups->grps[egcTC].nm_ind[i];
bufi = *(groups->grpname[ni]);
for(j=0; (j<state->nhchainlength); j++)
{
sprintf(buf,"Xi-%d-%s",j,bufi);
state->nosehoover_xi[i] = find_energy(buf,nre,enm,fr);
sprintf(buf,"vXi-%d-%s",j,bufi);
state->nosehoover_vxi[i] = find_energy(buf,nre,enm,fr);
}
}
fprintf(stderr,"\nREAD %d NOSE-HOOVER Xi chains FROM %s\n\n",state->ngtc,fn);
if (IR_NPT_TROTTER(ir))
{
for(i=0; i<state->nnhpres; i++) {
bufi = baro_nm[0]; /* All barostat DOF's together for now */
for(j=0; (j<state->nhchainlength); j++)
{
sprintf(buf,"Xi-%d-%s",j,bufi);
state->nhpres_xi[i] = find_energy(buf,nre,enm,fr);
sprintf(buf,"vXi-%d-%s",j,bufi);
state->nhpres_vxi[i] = find_energy(buf,nre,enm,fr);
}
}
fprintf(stderr,"\nREAD %d NOSE-HOOVER BAROSTAT Xi chains FROM %s\n\n",state->nnhpres,fn);
}
}
free_enxnms(nre,enm);
free_enxframe(fr);
sfree(fr);
}
int gmx_eneconv(int argc, char *argv[])
{
const char *desc[] = {
"With [IT]multiple files[it] specified for the [TT]-f[tt] option:[PAR]",
"Concatenates several energy files in sorted order.",
"In the case of double time frames, the one",
"in the later file is used. By specifying [TT]-settime[tt] you will be",
"asked for the start time of each file. The input files are taken",
"from the command line,",
"such that the command [TT]gmx eneconv -f *.edr -o fixed.edr[tt] should do",
"the trick. [PAR]",
"With [IT]one file[it] specified for [TT]-f[tt]:[PAR]",
"Reads one energy file and writes another, applying the [TT]-dt[tt],",
"[TT]-offset[tt], [TT]-t0[tt] and [TT]-settime[tt] options and",
"converting to a different format if necessary (indicated by file",
"extentions).[PAR]",
"[TT]-settime[tt] is applied first, then [TT]-dt[tt]/[TT]-offset[tt]",
"followed by [TT]-b[tt] and [TT]-e[tt] to select which frames to write."
};
const char *bugs[] = {
"When combining trajectories the sigma and E^2 (necessary for statistics) are not updated correctly. Only the actual energy is correct. One thus has to compute statistics in another way."
};
ener_file_t in = NULL, out = NULL;
gmx_enxnm_t *enm = NULL;
#if 0
ener_file_t in, out = NULL;
gmx_enxnm_t *enm = NULL;
#endif
t_enxframe *fr, *fro;
gmx_int64_t ee_sum_step = 0, ee_sum_nsteps, ee_sum_nsum;
t_energy *ee_sum;
gmx_int64_t lastfilestep, laststep, startstep_file = 0;
int noutfr;
int nre, nremax, this_nre, nfile, f, i, kkk, nset, *set = NULL;
double last_t;
char **fnms;
real *readtime, *settime, timestep, tadjust;
char buf[22], buf2[22];
int *cont_type;
gmx_bool bNewFile, bFirst, bNewOutput;
gmx_output_env_t *oenv;
gmx_bool warned_about_dh = FALSE;
t_enxblock *blocks = NULL;
int nblocks = 0;
int nblocks_alloc = 0;
t_filenm fnm[] = {
{ efEDR, "-f", NULL, ffRDMULT },
{ efEDR, "-o", "fixed", ffWRITE },
};
#define NFILE asize(fnm)
gmx_bool bWrite;
static real delta_t = 0.0, toffset = 0, scalefac = 1;
static gmx_bool bSetTime = FALSE;
static gmx_bool bSort = TRUE, bError = TRUE;
static real begin = -1;
static real end = -1;
gmx_bool remove_dh = FALSE;
t_pargs pa[] = {
{ "-b", FALSE, etREAL, {&begin},
"First time to use"},
{ "-e", FALSE, etREAL, {&end},
"Last time to use"},
{ "-dt", FALSE, etREAL, {&delta_t},
"Only write out frame when t MOD dt = offset" },
{ "-offset", FALSE, etREAL, {&toffset},
"Time offset for [TT]-dt[tt] option" },
{ "-settime", FALSE, etBOOL, {&bSetTime},
"Change starting time interactively" },
{ "-sort", FALSE, etBOOL, {&bSort},
"Sort energy files (not frames)"},
{ "-rmdh", FALSE, etBOOL, {&remove_dh},
"Remove free energy block data" },
{ "-scalefac", FALSE, etREAL, {&scalefac},
"Multiply energy component by this factor" },
{ "-error", FALSE, etBOOL, {&bError},
"Stop on errors in the file" }
};
if (!parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa),
pa, asize(desc), desc, asize(bugs), bugs, &oenv))
{
return 0;
}
tadjust = 0;
nremax = 0;
nset = 0;
timestep = 0.0;
snew(fnms, argc);
lastfilestep = 0;
laststep = 0;
nfile = opt2fns(&fnms, "-f", NFILE, fnm);
if (!nfile)
{
gmx_fatal(FARGS, "No input files!");
}
snew(settime, nfile+1);
snew(readtime, nfile+1);
snew(cont_type, nfile+1);
nre = scan_ene_files(fnms, nfile, readtime, ×tep, &nremax);
edit_files(fnms, nfile, readtime, settime, cont_type, bSetTime, bSort);
ee_sum_nsteps = 0;
ee_sum_nsum = 0;
snew(ee_sum, nremax);
snew(fr, 1);
snew(fro, 1);
fro->t = -1e20;
fro->nre = nre;
snew(fro->ener, nremax);
noutfr = 0;
bFirst = TRUE;
last_t = fro->t;
for (f = 0; f < nfile; f++)
{
bNewFile = TRUE;
bNewOutput = TRUE;
in = open_enx(fnms[f], "r");
enm = NULL;
do_enxnms(in, &this_nre, &enm);
if (f == 0)
{
if (scalefac != 1)
{
set = select_it(nre, enm, &nset);
}
/* write names to the output file */
out = open_enx(opt2fn("-o", NFILE, fnm), "w");
do_enxnms(out, &nre, &enm);
}
/* start reading from the next file */
while ((fro->t <= (settime[f+1] + GMX_REAL_EPS)) &&
do_enx(in, fr))
{
if (bNewFile)
{
startstep_file = fr->step;
tadjust = settime[f] - fr->t;
if (cont_type[f+1] == TIME_LAST)
{
settime[f+1] = readtime[f+1]-readtime[f]+settime[f];
cont_type[f+1] = TIME_EXPLICIT;
}
bNewFile = FALSE;
}
if (tadjust + fr->t <= last_t)
{
/* Skip this frame, since we already have it / past it */
if (debug)
{
fprintf(debug, "fr->step %s, fr->t %.4f\n",
gmx_step_str(fr->step, buf), fr->t);
fprintf(debug, "tadjust %12.6e + fr->t %12.6e <= t %12.6e\n",
tadjust, fr->t, last_t);
}
continue;
}
fro->step = lastfilestep + fr->step - startstep_file;
fro->t = tadjust + fr->t;
bWrite = ((begin < 0 || (fro->t >= begin-GMX_REAL_EPS)) &&
(end < 0 || (fro->t <= end +GMX_REAL_EPS)) &&
(fro->t <= settime[f+1]+0.5*timestep));
if (debug)
{
fprintf(debug,
"fr->step %s, fr->t %.4f, fro->step %s fro->t %.4f, w %d\n",
gmx_step_str(fr->step, buf), fr->t,
gmx_step_str(fro->step, buf2), fro->t, bWrite);
}
if (bError)
{
if ((end > 0) && (fro->t > end+GMX_REAL_EPS))
{
f = nfile;
break;
}
}
if (fro->t >= begin-GMX_REAL_EPS)
{
if (bFirst)
{
bFirst = FALSE;
}
if (bWrite)
{
update_ee_sum(nre, &ee_sum_step, &ee_sum_nsteps, &ee_sum_nsum, ee_sum,
fr, fro->step);
}
}
/* determine if we should write it */
if (bWrite && (delta_t == 0 || bRmod(fro->t, toffset, delta_t)))
{
laststep = fro->step;
last_t = fro->t;
if (bNewOutput)
{
bNewOutput = FALSE;
fprintf(stderr, "\nContinue writing frames from t=%g, step=%s\n",
fro->t, gmx_step_str(fro->step, buf));
}
/* Copy the energies */
for (i = 0; i < nre; i++)
{
fro->ener[i].e = fr->ener[i].e;
}
fro->nsteps = ee_sum_nsteps;
fro->dt = fr->dt;
if (ee_sum_nsum <= 1)
{
fro->nsum = 0;
}
else
{
fro->nsum = gmx_int64_to_int(ee_sum_nsum,
"energy average summation");
/* Copy the energy sums */
for (i = 0; i < nre; i++)
{
fro->ener[i].esum = ee_sum[i].esum;
fro->ener[i].eav = ee_sum[i].eav;
}
}
/* We wrote the energies, so reset the counts */
ee_sum_nsteps = 0;
ee_sum_nsum = 0;
if (scalefac != 1)
{
for (kkk = 0; kkk < nset; kkk++)
{
fro->ener[set[kkk]].e *= scalefac;
if (fro->nsum > 0)
{
fro->ener[set[kkk]].eav *= scalefac*scalefac;
fro->ener[set[kkk]].esum *= scalefac;
}
}
}
/* Copy restraint stuff */
/*fro->ndisre = fr->ndisre;
fro->disre_rm3tav = fr->disre_rm3tav;
fro->disre_rt = fr->disre_rt;*/
fro->nblock = fr->nblock;
/*fro->nr = fr->nr;*/
fro->block = fr->block;
/* check if we have blocks with delta_h data and are throwing
away data */
if (fro->nblock > 0)
{
if (remove_dh)
{
int i;
if (!blocks || nblocks_alloc < fr->nblock)
{
/* we pre-allocate the blocks */
nblocks_alloc = fr->nblock;
snew(blocks, nblocks_alloc);
}
nblocks = 0; /* number of blocks so far */
for (i = 0; i < fr->nblock; i++)
{
if ( (fr->block[i].id != enxDHCOLL) &&
(fr->block[i].id != enxDH) &&
(fr->block[i].id != enxDHHIST) )
{
/* copy everything verbatim */
blocks[nblocks] = fr->block[i];
nblocks++;
}
}
/* now set the block pointer to the new blocks */
fro->nblock = nblocks;
fro->block = blocks;
}
else if (delta_t > 0)
{
if (!warned_about_dh)
{
for (i = 0; i < fr->nblock; i++)
{
if (fr->block[i].id == enxDH ||
fr->block[i].id == enxDHHIST)
{
int size;
if (fr->block[i].id == enxDH)
{
size = fr->block[i].sub[2].nr;
}
else
{
size = fr->nsteps;
}
if (size > 0)
{
printf("\nWARNING: %s contains delta H blocks or histograms for which\n"
" some data is thrown away on a block-by-block basis, where each block\n"
" contains up to %d samples.\n"
" This is almost certainly not what you want.\n"
" Use the -rmdh option to throw all delta H samples away.\n"
" Use g_energy -odh option to extract these samples.\n",
fnms[f], size);
warned_about_dh = TRUE;
break;
}
}
}
}
}
}
do_enx(out, fro);
if (noutfr % 1000 == 0)
{
fprintf(stderr, "Writing frame time %g ", fro->t);
}
noutfr++;
}
}
if (f == nfile)
{
f--;
}
printf("\nLast step written from %s: t %g, step %s\n",
fnms[f], last_t, gmx_step_str(laststep, buf));
lastfilestep = laststep;
/* set the next time from the last in previous file */
if (cont_type[f+1] == TIME_CONTINUE)
{
settime[f+1] = fro->t;
/* in this case we have already written the last frame of
* previous file, so update begin to avoid doubling it
* with the start of the next file
*/
begin = fro->t+0.5*timestep;
/* cont_type[f+1]==TIME_EXPLICIT; */
}
if ((fro->t < end) && (f < nfile-1) &&
(fro->t < settime[f+1]-1.5*timestep))
{
fprintf(stderr,
"\nWARNING: There might be a gap around t=%g\n", fro->t);
}
/* move energies to lastee */
close_enx(in);
free_enxnms(this_nre, enm);
fprintf(stderr, "\n");
}
if (noutfr == 0)
{
fprintf(stderr, "No frames written.\n");
}
else
{
fprintf(stderr, "Last frame written was at step %s, time %f\n",
gmx_step_str(fro->step, buf), fro->t);
fprintf(stderr, "Wrote %d frames\n", noutfr);
}
return 0;
}
int gmx_convert_tpr(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] can edit run input files in four ways.[PAR]",
"[BB]1.[bb] by modifying the number of steps in a run input file",
"with options [TT]-extend[tt], [TT]-until[tt] or [TT]-nsteps[tt]",
"(nsteps=-1 means unlimited number of steps)[PAR]",
"[BB]2.[bb] (OBSOLETE) by creating a run input file",
"for a continuation run when your simulation has crashed due to e.g.",
"a full disk, or by making a continuation run input file.",
"This option is obsolete, since mdrun now writes and reads",
"checkpoint files.",
"[BB]Note[bb] that a frame with coordinates and velocities is needed.",
"When pressure and/or Nose-Hoover temperature coupling is used",
"an energy file can be supplied to get an exact continuation",
"of the original run.[PAR]",
"[BB]3.[bb] by creating a [TT].tpx[tt] file for a subset of your original",
"tpx file, which is useful when you want to remove the solvent from",
"your [TT].tpx[tt] file, or when you want to make e.g. a pure C[GRK]alpha[grk] [TT].tpx[tt] file.",
"Note that you may need to use [TT]-nsteps -1[tt] (or similar) to get",
"this to work.",
"[BB]WARNING: this [TT].tpx[tt] file is not fully functional[bb].[PAR]",
"[BB]4.[bb] by setting the charges of a specified group",
"to zero. This is useful when doing free energy estimates",
"using the LIE (Linear Interaction Energy) method."
};
const char *top_fn, *frame_fn;
t_fileio *fp;
ener_file_t fp_ener = NULL;
t_trnheader head;
int i;
gmx_int64_t nsteps_req, run_step, frame;
double run_t, state_t;
gmx_bool bOK, bNsteps, bExtend, bUntil, bTime, bTraj;
gmx_bool bFrame, bUse, bSel, bNeedEner, bReadEner, bScanEner, bFepState;
gmx_mtop_t mtop;
t_atoms atoms;
t_inputrec *ir, *irnew = NULL;
t_gromppopts *gopts;
t_state state;
rvec *newx = NULL, *newv = NULL, *tmpx, *tmpv;
matrix newbox;
int gnx;
char *grpname;
atom_id *index = NULL;
int nre;
gmx_enxnm_t *enm = NULL;
t_enxframe *fr_ener = NULL;
char buf[200], buf2[200];
output_env_t oenv;
t_filenm fnm[] = {
{ efTPX, NULL, NULL, ffREAD },
{ efTRN, "-f", NULL, ffOPTRD },
{ efEDR, "-e", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTPX, "-o", "tpxout", ffWRITE }
};
#define NFILE asize(fnm)
/* Command line options */
static int nsteps_req_int = 0;
static real start_t = -1.0, extend_t = 0.0, until_t = 0.0;
static int init_fep_state = 0;
static gmx_bool bContinuation = TRUE, bZeroQ = FALSE, bVel = TRUE;
static t_pargs pa[] = {
{ "-extend", FALSE, etREAL, {&extend_t},
"Extend runtime by this amount (ps)" },
{ "-until", FALSE, etREAL, {&until_t},
"Extend runtime until this ending time (ps)" },
{ "-nsteps", FALSE, etINT, {&nsteps_req_int},
"Change the number of steps" },
{ "-time", FALSE, etREAL, {&start_t},
"Continue from frame at this time (ps) instead of the last frame" },
{ "-zeroq", FALSE, etBOOL, {&bZeroQ},
"Set the charges of a group (from the index) to zero" },
{ "-vel", FALSE, etBOOL, {&bVel},
"Require velocities from trajectory" },
{ "-cont", FALSE, etBOOL, {&bContinuation},
"For exact continuation, the constraints should not be applied before the first step" },
{ "-init_fep_state", FALSE, etINT, {&init_fep_state},
"fep state to initialize from" },
};
int nerror = 0;
/* Parse the command line */
if (!parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
/* Convert int to gmx_int64_t */
nsteps_req = nsteps_req_int;
bNsteps = opt2parg_bSet("-nsteps", asize(pa), pa);
bExtend = opt2parg_bSet("-extend", asize(pa), pa);
bUntil = opt2parg_bSet("-until", asize(pa), pa);
bFepState = opt2parg_bSet("-init_fep_state", asize(pa), pa);
bTime = opt2parg_bSet("-time", asize(pa), pa);
bTraj = (opt2bSet("-f", NFILE, fnm) || bTime);
top_fn = ftp2fn(efTPX, NFILE, fnm);
fprintf(stderr, "Reading toplogy and stuff from %s\n", top_fn);
snew(ir, 1);
read_tpx_state(top_fn, ir, &state, NULL, &mtop);
run_step = ir->init_step;
run_t = ir->init_step*ir->delta_t + ir->init_t;
if (!EI_STATE_VELOCITY(ir->eI))
{
bVel = FALSE;
}
if (bTraj)
{
fprintf(stderr, "\n"
"NOTE: Reading the state from trajectory is an obsolete feature of gmx convert-tpr.\n"
" Continuation should be done by loading a checkpoint file with mdrun -cpi\n"
" This guarantees that all state variables are transferred.\n"
" gmx convert-tpr is now only useful for increasing nsteps,\n"
" but even that can often be avoided by using mdrun -maxh\n"
"\n");
if (ir->bContinuation != bContinuation)
{
fprintf(stderr, "Modifying ir->bContinuation to %s\n",
bool_names[bContinuation]);
}
ir->bContinuation = bContinuation;
bNeedEner = (ir->epc == epcPARRINELLORAHMAN || ir->etc == etcNOSEHOOVER);
bReadEner = (bNeedEner && ftp2bSet(efEDR, NFILE, fnm));
bScanEner = (bReadEner && !bTime);
if (ir->epc != epcNO || EI_SD(ir->eI) || ir->eI == eiBD)
{
fprintf(stderr, "NOTE: The simulation uses pressure coupling and/or stochastic dynamics.\n"
"gmx convert-tpr can not provide binary identical continuation.\n"
"If you want that, supply a checkpoint file to mdrun\n\n");
}
if (EI_SD(ir->eI) || ir->eI == eiBD)
{
fprintf(stderr, "\nChanging ld-seed from %"GMX_PRId64 " ", ir->ld_seed);
ir->ld_seed = (gmx_int64_t)gmx_rng_make_seed();
fprintf(stderr, "to %"GMX_PRId64 "\n\n", ir->ld_seed);
}
frame_fn = ftp2fn(efTRN, NFILE, fnm);
if (fn2ftp(frame_fn) == efCPT)
{
int sim_part;
fprintf(stderr,
"\nREADING STATE FROM CHECKPOINT %s...\n\n",
frame_fn);
read_checkpoint_state(frame_fn, &sim_part,
&run_step, &run_t, &state);
}
else
{
fprintf(stderr,
"\nREADING COORDS, VELS AND BOX FROM TRAJECTORY %s...\n\n",
frame_fn);
fp = open_trn(frame_fn, "r");
if (bScanEner)
{
fp_ener = open_enx(ftp2fn(efEDR, NFILE, fnm), "r");
do_enxnms(fp_ener, &nre, &enm);
snew(fr_ener, 1);
fr_ener->t = -1e-12;
}
/* Now scan until the last set of x and v (step == 0)
* or the ones at step step.
*/
bFrame = TRUE;
frame = 0;
while (bFrame)
{
bFrame = fread_trnheader(fp, &head, &bOK);
if (bOK && frame == 0)
{
if (mtop.natoms != head.natoms)
{
gmx_fatal(FARGS, "Number of atoms in Topology (%d) "
"is not the same as in Trajectory (%d)\n",
mtop.natoms, head.natoms);
}
snew(newx, head.natoms);
snew(newv, head.natoms);
}
bFrame = bFrame && bOK;
if (bFrame)
{
bOK = fread_htrn(fp, &head, newbox, newx, newv, NULL);
}
bFrame = bFrame && bOK;
bUse = FALSE;
if (bFrame &&
(head.x_size) && (head.v_size || !bVel))
{
bUse = TRUE;
if (bScanEner)
{
/* Read until the energy time is >= the trajectory time */
while (fr_ener->t < head.t && do_enx(fp_ener, fr_ener))
{
;
}
bUse = (fr_ener->t == head.t);
}
if (bUse)
{
tmpx = newx;
newx = state.x;
state.x = tmpx;
tmpv = newv;
newv = state.v;
state.v = tmpv;
run_t = head.t;
run_step = head.step;
state.fep_state = head.fep_state;
state.lambda[efptFEP] = head.lambda;
copy_mat(newbox, state.box);
}
}
if (bFrame || !bOK)
{
sprintf(buf, "\r%s %s frame %s%s: step %s%s time %s",
"%s", "%s", "%6", GMX_PRId64, "%6", GMX_PRId64, " %8.3f");
fprintf(stderr, buf,
bUse ? "Read " : "Skipped", ftp2ext(fn2ftp(frame_fn)),
frame, head.step, head.t);
frame++;
if (bTime && (head.t >= start_t))
{
bFrame = FALSE;
}
}
}
if (bScanEner)
{
close_enx(fp_ener);
free_enxframe(fr_ener);
free_enxnms(nre, enm);
}
close_trn(fp);
fprintf(stderr, "\n");
if (!bOK)
{
fprintf(stderr, "%s frame %s (step %s, time %g) is incomplete\n",
ftp2ext(fn2ftp(frame_fn)), gmx_step_str(frame-1, buf2),
gmx_step_str(head.step, buf), head.t);
}
fprintf(stderr, "\nUsing frame of step %s time %g\n",
gmx_step_str(run_step, buf), run_t);
if (bNeedEner)
{
if (bReadEner)
{
get_enx_state(ftp2fn(efEDR, NFILE, fnm), run_t, &mtop.groups, ir, &state);
}
else
{
fprintf(stderr, "\nWARNING: The simulation uses %s temperature and/or %s pressure coupling,\n"
" the continuation will only be exact when an energy file is supplied\n\n",
ETCOUPLTYPE(etcNOSEHOOVER),
EPCOUPLTYPE(epcPARRINELLORAHMAN));
}
}
if (bFepState)
{
ir->fepvals->init_fep_state = init_fep_state;
}
}
}
if (bNsteps)
{
fprintf(stderr, "Setting nsteps to %s\n", gmx_step_str(nsteps_req, buf));
ir->nsteps = nsteps_req;
}
else
{
/* Determine total number of steps remaining */
if (bExtend)
{
ir->nsteps = ir->nsteps - (run_step - ir->init_step) + (gmx_int64_t)(extend_t/ir->delta_t + 0.5);
printf("Extending remaining runtime of by %g ps (now %s steps)\n",
extend_t, gmx_step_str(ir->nsteps, buf));
}
else if (bUntil)
{
printf("nsteps = %s, run_step = %s, current_t = %g, until = %g\n",
gmx_step_str(ir->nsteps, buf),
gmx_step_str(run_step, buf2),
run_t, until_t);
ir->nsteps = (gmx_int64_t)((until_t - run_t)/ir->delta_t + 0.5);
printf("Extending remaining runtime until %g ps (now %s steps)\n",
until_t, gmx_step_str(ir->nsteps, buf));
}
else
{
ir->nsteps -= run_step - ir->init_step;
/* Print message */
printf("%s steps (%g ps) remaining from first run.\n",
gmx_step_str(ir->nsteps, buf), ir->nsteps*ir->delta_t);
}
}
if (bNsteps || bZeroQ || (ir->nsteps > 0))
{
ir->init_step = run_step;
if (ftp2bSet(efNDX, NFILE, fnm) ||
!(bNsteps || bExtend || bUntil || bTraj))
{
atoms = gmx_mtop_global_atoms(&mtop);
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm), 1,
&gnx, &index, &grpname);
if (!bZeroQ)
{
bSel = (gnx != state.natoms);
for (i = 0; ((i < gnx) && (!bSel)); i++)
{
bSel = (i != index[i]);
}
}
else
{
bSel = FALSE;
}
if (bSel)
{
fprintf(stderr, "Will write subset %s of original tpx containing %d "
"atoms\n", grpname, gnx);
reduce_topology_x(gnx, index, &mtop, state.x, state.v);
state.natoms = gnx;
}
else if (bZeroQ)
{
zeroq(index, &mtop);
fprintf(stderr, "Zero-ing charges for group %s\n", grpname);
}
else
{
fprintf(stderr, "Will write full tpx file (no selection)\n");
}
}
state_t = ir->init_t + ir->init_step*ir->delta_t;
sprintf(buf, "Writing statusfile with starting step %s%s and length %s%s steps...\n", "%10", GMX_PRId64, "%10", GMX_PRId64);
fprintf(stderr, buf, ir->init_step, ir->nsteps);
fprintf(stderr, " time %10.3f and length %10.3f ps\n",
state_t, ir->nsteps*ir->delta_t);
write_tpx_state(opt2fn("-o", NFILE, fnm), ir, &state, &mtop);
}
else
{
printf("You've simulated long enough. Not writing tpr file\n");
}
return 0;
}
int gmx_enemat(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] extracts an energy matrix from the energy file ([TT]-f[tt]).",
"With [TT]-groups[tt] a file must be supplied with on each",
"line a group of atoms to be used. For these groups matrix of",
"interaction energies will be extracted from the energy file",
"by looking for energy groups with names corresponding to pairs",
"of groups of atoms, e.g. if your [TT]-groups[tt] file contains::",
"",
" 2",
" Protein",
" SOL",
"",
"then energy groups with names like 'Coul-SR:Protein-SOL' and ",
"'LJ:Protein-SOL' are expected in the energy file (although",
"[THISMODULE] is most useful if many groups are analyzed",
"simultaneously). Matrices for different energy types are written",
"out separately, as controlled by the",
"[TT]-[no]coul[tt], [TT]-[no]coulr[tt], [TT]-[no]coul14[tt], ",
"[TT]-[no]lj[tt], [TT]-[no]lj14[tt], ",
"[TT]-[no]bham[tt] and [TT]-[no]free[tt] options.",
"Finally, the total interaction energy energy per group can be ",
"calculated ([TT]-etot[tt]).[PAR]",
"An approximation of the free energy can be calculated using:",
"[MATH]E[SUB]free[sub] = E[SUB]0[sub] + kT [LOG][CHEVRON][EXP](E-E[SUB]0[sub])/kT[exp][chevron][log][math], where '[MATH][CHEVRON][chevron][math]'",
"stands for time-average. A file with reference free energies",
"can be supplied to calculate the free energy difference",
"with some reference state. Group names (e.g. residue names)",
"in the reference file should correspond to the group names",
"as used in the [TT]-groups[tt] file, but a appended number",
"(e.g. residue number) in the [TT]-groups[tt] will be ignored",
"in the comparison."
};
static gmx_bool bSum = FALSE;
static gmx_bool bMeanEmtx = TRUE;
static int skip = 0, nlevels = 20;
static real cutmax = 1e20, cutmin = -1e20, reftemp = 300.0;
static gmx_bool bCoulSR = TRUE, bCoul14 = FALSE;
static gmx_bool bLJSR = TRUE, bLJ14 = FALSE, bBhamSR = FALSE,
bFree = TRUE;
t_pargs pa[] = {
{ "-sum", FALSE, etBOOL, {&bSum},
"Sum the energy terms selected rather than display them all" },
{ "-skip", FALSE, etINT, {&skip},
"Skip number of frames between data points" },
{ "-mean", FALSE, etBOOL, {&bMeanEmtx},
"with [TT]-groups[tt] extracts matrix of mean energies instead of "
"matrix for each timestep" },
{ "-nlevels", FALSE, etINT, {&nlevels}, "number of levels for matrix colors"},
{ "-max", FALSE, etREAL, {&cutmax}, "max value for energies"},
{ "-min", FALSE, etREAL, {&cutmin}, "min value for energies"},
{ "-coulsr", FALSE, etBOOL, {&bCoulSR}, "extract Coulomb SR energies"},
{ "-coul14", FALSE, etBOOL, {&bCoul14}, "extract Coulomb 1-4 energies"},
{ "-ljsr", FALSE, etBOOL, {&bLJSR}, "extract Lennard-Jones SR energies"},
{ "-lj14", FALSE, etBOOL, {&bLJ14}, "extract Lennard-Jones 1-4 energies"},
{ "-bhamsr", FALSE, etBOOL, {&bBhamSR}, "extract Buckingham SR energies"},
{ "-free", FALSE, etBOOL, {&bFree}, "calculate free energy"},
{ "-temp", FALSE, etREAL, {&reftemp},
"reference temperature for free energy calculation"}
};
/* We will define egSP more energy-groups:
egTotal (total energy) */
#define egTotal egNR
#define egSP 1
gmx_bool egrp_use[egNR+egSP];
ener_file_t in;
FILE *out;
int timecheck = 0;
gmx_enxnm_t *enm = NULL;
t_enxframe *fr;
int teller = 0;
real sum;
gmx_bool bCont, bRef;
gmx_bool bCutmax, bCutmin;
real **eneset, *time = NULL;
int *set, i, j, k, prevk, m = 0, n, nre, nset, nenergy;
char **groups = NULL;
char groupname[255], fn[255];
int ngroups;
t_rgb rlo, rhi, rmid;
real emax, emid, emin;
real ***emat, **etot, *groupnr;
double beta, expE, **e, *eaver, *efree = NULL, edum;
char label[234];
char **ereflines, **erefres = NULL;
real *eref = NULL, *edif = NULL;
int neref = 0;
gmx_output_env_t *oenv;
t_filenm fnm[] = {
{ efEDR, "-f", NULL, ffOPTRD },
{ efDAT, "-groups", "groups", ffREAD },
{ efDAT, "-eref", "eref", ffOPTRD },
{ efXPM, "-emat", "emat", ffWRITE },
{ efXVG, "-etot", "energy", ffWRITE }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_VIEW | PCA_CAN_TIME,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
for (i = 0; (i < egNR+egSP); i++)
{
egrp_use[i] = FALSE;
}
egrp_use[egCOULSR] = bCoulSR;
egrp_use[egLJSR] = bLJSR;
egrp_use[egBHAMSR] = bBhamSR;
egrp_use[egCOUL14] = bCoul14;
egrp_use[egLJ14] = bLJ14;
egrp_use[egTotal] = TRUE;
bRef = opt2bSet("-eref", NFILE, fnm);
in = open_enx(ftp2fn(efEDR, NFILE, fnm), "r");
do_enxnms(in, &nre, &enm);
if (nre == 0)
{
gmx_fatal(FARGS, "No energies!\n");
}
bCutmax = opt2parg_bSet("-max", asize(pa), pa);
bCutmin = opt2parg_bSet("-min", asize(pa), pa);
nenergy = 0;
/* Read groupnames from input file and construct selection of
energy groups from it*/
fprintf(stderr, "Will read groupnames from inputfile\n");
ngroups = get_lines(opt2fn("-groups", NFILE, fnm), &groups);
fprintf(stderr, "Read %d groups\n", ngroups);
snew(set, static_cast<size_t>(gmx::square(ngroups)*egNR/2));
n = 0;
prevk = 0;
for (i = 0; (i < ngroups); i++)
{
fprintf(stderr, "\rgroup %d", i);
for (j = i; (j < ngroups); j++)
{
for (m = 0; (m < egNR); m++)
{
if (egrp_use[m])
{
sprintf(groupname, "%s:%s-%s", egrp_nm[m], groups[i], groups[j]);
#ifdef DEBUG
fprintf(stderr, "\r%-15s %5d", groupname, n);
#endif
for (k = prevk; (k < prevk+nre); k++)
{
if (std::strcmp(enm[k%nre].name, groupname) == 0)
{
set[n++] = k;
break;
}
}
if (k == prevk+nre)
{
fprintf(stderr, "WARNING! could not find group %s (%d,%d)"
"in energy file\n", groupname, i, j);
}
else
{
prevk = k;
}
}
}
}
}
fprintf(stderr, "\n");
nset = n;
snew(eneset, nset+1);
fprintf(stderr, "Will select half-matrix of energies with %d elements\n", n);
/* Start reading energy frames */
snew(fr, 1);
do
{
do
{
bCont = do_enx(in, fr);
if (bCont)
{
timecheck = check_times(fr->t);
}
}
while (bCont && (timecheck < 0));
if (timecheck == 0)
{
#define DONTSKIP(cnt) (skip) ? ((cnt % skip) == 0) : TRUE
if (bCont)
{
fprintf(stderr, "\rRead frame: %d, Time: %.3f", teller, fr->t);
if ((nenergy % 1000) == 0)
{
srenew(time, nenergy+1000);
for (i = 0; (i <= nset); i++)
{
srenew(eneset[i], nenergy+1000);
}
}
time[nenergy] = fr->t;
sum = 0;
for (i = 0; (i < nset); i++)
{
eneset[i][nenergy] = fr->ener[set[i]].e;
sum += fr->ener[set[i]].e;
}
if (bSum)
{
eneset[nset][nenergy] = sum;
}
nenergy++;
}
teller++;
}
}
while (bCont && (timecheck == 0));
fprintf(stderr, "\n");
fprintf(stderr, "Will build energy half-matrix of %d groups, %d elements, "
"over %d frames\n", ngroups, nset, nenergy);
snew(emat, egNR+egSP);
for (j = 0; (j < egNR+egSP); j++)
{
if (egrp_use[m])
{
snew(emat[j], ngroups);
for (i = 0; (i < ngroups); i++)
{
snew(emat[j][i], ngroups);
}
}
}
snew(groupnr, ngroups);
for (i = 0; (i < ngroups); i++)
{
groupnr[i] = i+1;
}
rlo.r = 1.0, rlo.g = 0.0, rlo.b = 0.0;
rmid.r = 1.0, rmid.g = 1.0, rmid.b = 1.0;
rhi.r = 0.0, rhi.g = 0.0, rhi.b = 1.0;
if (bMeanEmtx)
{
snew(e, ngroups);
for (i = 0; (i < ngroups); i++)
{
snew(e[i], nenergy);
}
n = 0;
for (i = 0; (i < ngroups); i++)
{
for (j = i; (j < ngroups); j++)
{
for (m = 0; (m < egNR); m++)
{
if (egrp_use[m])
{
for (k = 0; (k < nenergy); k++)
{
emat[m][i][j] += eneset[n][k];
e[i][k] += eneset[n][k]; /* *0.5; */
e[j][k] += eneset[n][k]; /* *0.5; */
}
n++;
emat[egTotal][i][j] += emat[m][i][j];
emat[m][i][j] /= nenergy;
emat[m][j][i] = emat[m][i][j];
}
}
emat[egTotal][i][j] /= nenergy;
emat[egTotal][j][i] = emat[egTotal][i][j];
}
}
if (bFree)
{
if (bRef)
{
fprintf(stderr, "Will read reference energies from inputfile\n");
neref = get_lines(opt2fn("-eref", NFILE, fnm), &ereflines);
fprintf(stderr, "Read %d reference energies\n", neref);
snew(eref, neref);
snew(erefres, neref);
for (i = 0; (i < neref); i++)
{
snew(erefres[i], 5);
sscanf(ereflines[i], "%s %lf", erefres[i], &edum);
eref[i] = edum;
}
}
snew(eaver, ngroups);
for (i = 0; (i < ngroups); i++)
{
for (k = 0; (k < nenergy); k++)
{
eaver[i] += e[i][k];
}
eaver[i] /= nenergy;
}
beta = 1.0/(BOLTZ*reftemp);
snew(efree, ngroups);
snew(edif, ngroups);
for (i = 0; (i < ngroups); i++)
{
expE = 0;
for (k = 0; (k < nenergy); k++)
{
expE += std::exp(beta*(e[i][k]-eaver[i]));
}
efree[i] = std::log(expE/nenergy)/beta + eaver[i];
if (bRef)
{
n = search_str2(neref, erefres, groups[i]);
if (n != -1)
{
edif[i] = efree[i]-eref[n];
}
else
{
edif[i] = efree[i];
fprintf(stderr, "WARNING: group %s not found "
"in reference energies.\n", groups[i]);
}
}
else
{
edif[i] = 0;
}
}
}
emid = 0.0; /*(emin+emax)*0.5;*/
egrp_nm[egTotal] = "total";
for (m = 0; (m < egNR+egSP); m++)
{
if (egrp_use[m])
{
emin = 1e10;
emax = -1e10;
for (i = 0; (i < ngroups); i++)
{
for (j = i; (j < ngroups); j++)
{
if (emat[m][i][j] > emax)
{
emax = emat[m][i][j];
}
else if (emat[m][i][j] < emin)
{
emin = emat[m][i][j];
}
}
}
if (emax == emin)
{
fprintf(stderr, "Matrix of %s energy is uniform at %f "
"(will not produce output).\n", egrp_nm[m], emax);
}
else
{
fprintf(stderr, "Matrix of %s energy ranges from %f to %f\n",
egrp_nm[m], emin, emax);
if ((bCutmax) || (emax > cutmax))
{
emax = cutmax;
}
if ((bCutmin) || (emin < cutmin))
{
emin = cutmin;
}
if ((emax == cutmax) || (emin == cutmin))
{
fprintf(stderr, "Energy range adjusted: %f to %f\n", emin, emax);
}
sprintf(fn, "%s%s", egrp_nm[m], ftp2fn(efXPM, NFILE, fnm));
sprintf(label, "%s Interaction Energies", egrp_nm[m]);
out = gmx_ffopen(fn, "w");
if (emin >= emid)
{
write_xpm(out, 0, label, "Energy (kJ/mol)",
"Residue Index", "Residue Index",
ngroups, ngroups, groupnr, groupnr, emat[m],
emid, emax, rmid, rhi, &nlevels);
}
else if (emax <= emid)
{
write_xpm(out, 0, label, "Energy (kJ/mol)",
"Residue Index", "Residue Index",
ngroups, ngroups, groupnr, groupnr, emat[m],
emin, emid, rlo, rmid, &nlevels);
}
else
{
write_xpm3(out, 0, label, "Energy (kJ/mol)",
"Residue Index", "Residue Index",
ngroups, ngroups, groupnr, groupnr, emat[m],
emin, emid, emax, rlo, rmid, rhi, &nlevels);
}
gmx_ffclose(out);
}
}
}
snew(etot, egNR+egSP);
for (m = 0; (m < egNR+egSP); m++)
{
snew(etot[m], ngroups);
for (i = 0; (i < ngroups); i++)
{
for (j = 0; (j < ngroups); j++)
{
etot[m][i] += emat[m][i][j];
}
}
}
out = xvgropen(ftp2fn(efXVG, NFILE, fnm), "Mean Energy", "Residue", "kJ/mol",
oenv);
xvgr_legend(out, 0, NULL, oenv);
j = 0;
if (output_env_get_print_xvgr_codes(oenv))
{
char str1[STRLEN], str2[STRLEN];
if (output_env_get_xvg_format(oenv) == exvgXMGR)
{
sprintf(str1, "@ legend string ");
sprintf(str2, " ");
}
else
{
sprintf(str1, "@ s");
sprintf(str2, " legend ");
}
for (m = 0; (m < egNR+egSP); m++)
{
if (egrp_use[m])
{
fprintf(out, "%s%d%s \"%s\"\n", str1, j++, str2, egrp_nm[m]);
}
}
if (bFree)
{
fprintf(out, "%s%d%s \"%s\"\n", str1, j++, str2, "Free");
}
if (bFree)
{
fprintf(out, "%s%d%s \"%s\"\n", str1, j++, str2, "Diff");
}
fprintf(out, "@TYPE xy\n");
fprintf(out, "#%3s", "grp");
for (m = 0; (m < egNR+egSP); m++)
{
if (egrp_use[m])
{
fprintf(out, " %9s", egrp_nm[m]);
}
}
if (bFree)
{
fprintf(out, " %9s", "Free");
}
if (bFree)
{
fprintf(out, " %9s", "Diff");
}
fprintf(out, "\n");
}
for (i = 0; (i < ngroups); i++)
{
fprintf(out, "%3.0f", groupnr[i]);
for (m = 0; (m < egNR+egSP); m++)
{
if (egrp_use[m])
{
fprintf(out, " %9.5g", etot[m][i]);
}
}
if (bFree)
{
fprintf(out, " %9.5g", efree[i]);
}
if (bRef)
{
fprintf(out, " %9.5g", edif[i]);
}
fprintf(out, "\n");
}
xvgrclose(out);
}
else
{
fprintf(stderr, "While typing at your keyboard, suddenly...\n"
"...nothing happens.\nWARNING: Not Implemented Yet\n");
/*
out=ftp2FILE(efMAT,NFILE,fnm,"w");
n=0;
emin=emax=0.0;
for (k=0; (k<nenergy); k++) {
for (i=0; (i<ngroups); i++)
for (j=i+1; (j<ngroups); j++)
emat[i][j]=eneset[n][k];
sprintf(label,"t=%.0f ps",time[k]);
write_matrix(out,ngroups,1,ngroups,groupnr,emat,label,emin,emax,nlevels);
n++;
}
gmx_ffclose(out);
*/
}
close_enx(in);
return 0;
}
static int scan_ene_files(char **fnms, int nfiles,
real *readtime, real *timestep, int *nremax)
{
/* Check number of energy terms and start time of all files */
int f, nre, nremin = 0, nresav = 0;
ener_file_t in;
real t1, t2;
char inputstring[STRLEN];
gmx_enxnm_t *enm;
t_enxframe *fr;
snew(fr, 1);
for (f = 0; f < nfiles; f++)
{
in = open_enx(fnms[f], "r");
enm = NULL;
do_enxnms(in, &nre, &enm);
if (f == 0)
{
nresav = nre;
nremin = nre;
*nremax = nre;
do_enx(in, fr);
t1 = fr->t;
do_enx(in, fr);
t2 = fr->t;
*timestep = t2-t1;
readtime[f] = t1;
close_enx(in);
}
else
{
nremin = std::min(nremin, fr->nre);
*nremax = std::max(*nremax, fr->nre);
if (nre != nresav)
{
fprintf(stderr,
"Energy files don't match, different number of energies:\n"
" %s: %d\n %s: %d\n", fnms[f-1], nresav, fnms[f], fr->nre);
fprintf(stderr,
"\nContinue conversion using only the first %d terms (n/y)?\n"
"(you should be sure that the energy terms match)\n", nremin);
if (NULL == fgets(inputstring, STRLEN-1, stdin))
{
gmx_fatal(FARGS, "Error reading user input");
}
if (inputstring[0] != 'y' && inputstring[0] != 'Y')
{
fprintf(stderr, "Will not convert\n");
exit(0);
}
nresav = fr->nre;
}
do_enx(in, fr);
readtime[f] = fr->t;
close_enx(in);
}
fprintf(stderr, "\n");
free_enxnms(nre, enm);
}
free_enxframe(fr);
sfree(fr);
return nremin;
}
void list_ene(const char *fn)
{
int ndr;
ener_file_t in;
gmx_bool bCont;
gmx_enxnm_t *enm = NULL;
t_enxframe *fr;
int i, j, nre, b;
real rav, minthird;
char buf[22];
printf("gmx dump: %s\n", fn);
in = open_enx(fn, "r");
do_enxnms(in, &nre, &enm);
assert(enm);
printf("energy components:\n");
for (i = 0; (i < nre); i++)
{
printf("%5d %-24s (%s)\n", i, enm[i].name, enm[i].unit);
}
minthird = -1.0/3.0;
snew(fr, 1);
do
{
bCont = do_enx(in, fr);
if (bCont)
{
printf("\n%24s %12.5e %12s %12s\n", "time:",
fr->t, "step:", gmx_step_str(fr->step, buf));
printf("%24s %12s %12s %12s\n",
"", "", "nsteps:", gmx_step_str(fr->nsteps, buf));
printf("%24s %12.5e %12s %12s\n",
"delta_t:", fr->dt, "sum steps:", gmx_step_str(fr->nsum, buf));
if (fr->nre == nre)
{
printf("%24s %12s %12s %12s\n",
"Component", "Energy", "Av. Energy", "Sum Energy");
if (fr->nsum > 0)
{
for (i = 0; (i < nre); i++)
{
printf("%24s %12.5e %12.5e %12.5e\n",
enm[i].name, fr->ener[i].e, fr->ener[i].eav,
fr->ener[i].esum);
}
}
else
{
for (i = 0; (i < nre); i++)
{
printf("%24s %12.5e\n",
enm[i].name, fr->ener[i].e);
}
}
}
for (b = 0; b < fr->nblock; b++)
{
const char *typestr = "";
t_enxblock *eb = &(fr->block[b]);
printf("Block data %2d (%3d subblocks, id=%d)\n",
b, eb->nsub, eb->id);
if (eb->id < enxNR)
{
typestr = enx_block_id_name[eb->id];
}
printf(" id='%s'\n", typestr);
for (i = 0; i < eb->nsub; i++)
{
t_enxsubblock *sb = &(eb->sub[i]);
printf(" Sub block %3d (%5d elems, type=%s) values:\n",
i, sb->nr, xdr_datatype_names[sb->type]);
switch (sb->type)
{
case xdr_datatype_float:
for (j = 0; j < sb->nr; j++)
{
printf("%14d %8.4f\n", j, sb->fval[j]);
}
break;
case xdr_datatype_double:
for (j = 0; j < sb->nr; j++)
{
printf("%14d %10.6f\n", j, sb->dval[j]);
}
break;
case xdr_datatype_int:
for (j = 0; j < sb->nr; j++)
{
printf("%14d %10d\n", j, sb->ival[j]);
}
break;
case xdr_datatype_int64:
for (j = 0; j < sb->nr; j++)
{
printf("%14d %s\n",
j, gmx_step_str(sb->lval[j], buf));
}
break;
case xdr_datatype_char:
for (j = 0; j < sb->nr; j++)
{
printf("%14d %1c\n", j, sb->cval[j]);
}
break;
case xdr_datatype_string:
for (j = 0; j < sb->nr; j++)
{
printf("%14d %80s\n", j, sb->sval[j]);
}
break;
default:
gmx_incons("Unknown subblock type");
}
}
}
}
}
while (bCont);
close_enx(in);
free_enxframe(fr);
sfree(fr);
sfree(enm);
}
void print_ebin(int fp_ene,bool bEne,bool bDR,bool bOR,
FILE *log,int steps,real time,int mode,bool bCompact,
t_mdebin *md,t_fcdata *fcd,t_atoms *atoms)
{
static char **grpnms=NULL;
static char *kjm="(kJ/mol)";
char buf[246];
int i,j,n,ni,nj,ndr,nor;
int nr[enxNR];
real *block[enxNR];
t_enxframe fr;
switch (mode) {
case eprNORMAL:
fr.t = time;
fr.step = steps;
fr.nre = (bEne) ? md->ebin->nener : 0;
fr.ener = md->ebin->e;
fr.ndisre = bDR ? fcd->disres.npr : 0;
fr.rav = fcd->disres.rav;
fr.rt = fcd->disres.rt;
nr[enxOR] = bOR ? fcd->orires.nr : 0;
nr[enxORI] = (bOR && (fcd->orires.oinsl != fcd->orires.otav)) ?
fcd->orires.nr : 0;
fr.nr = nr;
block[enxOR] = fcd->orires.otav;
block[enxORI] = fcd->orires.oinsl;
fr.block = block;
if (fr.nr[enxOR])
fr.nblock = 2;
else
fr.nblock = 0;
if (fr.nre || fr.ndisre || fr.nr[enxOR] || fr.nr[enxORI])
do_enx(fp_ene,&fr);
break;
case eprAVER:
if (log) pprint(log,"A V E R A G E S");
break;
case eprRMS:
if (log) pprint(log,"R M S - F L U C T U A T I O N S");
break;
default:
fatal_error(0,"Invalid print mode (%d)",mode);
}
if (log)
{
if (fcd->orires.nr)
print_orires_log(log,fcd);
fprintf(log," Energies %s\n",kjm);
pr_ebin(log,md->ebin,md->ie,f_nre,5,mode,steps,TRUE);
fprintf(log,"\n");
if (!bCompact) {
if (bPC) {
pr_ebin(log,md->ebin,md->ib, bTricl ? NTRICLBOXS : NBOXS,5,mode,steps,TRUE);
fprintf(log,"\n");
}
if (bShake) {
fprintf(log," Shake Virial %s\n",kjm);
pr_ebin(log,md->ebin,md->isvir,9,3,mode,steps,FALSE);
fprintf(log,"\n");
fprintf(log," Force Virial %s\n",kjm);
pr_ebin(log,md->ebin,md->ifvir,9,3,mode,steps,FALSE);
fprintf(log,"\n");
}
fprintf(log," Total Virial %s\n",kjm);
pr_ebin(log,md->ebin,md->ivir,9,3,mode,steps,FALSE);
fprintf(log,"\n");
fprintf(log," Pressure (bar)\n");
pr_ebin(log,md->ebin,md->ipres,9,3,mode,steps,FALSE);
fprintf(log,"\n");
fprintf(log," Total Dipole (Debye)\n");
pr_ebin(log,md->ebin,md->imu,3,3,mode,steps,FALSE);
fprintf(log,"\n");
if (md->nE > 1) {
if (grpnms==NULL) {
snew(grpnms,md->nE);
n=0;
for(i=0; (i<md->nEg); i++) {
ni=atoms->grps[egcENER].nm_ind[i];
for(j=i; (j<md->nEg); j++) {
nj=atoms->grps[egcENER].nm_ind[j];
sprintf(buf,"%s-%s",*(atoms->grpname[ni]),*(atoms->grpname[nj]));
grpnms[n++]=strdup(buf);
}
}
}
sprintf(buf,"Epot %s",kjm);
fprintf(log,"%15s ",buf);
for(i=0; (i<egNR); i++)
if (bEInd[i])
fprintf(log,"%12s ",egrp_nm[i]);
fprintf(log,"\n");
for(i=0; (i<md->nE); i++) {
fprintf(log,"%15s",grpnms[i]);
pr_ebin(log,md->ebin,md->igrp[i],md->nEc,md->nEc,mode,steps,FALSE);
}
fprintf(log,"\n");
}
if (md->nTC > 1) {
pr_ebin(log,md->ebin,md->itc,2*md->nTC,4,mode,steps,TRUE);
fprintf(log,"\n");
}
if (md->nU > 1) {
fprintf(log,"%15s %12s %12s %12s\n",
"Group","Ux","Uy","Uz");
for(i=0; (i<md->nU); i++) {
ni=atoms->grps[egcACC].nm_ind[i];
fprintf(log,"%15s",*atoms->grpname[ni]);
pr_ebin(log,md->ebin,md->iu+3*i,3,3,mode,steps,FALSE);
}
fprintf(log,"\n");
}
}
}
}
int gmx_lie(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes a free energy estimate based on an energy analysis",
"from nonbonded energies. One needs an energy file with the following components:",
"Coul-(A-B) LJ-SR (A-B) etc.[PAR]",
"To utilize [TT]g_lie[tt] correctly, two simulations are required: one with the",
"molecule of interest bound to its receptor and one with the molecule in water.",
"Both need to utilize [TT]energygrps[tt] such that Coul-SR(A-B), LJ-SR(A-B), etc. terms",
"are written to the [REF].edr[ref] file. Values from the molecule-in-water simulation",
"are necessary for supplying suitable values for -Elj and -Eqq."
};
static real lie_lj = 0, lie_qq = 0, fac_lj = 0.181, fac_qq = 0.5;
static const char *ligand = "none";
t_pargs pa[] = {
{ "-Elj", FALSE, etREAL, {&lie_lj},
"Lennard-Jones interaction between ligand and solvent" },
{ "-Eqq", FALSE, etREAL, {&lie_qq},
"Coulomb interaction between ligand and solvent" },
{ "-Clj", FALSE, etREAL, {&fac_lj},
"Factor in the LIE equation for Lennard-Jones component of energy" },
{ "-Cqq", FALSE, etREAL, {&fac_qq},
"Factor in the LIE equation for Coulomb component of energy" },
{ "-ligand", FALSE, etSTR, {&ligand},
"Name of the ligand in the energy file" }
};
#define NPA asize(pa)
FILE *out;
int nre, nframes = 0, ct = 0;
ener_file_t fp;
t_liedata *ld;
gmx_enxnm_t *enm = NULL;
t_enxframe *fr;
real lie;
double lieaver = 0, lieav2 = 0;
gmx_output_env_t *oenv;
t_filenm fnm[] = {
{ efEDR, "-f", "ener", ffREAD },
{ efXVG, "-o", "lie", ffWRITE }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_VIEW | PCA_CAN_TIME,
NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
fp = open_enx(ftp2fn(efEDR, NFILE, fnm), "r");
do_enxnms(fp, &nre, &enm);
ld = analyze_names(nre, enm, ligand);
snew(fr, 1);
out = xvgropen(ftp2fn(efXVG, NFILE, fnm), "LIE free energy estimate",
"Time (ps)", "DGbind (kJ/mol)", oenv);
while (do_enx(fp, fr))
{
ct = check_times(fr->t);
if (ct == 0)
{
lie = calc_lie(ld, fr->ener, lie_lj, lie_qq, fac_lj, fac_qq);
lieaver += lie;
lieav2 += lie*lie;
nframes++;
fprintf(out, "%10g %10g\n", fr->t, lie);
}
}
close_enx(fp);
xvgrclose(out);
fprintf(stderr, "\n");
if (nframes > 0)
{
printf("DGbind = %.3f (%.3f)\n", lieaver/nframes,
std::sqrt(lieav2/nframes-sqr(lieaver/nframes)));
}
do_view(oenv, ftp2fn(efXVG, NFILE, fnm), "-nxy");
return 0;
}
void print_ebin(ener_file_t fp_ene,gmx_bool bEne,gmx_bool bDR,gmx_bool bOR,
FILE *log,
gmx_large_int_t step,double time,
int mode,gmx_bool bCompact,
t_mdebin *md,t_fcdata *fcd,
gmx_groups_t *groups,t_grpopts *opts)
{
/*static char **grpnms=NULL;*/
char buf[246];
int i,j,n,ni,nj,ndr,nor,b;
int ndisre=0;
real *disre_rm3tav, *disre_rt;
/* these are for the old-style blocks (1 subblock, only reals), because
there can be only one per ID for these */
int nr[enxNR];
int id[enxNR];
real *block[enxNR];
/* temporary arrays for the lambda values to write out */
double enxlambda_data[2];
t_enxframe fr;
switch (mode)
{
case eprNORMAL:
init_enxframe(&fr);
fr.t = time;
fr.step = step;
fr.nsteps = md->ebin->nsteps;
fr.dt = md->delta_t;
fr.nsum = md->ebin->nsum;
fr.nre = (bEne) ? md->ebin->nener : 0;
fr.ener = md->ebin->e;
ndisre = bDR ? fcd->disres.npair : 0;
disre_rm3tav = fcd->disres.rm3tav;
disre_rt = fcd->disres.rt;
/* Optional additional old-style (real-only) blocks. */
for(i=0; i<enxNR; i++)
{
nr[i] = 0;
}
if (fcd->orires.nr > 0 && bOR)
{
diagonalize_orires_tensors(&(fcd->orires));
nr[enxOR] = fcd->orires.nr;
block[enxOR] = fcd->orires.otav;
id[enxOR] = enxOR;
nr[enxORI] = (fcd->orires.oinsl != fcd->orires.otav) ?
fcd->orires.nr : 0;
block[enxORI] = fcd->orires.oinsl;
id[enxORI] = enxORI;
nr[enxORT] = fcd->orires.nex*12;
block[enxORT] = fcd->orires.eig;
id[enxORT] = enxORT;
}
/* whether we are going to wrte anything out: */
if (fr.nre || ndisre || nr[enxOR] || nr[enxORI])
{
/* the old-style blocks go first */
fr.nblock = 0;
for(i=0; i<enxNR; i++)
{
if (nr[i] > 0)
{
fr.nblock = i + 1;
}
}
add_blocks_enxframe(&fr, fr.nblock);
for(b=0;b<fr.nblock;b++)
{
add_subblocks_enxblock(&(fr.block[b]), 1);
fr.block[b].id=id[b];
fr.block[b].sub[0].nr = nr[b];
#ifndef GMX_DOUBLE
fr.block[b].sub[0].type = xdr_datatype_float;
fr.block[b].sub[0].fval = block[b];
#else
fr.block[b].sub[0].type = xdr_datatype_double;
fr.block[b].sub[0].dval = block[b];
#endif
}
/* check for disre block & fill it. */
if (ndisre>0)
{
int db = fr.nblock;
fr.nblock+=1;
add_blocks_enxframe(&fr, fr.nblock);
add_subblocks_enxblock(&(fr.block[db]), 2);
fr.block[db].id=enxDISRE;
fr.block[db].sub[0].nr=ndisre;
fr.block[db].sub[1].nr=ndisre;
#ifndef GMX_DOUBLE
fr.block[db].sub[0].type=xdr_datatype_float;
fr.block[db].sub[1].type=xdr_datatype_float;
fr.block[db].sub[0].fval=disre_rt;
fr.block[db].sub[1].fval=disre_rm3tav;
#else
fr.block[db].sub[0].type=xdr_datatype_double;
fr.block[db].sub[1].type=xdr_datatype_double;
fr.block[db].sub[0].dval=disre_rt;
fr.block[db].sub[1].dval=disre_rm3tav;
#endif
}
/* here we can put new-style blocks */
/* Free energy perturbation blocks */
if (md->dhc)
{
mde_delta_h_coll_handle_block(md->dhc, &fr, fr.nblock);
}
/* do the actual I/O */
do_enx(fp_ene,&fr);
gmx_fio_check_file_position(enx_file_pointer(fp_ene));
if (fr.nre)
{
/* We have stored the sums, so reset the sum history */
reset_ebin_sums(md->ebin);
}
/* we can now free & reset the data in the blocks */
if (md->dhc)
mde_delta_h_coll_reset(md->dhc);
}
free_enxframe(&fr);
break;
case eprAVER:
if (log)
{
pprint(log,"A V E R A G E S",md);
}
break;
case eprRMS:
if (log)
{
pprint(log,"R M S - F L U C T U A T I O N S",md);
}
break;
default:
gmx_fatal(FARGS,"Invalid print mode (%d)",mode);
}
if (log)
{
for(i=0;i<opts->ngtc;i++)
{
if(opts->annealing[i]!=eannNO)
{
fprintf(log,"Current ref_t for group %s: %8.1f\n",
*(groups->grpname[groups->grps[egcTC].nm_ind[i]]),
opts->ref_t[i]);
}
}
if (mode==eprNORMAL && fcd->orires.nr>0)
{
print_orires_log(log,&(fcd->orires));
}
fprintf(log," Energies (%s)\n",unit_energy);
pr_ebin(log,md->ebin,md->ie,md->f_nre+md->nCrmsd,5,mode,TRUE);
fprintf(log,"\n");
if (!bCompact)
{
if (md->bDynBox)
{
pr_ebin(log,md->ebin,md->ib, md->bTricl ? NTRICLBOXS : NBOXS,5,
mode,TRUE);
fprintf(log,"\n");
}
if (md->bConstrVir)
{
fprintf(log," Constraint Virial (%s)\n",unit_energy);
pr_ebin(log,md->ebin,md->isvir,9,3,mode,FALSE);
fprintf(log,"\n");
fprintf(log," Force Virial (%s)\n",unit_energy);
pr_ebin(log,md->ebin,md->ifvir,9,3,mode,FALSE);
fprintf(log,"\n");
}
fprintf(log," Total Virial (%s)\n",unit_energy);
pr_ebin(log,md->ebin,md->ivir,9,3,mode,FALSE);
fprintf(log,"\n");
fprintf(log," Pressure (%s)\n",unit_pres_bar);
pr_ebin(log,md->ebin,md->ipres,9,3,mode,FALSE);
fprintf(log,"\n");
fprintf(log," Total Dipole (%s)\n",unit_dipole_D);
pr_ebin(log,md->ebin,md->imu,3,3,mode,FALSE);
fprintf(log,"\n");
if (md->nE > 1)
{
if (md->print_grpnms==NULL)
{
snew(md->print_grpnms,md->nE);
n=0;
for(i=0; (i<md->nEg); i++)
{
ni=groups->grps[egcENER].nm_ind[i];
for(j=i; (j<md->nEg); j++)
{
nj=groups->grps[egcENER].nm_ind[j];
sprintf(buf,"%s-%s",*(groups->grpname[ni]),
*(groups->grpname[nj]));
md->print_grpnms[n++]=strdup(buf);
}
}
}
sprintf(buf,"Epot (%s)",unit_energy);
fprintf(log,"%15s ",buf);
for(i=0; (i<egNR); i++)
{
if (md->bEInd[i])
{
fprintf(log,"%12s ",egrp_nm[i]);
}
}
fprintf(log,"\n");
for(i=0; (i<md->nE); i++)
{
fprintf(log,"%15s",md->print_grpnms[i]);
pr_ebin(log,md->ebin,md->igrp[i],md->nEc,md->nEc,mode,
FALSE);
}
fprintf(log,"\n");
}
if (md->nTC > 1)
{
pr_ebin(log,md->ebin,md->itemp,md->nTC,4,mode,TRUE);
fprintf(log,"\n");
}
if (md->nU > 1)
{
fprintf(log,"%15s %12s %12s %12s\n",
"Group","Ux","Uy","Uz");
for(i=0; (i<md->nU); i++)
{
ni=groups->grps[egcACC].nm_ind[i];
fprintf(log,"%15s",*groups->grpname[ni]);
pr_ebin(log,md->ebin,md->iu+3*i,3,3,mode,FALSE);
}
fprintf(log,"\n");
}
}
}
}
void comp_enx(const char *fn1, const char *fn2, real ftol, real abstol, const char *lastener)
{
int nre, nre1, nre2;
ener_file_t in1, in2;
int i, j, maxener, *ind1, *ind2, *have;
gmx_enxnm_t *enm1 = NULL, *enm2 = NULL;
t_enxframe *fr1, *fr2;
gmx_bool b1, b2;
fprintf(stdout, "comparing energy file %s and %s\n\n", fn1, fn2);
in1 = open_enx(fn1, "r");
in2 = open_enx(fn2, "r");
do_enxnms(in1, &nre1, &enm1);
do_enxnms(in2, &nre2, &enm2);
if (nre1 != nre2)
{
fprintf(stdout, "There are %d and %d terms in the energy files\n\n",
nre1, nre2);
}
else
{
fprintf(stdout, "There are %d terms in the energy files\n\n", nre1);
}
snew(ind1, nre1);
snew(ind2, nre2);
snew(have, nre2);
nre = 0;
for (i = 0; i < nre1; i++)
{
for (j = 0; j < nre2; j++)
{
if (enernm_equal(enm1[i].name, enm2[j].name))
{
ind1[nre] = i;
ind2[nre] = j;
have[j] = 1;
nre++;
break;
}
}
if (nre == 0 || ind1[nre-1] != i)
{
cmp_str(stdout, "enm", i, enm1[i].name, "-");
}
}
for (i = 0; i < nre2; i++)
{
if (have[i] == 0)
{
cmp_str(stdout, "enm", i, "-", enm2[i].name);
}
}
maxener = nre;
for (i = 0; i < nre; i++)
{
if ((lastener != NULL) && (std::strstr(enm1[i].name, lastener) != NULL))
{
maxener = i+1;
break;
}
}
fprintf(stdout, "There are %d terms to compare in the energy files\n\n",
maxener);
for (i = 0; i < maxener; i++)
{
cmp_str(stdout, "unit", i, enm1[ind1[i]].unit, enm2[ind2[i]].unit);
}
snew(fr1, 1);
snew(fr2, 1);
do
{
b1 = do_enx(in1, fr1);
b2 = do_enx(in2, fr2);
if (b1 && !b2)
{
fprintf(stdout, "\nEnd of file on %s but not on %s\n", fn2, fn1);
}
else if (!b1 && b2)
{
fprintf(stdout, "\nEnd of file on %s but not on %s\n", fn1, fn2);
}
else if (!b1 && !b2)
{
fprintf(stdout, "\nFiles read successfully\n");
}
else
{
cmp_real(stdout, "t", -1, fr1->t, fr2->t, ftol, abstol);
cmp_int(stdout, "step", -1, fr1->step, fr2->step);
/* We don't want to print the nre mismatch for every frame */
/* cmp_int(stdout,"nre",-1,fr1->nre,fr2->nre); */
if ((fr1->nre >= nre) && (fr2->nre >= nre))
{
cmp_energies(stdout, fr1->step, fr1->step, fr1->ener, fr2->ener,
enm1, ftol, abstol, nre, ind1, ind2, maxener);
}
/*cmp_disres(fr1,fr2,ftol,abstol);*/
cmp_eblocks(fr1, fr2, ftol, abstol);
}
}
while (b1 && b2);
close_enx(in1);
close_enx(in2);
free_enxframe(fr2);
sfree(fr2);
free_enxframe(fr1);
sfree(fr1);
}
int gmx_eneconv(int argc,char *argv[])
{
static char *desc[] = {
"With [IT]multiple files[it] specified for the [TT]-f[tt] option:[BR]",
"Concatenates several energy files in sorted order.",
"In case of double time frames the one",
"in the later file is used. By specifying [TT]-settime[tt] you will be",
"asked for the start time of each file. The input files are taken",
"from the command line,",
"such that the command [TT]eneconv -o fixed.edr *.edr[tt] should do",
"the trick. [PAR]",
"With [IT]one file[it] specified for [TT]-f[tt]:[BR]",
"Reads one energy file and writes another, applying the [TT]-dt[tt],",
"[TT]-offset[tt], [TT]-t0[tt] and [TT]-settime[tt] options and",
"converting to a different format if necessary (indicated by file",
"extentions).[PAR]",
"[TT]-settime[tt] is applied first, then [TT]-dt[tt]/[TT]-offset[tt]",
"followed by [TT]-b[tt] and [TT]-e[tt] to select which frames to write."
};
static char *bugs[] = {
"When combining trajectories the sigma and E^2 (necessary for statistics) are not updated correctly. Only the actual energy is correct. One thus has to compute statistics in another way."
};
int in,out=0;
t_enxframe *fr,*fro;
t_energy *lastee,*startee;
int laststep,startstep,startstep_file=0,noutfr;
int nre,nremax,this_nre,nfile,i,j,kkk,nset,*set=NULL;
real t=0;
char **fnms;
char **enm=NULL;
real *readtime,*settime,timestep,t1,tadjust;
char inputstring[STRLEN],*chptr;
bool ok;
int *cont_type;
bool bNewFile,bFirst,bNewOutput;
t_filenm fnm[] = {
{ efENX, "-f", NULL, ffRDMULT },
{ efENX, "-o", "fixed", ffWRITE },
};
#define NFILE asize(fnm)
bool bWrite;
static real delta_t=0.0, toffset=0,scalefac=1;
static bool bSetTime=FALSE;
static bool bSort=TRUE,bError=TRUE;
static real begin=-1;
static real end=-1;
t_pargs pa[] = {
{ "-b", FALSE, etREAL, {&begin},
"First time to use"},
{ "-e", FALSE, etREAL, {&end},
"Last time to use"},
{ "-dt", FALSE, etREAL, {&delta_t},
"Only write out frame when t MOD dt = offset" },
{ "-offset", FALSE, etREAL, {&toffset},
"Time offset for -dt option" },
{ "-settime", FALSE, etBOOL, {&bSetTime},
"Change starting time interactively" },
{ "-sort", FALSE, etBOOL, {&bSort},
"Sort energy files (not frames)"},
{ "-scalefac", FALSE, etREAL, {&scalefac},
"Multiply energy component by this factor" },
{ "-error", FALSE, etBOOL, {&bError},
"Stop on errors in the file" }
};
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_BE_NICE ,
NFILE,fnm,asize(pa),pa,asize(desc),desc,asize(bugs),bugs);
tadjust = 0;
nremax = 0;
nset = 0;
timestep = 0.0;
snew(fnms,argc);
nfile=0;
laststep=startstep=0;
nfile = opt2fns(&fnms,"-f",NFILE,fnm);
if (!nfile)
gmx_fatal(FARGS,"No input files!");
snew(settime,nfile+1);
snew(readtime,nfile+1);
snew(cont_type,nfile+1);
nre=scan_ene_files(fnms,nfile,readtime,×tep,&nremax);
edit_files(fnms,nfile,readtime,settime,cont_type,bSetTime,bSort);
snew(fr,1);
snew(fro,1);
fro->t = -1;
fro->nre = nre;
snew(fro->ener,nremax);
if(nfile>1)
snew(lastee,nremax);
else
lastee=NULL;
snew(startee,nremax);
noutfr=0;
bFirst=TRUE;
for(i=0;i<nfile;i++) {
bNewFile=TRUE;
bNewOutput=TRUE;
in=open_enx(fnms[i],"r");
do_enxnms(in,&this_nre,&enm);
if(i==0) {
if (scalefac != 1)
set = select_it(nre,enm,&nset);
/* write names to the output file */
out=open_enx(opt2fn("-o",NFILE,fnm),"w");
do_enxnms(out,&nre,&enm);
}
/* start reading from the next file */
while((t<(settime[i+1]-GMX_REAL_EPS)) &&
do_enx(in,fr)) {
if(bNewFile) {
startstep_file = fr->step;
tadjust = settime[i] - fr->t;
if(cont_type[i+1]==TIME_LAST) {
settime[i+1] = readtime[i+1]-readtime[i]+settime[i];
cont_type[i+1] = TIME_EXPLICIT;
}
bNewFile = FALSE;
}
fro->step = laststep + fr->step - startstep_file;
t = tadjust + fr->t;
/*bWrite = ((begin<0 || (begin>=0 && (t >= begin-GMX_REAL_EPS))) &&
(end <0 || (end >=0 && (t <= end +GMX_REAL_EPS))) &&
(t < settime[i+1]-GMX_REAL_EPS));*/
bWrite = ((begin<0 || (begin>=0 && (t >= begin-GMX_REAL_EPS))) &&
(end <0 || (end >=0 && (t <= end +GMX_REAL_EPS))) &&
(t < settime[i+1]-0.5*timestep));
if (bError)
if ((end > 0) && (t > end+GMX_REAL_EPS)) {
i = nfile;
break;
}
if (t >= begin-GMX_REAL_EPS) {
if (bFirst) {
bFirst = FALSE;
startstep = fr->step;
if (begin > 0)
copy_ee(fr->ener,startee,nre);
}
update_ee(lastee,laststep,startee,startstep,
fr->ener,fro->step,fro->ener,nre);
}
/* determine if we should write it */
if (bWrite && (delta_t==0 || bRmod(t,toffset,delta_t))) {
fro->t = t;
if(bNewOutput) {
bNewOutput=FALSE;
fprintf(stderr,"\nContinue writing frames from t=%g, step=%d\n",
t,fro->step);
}
if (scalefac != 1) {
for(kkk=0; kkk<nset; kkk++) {
fro->ener[set[kkk]].e *= scalefac;
fro->ener[set[kkk]].eav *= scalefac;
fro->ener[set[kkk]].esum *= scalefac;
}
}
/* Copy restraint stuff */
fro->ndisre = fr->ndisre;
fro->disre_rm3tav = fr->disre_rm3tav;
fro->disre_rt = fr->disre_rt;
fro->nblock = fr->nblock;
fro->nr = fr->nr;
fro->block = fr->block;
do_enx(out,fro);
if (noutfr % 1000 == 0)
fprintf(stderr,"Writing frame time %g ",fro->t);
noutfr++;
}
}
/* copy statistics to old */
if (lastee != NULL) {
update_last_ee(lastee,laststep,fr->ener,fro->step,nre);
laststep = fro->step;
/* remove the last frame from statistics since gromacs2.0
* repeats it in the next file
*/
remove_last_eeframe(lastee,laststep,fr->ener,nre);
/* the old part now has (laststep) values, and the new (step+1) */
printf("laststep=%d step=%d\n",laststep,fro->step);
}
/* set the next time from the last in previous file */
if (cont_type[i+1]==TIME_CONTINUE) {
settime[i+1] = fro->t;
/* in this case we have already written the last frame of
* previous file, so update begin to avoid doubling it
* with the start of the next file
*/
begin = fro->t+0.5*timestep;
/* cont_type[i+1]==TIME_EXPLICIT; */
}
if ((fro->t < end) && (i < nfile-1) &&
(fro->t < settime[i+1]-1.5*timestep))
fprintf(stderr,
"\nWARNING: There might be a gap around t=%g\n",t);
/* move energies to lastee */
close_enx(in);
for(kkk=0; kkk<this_nre; kkk++)
sfree(enm[kkk]);
sfree(enm);
enm = NULL;
fprintf(stderr,"\n");
}
if (noutfr == 0)
fprintf(stderr,"No frames written.\n");
else {
fprintf(stderr,"Last frame written was at step %d, time %f\n",
fro->step,fro->t);
fprintf(stderr,"Wrote %d frames\n",noutfr);
}
thanx(stderr);
return 0;
}
void print_ebin(int fp_ene,bool bEne,bool bDR,bool bOR,
FILE *log,int step,int nsteps,real time,int mode,bool bCompact,
t_mdebin *md,t_fcdata *fcd,
gmx_groups_t *groups,t_grpopts *opts)
{
static char **grpnms=NULL;
static char *kjm="(kJ/mol)";
char buf[246];
int i,j,n,ni,nj,ndr,nor;
int nr[enxNR];
real *block[enxNR];
t_enxframe fr;
switch (mode) {
case eprNORMAL:
fr.t = time;
fr.step = step;
fr.nre = (bEne) ? md->ebin->nener : 0;
fr.ener = md->ebin->e;
fr.ndisre = bDR ? fcd->disres.npair : 0;
fr.disre_rm3tav = fcd->disres.rm3tav;
fr.disre_rt = fcd->disres.rt;
/* Optional additional blocks */
for(i=0; i<enxNR; i++)
nr[i] = 0;
if (fcd->orires.nr > 0 && bOR) {
diagonalize_orires_tensors(&(fcd->orires));
nr[enxOR] = fcd->orires.nr;
block[enxOR] = fcd->orires.otav;
nr[enxORI] = (fcd->orires.oinsl != fcd->orires.otav) ?
fcd->orires.nr : 0;
block[enxORI] = fcd->orires.oinsl;
nr[enxORT] = fcd->orires.nex*12;
block[enxORT] = fcd->orires.eig;
}
fr.nblock = 0;
for(i=0; i<enxNR; i++)
if (nr[i] > 0)
fr.nblock = i+1;
fr.nr = nr;
fr.block = block;
if (fr.nre || fr.ndisre || fr.nr[enxOR] || fr.nr[enxORI])
do_enx(fp_ene,&fr);
break;
case eprAVER:
if (log) pprint(log,"A V E R A G E S");
break;
case eprRMS:
if (log) pprint(log,"R M S - F L U C T U A T I O N S");
break;
default:
gmx_fatal(FARGS,"Invalid print mode (%d)",mode);
}
if (log) {
for(i=0;i<opts->ngtc;i++)
if(opts->annealing[i]!=eannNO)
fprintf(log,"Current ref_t for group %s: %8.1f\n",
*(groups->grpname[groups->grps[egcTC].nm_ind[i]]),opts->ref_t[i]);
if (mode==eprNORMAL && fcd->orires.nr>0)
print_orires_log(log,&(fcd->orires));
fprintf(log," Energies %s\n",kjm);
pr_ebin(log,md->ebin,md->ie,f_nre+nCrmsd,5,mode,nsteps,TRUE);
fprintf(log,"\n");
if (!bCompact) {
if (bDynBox) {
pr_ebin(log,md->ebin,md->ib, bTricl ? NTRICLBOXS : NBOXS,5,mode,
nsteps,TRUE);
fprintf(log,"\n");
}
if (bConstrVir) {
fprintf(log," Constraint Virial %s\n",kjm);
pr_ebin(log,md->ebin,md->isvir,9,3,mode,nsteps,FALSE);
fprintf(log,"\n");
fprintf(log," Force Virial %s\n",kjm);
pr_ebin(log,md->ebin,md->ifvir,9,3,mode,nsteps,FALSE);
fprintf(log,"\n");
}
fprintf(log," Total Virial %s\n",kjm);
pr_ebin(log,md->ebin,md->ivir,9,3,mode,nsteps,FALSE);
fprintf(log,"\n");
fprintf(log," Pressure (bar)\n");
pr_ebin(log,md->ebin,md->ipres,9,3,mode,nsteps,FALSE);
fprintf(log,"\n");
fprintf(log," Total Dipole (Debye)\n");
pr_ebin(log,md->ebin,md->imu,3,3,mode,nsteps,FALSE);
fprintf(log,"\n");
if (md->nE > 1) {
if (grpnms==NULL) {
snew(grpnms,md->nE);
n=0;
for(i=0; (i<md->nEg); i++) {
ni=groups->grps[egcENER].nm_ind[i];
for(j=i; (j<md->nEg); j++) {
nj=groups->grps[egcENER].nm_ind[j];
sprintf(buf,"%s-%s",*(groups->grpname[ni]),*(groups->grpname[nj]));
grpnms[n++]=strdup(buf);
}
}
}
sprintf(buf,"Epot %s",kjm);
fprintf(log,"%15s ",buf);
for(i=0; (i<egNR); i++)
if (bEInd[i])
fprintf(log,"%12s ",egrp_nm[i]);
fprintf(log,"\n");
for(i=0; (i<md->nE); i++) {
fprintf(log,"%15s",grpnms[i]);
pr_ebin(log,md->ebin,md->igrp[i],md->nEc,md->nEc,mode,nsteps,FALSE);
}
fprintf(log,"\n");
}
if (md->nTC > 1) {
pr_ebin(log,md->ebin,md->itemp,md->nTC,4,mode,nsteps,TRUE);
fprintf(log,"\n");
}
if (md->nU > 1) {
fprintf(log,"%15s %12s %12s %12s\n",
"Group","Ux","Uy","Uz");
for(i=0; (i<md->nU); i++) {
ni=groups->grps[egcACC].nm_ind[i];
fprintf(log,"%15s",*groups->grpname[ni]);
pr_ebin(log,md->ebin,md->iu+3*i,3,3,mode,nsteps,FALSE);
}
fprintf(log,"\n");
}
}
}
}
