static void check_cg_sizes(char *topfn,t_block *cgs)
{
int maxsize,cg;
maxsize = 0;
for(cg=0; cg<cgs->nr; cg++)
maxsize = max(maxsize,cgs->index[cg+1]-cgs->index[cg]);
if (maxsize > 10) {
set_warning_line(topfn,-1);
sprintf(warn_buf,
"The largest charge group contains %d atoms.\n"
"Since atoms only see each other when the centers of geometry of the charge groups they belong to are within the cut-off distance, too large charge groups can lead to serious cut-off artifacts.\n"
"For efficiency and accuracy, charge group should consist of a few atoms.\n"
"For all-atom force fields use: CH3, CH2, CH, NH2, NH, OH, CO2, CO, etc.",
maxsize);
warning_note(warn_buf);
}
}
t_inpfile *read_inpfile(const char *fn, int *ninp,
char **cppopts,
warninp_t wi)
{
FILE *in;
char buf[STRLEN], lbuf[STRLEN], rbuf[STRLEN], warn_buf[STRLEN];
char *ptr, *cptr;
t_inpfile *inp = NULL;
int nin, lc, i, j, k;
/* setting cppopts from command-line options would be cooler */
gmx_bool allow_override = FALSE;
if (debug)
{
fprintf(debug, "Reading MDP file %s\n", fn);
}
in = ffopen(fn, "r");
nin = lc = 0;
do
{
ptr = fgets2(buf, STRLEN-1, in);
lc++;
set_warning_line(wi, fn, lc);
if (ptr)
{
/* Strip comment */
if ((cptr = strchr(buf, COMMENTSIGN)) != NULL)
{
*cptr = '\0';
}
/* Strip spaces */
trim(buf);
for (j = 0; (buf[j] != '=') && (buf[j] != '\0'); j++)
{
;
}
if (buf[j] == '\0')
{
if (j > 0)
{
if (debug)
{
fprintf(debug, "No = on line %d in file %s, ignored\n", lc, fn);
}
}
}
else
{
for (i = 0; (i < j); i++)
{
lbuf[i] = buf[i];
}
lbuf[i] = '\0';
trim(lbuf);
if (lbuf[0] == '\0')
{
if (debug)
{
fprintf(debug, "Empty left hand side on line %d in file %s, ignored\n", lc, fn);
}
}
else
{
for (i = j+1, k = 0; (buf[i] != '\0'); i++, k++)
{
rbuf[k] = buf[i];
}
rbuf[k] = '\0';
trim(rbuf);
if (rbuf[0] == '\0')
{
if (debug)
{
fprintf(debug, "Empty right hand side on line %d in file %s, ignored\n", lc, fn);
}
}
else
{
/* Now finally something sensible */
int found_index;
/* first check whether we hit the 'multiple_entries' option */
if (gmx_strcasecmp_min(eMultentOpt_names[eMultentOptName], lbuf) == 0)
{
/* we now check whether to allow overrides from here or not */
if (gmx_strcasecmp_min(eMultentOpt_names[eMultentOptNo], rbuf) == 0)
{
allow_override = FALSE;
}
else if (gmx_strcasecmp_min(eMultentOpt_names[eMultentOptLast], rbuf) == 0)
{
allow_override = TRUE;
}
else
{
sprintf(warn_buf,
"Parameter \"%s\" should either be %s or %s\n",
lbuf,
eMultentOpt_names[eMultentOptNo],
eMultentOpt_names[eMultentOptLast]);
warning_error(wi, warn_buf);
}
}
else
{
/* it is a regular option; check for duplicates */
found_index = search_einp(nin, inp, lbuf);
if (found_index == -1)
{
/* add a new item */
srenew(inp, ++nin);
inp[nin-1].inp_count = 1;
inp[nin-1].count = 0;
inp[nin-1].bObsolete = FALSE;
inp[nin-1].bSet = FALSE;
inp[nin-1].name = strdup(lbuf);
inp[nin-1].value = strdup(rbuf);
}
else
{
if (!allow_override)
{
sprintf(warn_buf,
"Parameter \"%s\" doubly defined (and multiple assignments not allowed)\n",
lbuf);
warning_error(wi, warn_buf);
}
else
{
/* override */
sfree(inp[found_index].value);
inp[found_index].value = strdup(rbuf);
sprintf(warn_buf,
"Overriding existing parameter \"%s\" with value \"%s\"\n",
lbuf, rbuf);
warning_note(wi, warn_buf);
}
}
}
}
}
}
}
}
while (ptr);
ffclose(in);
if (debug)
{
fprintf(debug, "Done reading MDP file, there were %d entries in there\n",
nin);
}
*ninp = nin;
return inp;
}
static void init_pull_coord(t_pull_coord *pcrd, int coord_index_for_output,
char *dim_buf,
const char *origin_buf, const char *vec_buf,
warninp_t wi)
{
int m;
dvec origin, vec;
char buf[STRLEN];
if (pcrd->eType == epullCONSTRAINT && (pcrd->eGeom == epullgCYL ||
pcrd->eGeom == epullgDIRRELATIVE ||
pcrd->eGeom == epullgANGLE ||
pcrd->eGeom == epullgANGLEAXIS ||
pcrd->eGeom == epullgDIHEDRAL))
{
gmx_fatal(FARGS, "Pulling of type %s can not be combined with geometry %s. Consider using pull type %s.",
epull_names[pcrd->eType],
epullg_names[pcrd->eGeom],
epull_names[epullUMBRELLA]);
}
if (pcrd->eType == epullEXTERNAL)
{
if (pcrd->externalPotentialProvider[0] == '\0')
{
sprintf(buf, "The use of pull type '%s' for pull coordinate %d requires that the name of the module providing the potential external is set with the option %s%d%s",
epull_names[pcrd->eType], coord_index_for_output,
"pull-coord", coord_index_for_output, "-potential-provider");
warning_error(wi, buf);
}
if (pcrd->rate != 0)
{
sprintf(buf, "The use of pull type '%s' for pull coordinate %d requires that the pull rate is zero",
epull_names[pcrd->eType], coord_index_for_output);
warning_error(wi, buf);
}
if (pcrd->eGeom == epullgCYL)
{
/* Warn the user of a PBC restriction, caused by the fact that
* there is no reference value with an external pull potential.
*/
sprintf(buf, "With pull type '%s' and geometry '%s', the distance component along the cylinder axis between atoms in the cylinder group and the COM of the pull group should be smaller than half the box length",
epull_names[pcrd->eType], epullg_names[pcrd->eGeom]);
warning_note(wi, buf);
}
}
process_pull_dim(dim_buf, pcrd->dim, pcrd);
string2dvec(origin_buf, origin);
if (pcrd->group[0] != 0 && dnorm(origin) > 0)
{
gmx_fatal(FARGS, "The pull origin can only be set with an absolute reference");
}
/* Check the given initial reference value and warn for dangerous values */
if (pcrd->eGeom == epullgDIST)
{
if (pcrd->bStart && pcrd->init < 0)
{
sprintf(buf, "The initial reference distance set by pull-coord-init is set to a negative value (%g) with geometry %s while distances need to be non-negative. "
"This may work, since you have set pull-coord-start to 'yes' which modifies this value, but only for certain starting distances. "
"If this is a mistake you may want to use geometry %s instead.",
pcrd->init, EPULLGEOM(pcrd->eGeom), EPULLGEOM(epullgDIR));
warning(wi, buf);
}
}
else if (pcrd->eGeom == epullgANGLE || pcrd->eGeom == epullgANGLEAXIS)
{
if (pcrd->bStart && (pcrd->init < 0 || pcrd->init > 180))
{
/* This value of pcrd->init may be ok depending on pcrd->bStart which modifies pcrd->init later on */
sprintf(buf, "The initial reference angle set by pull-coord-init (%g) is outside of the allowed range [0, 180] degrees for geometry (%s). "
"This may work, since you have set pull-coord-start to 'yes' which modifies this value, but only for certain starting angles.",
pcrd->init, EPULLGEOM(pcrd->eGeom));
warning(wi, buf);
}
}
else if (pcrd->eGeom == epullgDIHEDRAL)
{
if (pcrd->bStart && (pcrd->init < -180 || pcrd->init > 180))
{
sprintf(buf, "The initial reference angle set by pull-coord-init (%g) is outside of the allowed range [-180, 180] degrees for geometry (%s). "
"This may work, since you have set pull-coord-start to 'yes' which modifies this value, but only for certain starting angles.",
pcrd->init, EPULLGEOM(pcrd->eGeom));
warning(wi, buf);
}
}
/* Check and set the pull vector */
clear_dvec(vec);
string2dvec(vec_buf, vec);
if (pcrd->eGeom == epullgDIR || pcrd->eGeom == epullgCYL || pcrd->eGeom == epullgDIRPBC || pcrd->eGeom == epullgANGLEAXIS)
{
if (dnorm2(vec) == 0)
{
gmx_fatal(FARGS, "With pull geometry %s the pull vector can not be 0,0,0",
epullg_names[pcrd->eGeom]);
}
for (int d = 0; d < DIM; d++)
{
if (vec[d] != 0 && pcrd->dim[d] == 0)
{
gmx_fatal(FARGS, "pull-coord-vec has non-zero %c-component while pull_dim for the %c-dimension is set to N", 'x'+d, 'x'+d);
}
}
/* Normalize the direction vector */
dsvmul(1/dnorm(vec), vec, vec);
}
else /* This case is for are all the geometries where the pull vector is not used */
{
if (dnorm2(vec) > 0)
{
sprintf(buf, "A pull vector is given (%g %g %g) but will not be used with geometry %s. If you really want to use this "
"vector, consider using geometry %s instead.",
vec[0], vec[1], vec[2], EPULLGEOM(pcrd->eGeom),
pcrd->eGeom == epullgANGLE ? EPULLGEOM(epullgANGLEAXIS) : EPULLGEOM(epullgDIR));
warning(wi, buf);
}
}
for (m = 0; m < DIM; m++)
{
pcrd->origin[m] = origin[m];
pcrd->vec[m] = vec[m];
}
}
/*! \brief
* Read parameters of an AWH bias.
*
* \param[in,out] ninp_p Number of read input file entries.
* \param[in,out] inp_p Input file entries.
* \param[in,out] awhBiasParams AWH dimensional parameters.
* \param[in] prefix Prefix for bias parameters.
* \param[in] ir Input parameter struct.
* \param[in,out] wi Struct for bookeeping warnings.
* \param[in] bComment True if comments should be printed.
*/
static void read_bias_params(int *ninp_p, t_inpfile **inp_p, AwhBiasParams *awhBiasParams, const char *prefix,
const t_inputrec *ir, warninp_t wi, bool bComment)
{
int ninp;
t_inpfile *inp;
char opt[STRLEN], prefixdim[STRLEN];
char warningmsg[STRLEN];
/* These are assumed to be declared by the gromacs reading functions */
ninp = *ninp_p;
inp = *inp_p;
if (bComment)
{
CTYPE("Estimated initial PMF error (kJ/mol)");
}
sprintf(opt, "%s-error-init", prefix);
/* We allow using a default value here without warning (but warn the user if the diffusion constant is not set). */
RTYPE(opt, awhBiasParams->errorInitial, 10);
if (awhBiasParams->errorInitial <= 0)
{
gmx_fatal(FARGS, "%s (%d) needs to be > 0.", opt);
}
if (bComment)
{
CTYPE("Growth rate of the reference histogram determining the bias update size: exp-linear or linear");
}
sprintf(opt, "%s-growth", prefix);
EETYPE(opt, awhBiasParams->eGrowth, eawhgrowth_names);
if (bComment)
{
CTYPE("Start the simulation by equilibrating histogram towards the target distribution: no or yes");
}
sprintf(opt, "%s-equilibrate-histogram", prefix);
EETYPE(opt, awhBiasParams->equilibrateHistogram, yesno_names);
if (awhBiasParams->equilibrateHistogram && awhBiasParams->eGrowth != eawhgrowthEXP_LINEAR)
{
sprintf(warningmsg, "Option %s will only have an effect for histogram growth type '%s'.",
opt, EAWHGROWTH(eawhgrowthEXP_LINEAR));
warning(wi, warningmsg);
}
if (bComment)
{
CTYPE("Target distribution type: constant, cutoff, boltzmann or local-boltzmann");
}
sprintf(opt, "%s-target", prefix);
EETYPE(opt, awhBiasParams->eTarget, eawhtarget_names);
if ((awhBiasParams->eTarget == eawhtargetLOCALBOLTZMANN) &&
(awhBiasParams->eGrowth == eawhgrowthEXP_LINEAR))
{
sprintf(warningmsg, "Target type '%s' combined with histogram growth type '%s' is not "
"expected to give stable bias updates. You probably want to use growth type "
"'%s' instead.",
EAWHTARGET(eawhtargetLOCALBOLTZMANN), EAWHGROWTH(eawhgrowthEXP_LINEAR),
EAWHGROWTH(eawhgrowthLINEAR));
warning(wi, warningmsg);
}
if (bComment)
{
CTYPE("Boltzmann beta scaling factor for target distribution types 'boltzmann' and 'boltzmann-local'");
}
sprintf(opt, "%s-target-beta-scaling", prefix);
RTYPE(opt, awhBiasParams->targetBetaScaling, 0);
switch (awhBiasParams->eTarget)
{
case eawhtargetBOLTZMANN:
case eawhtargetLOCALBOLTZMANN:
if (awhBiasParams->targetBetaScaling < 0 || awhBiasParams->targetBetaScaling > 1)
{
gmx_fatal(FARGS, "%s = %g is not useful for target type %s.",
opt, awhBiasParams->targetBetaScaling, EAWHTARGET(awhBiasParams->eTarget));
}
break;
default:
if (awhBiasParams->targetBetaScaling != 0)
{
gmx_fatal(FARGS, "Value for %s (%g) set explicitly but will not be used for target type %s.",
opt, awhBiasParams->targetBetaScaling, EAWHTARGET(awhBiasParams->eTarget));
}
break;
}
if (bComment)
{
CTYPE("Free energy cutoff value for target distribution type 'cutoff'");
}
sprintf(opt, "%s-target-cutoff", prefix);
RTYPE(opt, awhBiasParams->targetCutoff, 0);
switch (awhBiasParams->eTarget)
{
case eawhtargetCUTOFF:
if (awhBiasParams->targetCutoff <= 0)
{
gmx_fatal(FARGS, "%s = %g is not useful for target type %s.",
opt, awhBiasParams->targetCutoff, EAWHTARGET(awhBiasParams->eTarget));
}
break;
default:
if (awhBiasParams->targetCutoff != 0)
{
gmx_fatal(FARGS, "Value for %s (%g) set explicitly but will not be used for target type %s.",
opt, awhBiasParams->targetCutoff, EAWHTARGET(awhBiasParams->eTarget));
}
break;
}
if (bComment)
{
CTYPE("Initialize PMF and target with user data: no or yes");
}
sprintf(opt, "%s-user-data", prefix);
EETYPE(opt, awhBiasParams->bUserData, yesno_names);
if (bComment)
{
CTYPE("Group index to share the bias with, 0 means not shared");
}
sprintf(opt, "%s-share-group", prefix);
ITYPE(opt, awhBiasParams->shareGroup, 0);
if (awhBiasParams->shareGroup < 0)
{
warning_error(wi, "AWH bias share-group should be >= 0");
}
if (bComment)
{
CTYPE("Dimensionality of the coordinate");
}
sprintf(opt, "%s-ndim", prefix);
ITYPE(opt, awhBiasParams->ndim, 0);
if (awhBiasParams->ndim <= 0 ||
awhBiasParams->ndim > c_biasMaxNumDim)
{
gmx_fatal(FARGS, "%s-ndim (%d) needs to be > 0 and at most %d\n", prefix, awhBiasParams->ndim, c_biasMaxNumDim);
}
if (awhBiasParams->ndim > 2)
{
warning_note(wi, "For awh-dim > 2 the estimate based on the diffusion and the initial error is currently only a rough guideline."
" You should verify its usefulness for your system before production runs!");
}
snew(awhBiasParams->dimParams, awhBiasParams->ndim);
for (int d = 0; d < awhBiasParams->ndim; d++)
{
bComment = bComment && d == 0;
sprintf(prefixdim, "%s-dim%d", prefix, d + 1);
readDimParams(&ninp, &inp, prefixdim, &awhBiasParams->dimParams[d], ir->pull, wi, bComment);
}
/* Check consistencies here that cannot be checked at read time at a lower level. */
checkInputConsistencyAwhBias(*awhBiasParams, wi);
*ninp_p = ninp;
*inp_p = inp;
}
int main (int argc, char *argv[])
{
static const char *desc[] = {
"The gromacs preprocessor",
"reads a molecular topology file, checks the validity of the",
"file, expands the topology from a molecular description to an atomic",
"description. The topology file contains information about",
"molecule types and the number of molecules, the preprocessor",
"copies each molecule as needed. ",
"There is no limitation on the number of molecule types. ",
"Bonds and bond-angles can be converted into constraints, separately",
"for hydrogens and heavy atoms.",
"Then a coordinate file is read and velocities can be generated",
"from a Maxwellian distribution if requested.",
"grompp also reads parameters for the mdrun ",
"(eg. number of MD steps, time step, cut-off), and others such as",
"NEMD parameters, which are corrected so that the net acceleration",
"is zero.",
"Eventually a binary file is produced that can serve as the sole input",
"file for the MD program.[PAR]",
"grompp uses the atom names from the topology file. The atom names",
"in the coordinate file (option [TT]-c[tt]) are only read to generate",
"warnings when they do not match the atom names in the topology.",
"Note that the atom names are irrelevant for the simulation as",
"only the atom types are used for generating interaction parameters.[PAR]",
"grompp calls a preprocessor to resolve includes, macros ",
"etcetera. By default we use the cpp in your path. To specify a "
"different macro-preprocessor (e.g. m4) or alternative location",
"you can put a line in your parameter file specifying the path",
"to that program. Specifying [TT]-pp[tt] will get the pre-processed",
"topology file written out.[PAR]",
"If your system does not have a c-preprocessor, you can still",
"use grompp, but you do not have access to the features ",
"from the cpp. Command line options to the c-preprocessor can be given",
"in the [TT].mdp[tt] file. See your local manual (man cpp).[PAR]",
"When using position restraints a file with restraint coordinates",
"can be supplied with [TT]-r[tt], otherwise restraining will be done",
"with respect to the conformation from the [TT]-c[tt] option.",
"For free energy calculation the the coordinates for the B topology",
"can be supplied with [TT]-rb[tt], otherwise they will be equal to",
"those of the A topology.[PAR]",
"Starting coordinates can be read from trajectory with [TT]-t[tt].",
"The last frame with coordinates and velocities will be read,",
"unless the [TT]-time[tt] option is used.",
"Note that these velocities will not be used when [TT]gen_vel = yes[tt]",
"in your [TT].mdp[tt] file. An energy file can be supplied with",
"[TT]-e[tt] to have exact restarts when using pressure and/or",
"Nose-Hoover temperature coupling. For an exact restart do not forget",
"to turn off velocity generation and turn on unconstrained starting",
"when constraints are present in the system.",
"If you want to continue a crashed run, it is",
"easier to use [TT]tpbconv[tt].[PAR]",
"Using the [TT]-morse[tt] option grompp can convert the harmonic bonds",
"in your topology to morse potentials. This makes it possible to break",
"bonds. For this option to work you need an extra file in your $GMXLIB",
"with dissociation energy. Use the -debug option to get more information",
"on the workings of this option (look for MORSE in the grompp.log file",
"using less or something like that).[PAR]",
"By default all bonded interactions which have constant energy due to",
"virtual site constructions will be removed. If this constant energy is",
"not zero, this will result in a shift in the total energy. All bonded",
"interactions can be kept by turning off [TT]-rmvsbds[tt]. Additionally,",
"all constraints for distances which will be constant anyway because",
"of virtual site constructions will be removed. If any constraints remain",
"which involve virtual sites, a fatal error will result.[PAR]"
"To verify your run input file, please make notice of all warnings",
"on the screen, and correct where necessary. Do also look at the contents",
"of the [TT]mdout.mdp[tt] file, this contains comment lines, as well as",
"the input that [TT]grompp[tt] has read. If in doubt you can start grompp",
"with the [TT]-debug[tt] option which will give you more information",
"in a file called grompp.log (along with real debug info). Finally, you",
"can see the contents of the run input file with the [TT]gmxdump[tt]",
"program."
};
t_gromppopts *opts;
gmx_mtop_t *sys;
int nmi;
t_molinfo *mi;
gpp_atomtype_t atype;
t_inputrec *ir;
int natoms,nvsite,comb,mt;
t_params *plist;
t_state state;
matrix box;
real max_spacing,fudgeQQ;
double reppow;
char fn[STRLEN],fnB[STRLEN],*mdparin;
int nerror,ntype;
bool bNeedVel,bGenVel;
bool have_radius,have_vol,have_surftens,have_gb_radius,have_S_hct;
bool have_atomnumber;
int n12,n13,n14;
t_params *gb_plist = NULL;
gmx_genborn_t *born = NULL;
t_filenm fnm[] = {
{ efMDP, NULL, NULL, ffOPTRD },
{ efMDP, "-po", "mdout", ffWRITE },
{ efSTX, "-c", NULL, ffREAD },
{ efSTX, "-r", NULL, ffOPTRD },
{ efSTX, "-rb", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTOP, NULL, NULL, ffREAD },
{ efTOP, "-pp", "processed", ffOPTWR },
{ efTPX, "-o", NULL, ffWRITE },
{ efTRN, "-t", NULL, ffOPTRD },
{ efEDR, "-e", NULL, ffOPTRD }
};
#define NFILE asize(fnm)
/* Command line options */
static bool bVerbose=TRUE,bRenum=TRUE;
static bool bRmVSBds=TRUE,bZero=FALSE;
static int i,maxwarn=0;
static real fr_time=-1;
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"Be loud and noisy" },
{ "-time", FALSE, etREAL, {&fr_time},
"Take frame at or first after this time." },
{ "-rmvsbds",FALSE, etBOOL, {&bRmVSBds},
"Remove constant bonded interactions with virtual sites" },
{ "-maxwarn", FALSE, etINT, {&maxwarn},
"Number of allowed warnings during input processing" },
{ "-zero", FALSE, etBOOL, {&bZero},
"Set parameters for bonded interactions without defaults to zero instead of generating an error" },
{ "-renum", FALSE, etBOOL, {&bRenum},
"Renumber atomtypes and minimize number of atomtypes" }
};
CopyRight(stdout,argv[0]);
/* Initiate some variables */
nerror=0;
snew(ir,1);
snew(opts,1);
init_ir(ir,opts);
/* Parse the command line */
parse_common_args(&argc,argv,0,NFILE,fnm,asize(pa),pa,
asize(desc),desc,0,NULL);
init_warning(maxwarn);
/* PARAMETER file processing */
mdparin = opt2fn("-f",NFILE,fnm);
set_warning_line(mdparin,-1);
get_ir(mdparin,opt2fn("-po",NFILE,fnm),ir,opts,&nerror);
if (bVerbose)
fprintf(stderr,"checking input for internal consistency...\n");
check_ir(mdparin,ir,opts,&nerror);
if (ir->ld_seed == -1) {
ir->ld_seed = make_seed();
fprintf(stderr,"Setting the LD random seed to %d\n",ir->ld_seed);
}
bNeedVel = EI_STATE_VELOCITY(ir->eI);
bGenVel = (bNeedVel && opts->bGenVel);
snew(plist,F_NRE);
init_plist(plist);
snew(sys,1);
atype = init_atomtype();
if (debug)
pr_symtab(debug,0,"Just opened",&sys->symtab);
strcpy(fn,ftp2fn(efTOP,NFILE,fnm));
if (!gmx_fexist(fn))
gmx_fatal(FARGS,"%s does not exist",fn);
new_status(fn,opt2fn_null("-pp",NFILE,fnm),opt2fn("-c",NFILE,fnm),
opts,ir,bZero,bGenVel,bVerbose,&state,
atype,sys,&nmi,&mi,plist,&comb,&reppow,&fudgeQQ,
opts->bMorse,
&nerror);
if (debug)
pr_symtab(debug,0,"After new_status",&sys->symtab);
if (count_constraints(sys,mi) && (ir->eConstrAlg == econtSHAKE)) {
if (ir->eI == eiCG || ir->eI == eiLBFGS) {
fprintf(stderr,
"ERROR: Can not do %s with %s, use %s\n",
EI(ir->eI),econstr_names[econtSHAKE],econstr_names[econtLINCS]);
nerror++;
}
if (ir->bPeriodicMols) {
fprintf(stderr,
"ERROR: can not do periodic molecules with %s, use %s\n",
econstr_names[econtSHAKE],econstr_names[econtLINCS]);
nerror++;
}
}
/* If we are doing GBSA, check that we got the parameters we need
* This checking is to see if there are GBSA paratmeters for all
* atoms in the force field. To go around this for testing purposes
* comment out the nerror++ counter temporarliy
*/
have_radius=have_vol=have_surftens=have_gb_radius=have_S_hct=TRUE;
for(i=0;i<get_atomtype_ntypes(atype);i++) {
have_radius=have_radius && (get_atomtype_radius(i,atype) > 0);
have_vol=have_vol && (get_atomtype_vol(i,atype) > 0);
have_surftens=have_surftens && (get_atomtype_surftens(i,atype) > 0);
have_gb_radius=have_gb_radius && (get_atomtype_gb_radius(i,atype) > 0);
have_S_hct=have_S_hct && (get_atomtype_S_hct(i,atype) > 0);
}
if(!have_radius && ir->implicit_solvent==eisGBSA) {
fprintf(stderr,"Can't do GB electrostatics; the forcefield is missing values for\n"
"atomtype radii, or they might be zero\n.");
/* nerror++; */
}
/*
if(!have_surftens && ir->implicit_solvent!=eisNO) {
fprintf(stderr,"Can't do implicit solvent; the forcefield is missing values\n"
" for atomtype surface tension\n.");
nerror++;
}
*/
/* If we are doing QM/MM, check that we got the atom numbers */
have_atomnumber = TRUE;
for (i=0; i<get_atomtype_ntypes(atype); i++) {
have_atomnumber = have_atomnumber && (get_atomtype_atomnumber(i,atype) >= 0);
}
if (!have_atomnumber && ir->bQMMM)
{
fprintf(stderr,"\n"
"It appears as if you are trying to run a QM/MM calculation, but the force\n"
"field you are using does not contain atom numbers fields. This is an\n"
"optional field (introduced in Gromacs 3.3) for general runs, but mandatory\n"
"for QM/MM. The good news is that it is easy to add - put the atom number as\n"
"an integer just before the mass column in ffXXXnb.itp.\n"
"NB: United atoms have the same atom numbers as normal ones.\n\n");
nerror++;
}
if (nerror) {
print_warn_num(FALSE);
gmx_fatal(FARGS,"There were %d error(s) processing your input",nerror);
}
if (opt2bSet("-r",NFILE,fnm))
sprintf(fn,"%s",opt2fn("-r",NFILE,fnm));
else
sprintf(fn,"%s",opt2fn("-c",NFILE,fnm));
if (opt2bSet("-rb",NFILE,fnm))
sprintf(fnB,"%s",opt2fn("-rb",NFILE,fnm));
else
strcpy(fnB,fn);
if (nint_ftype(sys,mi,F_POSRES) > 0) {
if (bVerbose) {
fprintf(stderr,"Reading position restraint coords from %s",fn);
if (strcmp(fn,fnB) == 0) {
fprintf(stderr,"\n");
} else {
fprintf(stderr," and %s\n",fnB);
if (ir->efep != efepNO && ir->n_flambda > 0) {
fprintf(stderr,"ERROR: can not change the position restraint reference coordinates with lambda togther with foreign lambda calculation.\n");
nerror++;
}
}
}
gen_posres(sys,mi,fn,fnB,
ir->refcoord_scaling,ir->ePBC,
ir->posres_com,ir->posres_comB);
}
nvsite = 0;
/* set parameters for virtual site construction (not for vsiten) */
for(mt=0; mt<sys->nmoltype; mt++) {
nvsite +=
set_vsites(bVerbose, &sys->moltype[mt].atoms, atype, mi[mt].plist);
}
/* now throw away all obsolete bonds, angles and dihedrals: */
/* note: constraints are ALWAYS removed */
if (nvsite) {
for(mt=0; mt<sys->nmoltype; mt++) {
clean_vsite_bondeds(mi[mt].plist,sys->moltype[mt].atoms.nr,bRmVSBds);
}
}
/* If we are using CMAP, setup the pre-interpolation grid */
if(plist->ncmap>0)
{
init_cmap_grid(&sys->cmap_grid, plist->nc, plist->grid_spacing);
setup_cmap(plist->grid_spacing, plist->nc, plist->cmap,&sys->cmap_grid);
}
set_wall_atomtype(atype,opts,ir);
if (bRenum) {
renum_atype(plist, sys, ir->wall_atomtype, atype, bVerbose);
ntype = get_atomtype_ntypes(atype);
}
/* PELA: Copy the atomtype data to the topology atomtype list */
copy_atomtype_atomtypes(atype,&(sys->atomtypes));
if (debug)
pr_symtab(debug,0,"After renum_atype",&sys->symtab);
if (bVerbose)
fprintf(stderr,"converting bonded parameters...\n");
ntype = get_atomtype_ntypes(atype);
convert_params(ntype, plist, mi, comb, reppow, fudgeQQ, sys);
if(ir->implicit_solvent)
{
printf("Constructing Generalized Born topology...\n");
/* Check for -normvsbds switch to grompp, necessary for gb together with vsites */
if(bRmVSBds && nvsite)
{
fprintf(stderr, "ERROR: Must use -normvsbds switch to grompp when doing Generalized Born\n"
"together with virtual sites\n");
nerror++;
}
if (nerror)
{
print_warn_num(FALSE);
gmx_fatal(FARGS,"There were %d error(s) processing your input",nerror);
}
generate_gb_topology(sys,mi);
}
if (debug)
pr_symtab(debug,0,"After convert_params",&sys->symtab);
/* set ptype to VSite for virtual sites */
for(mt=0; mt<sys->nmoltype; mt++) {
set_vsites_ptype(FALSE,&sys->moltype[mt]);
}
if (debug) {
pr_symtab(debug,0,"After virtual sites",&sys->symtab);
}
/* Check velocity for virtual sites and shells */
if (bGenVel) {
check_vel(sys,state.v);
}
/* check masses */
check_mol(sys);
for(i=0; i<sys->nmoltype; i++) {
check_cg_sizes(ftp2fn(efTOP,NFILE,fnm),&sys->moltype[i].cgs);
}
check_warning_error(FARGS);
if (bVerbose)
fprintf(stderr,"initialising group options...\n");
do_index(mdparin,ftp2fn_null(efNDX,NFILE,fnm),
sys,bVerbose,ir,
bGenVel ? state.v : NULL);
/* Init the temperature coupling state */
init_gtc_state(&state,ir->opts.ngtc);
if (bVerbose)
fprintf(stderr,"Checking consistency between energy and charge groups...\n");
check_eg_vs_cg(sys);
if (debug)
pr_symtab(debug,0,"After index",&sys->symtab);
triple_check(mdparin,ir,sys,&nerror);
close_symtab(&sys->symtab);
if (debug)
pr_symtab(debug,0,"After close",&sys->symtab);
/* make exclusions between QM atoms */
if (ir->bQMMM) {
generate_qmexcl(sys,ir);
}
if (ftp2bSet(efTRN,NFILE,fnm)) {
if (bVerbose)
fprintf(stderr,"getting data from old trajectory ...\n");
cont_status(ftp2fn(efTRN,NFILE,fnm),ftp2fn_null(efEDR,NFILE,fnm),
bNeedVel,bGenVel,fr_time,ir,&state,sys);
}
if (ir->ePBC==epbcXY && ir->nwall!=2)
clear_rvec(state.box[ZZ]);
if (EEL_FULL(ir->coulombtype)) {
/* Calculate the optimal grid dimensions */
copy_mat(state.box,box);
if (ir->ePBC==epbcXY && ir->nwall==2)
svmul(ir->wall_ewald_zfac,box[ZZ],box[ZZ]);
max_spacing = calc_grid(stdout,box,opts->fourierspacing,
&(ir->nkx),&(ir->nky),&(ir->nkz),1);
if ((ir->coulombtype == eelPPPM) && (max_spacing > 0.1)) {
set_warning_line(mdparin,-1);
sprintf(warn_buf,"Grid spacing larger then 0.1 while using PPPM.");
warning_note(NULL);
}
}
if (ir->ePull != epullNO)
set_pull_init(ir,sys,state.x,state.box,opts->pull_start);
/* reset_multinr(sys); */
if (EEL_PME(ir->coulombtype)) {
float ratio = pme_load_estimate(sys,ir,state.box);
fprintf(stderr,"Estimate for the relative computational load of the PME mesh part: %.2f\n",ratio);
if (ratio > 0.5)
warning_note("The optimal PME mesh load for parallel simulations is below 0.5\n"
"and for highly parallel simulations between 0.25 and 0.33,\n"
"for higher performance, increase the cut-off and the PME grid spacing");
}
{
double cio = compute_io(ir,sys->natoms,&sys->groups,F_NRE,1);
sprintf(warn_buf,"This run will generate roughly %.0f Mb of data",cio);
if (cio > 2000) {
set_warning_line(mdparin,-1);
warning_note(NULL);
} else {
printf("%s\n",warn_buf);
}
}
if (bVerbose)
fprintf(stderr,"writing run input file...\n");
print_warn_num(TRUE);
state.lambda = ir->init_lambda;
write_tpx_state(ftp2fn(efTPX,NFILE,fnm),ir,&state,sys);
thanx(stderr);
return 0;
}
static void
new_status(char *topfile,char *topppfile,char *confin,
t_gromppopts *opts,t_inputrec *ir,bool bZero,
bool bGenVel,bool bVerbose,t_state *state,
gpp_atomtype_t atype,gmx_mtop_t *sys,
int *nmi,t_molinfo **mi,t_params plist[],
int *comb,double *reppow,real *fudgeQQ,
bool bMorse,
int *nerror)
{
t_molinfo *molinfo=NULL;
int nmolblock;
gmx_molblock_t *molblock,*molbs;
t_atoms *confat;
int mb,mbs,i,nrmols,nmismatch;
char buf[STRLEN];
bool bGB=FALSE;
init_mtop(sys);
/* Set boolean for GB */
if(ir->implicit_solvent)
bGB=TRUE;
/* TOPOLOGY processing */
sys->name = do_top(bVerbose,topfile,topppfile,opts,bZero,&(sys->symtab),
plist,comb,reppow,fudgeQQ,
atype,&nrmols,&molinfo,ir,
&nmolblock,&molblock,bGB);
sys->nmolblock = 0;
snew(sys->molblock,nmolblock);
mbs;
sys->natoms = 0;
for(mb=0; mb<nmolblock; mb++) {
if (sys->nmolblock > 0 &&
molblock[mb].type == sys->molblock[sys->nmolblock-1].type) {
/* Merge consecutive blocks with the same molecule type */
sys->molblock[sys->nmolblock-1].nmol += molblock[mb].nmol;
sys->natoms += molblock[mb].nmol*sys->molblock[sys->nmolblock-1].natoms_mol;
} else if (molblock[mb].nmol > 0) {
/* Add a new molblock to the topology */
molbs = &sys->molblock[sys->nmolblock];
*molbs = molblock[mb];
molbs->natoms_mol = molinfo[molbs->type].atoms.nr;
molbs->nposres_xA = 0;
molbs->nposres_xB = 0;
sys->natoms += molbs->nmol*molbs->natoms_mol;
sys->nmolblock++;
}
}
if (sys->nmolblock == 0) {
gmx_fatal(FARGS,"No molecules were defined in the system");
}
renumber_moltypes(sys,&nrmols,&molinfo);
if (bMorse)
convert_harmonics(nrmols,molinfo,atype);
if (ir->eDisre == edrNone) {
i = rm_interactions(F_DISRES,nrmols,molinfo);
if (i > 0) {
set_warning_line("unknown",-1);
sprintf(warn_buf,"disre = no, removed %d distance restraints",i);
warning_note(NULL);
}
}
if (opts->bOrire == FALSE) {
i = rm_interactions(F_ORIRES,nrmols,molinfo);
if (i > 0) {
set_warning_line("unknown",-1);
sprintf(warn_buf,"orire = no, removed %d orientation restraints",i);
warning_note(NULL);
}
}
if (opts->bDihre == FALSE) {
i = rm_interactions(F_DIHRES,nrmols,molinfo);
if (i > 0) {
set_warning_line("unknown",-1);
sprintf(warn_buf,"dihre = no, removed %d dihedral restraints",i);
warning_note(NULL);
}
}
/* Copy structures from msys to sys */
molinfo2mtop(nrmols,molinfo,sys);
/* COORDINATE file processing */
if (bVerbose)
fprintf(stderr,"processing coordinates...\n");
get_stx_coordnum(confin,&state->natoms);
if (state->natoms != sys->natoms)
gmx_fatal(FARGS,"number of coordinates in coordinate file (%s, %d)\n"
" does not match topology (%s, %d)",
confin,state->natoms,topfile,sys->natoms);
else {
/* make space for coordinates and velocities */
char title[STRLEN];
snew(confat,1);
init_t_atoms(confat,state->natoms,FALSE);
init_state(state,state->natoms,0);
read_stx_conf(confin,title,confat,state->x,state->v,NULL,state->box);
/* This call fixes the box shape for runs with pressure scaling */
set_box_rel(ir,state);
nmismatch = check_atom_names(topfile, confin, sys, confat);
free_t_atoms(confat,TRUE);
sfree(confat);
if (nmismatch) {
sprintf(buf,"%d non-matching atom name%s\n"
"atom names from %s will be used\n"
"atom names from %s will be ignored\n",
nmismatch,(nmismatch == 1) ? "" : "s",topfile,confin);
warning(buf);
}
if (bVerbose)
fprintf(stderr,"double-checking input for internal consistency...\n");
double_check(ir,state->box,nint_ftype(sys,molinfo,F_CONSTR),nerror);
}
if (bGenVel) {
real *mass;
gmx_mtop_atomloop_all_t aloop;
t_atom *atom;
snew(mass,state->natoms);
aloop = gmx_mtop_atomloop_all_init(sys);
while (gmx_mtop_atomloop_all_next(aloop,&i,&atom)) {
mass[i] = atom->m;
}
if (opts->seed == -1) {
opts->seed = make_seed();
fprintf(stderr,"Setting gen_seed to %d\n",opts->seed);
}
maxwell_speed(opts->tempi,opts->seed,sys,state->v);
stop_cm(stdout,state->natoms,mass,state->x,state->v);
sfree(mass);
}
*nmi = nrmols;
*mi = molinfo;
}
