static void pukeit(const char *db, const char *defstring, char *retstring,
int retsize, int *cqnum)
{
FILE *fp;
char **help;
int i, nhlp;
gmx_rng_t rng;
if (be_cool() && ((fp = low_libopen(db, FALSE)) != NULL))
{
nhlp = fget_lines(fp, &help);
/* for libraries we can use the low-level close routines */
gmx_ffclose(fp);
rng = gmx_rng_init(gmx_rng_make_seed());
*cqnum = static_cast<int>(nhlp*gmx_rng_uniform_real(rng));
gmx_rng_destroy(rng);
if (strlen(help[*cqnum]) >= STRLEN)
{
help[*cqnum][STRLEN-1] = '\0';
}
strncpy(retstring, help[*cqnum], retsize);
for (i = 0; (i < nhlp); i++)
{
sfree(help[i]);
}
sfree(help);
}
else
{
*cqnum = -1;
strncpy(retstring, defstring, retsize);
}
}
void maxwell_speed(real tempi, unsigned int seed, gmx_mtop_t *mtop, rvec v[])
{
gmx_rng_t rng;
if (seed == 0)
{
seed = gmx_rng_make_seed();
fprintf(stderr, "Using random seed %u for generating velocities\n", seed);
}
rng = gmx_rng_init(seed);
low_mspeed(tempi, mtop, v, rng);
gmx_rng_destroy(rng);
}
int gmx_genion(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] randomly replaces solvent molecules with monoatomic ions.",
"The group of solvent molecules should be continuous and all molecules",
"should have the same number of atoms.",
"The user should add the ion molecules to the topology file or use",
"the [TT]-p[tt] option to automatically modify the topology.[PAR]",
"The ion molecule type, residue and atom names in all force fields",
"are the capitalized element names without sign. This molecule name",
"should be given with [TT]-pname[tt] or [TT]-nname[tt], and the",
"[TT][molecules][tt] section of your topology updated accordingly,",
"either by hand or with [TT]-p[tt]. Do not use an atom name instead!",
"[PAR]Ions which can have multiple charge states get the multiplicity",
"added, without sign, for the uncommon states only.[PAR]",
"For larger ions, e.g. sulfate we recommended using [gmx-insert-molecules]."
};
const char *bugs[] = {
"If you specify a salt concentration existing ions are not taken into "
"account. In effect you therefore specify the amount of salt to be added.",
};
static int p_num = 0, n_num = 0, p_q = 1, n_q = -1;
static const char *p_name = "NA", *n_name = "CL";
static real rmin = 0.6, conc = 0;
static int seed = 1993;
static gmx_bool bNeutral = FALSE;
static t_pargs pa[] = {
{ "-np", FALSE, etINT, {&p_num}, "Number of positive ions" },
{ "-pname", FALSE, etSTR, {&p_name}, "Name of the positive ion" },
{ "-pq", FALSE, etINT, {&p_q}, "Charge of the positive ion" },
{ "-nn", FALSE, etINT, {&n_num}, "Number of negative ions" },
{ "-nname", FALSE, etSTR, {&n_name}, "Name of the negative ion" },
{ "-nq", FALSE, etINT, {&n_q}, "Charge of the negative ion" },
{ "-rmin", FALSE, etREAL, {&rmin}, "Minimum distance between ions" },
{ "-seed", FALSE, etINT, {&seed}, "Seed for random number generator" },
{ "-conc", FALSE, etREAL, {&conc},
"Specify salt concentration (mol/liter). This will add sufficient ions to reach up to the specified concentration as computed from the volume of the cell in the input [REF].tpr[ref] file. Overrides the [TT]-np[tt] and [TT]-nn[tt] options." },
{ "-neutral", FALSE, etBOOL, {&bNeutral}, "This option will add enough ions to neutralize the system. These ions are added on top of those specified with [TT]-np[tt]/[TT]-nn[tt] or [TT]-conc[tt]. "}
};
t_topology top;
rvec *x, *v;
real vol, qtot;
matrix box;
t_atoms atoms;
t_pbc pbc;
int *repl, ePBC;
atom_id *index;
char *grpname;
gmx_bool *bSet;
int i, nw, nwa, nsa, nsalt, iqtot;
gmx_output_env_t *oenv;
gmx_rng_t rng;
t_filenm fnm[] = {
{ efTPR, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efSTO, "-o", NULL, ffWRITE },
{ efTOP, "-p", "topol", ffOPTRW }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, asize(bugs), bugs, &oenv))
{
return 0;
}
/* Check input for something sensible */
if ((p_num < 0) || (n_num < 0))
{
gmx_fatal(FARGS, "Negative number of ions to add?");
}
if (conc > 0 && (p_num > 0 || n_num > 0))
{
fprintf(stderr, "WARNING: -conc specified, overriding -nn and -np.\n");
}
/* Read atom positions and charges */
read_tps_conf(ftp2fn(efTPR, NFILE, fnm), &top, &ePBC, &x, &v, box, FALSE);
atoms = top.atoms;
/* Compute total charge */
qtot = 0;
for (i = 0; (i < atoms.nr); i++)
{
qtot += atoms.atom[i].q;
}
iqtot = std::round(qtot);
if (conc > 0)
{
/* Compute number of ions to be added */
vol = det(box);
nsalt = std::round(conc*vol*AVOGADRO/1e24);
p_num = abs(nsalt*n_q);
n_num = abs(nsalt*p_q);
}
if (bNeutral)
{
int qdelta = p_num*p_q + n_num*n_q + iqtot;
/* Check if the system is neutralizable
* is (qdelta == p_q*p_num + n_q*n_num) solvable for p_num and n_num? */
int gcd = gmx_greatest_common_divisor(n_q, p_q);
if ((qdelta % gcd) != 0)
{
gmx_fatal(FARGS, "Can't neutralize this system using -nq %d and"
" -pq %d.\n", n_q, p_q);
}
while (qdelta != 0)
{
while (qdelta < 0)
{
p_num++;
qdelta += p_q;
}
while (qdelta > 0)
{
n_num++;
qdelta += n_q;
}
}
}
if ((p_num == 0) && (n_num == 0))
{
fprintf(stderr, "No ions to add, will just copy input configuration.\n");
}
else
{
printf("Will try to add %d %s ions and %d %s ions.\n",
p_num, p_name, n_num, n_name);
printf("Select a continuous group of solvent molecules\n");
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &nwa, &index, &grpname);
for (i = 1; i < nwa; i++)
{
if (index[i] != index[i-1]+1)
{
gmx_fatal(FARGS, "The solvent group %s is not continuous: "
"index[%d]=%d, index[%d]=%d",
grpname, i, index[i-1]+1, i+1, index[i]+1);
}
}
nsa = 1;
while ((nsa < nwa) &&
(atoms.atom[index[nsa]].resind ==
atoms.atom[index[nsa-1]].resind))
{
nsa++;
}
if (nwa % nsa)
{
gmx_fatal(FARGS, "Your solvent group size (%d) is not a multiple of %d",
nwa, nsa);
}
nw = nwa/nsa;
fprintf(stderr, "Number of (%d-atomic) solvent molecules: %d\n", nsa, nw);
if (p_num+n_num > nw)
{
gmx_fatal(FARGS, "Not enough solvent for adding ions");
}
if (opt2bSet("-p", NFILE, fnm))
{
update_topol(opt2fn("-p", NFILE, fnm), p_num, n_num, p_name, n_name, grpname);
}
snew(bSet, nw);
snew(repl, nw);
snew(v, atoms.nr);
snew(atoms.pdbinfo, atoms.nr);
set_pbc(&pbc, ePBC, box);
if (seed == 0)
{
rng = gmx_rng_init(gmx_rng_make_seed());
}
else
{
rng = gmx_rng_init(seed);
}
/* Now loop over the ions that have to be placed */
while (p_num-- > 0)
{
insert_ion(nsa, &nw, bSet, repl, index, x, &pbc,
1, p_q, p_name, &atoms, rmin, rng);
}
while (n_num-- > 0)
{
insert_ion(nsa, &nw, bSet, repl, index, x, &pbc,
-1, n_q, n_name, &atoms, rmin, rng);
}
gmx_rng_destroy(rng);
fprintf(stderr, "\n");
if (nw)
{
sort_ions(nsa, nw, repl, index, &atoms, x, p_name, n_name);
}
sfree(atoms.pdbinfo);
atoms.pdbinfo = NULL;
}
write_sto_conf(ftp2fn(efSTO, NFILE, fnm), *top.name, &atoms, x, NULL, ePBC, box);
return 0;
}
gmx_repl_ex_t init_replica_exchange(FILE *fplog,
const gmx_multisim_t *ms,
const t_state *state,
const t_inputrec *ir,
int nst, int nex, int init_seed)
{
real temp, pres;
int i, j, k;
struct gmx_repl_ex *re;
gmx_bool bTemp;
gmx_bool bLambda = FALSE;
fprintf(fplog, "\nInitializing Replica Exchange\n");
if (ms == NULL || ms->nsim == 1)
{
gmx_fatal(FARGS, "Nothing to exchange with only one replica, maybe you forgot to set the -multi option of mdrun?");
}
if (!EI_DYNAMICS(ir->eI))
{
gmx_fatal(FARGS, "Replica exchange is only supported by dynamical simulations");
/* Note that PAR(cr) is defined by cr->nnodes > 1, which is
* distinct from MULTISIM(cr). A multi-simulation only runs
* with real MPI parallelism, but this does not imply PAR(cr)
* is true!
*
* Since we are using a dynamical integrator, the only
* decomposition is DD, so PAR(cr) and DOMAINDECOMP(cr) are
* synonymous. The only way for cr->nnodes > 1 to be true is
* if we are using DD. */
}
snew(re, 1);
re->repl = ms->sim;
re->nrepl = ms->nsim;
snew(re->q, ereENDSINGLE);
fprintf(fplog, "Repl There are %d replicas:\n", re->nrepl);
check_multi_int(fplog, ms, state->natoms, "the number of atoms", FALSE);
check_multi_int(fplog, ms, ir->eI, "the integrator", FALSE);
check_multi_int64(fplog, ms, ir->init_step+ir->nsteps, "init_step+nsteps", FALSE);
check_multi_int64(fplog, ms, (ir->init_step+nst-1)/nst,
"first exchange step: init_step/-replex", FALSE);
check_multi_int(fplog, ms, ir->etc, "the temperature coupling", FALSE);
check_multi_int(fplog, ms, ir->opts.ngtc,
"the number of temperature coupling groups", FALSE);
check_multi_int(fplog, ms, ir->epc, "the pressure coupling", FALSE);
check_multi_int(fplog, ms, ir->efep, "free energy", FALSE);
check_multi_int(fplog, ms, ir->fepvals->n_lambda, "number of lambda states", FALSE);
re->temp = ir->opts.ref_t[0];
for (i = 1; (i < ir->opts.ngtc); i++)
{
if (ir->opts.ref_t[i] != re->temp)
{
fprintf(fplog, "\nWARNING: The temperatures of the different temperature coupling groups are not identical\n\n");
fprintf(stderr, "\nWARNING: The temperatures of the different temperature coupling groups are not identical\n\n");
}
}
re->type = -1;
bTemp = repl_quantity(ms, re, ereTEMP, re->temp);
if (ir->efep != efepNO)
{
bLambda = repl_quantity(ms, re, ereLAMBDA, (real)ir->fepvals->init_fep_state);
}
if (re->type == -1) /* nothing was assigned */
{
gmx_fatal(FARGS, "The properties of the %d systems are all the same, there is nothing to exchange", re->nrepl);
}
if (bLambda && bTemp)
{
re->type = ereTL;
}
if (bTemp)
{
please_cite(fplog, "Sugita1999a");
if (ir->epc != epcNO)
{
re->bNPT = TRUE;
fprintf(fplog, "Repl Using Constant Pressure REMD.\n");
please_cite(fplog, "Okabe2001a");
}
if (ir->etc == etcBERENDSEN)
{
gmx_fatal(FARGS, "REMD with the %s thermostat does not produce correct potential energy distributions, consider using the %s thermostat instead",
ETCOUPLTYPE(ir->etc), ETCOUPLTYPE(etcVRESCALE));
}
}
if (bLambda)
{
if (ir->fepvals->delta_lambda != 0) /* check this? */
{
gmx_fatal(FARGS, "delta_lambda is not zero");
}
}
if (re->bNPT)
{
snew(re->pres, re->nrepl);
if (ir->epct == epctSURFACETENSION)
{
pres = ir->ref_p[ZZ][ZZ];
}
else
{
pres = 0;
j = 0;
for (i = 0; i < DIM; i++)
{
if (ir->compress[i][i] != 0)
{
pres += ir->ref_p[i][i];
j++;
}
}
pres /= j;
}
re->pres[re->repl] = pres;
gmx_sum_sim(re->nrepl, re->pres, ms);
}
/* Make an index for increasing replica order */
/* only makes sense if one or the other is varying, not both!
if both are varying, we trust the order the person gave. */
snew(re->ind, re->nrepl);
for (i = 0; i < re->nrepl; i++)
{
re->ind[i] = i;
}
if (re->type < ereENDSINGLE)
{
for (i = 0; i < re->nrepl; i++)
{
for (j = i+1; j < re->nrepl; j++)
{
if (re->q[re->type][re->ind[j]] < re->q[re->type][re->ind[i]])
{
k = re->ind[i];
re->ind[i] = re->ind[j];
re->ind[j] = k;
}
else if (re->q[re->type][re->ind[j]] == re->q[re->type][re->ind[i]])
{
gmx_fatal(FARGS, "Two replicas have identical %ss", erename[re->type]);
}
}
}
}
/* keep track of all the swaps, starting with the initial placement. */
snew(re->allswaps, re->nrepl);
for (i = 0; i < re->nrepl; i++)
{
re->allswaps[i] = re->ind[i];
}
switch (re->type)
{
case ereTEMP:
fprintf(fplog, "\nReplica exchange in temperature\n");
for (i = 0; i < re->nrepl; i++)
{
fprintf(fplog, " %5.1f", re->q[re->type][re->ind[i]]);
}
fprintf(fplog, "\n");
break;
case ereLAMBDA:
fprintf(fplog, "\nReplica exchange in lambda\n");
for (i = 0; i < re->nrepl; i++)
{
fprintf(fplog, " %3d", (int)re->q[re->type][re->ind[i]]);
}
fprintf(fplog, "\n");
break;
case ereTL:
fprintf(fplog, "\nReplica exchange in temperature and lambda state\n");
for (i = 0; i < re->nrepl; i++)
{
fprintf(fplog, " %5.1f", re->q[ereTEMP][re->ind[i]]);
}
fprintf(fplog, "\n");
for (i = 0; i < re->nrepl; i++)
{
fprintf(fplog, " %5d", (int)re->q[ereLAMBDA][re->ind[i]]);
}
fprintf(fplog, "\n");
break;
default:
gmx_incons("Unknown replica exchange quantity");
}
if (re->bNPT)
{
fprintf(fplog, "\nRepl p");
for (i = 0; i < re->nrepl; i++)
{
fprintf(fplog, " %5.2f", re->pres[re->ind[i]]);
}
for (i = 0; i < re->nrepl; i++)
{
if ((i > 0) && (re->pres[re->ind[i]] < re->pres[re->ind[i-1]]))
{
fprintf(fplog, "\nWARNING: The reference pressures decrease with increasing temperatures\n\n");
fprintf(stderr, "\nWARNING: The reference pressures decrease with increasing temperatures\n\n");
}
}
}
re->nst = nst;
if (init_seed == -1)
{
if (MASTERSIM(ms))
{
re->seed = (int)gmx_rng_make_seed();
}
else
{
re->seed = 0;
}
gmx_sumi_sim(1, &(re->seed), ms);
}
else
{
re->seed = init_seed;
}
fprintf(fplog, "\nReplica exchange interval: %d\n", re->nst);
fprintf(fplog, "\nReplica random seed: %d\n", re->seed);
re->rng = gmx_rng_init(re->seed);
re->nattempt[0] = 0;
re->nattempt[1] = 0;
snew(re->prob_sum, re->nrepl);
snew(re->nexchange, re->nrepl);
snew(re->nmoves, re->nrepl);
for (i = 0; i < re->nrepl; i++)
{
snew(re->nmoves[i], re->nrepl);
}
fprintf(fplog, "Replica exchange information below: x=exchange, pr=probability\n");
/* generate space for the helper functions so we don't have to snew each time */
snew(re->destinations, re->nrepl);
snew(re->incycle, re->nrepl);
snew(re->tmpswap, re->nrepl);
snew(re->cyclic, re->nrepl);
snew(re->order, re->nrepl);
for (i = 0; i < re->nrepl; i++)
{
snew(re->cyclic[i], re->nrepl);
snew(re->order[i], re->nrepl);
}
/* allocate space for the functions storing the data for the replicas */
/* not all of these arrays needed in all cases, but they don't take
up much space, since the max size is nrepl**2 */
snew(re->prob, re->nrepl);
snew(re->bEx, re->nrepl);
snew(re->beta, re->nrepl);
snew(re->Vol, re->nrepl);
snew(re->Epot, re->nrepl);
snew(re->de, re->nrepl);
for (i = 0; i < re->nrepl; i++)
{
snew(re->de[i], re->nrepl);
}
re->nex = nex;
return re;
}
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[] = {
{ efTPR, NULL, NULL, ffREAD },
{ efTRN, "-f", NULL, ffOPTRD },
{ efEDR, "-e", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTPR, "-o", "tprout", 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(efTPR, 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_nmens(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] generates an ensemble around an average structure",
"in a subspace that is defined by a set of normal modes (eigenvectors).",
"The eigenvectors are assumed to be mass-weighted.",
"The position along each eigenvector is randomly taken from a Gaussian",
"distribution with variance kT/eigenvalue.[PAR]",
"By default the starting eigenvector is set to 7, since the first six",
"normal modes are the translational and rotational degrees of freedom."
};
static int nstruct = 100, first = 7, last = -1, seed = -1;
static real temp = 300.0;
t_pargs pa[] = {
{ "-temp", FALSE, etREAL, {&temp},
"Temperature in Kelvin" },
{ "-seed", FALSE, etINT, {&seed},
"Random seed, -1 generates a seed from time and pid" },
{ "-num", FALSE, etINT, {&nstruct},
"Number of structures to generate" },
{ "-first", FALSE, etINT, {&first},
"First eigenvector to use (-1 is select)" },
{ "-last", FALSE, etINT, {&last},
"Last eigenvector to use (-1 is till the last)" }
};
#define NPA asize(pa)
t_trxstatus *out;
int status, trjout;
t_topology top;
int ePBC;
t_atoms *atoms;
rvec *xtop, *xref, *xav, *xout1, *xout2;
gmx_bool bDMR, bDMA, bFit;
int nvec, *eignr = NULL;
rvec **eigvec = NULL;
matrix box;
real *eigval, totmass, *invsqrtm, t, disp;
int natoms, neigval;
char *grpname, title[STRLEN];
const char *indexfile;
int i, j, d, s, v;
int nout, *iout, noutvec, *outvec;
atom_id *index;
real rfac, invfr, rhalf, jr;
int * eigvalnr;
output_env_t oenv;
gmx_rng_t rng;
unsigned long jran;
const unsigned long im = 0xffff;
const unsigned long ia = 1093;
const unsigned long ic = 18257;
t_filenm fnm[] = {
{ efTRN, "-v", "eigenvec", ffREAD },
{ efXVG, "-e", "eigenval", ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTRO, "-o", "ensemble", ffWRITE }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_BE_NICE,
NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
indexfile = ftp2fn_null(efNDX, NFILE, fnm);
read_eigenvectors(opt2fn("-v", NFILE, fnm), &natoms, &bFit,
&xref, &bDMR, &xav, &bDMA, &nvec, &eignr, &eigvec, &eigval);
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC, &xtop, NULL, box, bDMA);
atoms = &top.atoms;
printf("\nSelect an index group of %d elements that corresponds to the eigenvectors\n", natoms);
get_index(atoms, indexfile, 1, &i, &index, &grpname);
if (i != natoms)
{
gmx_fatal(FARGS, "you selected a group with %d elements instead of %d",
i, natoms);
}
printf("\n");
snew(invsqrtm, natoms);
if (bDMA)
{
for (i = 0; (i < natoms); i++)
{
invsqrtm[i] = gmx_invsqrt(atoms->atom[index[i]].m);
}
}
else
{
for (i = 0; (i < natoms); i++)
{
invsqrtm[i] = 1.0;
}
}
if (last == -1)
{
last = natoms*DIM;
}
if (first > -1)
{
/* make an index from first to last */
nout = last-first+1;
snew(iout, nout);
for (i = 0; i < nout; i++)
{
iout[i] = first-1+i;
}
}
else
{
printf("Select eigenvectors for output, end your selection with 0\n");
nout = -1;
iout = NULL;
do
{
nout++;
srenew(iout, nout+1);
if (1 != scanf("%d", &iout[nout]))
{
gmx_fatal(FARGS, "Error reading user input");
}
iout[nout]--;
}
while (iout[nout] >= 0);
printf("\n");
}
/* make an index of the eigenvectors which are present */
snew(outvec, nout);
noutvec = 0;
for (i = 0; i < nout; i++)
{
j = 0;
while ((j < nvec) && (eignr[j] != iout[i]))
{
j++;
}
if ((j < nvec) && (eignr[j] == iout[i]))
{
outvec[noutvec] = j;
iout[noutvec] = iout[i];
noutvec++;
}
}
fprintf(stderr, "%d eigenvectors selected for output\n", noutvec);
if (seed == -1)
{
seed = (int)gmx_rng_make_seed();
rng = gmx_rng_init(seed);
}
else
{
rng = gmx_rng_init(seed);
}
fprintf(stderr, "Using seed %d and a temperature of %g K\n", seed, temp);
snew(xout1, natoms);
snew(xout2, atoms->nr);
out = open_trx(ftp2fn(efTRO, NFILE, fnm), "w");
jran = (unsigned long)((real)im*gmx_rng_uniform_real(rng));
gmx_rng_destroy(rng);
for (s = 0; s < nstruct; s++)
{
for (i = 0; i < natoms; i++)
{
copy_rvec(xav[i], xout1[i]);
}
for (j = 0; j < noutvec; j++)
{
v = outvec[j];
/* (r-0.5) n times: var_n = n * var_1 = n/12
n=4: var_n = 1/3, so multiply with 3 */
rfac = sqrt(3.0 * BOLTZ*temp/eigval[iout[j]]);
rhalf = 2.0*rfac;
rfac = rfac/(real)im;
jran = (jran*ia+ic) & im;
jr = (real)jran;
jran = (jran*ia+ic) & im;
jr += (real)jran;
jran = (jran*ia+ic) & im;
jr += (real)jran;
jran = (jran*ia+ic) & im;
jr += (real)jran;
disp = rfac * jr - rhalf;
for (i = 0; i < natoms; i++)
{
for (d = 0; d < DIM; d++)
{
xout1[i][d] += disp*eigvec[v][i][d]*invsqrtm[i];
}
}
}
for (i = 0; i < natoms; i++)
{
copy_rvec(xout1[i], xout2[index[i]]);
}
t = s+1;
write_trx(out, natoms, index, atoms, 0, t, box, xout2, NULL, NULL);
fprintf(stderr, "\rGenerated %d structures", s+1);
}
fprintf(stderr, "\n");
close_trx(out);
return 0;
}
int gmx_genconf(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] multiplies a given coordinate file by simply stacking them",
"on top of each other, like a small child playing with wooden blocks.",
"The program makes a grid of [IT]user-defined[it]",
"proportions ([TT]-nbox[tt]), ",
"and interspaces the grid point with an extra space [TT]-dist[tt].[PAR]",
"When option [TT]-rot[tt] is used the program does not check for overlap",
"between molecules on grid points. It is recommended to make the box in",
"the input file at least as big as the coordinates + ",
"van der Waals radius.[PAR]",
"If the optional trajectory file is given, conformations are not",
"generated, but read from this file and translated appropriately to",
"build the grid."
};
const char *bugs[] = {
"The program should allow for random displacement of lattice points."
};
int vol;
t_atoms *atoms; /* list with all atoms */
rvec *x, *xx, *v; /* coordinates? */
real t;
vec4 *xrot, *vrot;
int ePBC;
matrix box, boxx; /* box length matrix */
rvec shift;
int natoms; /* number of atoms in one molecule */
int nres; /* number of molecules? */
int i, j, k, l, m, ndx, nrdx, nx, ny, nz;
t_trxstatus *status;
gmx_bool bTRX;
gmx_output_env_t *oenv;
gmx_rng_t rng;
t_filenm fnm[] = {
{ efSTX, "-f", "conf", ffREAD },
{ efSTO, "-o", "out", ffWRITE },
{ efTRX, "-trj", NULL, ffOPTRD }
};
#define NFILE asize(fnm)
static rvec nrbox = {1, 1, 1};
static int seed = 0; /* seed for random number generator */
static int nmolat = 3;
static int nblock = 1;
static gmx_bool bShuffle = FALSE;
static gmx_bool bSort = FALSE;
static gmx_bool bRandom = FALSE; /* False: no random rotations */
static gmx_bool bRenum = TRUE; /* renumber residues */
static rvec dist = {0, 0, 0}; /* space added between molecules ? */
static rvec max_rot = {180, 180, 180}; /* maximum rotation */
t_pargs pa[] = {
{ "-nbox", FALSE, etRVEC, {nrbox}, "Number of boxes" },
{ "-dist", FALSE, etRVEC, {dist}, "Distance between boxes" },
{ "-seed", FALSE, etINT, {&seed},
"Random generator seed, if 0 generated from the time" },
{ "-rot", FALSE, etBOOL, {&bRandom}, "Randomly rotate conformations" },
{ "-shuffle", FALSE, etBOOL, {&bShuffle}, "Random shuffling of molecules" },
{ "-sort", FALSE, etBOOL, {&bSort}, "Sort molecules on X coord" },
{ "-block", FALSE, etINT, {&nblock},
"Divide the box in blocks on this number of cpus" },
{ "-nmolat", FALSE, etINT, {&nmolat},
"Number of atoms per molecule, assumed to start from 0. "
"If you set this wrong, it will screw up your system!" },
{ "-maxrot", FALSE, etRVEC, {max_rot}, "Maximum random rotation" },
{ "-renumber", FALSE, etBOOL, {&bRenum}, "Renumber residues" }
};
if (!parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, asize(bugs), bugs, &oenv))
{
return 0;
}
if (seed == 0)
{
rng = gmx_rng_init(gmx_rng_make_seed());
}
else
{
rng = gmx_rng_init(seed);
}
bTRX = ftp2bSet(efTRX, NFILE, fnm);
nx = (int)(nrbox[XX]+0.5);
ny = (int)(nrbox[YY]+0.5);
nz = (int)(nrbox[ZZ]+0.5);
if ((nx <= 0) || (ny <= 0) || (nz <= 0))
{
gmx_fatal(FARGS, "Number of boxes (-nbox) should be larger than zero");
}
if ((nmolat <= 0) && bShuffle)
{
gmx_fatal(FARGS, "Can not shuffle if the molecules only have %d atoms",
nmolat);
}
vol = nx*ny*nz; /* calculate volume in grid points (= nr. molecules) */
t_topology *top;
snew(top, 1);
atoms = &top->atoms;
read_tps_conf(opt2fn("-f", NFILE, fnm), top, &ePBC, &x, &v, box, FALSE);
natoms = atoms->nr;
nres = atoms->nres; /* nr of residues in one element? */
/* make space for all the atoms */
add_t_atoms(atoms, natoms*(vol-1), nres*(vol-1));
srenew(x, natoms*vol); /* get space for coordinates of all atoms */
srenew(v, natoms*vol); /* velocities. not really needed? */
snew(xrot, natoms); /* get space for rotation matrix? */
snew(vrot, natoms);
if (bTRX)
{
if (!read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &xx, boxx))
{
gmx_fatal(FARGS, "No atoms in trajectory %s", ftp2fn(efTRX, NFILE, fnm));
}
}
else
{
snew(xx, natoms);
for (i = 0; i < natoms; i++)
{
copy_rvec(x[i], xx[i]);
}
}
for (k = 0; (k < nz); k++) /* loop over all gridpositions */
{
shift[ZZ] = k*(dist[ZZ]+box[ZZ][ZZ]);
for (j = 0; (j < ny); j++)
{
shift[YY] = j*(dist[YY]+box[YY][YY])+k*box[ZZ][YY];
for (i = 0; (i < nx); i++)
{
shift[XX] = i*(dist[XX]+box[XX][XX])+j*box[YY][XX]+k*box[ZZ][XX];
ndx = (i*ny*nz+j*nz+k)*natoms;
nrdx = (i*ny*nz+j*nz+k)*nres;
/* Random rotation on input coords */
if (bRandom)
{
rand_rot(natoms, xx, v, xrot, vrot, rng, max_rot);
}
for (l = 0; (l < natoms); l++)
{
for (m = 0; (m < DIM); m++)
{
if (bRandom)
{
x[ndx+l][m] = xrot[l][m];
v[ndx+l][m] = vrot[l][m];
}
else
{
x[ndx+l][m] = xx[l][m];
v[ndx+l][m] = v[l][m];
}
}
if (ePBC == epbcSCREW && i % 2 == 1)
{
/* Rotate around x axis */
for (m = YY; m <= ZZ; m++)
{
x[ndx+l][m] = box[YY][m] + box[ZZ][m] - x[ndx+l][m];
v[ndx+l][m] = -v[ndx+l][m];
}
}
for (m = 0; (m < DIM); m++)
{
x[ndx+l][m] += shift[m];
}
atoms->atom[ndx+l].resind = nrdx + atoms->atom[l].resind;
atoms->atomname[ndx+l] = atoms->atomname[l];
}
for (l = 0; (l < nres); l++)
{
atoms->resinfo[nrdx+l] = atoms->resinfo[l];
if (bRenum)
{
atoms->resinfo[nrdx+l].nr += nrdx;
}
}
if (bTRX)
{
if (!read_next_x(oenv, status, &t, xx, boxx) &&
((i+1)*(j+1)*(k+1) < vol))
{
gmx_fatal(FARGS, "Not enough frames in trajectory");
}
}
}
}
}
if (bTRX)
{
close_trj(status);
}
/* make box bigger */
for (m = 0; (m < DIM); m++)
{
box[m][m] += dist[m];
}
svmul(nx, box[XX], box[XX]);
svmul(ny, box[YY], box[YY]);
svmul(nz, box[ZZ], box[ZZ]);
if (ePBC == epbcSCREW && nx % 2 == 0)
{
/* With an even number of boxes in x we can forgot about the screw */
ePBC = epbcXYZ;
}
/* move_x(natoms*vol,x,box); */ /* put atoms in box? */
atoms->nr *= vol;
atoms->nres *= vol;
/*depending on how you look at it, this is either a nasty hack or the way it should work*/
if (bRenum)
{
for (i = 0; i < atoms->nres; i++)
{
atoms->resinfo[i].nr = i+1;
}
}
if (bShuffle)
{
randwater(0, atoms->nr/nmolat, nmolat, x, v, rng);
}
else if (bSort)
{
sortwater(0, atoms->nr/nmolat, nmolat, x, v);
}
else if (opt2parg_bSet("-block", asize(pa), pa))
{
mkcompact(0, atoms->nr/nmolat, nmolat, x, v, nblock, box);
}
gmx_rng_destroy(rng);
write_sto_conf(opt2fn("-o", NFILE, fnm), *top->name, atoms, x, v, ePBC, box);
return 0;
}
