2 * This file is part of the GROMACS molecular simulation package.
4 * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
5 * Copyright (c) 2001-2004, The GROMACS development team.
6 * Copyright (c) 2013,2014, by the GROMACS development team, led by
7 * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
8 * and including many others, as listed in the AUTHORS file in the
9 * top-level source directory and at http://www.gromacs.org.
11 * GROMACS is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public License
13 * as published by the Free Software Foundation; either version 2.1
14 * of the License, or (at your option) any later version.
16 * GROMACS is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with GROMACS; if not, see
23 * http://www.gnu.org/licenses, or write to the Free Software Foundation,
24 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 * If you want to redistribute modifications to GROMACS, please
27 * consider that scientific software is very special. Version
28 * control is crucial - bugs must be traceable. We will be happy to
29 * consider code for inclusion in the official distribution, but
30 * derived work must not be called official GROMACS. Details are found
31 * in the README & COPYING files - if they are missing, get the
32 * official version at http://www.gromacs.org.
34 * To help us fund GROMACS development, we humbly ask that you cite
35 * the research papers on the package. Check out http://www.gromacs.org.
49 #include "gmx_fatal.h"
62 #include "mtop_util.h"
63 #include "chargegroup.h"
69 /* Resource parameters
70 * Do not change any of these until you read the instruction
71 * in readinp.h. Some cpp's do not take spaces after the backslash
72 * (like the c-shell), which will give you a very weird compiler
76 typedef struct t_inputrec_strings
78 char tcgrps[STRLEN], tau_t[STRLEN], ref_t[STRLEN],
79 acc[STRLEN], accgrps[STRLEN], freeze[STRLEN], frdim[STRLEN],
80 energy[STRLEN], user1[STRLEN], user2[STRLEN], vcm[STRLEN], x_compressed_groups[STRLEN],
81 couple_moltype[STRLEN], orirefitgrp[STRLEN], egptable[STRLEN], egpexcl[STRLEN],
82 wall_atomtype[STRLEN], wall_density[STRLEN], deform[STRLEN], QMMM[STRLEN];
83 char fep_lambda[efptNR][STRLEN];
84 char lambda_weights[STRLEN];
87 char anneal[STRLEN], anneal_npoints[STRLEN],
88 anneal_time[STRLEN], anneal_temp[STRLEN];
89 char QMmethod[STRLEN], QMbasis[STRLEN], QMcharge[STRLEN], QMmult[STRLEN],
90 bSH[STRLEN], CASorbitals[STRLEN], CASelectrons[STRLEN], SAon[STRLEN],
91 SAoff[STRLEN], SAsteps[STRLEN], bTS[STRLEN], bOPT[STRLEN];
92 char efield_x[STRLEN], efield_xt[STRLEN], efield_y[STRLEN],
93 efield_yt[STRLEN], efield_z[STRLEN], efield_zt[STRLEN];
95 } gmx_inputrec_strings;
97 static gmx_inputrec_strings *is = NULL;
99 void init_inputrec_strings()
103 gmx_incons("Attempted to call init_inputrec_strings before calling done_inputrec_strings. Only one inputrec (i.e. .mdp file) can be parsed at a time.");
108 void done_inputrec_strings()
115 egrptpALL, /* All particles have to be a member of a group. */
116 egrptpALL_GENREST, /* A rest group with name is generated for particles *
117 * that are not part of any group. */
118 egrptpPART, /* As egrptpALL_GENREST, but no name is generated *
119 * for the rest group. */
120 egrptpONE /* Merge all selected groups into one group, *
121 * make a rest group for the remaining particles. */
124 static const char *constraints[eshNR+1] = {
125 "none", "h-bonds", "all-bonds", "h-angles", "all-angles", NULL
128 static const char *couple_lam[ecouplamNR+1] = {
129 "vdw-q", "vdw", "q", "none", NULL
132 void init_ir(t_inputrec *ir, t_gromppopts *opts)
134 snew(opts->include, STRLEN);
135 snew(opts->define, STRLEN);
136 snew(ir->fepvals, 1);
137 snew(ir->expandedvals, 1);
138 snew(ir->simtempvals, 1);
141 static void GetSimTemps(int ntemps, t_simtemp *simtemp, double *temperature_lambdas)
146 for (i = 0; i < ntemps; i++)
148 /* simple linear scaling -- allows more control */
149 if (simtemp->eSimTempScale == esimtempLINEAR)
151 simtemp->temperatures[i] = simtemp->simtemp_low + (simtemp->simtemp_high-simtemp->simtemp_low)*temperature_lambdas[i];
153 else if (simtemp->eSimTempScale == esimtempGEOMETRIC) /* should give roughly equal acceptance for constant heat capacity . . . */
155 simtemp->temperatures[i] = simtemp->simtemp_low * pow(simtemp->simtemp_high/simtemp->simtemp_low, (1.0*i)/(ntemps-1));
157 else if (simtemp->eSimTempScale == esimtempEXPONENTIAL)
159 simtemp->temperatures[i] = simtemp->simtemp_low + (simtemp->simtemp_high-simtemp->simtemp_low)*((exp(temperature_lambdas[i])-1)/(exp(1.0)-1));
164 sprintf(errorstr, "eSimTempScale=%d not defined", simtemp->eSimTempScale);
165 gmx_fatal(FARGS, errorstr);
172 static void _low_check(gmx_bool b, char *s, warninp_t wi)
176 warning_error(wi, s);
180 static void check_nst(const char *desc_nst, int nst,
181 const char *desc_p, int *p,
186 if (*p > 0 && *p % nst != 0)
188 /* Round up to the next multiple of nst */
189 *p = ((*p)/nst + 1)*nst;
190 sprintf(buf, "%s should be a multiple of %s, changing %s to %d\n",
191 desc_p, desc_nst, desc_p, *p);
196 static gmx_bool ir_NVE(const t_inputrec *ir)
198 return ((ir->eI == eiMD || EI_VV(ir->eI)) && ir->etc == etcNO);
201 static int lcd(int n1, int n2)
206 for (i = 2; (i <= n1 && i <= n2); i++)
208 if (n1 % i == 0 && n2 % i == 0)
217 static void process_interaction_modifier(const t_inputrec *ir, int *eintmod)
219 if (*eintmod == eintmodPOTSHIFT_VERLET)
221 if (ir->cutoff_scheme == ecutsVERLET)
223 *eintmod = eintmodPOTSHIFT;
227 *eintmod = eintmodNONE;
232 void check_ir(const char *mdparin, t_inputrec *ir, t_gromppopts *opts,
234 /* Check internal consistency */
236 /* Strange macro: first one fills the err_buf, and then one can check
237 * the condition, which will print the message and increase the error
240 #define CHECK(b) _low_check(b, err_buf, wi)
241 char err_buf[256], warn_buf[STRLEN];
247 t_lambda *fep = ir->fepvals;
248 t_expanded *expand = ir->expandedvals;
250 set_warning_line(wi, mdparin, -1);
252 /* BASIC CUT-OFF STUFF */
253 if (ir->rcoulomb < 0)
255 warning_error(wi, "rcoulomb should be >= 0");
259 warning_error(wi, "rvdw should be >= 0");
262 !(ir->cutoff_scheme == ecutsVERLET && ir->verletbuf_tol > 0))
264 warning_error(wi, "rlist should be >= 0");
267 process_interaction_modifier(ir, &ir->coulomb_modifier);
268 process_interaction_modifier(ir, &ir->vdw_modifier);
270 if (ir->cutoff_scheme == ecutsGROUP)
272 /* BASIC CUT-OFF STUFF */
273 if (ir->rlist == 0 ||
274 !((EEL_MIGHT_BE_ZERO_AT_CUTOFF(ir->coulombtype) && ir->rcoulomb > ir->rlist) ||
275 (EVDW_MIGHT_BE_ZERO_AT_CUTOFF(ir->vdwtype) && ir->rvdw > ir->rlist)))
277 /* No switched potential and/or no twin-range:
278 * we can set the long-range cut-off to the maximum of the other cut-offs.
280 ir->rlistlong = max_cutoff(ir->rlist, max_cutoff(ir->rvdw, ir->rcoulomb));
282 else if (ir->rlistlong < 0)
284 ir->rlistlong = max_cutoff(ir->rlist, max_cutoff(ir->rvdw, ir->rcoulomb));
285 sprintf(warn_buf, "rlistlong was not set, setting it to %g (no buffer)",
287 warning(wi, warn_buf);
289 if (ir->rlistlong == 0 && ir->ePBC != epbcNONE)
291 warning_error(wi, "Can not have an infinite cut-off with PBC");
293 if (ir->rlistlong > 0 && (ir->rlist == 0 || ir->rlistlong < ir->rlist))
295 warning_error(wi, "rlistlong can not be shorter than rlist");
297 if (IR_TWINRANGE(*ir) && ir->nstlist <= 0)
299 warning_error(wi, "Can not have nstlist<=0 with twin-range interactions");
303 if (ir->rlistlong == ir->rlist)
307 else if (ir->rlistlong > ir->rlist && ir->nstcalclr == 0)
309 warning_error(wi, "With different cutoffs for electrostatics and VdW, nstcalclr must be -1 or a positive number");
312 if (ir->cutoff_scheme == ecutsVERLET)
316 /* Normal Verlet type neighbor-list, currently only limited feature support */
317 if (inputrec2nboundeddim(ir) < 3)
319 warning_error(wi, "With Verlet lists only full pbc or pbc=xy with walls is supported");
321 if (ir->rcoulomb != ir->rvdw)
323 warning_error(wi, "With Verlet lists rcoulomb!=rvdw is not supported");
325 if (ir->vdwtype != evdwCUT)
327 warning_error(wi, "With Verlet lists only cut-off LJ interactions are supported");
329 if (!(ir->coulombtype == eelCUT ||
330 (EEL_RF(ir->coulombtype) && ir->coulombtype != eelRF_NEC) ||
331 EEL_PME(ir->coulombtype) || ir->coulombtype == eelEWALD))
333 warning_error(wi, "With Verlet lists only cut-off, reaction-field, PME and Ewald electrostatics are supported");
336 if (ir->nstlist <= 0)
338 warning_error(wi, "With Verlet lists nstlist should be larger than 0");
341 if (ir->nstlist < 10)
343 warning_note(wi, "With Verlet lists the optimal nstlist is >= 10, with GPUs >= 20. Note that with the Verlet scheme, nstlist has no effect on the accuracy of your simulation.");
346 rc_max = max(ir->rvdw, ir->rcoulomb);
348 if (ir->verletbuf_tol <= 0)
350 if (ir->verletbuf_tol == 0)
352 warning_error(wi, "Can not have Verlet buffer tolerance of exactly 0");
355 if (ir->rlist < rc_max)
357 warning_error(wi, "With verlet lists rlist can not be smaller than rvdw or rcoulomb");
360 if (ir->rlist == rc_max && ir->nstlist > 1)
362 warning_note(wi, "rlist is equal to rvdw and/or rcoulomb: there is no explicit Verlet buffer. The cluster pair list does have a buffering effect, but choosing a larger rlist might be necessary for good energy conservation.");
367 if (ir->rlist > rc_max)
369 warning_note(wi, "You have set rlist larger than the interaction cut-off, but you also have verlet-buffer-tolerance > 0. Will set rlist using verlet-buffer-tolerance.");
372 if (ir->nstlist == 1)
374 /* No buffer required */
379 if (EI_DYNAMICS(ir->eI))
381 if (EI_MD(ir->eI) && ir->etc == etcNO)
383 warning_error(wi, "Temperature coupling is required for calculating rlist using the energy tolerance with verlet-buffer-tolerance > 0. Either use temperature coupling or set rlist yourself together with verlet-buffer-tolerance = -1.");
386 if (inputrec2nboundeddim(ir) < 3)
388 warning_error(wi, "The box volume is required for calculating rlist from the energy drift with verlet-buffer-tolerance > 0. You are using at least one unbounded dimension, so no volume can be computed. Either use a finite box, or set rlist yourself together with verlet-buffer-tolerance = -1.");
390 /* Set rlist temporarily so we can continue processing */
395 /* Set the buffer to 5% of the cut-off */
396 ir->rlist = 1.05*rc_max;
401 /* No twin-range calculations with Verlet lists */
402 ir->rlistlong = ir->rlist;
405 if (ir->nstcalclr == -1)
407 /* if rlist=rlistlong, this will later be changed to nstcalclr=0 */
408 ir->nstcalclr = ir->nstlist;
410 else if (ir->nstcalclr > 0)
412 if (ir->nstlist > 0 && (ir->nstlist % ir->nstcalclr != 0))
414 warning_error(wi, "nstlist must be evenly divisible by nstcalclr. Use nstcalclr = -1 to automatically follow nstlist");
417 else if (ir->nstcalclr < -1)
419 warning_error(wi, "nstcalclr must be a positive number (divisor of nstcalclr), or -1 to follow nstlist.");
422 if (EEL_PME(ir->coulombtype) && ir->rcoulomb > ir->rvdw && ir->nstcalclr > 1)
424 warning_error(wi, "When used with PME, the long-range component of twin-range interactions must be updated every step (nstcalclr)");
427 /* GENERAL INTEGRATOR STUFF */
428 if (!(ir->eI == eiMD || EI_VV(ir->eI)))
432 if (ir->eI == eiVVAK)
434 sprintf(warn_buf, "Integrator method %s is implemented primarily for validation purposes; for molecular dynamics, you should probably be using %s or %s", ei_names[eiVVAK], ei_names[eiMD], ei_names[eiVV]);
435 warning_note(wi, warn_buf);
437 if (!EI_DYNAMICS(ir->eI))
441 if (EI_DYNAMICS(ir->eI))
443 if (ir->nstcalcenergy < 0)
445 ir->nstcalcenergy = ir_optimal_nstcalcenergy(ir);
446 if (ir->nstenergy != 0 && ir->nstenergy < ir->nstcalcenergy)
448 /* nstcalcenergy larger than nstener does not make sense.
449 * We ideally want nstcalcenergy=nstener.
453 ir->nstcalcenergy = lcd(ir->nstenergy, ir->nstlist);
457 ir->nstcalcenergy = ir->nstenergy;
461 else if ( (ir->nstenergy > 0 && ir->nstcalcenergy > ir->nstenergy) ||
462 (ir->efep != efepNO && ir->fepvals->nstdhdl > 0 &&
463 (ir->nstcalcenergy > ir->fepvals->nstdhdl) ) )
466 const char *nsten = "nstenergy";
467 const char *nstdh = "nstdhdl";
468 const char *min_name = nsten;
469 int min_nst = ir->nstenergy;
471 /* find the smallest of ( nstenergy, nstdhdl ) */
472 if (ir->efep != efepNO && ir->fepvals->nstdhdl > 0 &&
473 (ir->fepvals->nstdhdl < ir->nstenergy) )
475 min_nst = ir->fepvals->nstdhdl;
478 /* If the user sets nstenergy small, we should respect that */
480 "Setting nstcalcenergy (%d) equal to %s (%d)",
481 ir->nstcalcenergy, min_name, min_nst);
482 warning_note(wi, warn_buf);
483 ir->nstcalcenergy = min_nst;
486 if (ir->epc != epcNO)
488 if (ir->nstpcouple < 0)
490 ir->nstpcouple = ir_optimal_nstpcouple(ir);
493 if (IR_TWINRANGE(*ir))
495 check_nst("nstlist", ir->nstlist,
496 "nstcalcenergy", &ir->nstcalcenergy, wi);
497 if (ir->epc != epcNO)
499 check_nst("nstlist", ir->nstlist,
500 "nstpcouple", &ir->nstpcouple, wi);
504 if (ir->nstcalcenergy > 0)
506 if (ir->efep != efepNO)
508 /* nstdhdl should be a multiple of nstcalcenergy */
509 check_nst("nstcalcenergy", ir->nstcalcenergy,
510 "nstdhdl", &ir->fepvals->nstdhdl, wi);
511 /* nstexpanded should be a multiple of nstcalcenergy */
512 check_nst("nstcalcenergy", ir->nstcalcenergy,
513 "nstexpanded", &ir->expandedvals->nstexpanded, wi);
515 /* for storing exact averages nstenergy should be
516 * a multiple of nstcalcenergy
518 check_nst("nstcalcenergy", ir->nstcalcenergy,
519 "nstenergy", &ir->nstenergy, wi);
524 if ((EI_SD(ir->eI) || ir->eI == eiBD) &&
525 ir->bContinuation && ir->ld_seed != -1)
527 warning_note(wi, "You are doing a continuation with SD or BD, make sure that ld_seed is different from the previous run (using ld_seed=-1 will ensure this)");
533 sprintf(err_buf, "TPI only works with pbc = %s", epbc_names[epbcXYZ]);
534 CHECK(ir->ePBC != epbcXYZ);
535 sprintf(err_buf, "TPI only works with ns = %s", ens_names[ensGRID]);
536 CHECK(ir->ns_type != ensGRID);
537 sprintf(err_buf, "with TPI nstlist should be larger than zero");
538 CHECK(ir->nstlist <= 0);
539 sprintf(err_buf, "TPI does not work with full electrostatics other than PME");
540 CHECK(EEL_FULL(ir->coulombtype) && !EEL_PME(ir->coulombtype));
544 if ( (opts->nshake > 0) && (opts->bMorse) )
547 "Using morse bond-potentials while constraining bonds is useless");
548 warning(wi, warn_buf);
551 if ((EI_SD(ir->eI) || ir->eI == eiBD) &&
552 ir->bContinuation && ir->ld_seed != -1)
554 warning_note(wi, "You are doing a continuation with SD or BD, make sure that ld_seed is different from the previous run (using ld_seed=-1 will ensure this)");
556 /* verify simulated tempering options */
560 gmx_bool bAllTempZero = TRUE;
561 for (i = 0; i < fep->n_lambda; i++)
563 sprintf(err_buf, "Entry %d for %s must be between 0 and 1, instead is %g", i, efpt_names[efptTEMPERATURE], fep->all_lambda[efptTEMPERATURE][i]);
564 CHECK((fep->all_lambda[efptTEMPERATURE][i] < 0) || (fep->all_lambda[efptTEMPERATURE][i] > 1));
565 if (fep->all_lambda[efptTEMPERATURE][i] > 0)
567 bAllTempZero = FALSE;
570 sprintf(err_buf, "if simulated tempering is on, temperature-lambdas may not be all zero");
571 CHECK(bAllTempZero == TRUE);
573 sprintf(err_buf, "Simulated tempering is currently only compatible with md-vv");
574 CHECK(ir->eI != eiVV);
576 /* check compatability of the temperature coupling with simulated tempering */
578 if (ir->etc == etcNOSEHOOVER)
580 sprintf(warn_buf, "Nose-Hoover based temperature control such as [%s] my not be entirelyconsistent with simulated tempering", etcoupl_names[ir->etc]);
581 warning_note(wi, warn_buf);
584 /* check that the temperatures make sense */
586 sprintf(err_buf, "Higher simulated tempering temperature (%g) must be >= than the simulated tempering lower temperature (%g)", ir->simtempvals->simtemp_high, ir->simtempvals->simtemp_low);
587 CHECK(ir->simtempvals->simtemp_high <= ir->simtempvals->simtemp_low);
589 sprintf(err_buf, "Higher simulated tempering temperature (%g) must be >= zero", ir->simtempvals->simtemp_high);
590 CHECK(ir->simtempvals->simtemp_high <= 0);
592 sprintf(err_buf, "Lower simulated tempering temperature (%g) must be >= zero", ir->simtempvals->simtemp_low);
593 CHECK(ir->simtempvals->simtemp_low <= 0);
596 /* verify free energy options */
598 if (ir->efep != efepNO)
601 sprintf(err_buf, "The soft-core power is %d and can only be 1 or 2",
603 CHECK(fep->sc_alpha != 0 && fep->sc_power != 1 && fep->sc_power != 2);
605 sprintf(err_buf, "The soft-core sc-r-power is %d and can only be 6 or 48",
606 (int)fep->sc_r_power);
607 CHECK(fep->sc_alpha != 0 && fep->sc_r_power != 6.0 && fep->sc_r_power != 48.0);
609 sprintf(err_buf, "Can't use postive delta-lambda (%g) if initial state/lambda does not start at zero", fep->delta_lambda);
610 CHECK(fep->delta_lambda > 0 && ((fep->init_fep_state > 0) || (fep->init_lambda > 0)));
612 sprintf(err_buf, "Can't use postive delta-lambda (%g) with expanded ensemble simulations", fep->delta_lambda);
613 CHECK(fep->delta_lambda > 0 && (ir->efep == efepEXPANDED));
615 sprintf(err_buf, "Can only use expanded ensemble with md-vv for now; should be supported for other integrators in 5.0");
616 CHECK(!(EI_VV(ir->eI)) && (ir->efep == efepEXPANDED));
618 sprintf(err_buf, "Free-energy not implemented for Ewald");
619 CHECK(ir->coulombtype == eelEWALD);
621 /* check validty of lambda inputs */
622 if (fep->n_lambda == 0)
624 /* Clear output in case of no states:*/
625 sprintf(err_buf, "init-lambda-state set to %d: no lambda states are defined.", fep->init_fep_state);
626 CHECK((fep->init_fep_state >= 0) && (fep->n_lambda == 0));
630 sprintf(err_buf, "initial thermodynamic state %d does not exist, only goes to %d", fep->init_fep_state, fep->n_lambda-1);
631 CHECK((fep->init_fep_state >= fep->n_lambda));
634 sprintf(err_buf, "Lambda state must be set, either with init-lambda-state or with init-lambda");
635 CHECK((fep->init_fep_state < 0) && (fep->init_lambda < 0));
637 sprintf(err_buf, "init-lambda=%g while init-lambda-state=%d. Lambda state must be set either with init-lambda-state or with init-lambda, but not both",
638 fep->init_lambda, fep->init_fep_state);
639 CHECK((fep->init_fep_state >= 0) && (fep->init_lambda >= 0));
643 if ((fep->init_lambda >= 0) && (fep->delta_lambda == 0))
647 for (i = 0; i < efptNR; i++)
649 if (fep->separate_dvdl[i])
654 if (n_lambda_terms > 1)
656 sprintf(warn_buf, "If lambda vector states (fep-lambdas, coul-lambdas etc.) are set, don't use init-lambda to set lambda state (except for slow growth). Use init-lambda-state instead.");
657 warning(wi, warn_buf);
660 if (n_lambda_terms < 2 && fep->n_lambda > 0)
663 "init-lambda is deprecated for setting lambda state (except for slow growth). Use init-lambda-state instead.");
667 for (j = 0; j < efptNR; j++)
669 for (i = 0; i < fep->n_lambda; i++)
671 sprintf(err_buf, "Entry %d for %s must be between 0 and 1, instead is %g", i, efpt_names[j], fep->all_lambda[j][i]);
672 CHECK((fep->all_lambda[j][i] < 0) || (fep->all_lambda[j][i] > 1));
676 if ((fep->sc_alpha > 0) && (!fep->bScCoul))
678 for (i = 0; i < fep->n_lambda; i++)
680 sprintf(err_buf, "For state %d, vdw-lambdas (%f) is changing with vdw softcore, while coul-lambdas (%f) is nonzero without coulomb softcore: this will lead to crashes, and is not supported.", i, fep->all_lambda[efptVDW][i],
681 fep->all_lambda[efptCOUL][i]);
682 CHECK((fep->sc_alpha > 0) &&
683 (((fep->all_lambda[efptCOUL][i] > 0.0) &&
684 (fep->all_lambda[efptCOUL][i] < 1.0)) &&
685 ((fep->all_lambda[efptVDW][i] > 0.0) &&
686 (fep->all_lambda[efptVDW][i] < 1.0))));
690 if ((fep->bScCoul) && (EEL_PME(ir->coulombtype)))
692 real sigma, lambda, r_sc;
695 /* Maximum estimate for A and B charges equal with lambda power 1 */
697 r_sc = pow(lambda*fep->sc_alpha*pow(sigma/ir->rcoulomb, fep->sc_r_power) + 1.0, 1.0/fep->sc_r_power);
698 sprintf(warn_buf, "With PME there is a minor soft core effect present at the cut-off, proportional to (LJsigma/rcoulomb)^%g. This could have a minor effect on energy conservation, but usually other effects dominate. With a common sigma value of %g nm the fraction of the particle-particle potential at the cut-off at lambda=%g is around %.1e, while ewald-rtol is %.1e.",
700 sigma, lambda, r_sc - 1.0, ir->ewald_rtol);
701 warning_note(wi, warn_buf);
704 /* Free Energy Checks -- In an ideal world, slow growth and FEP would
705 be treated differently, but that's the next step */
707 for (i = 0; i < efptNR; i++)
709 for (j = 0; j < fep->n_lambda; j++)
711 sprintf(err_buf, "%s[%d] must be between 0 and 1", efpt_names[i], j);
712 CHECK((fep->all_lambda[i][j] < 0) || (fep->all_lambda[i][j] > 1));
717 if ((ir->bSimTemp) || (ir->efep == efepEXPANDED))
720 expand = ir->expandedvals;
722 /* checking equilibration of weights inputs for validity */
724 sprintf(err_buf, "weight-equil-number-all-lambda (%d) is ignored if lmc-weights-equil is not equal to %s",
725 expand->equil_n_at_lam, elmceq_names[elmceqNUMATLAM]);
726 CHECK((expand->equil_n_at_lam > 0) && (expand->elmceq != elmceqNUMATLAM));
728 sprintf(err_buf, "weight-equil-number-samples (%d) is ignored if lmc-weights-equil is not equal to %s",
729 expand->equil_samples, elmceq_names[elmceqSAMPLES]);
730 CHECK((expand->equil_samples > 0) && (expand->elmceq != elmceqSAMPLES));
732 sprintf(err_buf, "weight-equil-number-steps (%d) is ignored if lmc-weights-equil is not equal to %s",
733 expand->equil_steps, elmceq_names[elmceqSTEPS]);
734 CHECK((expand->equil_steps > 0) && (expand->elmceq != elmceqSTEPS));
736 sprintf(err_buf, "weight-equil-wl-delta (%d) is ignored if lmc-weights-equil is not equal to %s",
737 expand->equil_samples, elmceq_names[elmceqWLDELTA]);
738 CHECK((expand->equil_wl_delta > 0) && (expand->elmceq != elmceqWLDELTA));
740 sprintf(err_buf, "weight-equil-count-ratio (%f) is ignored if lmc-weights-equil is not equal to %s",
741 expand->equil_ratio, elmceq_names[elmceqRATIO]);
742 CHECK((expand->equil_ratio > 0) && (expand->elmceq != elmceqRATIO));
744 sprintf(err_buf, "weight-equil-number-all-lambda (%d) must be a positive integer if lmc-weights-equil=%s",
745 expand->equil_n_at_lam, elmceq_names[elmceqNUMATLAM]);
746 CHECK((expand->equil_n_at_lam <= 0) && (expand->elmceq == elmceqNUMATLAM));
748 sprintf(err_buf, "weight-equil-number-samples (%d) must be a positive integer if lmc-weights-equil=%s",
749 expand->equil_samples, elmceq_names[elmceqSAMPLES]);
750 CHECK((expand->equil_samples <= 0) && (expand->elmceq == elmceqSAMPLES));
752 sprintf(err_buf, "weight-equil-number-steps (%d) must be a positive integer if lmc-weights-equil=%s",
753 expand->equil_steps, elmceq_names[elmceqSTEPS]);
754 CHECK((expand->equil_steps <= 0) && (expand->elmceq == elmceqSTEPS));
756 sprintf(err_buf, "weight-equil-wl-delta (%f) must be > 0 if lmc-weights-equil=%s",
757 expand->equil_wl_delta, elmceq_names[elmceqWLDELTA]);
758 CHECK((expand->equil_wl_delta <= 0) && (expand->elmceq == elmceqWLDELTA));
760 sprintf(err_buf, "weight-equil-count-ratio (%f) must be > 0 if lmc-weights-equil=%s",
761 expand->equil_ratio, elmceq_names[elmceqRATIO]);
762 CHECK((expand->equil_ratio <= 0) && (expand->elmceq == elmceqRATIO));
764 sprintf(err_buf, "lmc-weights-equil=%s only possible when lmc-stats = %s or lmc-stats %s",
765 elmceq_names[elmceqWLDELTA], elamstats_names[elamstatsWL], elamstats_names[elamstatsWWL]);
766 CHECK((expand->elmceq == elmceqWLDELTA) && (!EWL(expand->elamstats)));
768 sprintf(err_buf, "lmc-repeats (%d) must be greater than 0", expand->lmc_repeats);
769 CHECK((expand->lmc_repeats <= 0));
770 sprintf(err_buf, "minimum-var-min (%d) must be greater than 0", expand->minvarmin);
771 CHECK((expand->minvarmin <= 0));
772 sprintf(err_buf, "weight-c-range (%d) must be greater or equal to 0", expand->c_range);
773 CHECK((expand->c_range < 0));
774 sprintf(err_buf, "init-lambda-state (%d) must be zero if lmc-forced-nstart (%d)> 0 and lmc-move != 'no'",
775 fep->init_fep_state, expand->lmc_forced_nstart);
776 CHECK((fep->init_fep_state != 0) && (expand->lmc_forced_nstart > 0) && (expand->elmcmove != elmcmoveNO));
777 sprintf(err_buf, "lmc-forced-nstart (%d) must not be negative", expand->lmc_forced_nstart);
778 CHECK((expand->lmc_forced_nstart < 0));
779 sprintf(err_buf, "init-lambda-state (%d) must be in the interval [0,number of lambdas)", fep->init_fep_state);
780 CHECK((fep->init_fep_state < 0) || (fep->init_fep_state >= fep->n_lambda));
782 sprintf(err_buf, "init-wl-delta (%f) must be greater than or equal to 0", expand->init_wl_delta);
783 CHECK((expand->init_wl_delta < 0));
784 sprintf(err_buf, "wl-ratio (%f) must be between 0 and 1", expand->wl_ratio);
785 CHECK((expand->wl_ratio <= 0) || (expand->wl_ratio >= 1));
786 sprintf(err_buf, "wl-scale (%f) must be between 0 and 1", expand->wl_scale);
787 CHECK((expand->wl_scale <= 0) || (expand->wl_scale >= 1));
789 /* if there is no temperature control, we need to specify an MC temperature */
790 sprintf(err_buf, "If there is no temperature control, and lmc-mcmove!= 'no',mc_temperature must be set to a positive number");
791 if (expand->nstTij > 0)
793 sprintf(err_buf, "nst-transition-matrix (%d) must be an integer multiple of nstlog (%d)",
794 expand->nstTij, ir->nstlog);
795 CHECK((mod(expand->nstTij, ir->nstlog) != 0));
800 sprintf(err_buf, "walls only work with pbc=%s", epbc_names[epbcXY]);
801 CHECK(ir->nwall && ir->ePBC != epbcXY);
804 if (ir->ePBC != epbcXYZ && ir->nwall != 2)
806 if (ir->ePBC == epbcNONE)
808 if (ir->epc != epcNO)
810 warning(wi, "Turning off pressure coupling for vacuum system");
816 sprintf(err_buf, "Can not have pressure coupling with pbc=%s",
817 epbc_names[ir->ePBC]);
818 CHECK(ir->epc != epcNO);
820 sprintf(err_buf, "Can not have Ewald with pbc=%s", epbc_names[ir->ePBC]);
821 CHECK(EEL_FULL(ir->coulombtype));
823 sprintf(err_buf, "Can not have dispersion correction with pbc=%s",
824 epbc_names[ir->ePBC]);
825 CHECK(ir->eDispCorr != edispcNO);
828 if (ir->rlist == 0.0)
830 sprintf(err_buf, "can only have neighborlist cut-off zero (=infinite)\n"
831 "with coulombtype = %s or coulombtype = %s\n"
832 "without periodic boundary conditions (pbc = %s) and\n"
833 "rcoulomb and rvdw set to zero",
834 eel_names[eelCUT], eel_names[eelUSER], epbc_names[epbcNONE]);
835 CHECK(((ir->coulombtype != eelCUT) && (ir->coulombtype != eelUSER)) ||
836 (ir->ePBC != epbcNONE) ||
837 (ir->rcoulomb != 0.0) || (ir->rvdw != 0.0));
841 warning_error(wi, "Can not have heuristic neighborlist updates without cut-off");
845 warning_note(wi, "Simulating without cut-offs is usually (slightly) faster with nstlist=0, nstype=simple and particle decomposition");
850 if (ir->nstcomm == 0)
852 ir->comm_mode = ecmNO;
854 if (ir->comm_mode != ecmNO)
858 warning(wi, "If you want to remove the rotation around the center of mass, you should set comm_mode = Angular instead of setting nstcomm < 0. nstcomm is modified to its absolute value");
859 ir->nstcomm = abs(ir->nstcomm);
862 if (ir->nstcalcenergy > 0 && ir->nstcomm < ir->nstcalcenergy)
864 warning_note(wi, "nstcomm < nstcalcenergy defeats the purpose of nstcalcenergy, setting nstcomm to nstcalcenergy");
865 ir->nstcomm = ir->nstcalcenergy;
868 if (ir->comm_mode == ecmANGULAR)
870 sprintf(err_buf, "Can not remove the rotation around the center of mass with periodic molecules");
871 CHECK(ir->bPeriodicMols);
872 if (ir->ePBC != epbcNONE)
874 warning(wi, "Removing the rotation around the center of mass in a periodic system (this is not a problem when you have only one molecule).");
879 if (EI_STATE_VELOCITY(ir->eI) && ir->ePBC == epbcNONE && ir->comm_mode != ecmANGULAR)
881 warning_note(wi, "Tumbling and or flying ice-cubes: We are not removing rotation around center of mass in a non-periodic system. You should probably set comm_mode = ANGULAR.");
884 sprintf(err_buf, "Twin-range neighbour searching (NS) with simple NS"
885 " algorithm not implemented");
886 CHECK(((ir->rcoulomb > ir->rlist) || (ir->rvdw > ir->rlist))
887 && (ir->ns_type == ensSIMPLE));
889 /* TEMPERATURE COUPLING */
890 if (ir->etc == etcYES)
892 ir->etc = etcBERENDSEN;
893 warning_note(wi, "Old option for temperature coupling given: "
894 "changing \"yes\" to \"Berendsen\"\n");
897 if ((ir->etc == etcNOSEHOOVER) || (ir->epc == epcMTTK))
899 if (ir->opts.nhchainlength < 1)
901 sprintf(warn_buf, "number of Nose-Hoover chains (currently %d) cannot be less than 1,reset to 1\n", ir->opts.nhchainlength);
902 ir->opts.nhchainlength = 1;
903 warning(wi, warn_buf);
906 if (ir->etc == etcNOSEHOOVER && !EI_VV(ir->eI) && ir->opts.nhchainlength > 1)
908 warning_note(wi, "leapfrog does not yet support Nose-Hoover chains, nhchainlength reset to 1");
909 ir->opts.nhchainlength = 1;
914 ir->opts.nhchainlength = 0;
917 if (ir->eI == eiVVAK)
919 sprintf(err_buf, "%s implemented primarily for validation, and requires nsttcouple = 1 and nstpcouple = 1.",
921 CHECK((ir->nsttcouple != 1) || (ir->nstpcouple != 1));
924 if (ETC_ANDERSEN(ir->etc))
926 sprintf(err_buf, "%s temperature control not supported for integrator %s.", etcoupl_names[ir->etc], ei_names[ir->eI]);
927 CHECK(!(EI_VV(ir->eI)));
929 for (i = 0; i < ir->opts.ngtc; i++)
931 sprintf(err_buf, "all tau_t must currently be equal using Andersen temperature control, violated for group %d", i);
932 CHECK(ir->opts.tau_t[0] != ir->opts.tau_t[i]);
933 sprintf(err_buf, "all tau_t must be postive using Andersen temperature control, tau_t[%d]=%10.6f",
934 i, ir->opts.tau_t[i]);
935 CHECK(ir->opts.tau_t[i] < 0);
937 if (ir->nstcomm > 0 && (ir->etc == etcANDERSEN))
939 sprintf(warn_buf, "Center of mass removal not necessary for %s. All velocities of coupled groups are rerandomized periodically, so flying ice cube errors will not occur.", etcoupl_names[ir->etc]);
940 warning_note(wi, warn_buf);
943 sprintf(err_buf, "nstcomm must be 1, not %d for %s, as velocities of atoms in coupled groups are randomized every time step", ir->nstcomm, etcoupl_names[ir->etc]);
944 CHECK(ir->nstcomm > 1 && (ir->etc == etcANDERSEN));
946 for (i = 0; i < ir->opts.ngtc; i++)
948 int nsteps = (int)(ir->opts.tau_t[i]/ir->delta_t);
949 sprintf(err_buf, "tau_t/delta_t for group %d for temperature control method %s must be a multiple of nstcomm (%d), as velocities of atoms in coupled groups are randomized every time step. The input tau_t (%8.3f) leads to %d steps per randomization", i, etcoupl_names[ir->etc], ir->nstcomm, ir->opts.tau_t[i], nsteps);
950 CHECK((nsteps % ir->nstcomm) && (ir->etc == etcANDERSENMASSIVE));
953 if (ir->etc == etcBERENDSEN)
955 sprintf(warn_buf, "The %s thermostat does not generate the correct kinetic energy distribution. You might want to consider using the %s thermostat.",
956 ETCOUPLTYPE(ir->etc), ETCOUPLTYPE(etcVRESCALE));
957 warning_note(wi, warn_buf);
960 if ((ir->etc == etcNOSEHOOVER || ETC_ANDERSEN(ir->etc))
961 && ir->epc == epcBERENDSEN)
963 sprintf(warn_buf, "Using Berendsen pressure coupling invalidates the "
964 "true ensemble for the thermostat");
965 warning(wi, warn_buf);
968 /* PRESSURE COUPLING */
969 if (ir->epc == epcISOTROPIC)
971 ir->epc = epcBERENDSEN;
972 warning_note(wi, "Old option for pressure coupling given: "
973 "changing \"Isotropic\" to \"Berendsen\"\n");
976 if (ir->epc != epcNO)
978 dt_pcoupl = ir->nstpcouple*ir->delta_t;
980 sprintf(err_buf, "tau-p must be > 0 instead of %g\n", ir->tau_p);
981 CHECK(ir->tau_p <= 0);
983 if (ir->tau_p/dt_pcoupl < pcouple_min_integration_steps(ir->epc))
985 sprintf(warn_buf, "For proper integration of the %s barostat, tau-p (%g) should be at least %d times larger than nstpcouple*dt (%g)",
986 EPCOUPLTYPE(ir->epc), ir->tau_p, pcouple_min_integration_steps(ir->epc), dt_pcoupl);
987 warning(wi, warn_buf);
990 sprintf(err_buf, "compressibility must be > 0 when using pressure"
991 " coupling %s\n", EPCOUPLTYPE(ir->epc));
992 CHECK(ir->compress[XX][XX] < 0 || ir->compress[YY][YY] < 0 ||
993 ir->compress[ZZ][ZZ] < 0 ||
994 (trace(ir->compress) == 0 && ir->compress[YY][XX] <= 0 &&
995 ir->compress[ZZ][XX] <= 0 && ir->compress[ZZ][YY] <= 0));
997 if (epcPARRINELLORAHMAN == ir->epc && opts->bGenVel)
1000 "You are generating velocities so I am assuming you "
1001 "are equilibrating a system. You are using "
1002 "%s pressure coupling, but this can be "
1003 "unstable for equilibration. If your system crashes, try "
1004 "equilibrating first with Berendsen pressure coupling. If "
1005 "you are not equilibrating the system, you can probably "
1006 "ignore this warning.",
1007 epcoupl_names[ir->epc]);
1008 warning(wi, warn_buf);
1014 if (ir->epc > epcNO)
1016 if ((ir->epc != epcBERENDSEN) && (ir->epc != epcMTTK))
1018 warning_error(wi, "for md-vv and md-vv-avek, can only use Berendsen and Martyna-Tuckerman-Tobias-Klein (MTTK) equations for pressure control; MTTK is equivalent to Parrinello-Rahman.");
1023 /* ELECTROSTATICS */
1024 /* More checks are in triple check (grompp.c) */
1026 if (ir->coulombtype == eelSWITCH)
1028 sprintf(warn_buf, "coulombtype = %s is only for testing purposes and can lead to serious "
1029 "artifacts, advice: use coulombtype = %s",
1030 eel_names[ir->coulombtype],
1031 eel_names[eelRF_ZERO]);
1032 warning(wi, warn_buf);
1035 if (ir->epsilon_r != 1 && ir->implicit_solvent == eisGBSA)
1037 sprintf(warn_buf, "epsilon-r = %g with GB implicit solvent, will use this value for inner dielectric", ir->epsilon_r);
1038 warning_note(wi, warn_buf);
1041 if (EEL_RF(ir->coulombtype) && ir->epsilon_rf == 1 && ir->epsilon_r != 1)
1043 sprintf(warn_buf, "epsilon-r = %g and epsilon-rf = 1 with reaction field, proceeding assuming old format and exchanging epsilon-r and epsilon-rf", ir->epsilon_r);
1044 warning(wi, warn_buf);
1045 ir->epsilon_rf = ir->epsilon_r;
1046 ir->epsilon_r = 1.0;
1049 if (getenv("GALACTIC_DYNAMICS") == NULL)
1051 sprintf(err_buf, "epsilon-r must be >= 0 instead of %g\n", ir->epsilon_r);
1052 CHECK(ir->epsilon_r < 0);
1055 if (EEL_RF(ir->coulombtype))
1057 /* reaction field (at the cut-off) */
1059 if (ir->coulombtype == eelRF_ZERO)
1061 sprintf(warn_buf, "With coulombtype = %s, epsilon-rf must be 0, assuming you meant epsilon_rf=0",
1062 eel_names[ir->coulombtype]);
1063 CHECK(ir->epsilon_rf != 0);
1064 ir->epsilon_rf = 0.0;
1067 sprintf(err_buf, "epsilon-rf must be >= epsilon-r");
1068 CHECK((ir->epsilon_rf < ir->epsilon_r && ir->epsilon_rf != 0) ||
1069 (ir->epsilon_r == 0));
1070 if (ir->epsilon_rf == ir->epsilon_r)
1072 sprintf(warn_buf, "Using epsilon-rf = epsilon-r with %s does not make sense",
1073 eel_names[ir->coulombtype]);
1074 warning(wi, warn_buf);
1077 /* Allow rlist>rcoulomb for tabulated long range stuff. This just
1078 * means the interaction is zero outside rcoulomb, but it helps to
1079 * provide accurate energy conservation.
1081 if (EEL_MIGHT_BE_ZERO_AT_CUTOFF(ir->coulombtype))
1083 if (EEL_SWITCHED(ir->coulombtype))
1086 "With coulombtype = %s rcoulomb_switch must be < rcoulomb. Or, better: Use the potential modifier options!",
1087 eel_names[ir->coulombtype]);
1088 CHECK(ir->rcoulomb_switch >= ir->rcoulomb);
1091 else if (ir->coulombtype == eelCUT || EEL_RF(ir->coulombtype))
1093 if (ir->cutoff_scheme == ecutsGROUP && ir->coulomb_modifier == eintmodNONE)
1095 sprintf(err_buf, "With coulombtype = %s, rcoulomb should be >= rlist unless you use a potential modifier",
1096 eel_names[ir->coulombtype]);
1097 CHECK(ir->rlist > ir->rcoulomb);
1101 if (ir->coulombtype == eelSWITCH || ir->coulombtype == eelSHIFT ||
1102 ir->vdwtype == evdwSWITCH || ir->vdwtype == evdwSHIFT)
1105 "The switch/shift interaction settings are just for compatibility; you will get better "
1106 "performance from applying potential modifiers to your interactions!\n");
1107 warning_note(wi, warn_buf);
1110 if (ir->coulombtype == eelPMESWITCH)
1112 if (ir->rcoulomb_switch/ir->rcoulomb < 0.9499)
1114 sprintf(warn_buf, "The switching range for %s should be 5%% or less, energy conservation will be good anyhow, since ewald_rtol = %g",
1115 eel_names[ir->coulombtype],
1117 warning(wi, warn_buf);
1121 if (EEL_FULL(ir->coulombtype))
1123 if (ir->coulombtype == eelPMESWITCH || ir->coulombtype == eelPMEUSER ||
1124 ir->coulombtype == eelPMEUSERSWITCH)
1126 sprintf(err_buf, "With coulombtype = %s, rcoulomb must be <= rlist",
1127 eel_names[ir->coulombtype]);
1128 CHECK(ir->rcoulomb > ir->rlist);
1130 else if (ir->cutoff_scheme == ecutsGROUP && ir->coulomb_modifier == eintmodNONE)
1132 if (ir->coulombtype == eelPME || ir->coulombtype == eelP3M_AD)
1135 "With coulombtype = %s (without modifier), rcoulomb must be equal to rlist,\n"
1136 "or rlistlong if nstcalclr=1. For optimal energy conservation,consider using\n"
1137 "a potential modifier.", eel_names[ir->coulombtype]);
1138 if (ir->nstcalclr == 1)
1140 CHECK(ir->rcoulomb != ir->rlist && ir->rcoulomb != ir->rlistlong);
1144 CHECK(ir->rcoulomb != ir->rlist);
1150 if (EVDW_PME(ir->vdwtype))
1152 if (EVDW_MIGHT_BE_ZERO_AT_CUTOFF(ir->vdwtype))
1154 sprintf(err_buf, "With vdwtype = %s, rvdw must be <= rlist",
1155 evdw_names[ir->vdwtype]);
1156 CHECK(ir->rvdw > ir->rlist);
1161 "With vdwtype = %s, rvdw must be equal to rlist\n",
1162 evdw_names[ir->vdwtype]);
1163 CHECK(ir->rvdw != ir->rlist);
1167 if (EEL_PME(ir->coulombtype) || EVDW_PME(ir->vdwtype))
1169 if (ir->pme_order < 3)
1171 warning_error(wi, "pme-order can not be smaller than 3");
1175 if (ir->nwall == 2 && EEL_FULL(ir->coulombtype))
1177 if (ir->ewald_geometry == eewg3D)
1179 sprintf(warn_buf, "With pbc=%s you should use ewald-geometry=%s",
1180 epbc_names[ir->ePBC], eewg_names[eewg3DC]);
1181 warning(wi, warn_buf);
1183 /* This check avoids extra pbc coding for exclusion corrections */
1184 sprintf(err_buf, "wall-ewald-zfac should be >= 2");
1185 CHECK(ir->wall_ewald_zfac < 2);
1188 if (EVDW_SWITCHED(ir->vdwtype))
1190 sprintf(err_buf, "With vdwtype = %s rvdw-switch must be < rvdw. Or, better - use a potential modifier.",
1191 evdw_names[ir->vdwtype]);
1192 CHECK(ir->rvdw_switch >= ir->rvdw);
1194 else if (ir->vdwtype == evdwCUT)
1196 if (ir->cutoff_scheme == ecutsGROUP && ir->vdw_modifier == eintmodNONE)
1198 sprintf(err_buf, "With vdwtype = %s, rvdw must be >= rlist unless you use a potential modifier", evdw_names[ir->vdwtype]);
1199 CHECK(ir->rlist > ir->rvdw);
1202 if (ir->cutoff_scheme == ecutsGROUP)
1204 if (((ir->coulomb_modifier != eintmodNONE && ir->rcoulomb == ir->rlist) ||
1205 (ir->vdw_modifier != eintmodNONE && ir->rvdw == ir->rlist)) &&
1208 warning_note(wi, "With exact cut-offs, rlist should be "
1209 "larger than rcoulomb and rvdw, so that there "
1210 "is a buffer region for particle motion "
1211 "between neighborsearch steps");
1214 if (EEL_IS_ZERO_AT_CUTOFF(ir->coulombtype)
1215 && (ir->rlistlong <= ir->rcoulomb))
1217 sprintf(warn_buf, "For energy conservation with switch/shift potentials, %s should be 0.1 to 0.3 nm larger than rcoulomb.",
1218 IR_TWINRANGE(*ir) ? "rlistlong" : "rlist");
1219 warning_note(wi, warn_buf);
1221 if (EVDW_SWITCHED(ir->vdwtype) && (ir->rlistlong <= ir->rvdw))
1223 sprintf(warn_buf, "For energy conservation with switch/shift potentials, %s should be 0.1 to 0.3 nm larger than rvdw.",
1224 IR_TWINRANGE(*ir) ? "rlistlong" : "rlist");
1225 warning_note(wi, warn_buf);
1229 if (ir->vdwtype == evdwUSER && ir->eDispCorr != edispcNO)
1231 warning_note(wi, "You have selected user tables with dispersion correction, the dispersion will be corrected to -C6/r^6 beyond rvdw_switch (the tabulated interaction between rvdw_switch and rvdw will not be double counted). Make sure that you really want dispersion correction to -C6/r^6.");
1234 if (ir->nstlist == -1)
1236 sprintf(err_buf, "With nstlist=-1 rvdw and rcoulomb should be smaller than rlist to account for diffusion and possibly charge-group radii");
1237 CHECK(ir->rvdw >= ir->rlist || ir->rcoulomb >= ir->rlist);
1239 sprintf(err_buf, "nstlist can not be smaller than -1");
1240 CHECK(ir->nstlist < -1);
1242 if (ir->eI == eiLBFGS && (ir->coulombtype == eelCUT || ir->vdwtype == evdwCUT)
1245 warning(wi, "For efficient BFGS minimization, use switch/shift/pme instead of cut-off.");
1248 if (ir->eI == eiLBFGS && ir->nbfgscorr <= 0)
1250 warning(wi, "Using L-BFGS with nbfgscorr<=0 just gets you steepest descent.");
1253 /* ENERGY CONSERVATION */
1254 if (ir_NVE(ir) && ir->cutoff_scheme == ecutsGROUP)
1256 if (!EVDW_MIGHT_BE_ZERO_AT_CUTOFF(ir->vdwtype) && ir->rvdw > 0 && ir->vdw_modifier == eintmodNONE)
1258 sprintf(warn_buf, "You are using a cut-off for VdW interactions with NVE, for good energy conservation use vdwtype = %s (possibly with DispCorr)",
1259 evdw_names[evdwSHIFT]);
1260 warning_note(wi, warn_buf);
1262 if (!EEL_MIGHT_BE_ZERO_AT_CUTOFF(ir->coulombtype) && ir->rcoulomb > 0 && ir->coulomb_modifier == eintmodNONE)
1264 sprintf(warn_buf, "You are using a cut-off for electrostatics with NVE, for good energy conservation use coulombtype = %s or %s",
1265 eel_names[eelPMESWITCH], eel_names[eelRF_ZERO]);
1266 warning_note(wi, warn_buf);
1270 /* IMPLICIT SOLVENT */
1271 if (ir->coulombtype == eelGB_NOTUSED)
1273 ir->coulombtype = eelCUT;
1274 ir->implicit_solvent = eisGBSA;
1275 fprintf(stderr, "Note: Old option for generalized born electrostatics given:\n"
1276 "Changing coulombtype from \"generalized-born\" to \"cut-off\" and instead\n"
1277 "setting implicit-solvent value to \"GBSA\" in input section.\n");
1280 if (ir->sa_algorithm == esaSTILL)
1282 sprintf(err_buf, "Still SA algorithm not available yet, use %s or %s instead\n", esa_names[esaAPPROX], esa_names[esaNO]);
1283 CHECK(ir->sa_algorithm == esaSTILL);
1286 if (ir->implicit_solvent == eisGBSA)
1288 sprintf(err_buf, "With GBSA implicit solvent, rgbradii must be equal to rlist.");
1289 CHECK(ir->rgbradii != ir->rlist);
1291 if (ir->coulombtype != eelCUT)
1293 sprintf(err_buf, "With GBSA, coulombtype must be equal to %s\n", eel_names[eelCUT]);
1294 CHECK(ir->coulombtype != eelCUT);
1296 if (ir->vdwtype != evdwCUT)
1298 sprintf(err_buf, "With GBSA, vdw-type must be equal to %s\n", evdw_names[evdwCUT]);
1299 CHECK(ir->vdwtype != evdwCUT);
1301 if (ir->nstgbradii < 1)
1303 sprintf(warn_buf, "Using GBSA with nstgbradii<1, setting nstgbradii=1");
1304 warning_note(wi, warn_buf);
1307 if (ir->sa_algorithm == esaNO)
1309 sprintf(warn_buf, "No SA (non-polar) calculation requested together with GB. Are you sure this is what you want?\n");
1310 warning_note(wi, warn_buf);
1312 if (ir->sa_surface_tension < 0 && ir->sa_algorithm != esaNO)
1314 sprintf(warn_buf, "Value of sa_surface_tension is < 0. Changing it to 2.05016 or 2.25936 kJ/nm^2/mol for Still and HCT/OBC respectively\n");
1315 warning_note(wi, warn_buf);
1317 if (ir->gb_algorithm == egbSTILL)
1319 ir->sa_surface_tension = 0.0049 * CAL2JOULE * 100;
1323 ir->sa_surface_tension = 0.0054 * CAL2JOULE * 100;
1326 if (ir->sa_surface_tension == 0 && ir->sa_algorithm != esaNO)
1328 sprintf(err_buf, "Surface tension set to 0 while SA-calculation requested\n");
1329 CHECK(ir->sa_surface_tension == 0 && ir->sa_algorithm != esaNO);
1336 if (ir->cutoff_scheme != ecutsGROUP)
1338 warning_error(wi, "AdresS simulation supports only cutoff-scheme=group");
1342 warning_error(wi, "AdresS simulation supports only stochastic dynamics");
1344 if (ir->epc != epcNO)
1346 warning_error(wi, "AdresS simulation does not support pressure coupling");
1348 if (EEL_FULL(ir->coulombtype))
1350 warning_error(wi, "AdresS simulation does not support long-range electrostatics");
1355 /* count the number of text elemets separated by whitespace in a string.
1356 str = the input string
1357 maxptr = the maximum number of allowed elements
1358 ptr = the output array of pointers to the first character of each element
1359 returns: the number of elements. */
1360 int str_nelem(const char *str, int maxptr, char *ptr[])
1365 copy0 = strdup(str);
1368 while (*copy != '\0')
1372 gmx_fatal(FARGS, "Too many groups on line: '%s' (max is %d)",
1380 while ((*copy != '\0') && !isspace(*copy))
1399 /* interpret a number of doubles from a string and put them in an array,
1400 after allocating space for them.
1401 str = the input string
1402 n = the (pre-allocated) number of doubles read
1403 r = the output array of doubles. */
1404 static void parse_n_real(char *str, int *n, real **r)
1409 *n = str_nelem(str, MAXPTR, ptr);
1412 for (i = 0; i < *n; i++)
1414 (*r)[i] = strtod(ptr[i], NULL);
1418 static void do_fep_params(t_inputrec *ir, char fep_lambda[][STRLEN], char weights[STRLEN])
1421 int i, j, max_n_lambda, nweights, nfep[efptNR];
1422 t_lambda *fep = ir->fepvals;
1423 t_expanded *expand = ir->expandedvals;
1424 real **count_fep_lambdas;
1425 gmx_bool bOneLambda = TRUE;
1427 snew(count_fep_lambdas, efptNR);
1429 /* FEP input processing */
1430 /* first, identify the number of lambda values for each type.
1431 All that are nonzero must have the same number */
1433 for (i = 0; i < efptNR; i++)
1435 parse_n_real(fep_lambda[i], &(nfep[i]), &(count_fep_lambdas[i]));
1438 /* now, determine the number of components. All must be either zero, or equal. */
1441 for (i = 0; i < efptNR; i++)
1443 if (nfep[i] > max_n_lambda)
1445 max_n_lambda = nfep[i]; /* here's a nonzero one. All of them
1446 must have the same number if its not zero.*/
1451 for (i = 0; i < efptNR; i++)
1455 ir->fepvals->separate_dvdl[i] = FALSE;
1457 else if (nfep[i] == max_n_lambda)
1459 if (i != efptTEMPERATURE) /* we treat this differently -- not really a reason to compute the derivative with
1460 respect to the temperature currently */
1462 ir->fepvals->separate_dvdl[i] = TRUE;
1467 gmx_fatal(FARGS, "Number of lambdas (%d) for FEP type %s not equal to number of other types (%d)",
1468 nfep[i], efpt_names[i], max_n_lambda);
1471 /* we don't print out dhdl if the temperature is changing, since we can't correctly define dhdl in this case */
1472 ir->fepvals->separate_dvdl[efptTEMPERATURE] = FALSE;
1474 /* the number of lambdas is the number we've read in, which is either zero
1475 or the same for all */
1476 fep->n_lambda = max_n_lambda;
1478 /* allocate space for the array of lambda values */
1479 snew(fep->all_lambda, efptNR);
1480 /* if init_lambda is defined, we need to set lambda */
1481 if ((fep->init_lambda > 0) && (fep->n_lambda == 0))
1483 ir->fepvals->separate_dvdl[efptFEP] = TRUE;
1485 /* otherwise allocate the space for all of the lambdas, and transfer the data */
1486 for (i = 0; i < efptNR; i++)
1488 snew(fep->all_lambda[i], fep->n_lambda);
1489 if (nfep[i] > 0) /* if it's zero, then the count_fep_lambda arrays
1492 for (j = 0; j < fep->n_lambda; j++)
1494 fep->all_lambda[i][j] = (double)count_fep_lambdas[i][j];
1496 sfree(count_fep_lambdas[i]);
1499 sfree(count_fep_lambdas);
1501 /* "fep-vals" is either zero or the full number. If zero, we'll need to define fep-lambdas for internal
1502 bookkeeping -- for now, init_lambda */
1504 if ((nfep[efptFEP] == 0) && (fep->init_lambda >= 0))
1506 for (i = 0; i < fep->n_lambda; i++)
1508 fep->all_lambda[efptFEP][i] = fep->init_lambda;
1512 /* check to see if only a single component lambda is defined, and soft core is defined.
1513 In this case, turn on coulomb soft core */
1515 if (max_n_lambda == 0)
1521 for (i = 0; i < efptNR; i++)
1523 if ((nfep[i] != 0) && (i != efptFEP))
1529 if ((bOneLambda) && (fep->sc_alpha > 0))
1531 fep->bScCoul = TRUE;
1534 /* Fill in the others with the efptFEP if they are not explicitly
1535 specified (i.e. nfep[i] == 0). This means if fep is not defined,
1536 they are all zero. */
1538 for (i = 0; i < efptNR; i++)
1540 if ((nfep[i] == 0) && (i != efptFEP))
1542 for (j = 0; j < fep->n_lambda; j++)
1544 fep->all_lambda[i][j] = fep->all_lambda[efptFEP][j];
1550 /* make it easier if sc_r_power = 48 by increasing it to the 4th power, to be in the right scale. */
1551 if (fep->sc_r_power == 48)
1553 if (fep->sc_alpha > 0.1)
1555 gmx_fatal(FARGS, "sc_alpha (%f) for sc_r_power = 48 should usually be between 0.001 and 0.004", fep->sc_alpha);
1559 expand = ir->expandedvals;
1560 /* now read in the weights */
1561 parse_n_real(weights, &nweights, &(expand->init_lambda_weights));
1564 snew(expand->init_lambda_weights, fep->n_lambda); /* initialize to zero */
1566 else if (nweights != fep->n_lambda)
1568 gmx_fatal(FARGS, "Number of weights (%d) is not equal to number of lambda values (%d)",
1569 nweights, fep->n_lambda);
1571 if ((expand->nstexpanded < 0) && (ir->efep != efepNO))
1573 expand->nstexpanded = fep->nstdhdl;
1574 /* if you don't specify nstexpanded when doing expanded ensemble free energy calcs, it is set to nstdhdl */
1576 if ((expand->nstexpanded < 0) && ir->bSimTemp)
1578 expand->nstexpanded = 2*(int)(ir->opts.tau_t[0]/ir->delta_t);
1579 /* if you don't specify nstexpanded when doing expanded ensemble simulated tempering, it is set to
1580 2*tau_t just to be careful so it's not to frequent */
1585 static void do_simtemp_params(t_inputrec *ir)
1588 snew(ir->simtempvals->temperatures, ir->fepvals->n_lambda);
1589 GetSimTemps(ir->fepvals->n_lambda, ir->simtempvals, ir->fepvals->all_lambda[efptTEMPERATURE]);
1594 static void do_wall_params(t_inputrec *ir,
1595 char *wall_atomtype, char *wall_density,
1599 char *names[MAXPTR];
1602 opts->wall_atomtype[0] = NULL;
1603 opts->wall_atomtype[1] = NULL;
1605 ir->wall_atomtype[0] = -1;
1606 ir->wall_atomtype[1] = -1;
1607 ir->wall_density[0] = 0;
1608 ir->wall_density[1] = 0;
1612 nstr = str_nelem(wall_atomtype, MAXPTR, names);
1613 if (nstr != ir->nwall)
1615 gmx_fatal(FARGS, "Expected %d elements for wall_atomtype, found %d",
1618 for (i = 0; i < ir->nwall; i++)
1620 opts->wall_atomtype[i] = strdup(names[i]);
1623 if (ir->wall_type == ewt93 || ir->wall_type == ewt104)
1625 nstr = str_nelem(wall_density, MAXPTR, names);
1626 if (nstr != ir->nwall)
1628 gmx_fatal(FARGS, "Expected %d elements for wall-density, found %d", ir->nwall, nstr);
1630 for (i = 0; i < ir->nwall; i++)
1632 sscanf(names[i], "%lf", &dbl);
1635 gmx_fatal(FARGS, "wall-density[%d] = %f\n", i, dbl);
1637 ir->wall_density[i] = dbl;
1643 static void add_wall_energrps(gmx_groups_t *groups, int nwall, t_symtab *symtab)
1651 srenew(groups->grpname, groups->ngrpname+nwall);
1652 grps = &(groups->grps[egcENER]);
1653 srenew(grps->nm_ind, grps->nr+nwall);
1654 for (i = 0; i < nwall; i++)
1656 sprintf(str, "wall%d", i);
1657 groups->grpname[groups->ngrpname] = put_symtab(symtab, str);
1658 grps->nm_ind[grps->nr++] = groups->ngrpname++;
1663 void read_expandedparams(int *ninp_p, t_inpfile **inp_p,
1664 t_expanded *expand, warninp_t wi)
1666 int ninp, nerror = 0;
1672 /* read expanded ensemble parameters */
1673 CCTYPE ("expanded ensemble variables");
1674 ITYPE ("nstexpanded", expand->nstexpanded, -1);
1675 EETYPE("lmc-stats", expand->elamstats, elamstats_names);
1676 EETYPE("lmc-move", expand->elmcmove, elmcmove_names);
1677 EETYPE("lmc-weights-equil", expand->elmceq, elmceq_names);
1678 ITYPE ("weight-equil-number-all-lambda", expand->equil_n_at_lam, -1);
1679 ITYPE ("weight-equil-number-samples", expand->equil_samples, -1);
1680 ITYPE ("weight-equil-number-steps", expand->equil_steps, -1);
1681 RTYPE ("weight-equil-wl-delta", expand->equil_wl_delta, -1);
1682 RTYPE ("weight-equil-count-ratio", expand->equil_ratio, -1);
1683 CCTYPE("Seed for Monte Carlo in lambda space");
1684 ITYPE ("lmc-seed", expand->lmc_seed, -1);
1685 RTYPE ("mc-temperature", expand->mc_temp, -1);
1686 ITYPE ("lmc-repeats", expand->lmc_repeats, 1);
1687 ITYPE ("lmc-gibbsdelta", expand->gibbsdeltalam, -1);
1688 ITYPE ("lmc-forced-nstart", expand->lmc_forced_nstart, 0);
1689 EETYPE("symmetrized-transition-matrix", expand->bSymmetrizedTMatrix, yesno_names);
1690 ITYPE("nst-transition-matrix", expand->nstTij, -1);
1691 ITYPE ("mininum-var-min", expand->minvarmin, 100); /*default is reasonable */
1692 ITYPE ("weight-c-range", expand->c_range, 0); /* default is just C=0 */
1693 RTYPE ("wl-scale", expand->wl_scale, 0.8);
1694 RTYPE ("wl-ratio", expand->wl_ratio, 0.8);
1695 RTYPE ("init-wl-delta", expand->init_wl_delta, 1.0);
1696 EETYPE("wl-oneovert", expand->bWLoneovert, yesno_names);
1704 void get_ir(const char *mdparin, const char *mdparout,
1705 t_inputrec *ir, t_gromppopts *opts,
1709 double dumdub[2][6];
1713 char warn_buf[STRLEN];
1714 t_lambda *fep = ir->fepvals;
1715 t_expanded *expand = ir->expandedvals;
1717 init_inputrec_strings();
1718 inp = read_inpfile(mdparin, &ninp, wi);
1720 snew(dumstr[0], STRLEN);
1721 snew(dumstr[1], STRLEN);
1723 if (-1 == search_einp(ninp, inp, "cutoff-scheme"))
1726 "%s did not specify a value for the .mdp option "
1727 "\"cutoff-scheme\". Probably it was first intended for use "
1728 "with GROMACS before 4.6. In 4.6, the Verlet scheme was "
1729 "introduced, but the group scheme was still the default. "
1730 "The default is now the Verlet scheme, so you will observe "
1731 "different behaviour.", mdparin);
1732 warning_note(wi, warn_buf);
1735 /* remove the following deprecated commands */
1738 REM_TYPE("domain-decomposition");
1739 REM_TYPE("andersen-seed");
1741 REM_TYPE("dihre-fc");
1742 REM_TYPE("dihre-tau");
1743 REM_TYPE("nstdihreout");
1744 REM_TYPE("nstcheckpoint");
1746 /* replace the following commands with the clearer new versions*/
1747 REPL_TYPE("unconstrained-start", "continuation");
1748 REPL_TYPE("foreign-lambda", "fep-lambdas");
1749 REPL_TYPE("verlet-buffer-drift", "verlet-buffer-tolerance");
1750 REPL_TYPE("nstxtcout", "nstxout-compressed");
1751 REPL_TYPE("xtc-grps", "compressed-x-grps");
1752 REPL_TYPE("xtc-precision", "compressed-x-precision");
1754 CCTYPE ("VARIOUS PREPROCESSING OPTIONS");
1755 CTYPE ("Preprocessor information: use cpp syntax.");
1756 CTYPE ("e.g.: -I/home/joe/doe -I/home/mary/roe");
1757 STYPE ("include", opts->include, NULL);
1758 CTYPE ("e.g.: -DPOSRES -DFLEXIBLE (note these variable names are case sensitive)");
1759 STYPE ("define", opts->define, NULL);
1761 CCTYPE ("RUN CONTROL PARAMETERS");
1762 EETYPE("integrator", ir->eI, ei_names);
1763 CTYPE ("Start time and timestep in ps");
1764 RTYPE ("tinit", ir->init_t, 0.0);
1765 RTYPE ("dt", ir->delta_t, 0.001);
1766 STEPTYPE ("nsteps", ir->nsteps, 0);
1767 CTYPE ("For exact run continuation or redoing part of a run");
1768 STEPTYPE ("init-step", ir->init_step, 0);
1769 CTYPE ("Part index is updated automatically on checkpointing (keeps files separate)");
1770 ITYPE ("simulation-part", ir->simulation_part, 1);
1771 CTYPE ("mode for center of mass motion removal");
1772 EETYPE("comm-mode", ir->comm_mode, ecm_names);
1773 CTYPE ("number of steps for center of mass motion removal");
1774 ITYPE ("nstcomm", ir->nstcomm, 100);
1775 CTYPE ("group(s) for center of mass motion removal");
1776 STYPE ("comm-grps", is->vcm, NULL);
1778 CCTYPE ("LANGEVIN DYNAMICS OPTIONS");
1779 CTYPE ("Friction coefficient (amu/ps) and random seed");
1780 RTYPE ("bd-fric", ir->bd_fric, 0.0);
1781 ITYPE ("ld-seed", ir->ld_seed, 1993);
1784 CCTYPE ("ENERGY MINIMIZATION OPTIONS");
1785 CTYPE ("Force tolerance and initial step-size");
1786 RTYPE ("emtol", ir->em_tol, 10.0);
1787 RTYPE ("emstep", ir->em_stepsize, 0.01);
1788 CTYPE ("Max number of iterations in relax-shells");
1789 ITYPE ("niter", ir->niter, 20);
1790 CTYPE ("Step size (ps^2) for minimization of flexible constraints");
1791 RTYPE ("fcstep", ir->fc_stepsize, 0);
1792 CTYPE ("Frequency of steepest descents steps when doing CG");
1793 ITYPE ("nstcgsteep", ir->nstcgsteep, 1000);
1794 ITYPE ("nbfgscorr", ir->nbfgscorr, 10);
1796 CCTYPE ("TEST PARTICLE INSERTION OPTIONS");
1797 RTYPE ("rtpi", ir->rtpi, 0.05);
1799 /* Output options */
1800 CCTYPE ("OUTPUT CONTROL OPTIONS");
1801 CTYPE ("Output frequency for coords (x), velocities (v) and forces (f)");
1802 ITYPE ("nstxout", ir->nstxout, 0);
1803 ITYPE ("nstvout", ir->nstvout, 0);
1804 ITYPE ("nstfout", ir->nstfout, 0);
1805 ir->nstcheckpoint = 1000;
1806 CTYPE ("Output frequency for energies to log file and energy file");
1807 ITYPE ("nstlog", ir->nstlog, 1000);
1808 ITYPE ("nstcalcenergy", ir->nstcalcenergy, 100);
1809 ITYPE ("nstenergy", ir->nstenergy, 1000);
1810 CTYPE ("Output frequency and precision for .xtc file");
1811 ITYPE ("nstxout-compressed", ir->nstxout_compressed, 0);
1812 RTYPE ("compressed-x-precision", ir->x_compression_precision, 1000.0);
1813 CTYPE ("This selects the subset of atoms for the compressed");
1814 CTYPE ("trajectory file. You can select multiple groups. By");
1815 CTYPE ("default, all atoms will be written.");
1816 STYPE ("compressed-x-grps", is->x_compressed_groups, NULL);
1817 CTYPE ("Selection of energy groups");
1818 STYPE ("energygrps", is->energy, NULL);
1820 /* Neighbor searching */
1821 CCTYPE ("NEIGHBORSEARCHING PARAMETERS");
1822 CTYPE ("cut-off scheme (Verlet: particle based cut-offs, group: using charge groups)");
1823 EETYPE("cutoff-scheme", ir->cutoff_scheme, ecutscheme_names);
1824 CTYPE ("nblist update frequency");
1825 ITYPE ("nstlist", ir->nstlist, 10);
1826 CTYPE ("ns algorithm (simple or grid)");
1827 EETYPE("ns-type", ir->ns_type, ens_names);
1828 /* set ndelta to the optimal value of 2 */
1830 CTYPE ("Periodic boundary conditions: xyz, no, xy");
1831 EETYPE("pbc", ir->ePBC, epbc_names);
1832 EETYPE("periodic-molecules", ir->bPeriodicMols, yesno_names);
1833 CTYPE ("Allowed energy error due to the Verlet buffer in kJ/mol/ps per atom,");
1834 CTYPE ("a value of -1 means: use rlist");
1835 RTYPE("verlet-buffer-tolerance", ir->verletbuf_tol, 0.005);
1836 CTYPE ("nblist cut-off");
1837 RTYPE ("rlist", ir->rlist, 1.0);
1838 CTYPE ("long-range cut-off for switched potentials");
1839 RTYPE ("rlistlong", ir->rlistlong, -1);
1840 ITYPE ("nstcalclr", ir->nstcalclr, -1);
1842 /* Electrostatics */
1843 CCTYPE ("OPTIONS FOR ELECTROSTATICS AND VDW");
1844 CTYPE ("Method for doing electrostatics");
1845 EETYPE("coulombtype", ir->coulombtype, eel_names);
1846 EETYPE("coulomb-modifier", ir->coulomb_modifier, eintmod_names);
1847 CTYPE ("cut-off lengths");
1848 RTYPE ("rcoulomb-switch", ir->rcoulomb_switch, 0.0);
1849 RTYPE ("rcoulomb", ir->rcoulomb, 1.0);
1850 CTYPE ("Relative dielectric constant for the medium and the reaction field");
1851 RTYPE ("epsilon-r", ir->epsilon_r, 1.0);
1852 RTYPE ("epsilon-rf", ir->epsilon_rf, 0.0);
1853 CTYPE ("Method for doing Van der Waals");
1854 EETYPE("vdw-type", ir->vdwtype, evdw_names);
1855 EETYPE("vdw-modifier", ir->vdw_modifier, eintmod_names);
1856 CTYPE ("cut-off lengths");
1857 RTYPE ("rvdw-switch", ir->rvdw_switch, 0.0);
1858 RTYPE ("rvdw", ir->rvdw, 1.0);
1859 CTYPE ("Apply long range dispersion corrections for Energy and Pressure");
1860 EETYPE("DispCorr", ir->eDispCorr, edispc_names);
1861 CTYPE ("Extension of the potential lookup tables beyond the cut-off");
1862 RTYPE ("table-extension", ir->tabext, 1.0);
1863 CTYPE ("Separate tables between energy group pairs");
1864 STYPE ("energygrp-table", is->egptable, NULL);
1865 CTYPE ("Spacing for the PME/PPPM FFT grid");
1866 RTYPE ("fourierspacing", ir->fourier_spacing, 0.12);
1867 CTYPE ("FFT grid size, when a value is 0 fourierspacing will be used");
1868 ITYPE ("fourier-nx", ir->nkx, 0);
1869 ITYPE ("fourier-ny", ir->nky, 0);
1870 ITYPE ("fourier-nz", ir->nkz, 0);
1871 CTYPE ("EWALD/PME/PPPM parameters");
1872 ITYPE ("pme-order", ir->pme_order, 4);
1873 RTYPE ("ewald-rtol", ir->ewald_rtol, 0.00001);
1874 RTYPE ("ewald-rtol-lj", ir->ewald_rtol_lj, 0.001);
1875 EETYPE("lj-pme-comb-rule", ir->ljpme_combination_rule, eljpme_names);
1876 EETYPE("ewald-geometry", ir->ewald_geometry, eewg_names);
1877 RTYPE ("epsilon-surface", ir->epsilon_surface, 0.0);
1878 EETYPE("optimize-fft", ir->bOptFFT, yesno_names);
1880 CCTYPE("IMPLICIT SOLVENT ALGORITHM");
1881 EETYPE("implicit-solvent", ir->implicit_solvent, eis_names);
1883 CCTYPE ("GENERALIZED BORN ELECTROSTATICS");
1884 CTYPE ("Algorithm for calculating Born radii");
1885 EETYPE("gb-algorithm", ir->gb_algorithm, egb_names);
1886 CTYPE ("Frequency of calculating the Born radii inside rlist");
1887 ITYPE ("nstgbradii", ir->nstgbradii, 1);
1888 CTYPE ("Cutoff for Born radii calculation; the contribution from atoms");
1889 CTYPE ("between rlist and rgbradii is updated every nstlist steps");
1890 RTYPE ("rgbradii", ir->rgbradii, 1.0);
1891 CTYPE ("Dielectric coefficient of the implicit solvent");
1892 RTYPE ("gb-epsilon-solvent", ir->gb_epsilon_solvent, 80.0);
1893 CTYPE ("Salt concentration in M for Generalized Born models");
1894 RTYPE ("gb-saltconc", ir->gb_saltconc, 0.0);
1895 CTYPE ("Scaling factors used in the OBC GB model. Default values are OBC(II)");
1896 RTYPE ("gb-obc-alpha", ir->gb_obc_alpha, 1.0);
1897 RTYPE ("gb-obc-beta", ir->gb_obc_beta, 0.8);
1898 RTYPE ("gb-obc-gamma", ir->gb_obc_gamma, 4.85);
1899 RTYPE ("gb-dielectric-offset", ir->gb_dielectric_offset, 0.009);
1900 EETYPE("sa-algorithm", ir->sa_algorithm, esa_names);
1901 CTYPE ("Surface tension (kJ/mol/nm^2) for the SA (nonpolar surface) part of GBSA");
1902 CTYPE ("The value -1 will set default value for Still/HCT/OBC GB-models.");
1903 RTYPE ("sa-surface-tension", ir->sa_surface_tension, -1);
1905 /* Coupling stuff */
1906 CCTYPE ("OPTIONS FOR WEAK COUPLING ALGORITHMS");
1907 CTYPE ("Temperature coupling");
1908 EETYPE("tcoupl", ir->etc, etcoupl_names);
1909 ITYPE ("nsttcouple", ir->nsttcouple, -1);
1910 ITYPE("nh-chain-length", ir->opts.nhchainlength, 10);
1911 EETYPE("print-nose-hoover-chain-variables", ir->bPrintNHChains, yesno_names);
1912 CTYPE ("Groups to couple separately");
1913 STYPE ("tc-grps", is->tcgrps, NULL);
1914 CTYPE ("Time constant (ps) and reference temperature (K)");
1915 STYPE ("tau-t", is->tau_t, NULL);
1916 STYPE ("ref-t", is->ref_t, NULL);
1917 CTYPE ("pressure coupling");
1918 EETYPE("pcoupl", ir->epc, epcoupl_names);
1919 EETYPE("pcoupltype", ir->epct, epcoupltype_names);
1920 ITYPE ("nstpcouple", ir->nstpcouple, -1);
1921 CTYPE ("Time constant (ps), compressibility (1/bar) and reference P (bar)");
1922 RTYPE ("tau-p", ir->tau_p, 1.0);
1923 STYPE ("compressibility", dumstr[0], NULL);
1924 STYPE ("ref-p", dumstr[1], NULL);
1925 CTYPE ("Scaling of reference coordinates, No, All or COM");
1926 EETYPE ("refcoord-scaling", ir->refcoord_scaling, erefscaling_names);
1929 CCTYPE ("OPTIONS FOR QMMM calculations");
1930 EETYPE("QMMM", ir->bQMMM, yesno_names);
1931 CTYPE ("Groups treated Quantum Mechanically");
1932 STYPE ("QMMM-grps", is->QMMM, NULL);
1933 CTYPE ("QM method");
1934 STYPE("QMmethod", is->QMmethod, NULL);
1935 CTYPE ("QMMM scheme");
1936 EETYPE("QMMMscheme", ir->QMMMscheme, eQMMMscheme_names);
1937 CTYPE ("QM basisset");
1938 STYPE("QMbasis", is->QMbasis, NULL);
1939 CTYPE ("QM charge");
1940 STYPE ("QMcharge", is->QMcharge, NULL);
1941 CTYPE ("QM multiplicity");
1942 STYPE ("QMmult", is->QMmult, NULL);
1943 CTYPE ("Surface Hopping");
1944 STYPE ("SH", is->bSH, NULL);
1945 CTYPE ("CAS space options");
1946 STYPE ("CASorbitals", is->CASorbitals, NULL);
1947 STYPE ("CASelectrons", is->CASelectrons, NULL);
1948 STYPE ("SAon", is->SAon, NULL);
1949 STYPE ("SAoff", is->SAoff, NULL);
1950 STYPE ("SAsteps", is->SAsteps, NULL);
1951 CTYPE ("Scale factor for MM charges");
1952 RTYPE ("MMChargeScaleFactor", ir->scalefactor, 1.0);
1953 CTYPE ("Optimization of QM subsystem");
1954 STYPE ("bOPT", is->bOPT, NULL);
1955 STYPE ("bTS", is->bTS, NULL);
1957 /* Simulated annealing */
1958 CCTYPE("SIMULATED ANNEALING");
1959 CTYPE ("Type of annealing for each temperature group (no/single/periodic)");
1960 STYPE ("annealing", is->anneal, NULL);
1961 CTYPE ("Number of time points to use for specifying annealing in each group");
1962 STYPE ("annealing-npoints", is->anneal_npoints, NULL);
1963 CTYPE ("List of times at the annealing points for each group");
1964 STYPE ("annealing-time", is->anneal_time, NULL);
1965 CTYPE ("Temp. at each annealing point, for each group.");
1966 STYPE ("annealing-temp", is->anneal_temp, NULL);
1969 CCTYPE ("GENERATE VELOCITIES FOR STARTUP RUN");
1970 EETYPE("gen-vel", opts->bGenVel, yesno_names);
1971 RTYPE ("gen-temp", opts->tempi, 300.0);
1972 ITYPE ("gen-seed", opts->seed, 173529);
1975 CCTYPE ("OPTIONS FOR BONDS");
1976 EETYPE("constraints", opts->nshake, constraints);
1977 CTYPE ("Type of constraint algorithm");
1978 EETYPE("constraint-algorithm", ir->eConstrAlg, econstr_names);
1979 CTYPE ("Do not constrain the start configuration");
1980 EETYPE("continuation", ir->bContinuation, yesno_names);
1981 CTYPE ("Use successive overrelaxation to reduce the number of shake iterations");
1982 EETYPE("Shake-SOR", ir->bShakeSOR, yesno_names);
1983 CTYPE ("Relative tolerance of shake");
1984 RTYPE ("shake-tol", ir->shake_tol, 0.0001);
1985 CTYPE ("Highest order in the expansion of the constraint coupling matrix");
1986 ITYPE ("lincs-order", ir->nProjOrder, 4);
1987 CTYPE ("Number of iterations in the final step of LINCS. 1 is fine for");
1988 CTYPE ("normal simulations, but use 2 to conserve energy in NVE runs.");
1989 CTYPE ("For energy minimization with constraints it should be 4 to 8.");
1990 ITYPE ("lincs-iter", ir->nLincsIter, 1);
1991 CTYPE ("Lincs will write a warning to the stderr if in one step a bond");
1992 CTYPE ("rotates over more degrees than");
1993 RTYPE ("lincs-warnangle", ir->LincsWarnAngle, 30.0);
1994 CTYPE ("Convert harmonic bonds to morse potentials");
1995 EETYPE("morse", opts->bMorse, yesno_names);
1997 /* Energy group exclusions */
1998 CCTYPE ("ENERGY GROUP EXCLUSIONS");
1999 CTYPE ("Pairs of energy groups for which all non-bonded interactions are excluded");
2000 STYPE ("energygrp-excl", is->egpexcl, NULL);
2004 CTYPE ("Number of walls, type, atom types, densities and box-z scale factor for Ewald");
2005 ITYPE ("nwall", ir->nwall, 0);
2006 EETYPE("wall-type", ir->wall_type, ewt_names);
2007 RTYPE ("wall-r-linpot", ir->wall_r_linpot, -1);
2008 STYPE ("wall-atomtype", is->wall_atomtype, NULL);
2009 STYPE ("wall-density", is->wall_density, NULL);
2010 RTYPE ("wall-ewald-zfac", ir->wall_ewald_zfac, 3);
2013 CCTYPE("COM PULLING");
2014 CTYPE("Pull type: no, umbrella, constraint or constant-force");
2015 EETYPE("pull", ir->ePull, epull_names);
2016 if (ir->ePull != epullNO)
2019 is->pull_grp = read_pullparams(&ninp, &inp, ir->pull, &opts->pull_start, wi);
2022 /* Enforced rotation */
2023 CCTYPE("ENFORCED ROTATION");
2024 CTYPE("Enforced rotation: No or Yes");
2025 EETYPE("rotation", ir->bRot, yesno_names);
2029 is->rot_grp = read_rotparams(&ninp, &inp, ir->rot, wi);
2033 CCTYPE("NMR refinement stuff");
2034 CTYPE ("Distance restraints type: No, Simple or Ensemble");
2035 EETYPE("disre", ir->eDisre, edisre_names);
2036 CTYPE ("Force weighting of pairs in one distance restraint: Conservative or Equal");
2037 EETYPE("disre-weighting", ir->eDisreWeighting, edisreweighting_names);
2038 CTYPE ("Use sqrt of the time averaged times the instantaneous violation");
2039 EETYPE("disre-mixed", ir->bDisreMixed, yesno_names);
2040 RTYPE ("disre-fc", ir->dr_fc, 1000.0);
2041 RTYPE ("disre-tau", ir->dr_tau, 0.0);
2042 CTYPE ("Output frequency for pair distances to energy file");
2043 ITYPE ("nstdisreout", ir->nstdisreout, 100);
2044 CTYPE ("Orientation restraints: No or Yes");
2045 EETYPE("orire", opts->bOrire, yesno_names);
2046 CTYPE ("Orientation restraints force constant and tau for time averaging");
2047 RTYPE ("orire-fc", ir->orires_fc, 0.0);
2048 RTYPE ("orire-tau", ir->orires_tau, 0.0);
2049 STYPE ("orire-fitgrp", is->orirefitgrp, NULL);
2050 CTYPE ("Output frequency for trace(SD) and S to energy file");
2051 ITYPE ("nstorireout", ir->nstorireout, 100);
2053 /* free energy variables */
2054 CCTYPE ("Free energy variables");
2055 EETYPE("free-energy", ir->efep, efep_names);
2056 STYPE ("couple-moltype", is->couple_moltype, NULL);
2057 EETYPE("couple-lambda0", opts->couple_lam0, couple_lam);
2058 EETYPE("couple-lambda1", opts->couple_lam1, couple_lam);
2059 EETYPE("couple-intramol", opts->bCoupleIntra, yesno_names);
2061 RTYPE ("init-lambda", fep->init_lambda, -1); /* start with -1 so
2063 it was not entered */
2064 ITYPE ("init-lambda-state", fep->init_fep_state, -1);
2065 RTYPE ("delta-lambda", fep->delta_lambda, 0.0);
2066 ITYPE ("nstdhdl", fep->nstdhdl, 50);
2067 STYPE ("fep-lambdas", is->fep_lambda[efptFEP], NULL);
2068 STYPE ("mass-lambdas", is->fep_lambda[efptMASS], NULL);
2069 STYPE ("coul-lambdas", is->fep_lambda[efptCOUL], NULL);
2070 STYPE ("vdw-lambdas", is->fep_lambda[efptVDW], NULL);
2071 STYPE ("bonded-lambdas", is->fep_lambda[efptBONDED], NULL);
2072 STYPE ("restraint-lambdas", is->fep_lambda[efptRESTRAINT], NULL);
2073 STYPE ("temperature-lambdas", is->fep_lambda[efptTEMPERATURE], NULL);
2074 ITYPE ("calc-lambda-neighbors", fep->lambda_neighbors, 1);
2075 STYPE ("init-lambda-weights", is->lambda_weights, NULL);
2076 EETYPE("dhdl-print-energy", fep->bPrintEnergy, yesno_names);
2077 RTYPE ("sc-alpha", fep->sc_alpha, 0.0);
2078 ITYPE ("sc-power", fep->sc_power, 1);
2079 RTYPE ("sc-r-power", fep->sc_r_power, 6.0);
2080 RTYPE ("sc-sigma", fep->sc_sigma, 0.3);
2081 EETYPE("sc-coul", fep->bScCoul, yesno_names);
2082 ITYPE ("dh_hist_size", fep->dh_hist_size, 0);
2083 RTYPE ("dh_hist_spacing", fep->dh_hist_spacing, 0.1);
2084 EETYPE("separate-dhdl-file", fep->separate_dhdl_file,
2085 separate_dhdl_file_names);
2086 EETYPE("dhdl-derivatives", fep->dhdl_derivatives, dhdl_derivatives_names);
2087 ITYPE ("dh_hist_size", fep->dh_hist_size, 0);
2088 RTYPE ("dh_hist_spacing", fep->dh_hist_spacing, 0.1);
2090 /* Non-equilibrium MD stuff */
2091 CCTYPE("Non-equilibrium MD stuff");
2092 STYPE ("acc-grps", is->accgrps, NULL);
2093 STYPE ("accelerate", is->acc, NULL);
2094 STYPE ("freezegrps", is->freeze, NULL);
2095 STYPE ("freezedim", is->frdim, NULL);
2096 RTYPE ("cos-acceleration", ir->cos_accel, 0);
2097 STYPE ("deform", is->deform, NULL);
2099 /* simulated tempering variables */
2100 CCTYPE("simulated tempering variables");
2101 EETYPE("simulated-tempering", ir->bSimTemp, yesno_names);
2102 EETYPE("simulated-tempering-scaling", ir->simtempvals->eSimTempScale, esimtemp_names);
2103 RTYPE("sim-temp-low", ir->simtempvals->simtemp_low, 300.0);
2104 RTYPE("sim-temp-high", ir->simtempvals->simtemp_high, 300.0);
2106 /* expanded ensemble variables */
2107 if (ir->efep == efepEXPANDED || ir->bSimTemp)
2109 read_expandedparams(&ninp, &inp, expand, wi);
2112 /* Electric fields */
2113 CCTYPE("Electric fields");
2114 CTYPE ("Format is number of terms (int) and for all terms an amplitude (real)");
2115 CTYPE ("and a phase angle (real)");
2116 STYPE ("E-x", is->efield_x, NULL);
2117 STYPE ("E-xt", is->efield_xt, NULL);
2118 STYPE ("E-y", is->efield_y, NULL);
2119 STYPE ("E-yt", is->efield_yt, NULL);
2120 STYPE ("E-z", is->efield_z, NULL);
2121 STYPE ("E-zt", is->efield_zt, NULL);
2123 /* AdResS defined thingies */
2124 CCTYPE ("AdResS parameters");
2125 EETYPE("adress", ir->bAdress, yesno_names);
2128 snew(ir->adress, 1);
2129 read_adressparams(&ninp, &inp, ir->adress, wi);
2132 /* User defined thingies */
2133 CCTYPE ("User defined thingies");
2134 STYPE ("user1-grps", is->user1, NULL);
2135 STYPE ("user2-grps", is->user2, NULL);
2136 ITYPE ("userint1", ir->userint1, 0);
2137 ITYPE ("userint2", ir->userint2, 0);
2138 ITYPE ("userint3", ir->userint3, 0);
2139 ITYPE ("userint4", ir->userint4, 0);
2140 RTYPE ("userreal1", ir->userreal1, 0);
2141 RTYPE ("userreal2", ir->userreal2, 0);
2142 RTYPE ("userreal3", ir->userreal3, 0);
2143 RTYPE ("userreal4", ir->userreal4, 0);
2146 write_inpfile(mdparout, ninp, inp, FALSE, wi);
2147 for (i = 0; (i < ninp); i++)
2150 sfree(inp[i].value);
2154 /* Process options if necessary */
2155 for (m = 0; m < 2; m++)
2157 for (i = 0; i < 2*DIM; i++)
2166 if (sscanf(dumstr[m], "%lf", &(dumdub[m][XX])) != 1)
2168 warning_error(wi, "Pressure coupling not enough values (I need 1)");
2170 dumdub[m][YY] = dumdub[m][ZZ] = dumdub[m][XX];
2172 case epctSEMIISOTROPIC:
2173 case epctSURFACETENSION:
2174 if (sscanf(dumstr[m], "%lf%lf",
2175 &(dumdub[m][XX]), &(dumdub[m][ZZ])) != 2)
2177 warning_error(wi, "Pressure coupling not enough values (I need 2)");
2179 dumdub[m][YY] = dumdub[m][XX];
2181 case epctANISOTROPIC:
2182 if (sscanf(dumstr[m], "%lf%lf%lf%lf%lf%lf",
2183 &(dumdub[m][XX]), &(dumdub[m][YY]), &(dumdub[m][ZZ]),
2184 &(dumdub[m][3]), &(dumdub[m][4]), &(dumdub[m][5])) != 6)
2186 warning_error(wi, "Pressure coupling not enough values (I need 6)");
2190 gmx_fatal(FARGS, "Pressure coupling type %s not implemented yet",
2191 epcoupltype_names[ir->epct]);
2195 clear_mat(ir->ref_p);
2196 clear_mat(ir->compress);
2197 for (i = 0; i < DIM; i++)
2199 ir->ref_p[i][i] = dumdub[1][i];
2200 ir->compress[i][i] = dumdub[0][i];
2202 if (ir->epct == epctANISOTROPIC)
2204 ir->ref_p[XX][YY] = dumdub[1][3];
2205 ir->ref_p[XX][ZZ] = dumdub[1][4];
2206 ir->ref_p[YY][ZZ] = dumdub[1][5];
2207 if (ir->ref_p[XX][YY] != 0 && ir->ref_p[XX][ZZ] != 0 && ir->ref_p[YY][ZZ] != 0)
2209 warning(wi, "All off-diagonal reference pressures are non-zero. Are you sure you want to apply a threefold shear stress?\n");
2211 ir->compress[XX][YY] = dumdub[0][3];
2212 ir->compress[XX][ZZ] = dumdub[0][4];
2213 ir->compress[YY][ZZ] = dumdub[0][5];
2214 for (i = 0; i < DIM; i++)
2216 for (m = 0; m < i; m++)
2218 ir->ref_p[i][m] = ir->ref_p[m][i];
2219 ir->compress[i][m] = ir->compress[m][i];
2224 if (ir->comm_mode == ecmNO)
2229 opts->couple_moltype = NULL;
2230 if (strlen(is->couple_moltype) > 0)
2232 if (ir->efep != efepNO)
2234 opts->couple_moltype = strdup(is->couple_moltype);
2235 if (opts->couple_lam0 == opts->couple_lam1)
2237 warning(wi, "The lambda=0 and lambda=1 states for coupling are identical");
2239 if (ir->eI == eiMD && (opts->couple_lam0 == ecouplamNONE ||
2240 opts->couple_lam1 == ecouplamNONE))
2242 warning(wi, "For proper sampling of the (nearly) decoupled state, stochastic dynamics should be used");
2247 warning(wi, "Can not couple a molecule with free_energy = no");
2250 /* FREE ENERGY AND EXPANDED ENSEMBLE OPTIONS */
2251 if (ir->efep != efepNO)
2253 if (fep->delta_lambda > 0)
2255 ir->efep = efepSLOWGROWTH;
2261 fep->bPrintEnergy = TRUE;
2262 /* always print out the energy to dhdl if we are doing expanded ensemble, since we need the total energy
2263 if the temperature is changing. */
2266 if ((ir->efep != efepNO) || ir->bSimTemp)
2268 ir->bExpanded = FALSE;
2269 if ((ir->efep == efepEXPANDED) || ir->bSimTemp)
2271 ir->bExpanded = TRUE;
2273 do_fep_params(ir, is->fep_lambda, is->lambda_weights);
2274 if (ir->bSimTemp) /* done after fep params */
2276 do_simtemp_params(ir);
2281 ir->fepvals->n_lambda = 0;
2284 /* WALL PARAMETERS */
2286 do_wall_params(ir, is->wall_atomtype, is->wall_density, opts);
2288 /* ORIENTATION RESTRAINT PARAMETERS */
2290 if (opts->bOrire && str_nelem(is->orirefitgrp, MAXPTR, NULL) != 1)
2292 warning_error(wi, "ERROR: Need one orientation restraint fit group\n");
2295 /* DEFORMATION PARAMETERS */
2297 clear_mat(ir->deform);
2298 for (i = 0; i < 6; i++)
2302 m = sscanf(is->deform, "%lf %lf %lf %lf %lf %lf",
2303 &(dumdub[0][0]), &(dumdub[0][1]), &(dumdub[0][2]),
2304 &(dumdub[0][3]), &(dumdub[0][4]), &(dumdub[0][5]));
2305 for (i = 0; i < 3; i++)
2307 ir->deform[i][i] = dumdub[0][i];
2309 ir->deform[YY][XX] = dumdub[0][3];
2310 ir->deform[ZZ][XX] = dumdub[0][4];
2311 ir->deform[ZZ][YY] = dumdub[0][5];
2312 if (ir->epc != epcNO)
2314 for (i = 0; i < 3; i++)
2316 for (j = 0; j <= i; j++)
2318 if (ir->deform[i][j] != 0 && ir->compress[i][j] != 0)
2320 warning_error(wi, "A box element has deform set and compressibility > 0");
2324 for (i = 0; i < 3; i++)
2326 for (j = 0; j < i; j++)
2328 if (ir->deform[i][j] != 0)
2330 for (m = j; m < DIM; m++)
2332 if (ir->compress[m][j] != 0)
2334 sprintf(warn_buf, "An off-diagonal box element has deform set while compressibility > 0 for the same component of another box vector, this might lead to spurious periodicity effects.");
2335 warning(wi, warn_buf);
2347 static int search_QMstring(const char *s, int ng, const char *gn[])
2349 /* same as normal search_string, but this one searches QM strings */
2352 for (i = 0; (i < ng); i++)
2354 if (gmx_strcasecmp(s, gn[i]) == 0)
2360 gmx_fatal(FARGS, "this QM method or basisset (%s) is not implemented\n!", s);
2364 } /* search_QMstring */
2366 /* We would like gn to be const as well, but C doesn't allow this */
2367 int search_string(const char *s, int ng, char *gn[])
2371 for (i = 0; (i < ng); i++)
2373 if (gmx_strcasecmp(s, gn[i]) == 0)
2380 "Group %s referenced in the .mdp file was not found in the index file.\n"
2381 "Group names must match either [moleculetype] names or custom index group\n"
2382 "names, in which case you must supply an index file to the '-n' option\n"
2389 static gmx_bool do_numbering(int natoms, gmx_groups_t *groups, int ng, char *ptrs[],
2390 t_blocka *block, char *gnames[],
2391 int gtype, int restnm,
2392 int grptp, gmx_bool bVerbose,
2395 unsigned short *cbuf;
2396 t_grps *grps = &(groups->grps[gtype]);
2397 int i, j, gid, aj, ognr, ntot = 0;
2400 char warn_buf[STRLEN];
2404 fprintf(debug, "Starting numbering %d groups of type %d\n", ng, gtype);
2407 title = gtypes[gtype];
2410 /* Mark all id's as not set */
2411 for (i = 0; (i < natoms); i++)
2416 snew(grps->nm_ind, ng+1); /* +1 for possible rest group */
2417 for (i = 0; (i < ng); i++)
2419 /* Lookup the group name in the block structure */
2420 gid = search_string(ptrs[i], block->nr, gnames);
2421 if ((grptp != egrptpONE) || (i == 0))
2423 grps->nm_ind[grps->nr++] = gid;
2427 fprintf(debug, "Found gid %d for group %s\n", gid, ptrs[i]);
2430 /* Now go over the atoms in the group */
2431 for (j = block->index[gid]; (j < block->index[gid+1]); j++)
2436 /* Range checking */
2437 if ((aj < 0) || (aj >= natoms))
2439 gmx_fatal(FARGS, "Invalid atom number %d in indexfile", aj);
2441 /* Lookup up the old group number */
2445 gmx_fatal(FARGS, "Atom %d in multiple %s groups (%d and %d)",
2446 aj+1, title, ognr+1, i+1);
2450 /* Store the group number in buffer */
2451 if (grptp == egrptpONE)
2464 /* Now check whether we have done all atoms */
2468 if (grptp == egrptpALL)
2470 gmx_fatal(FARGS, "%d atoms are not part of any of the %s groups",
2471 natoms-ntot, title);
2473 else if (grptp == egrptpPART)
2475 sprintf(warn_buf, "%d atoms are not part of any of the %s groups",
2476 natoms-ntot, title);
2477 warning_note(wi, warn_buf);
2479 /* Assign all atoms currently unassigned to a rest group */
2480 for (j = 0; (j < natoms); j++)
2482 if (cbuf[j] == NOGID)
2488 if (grptp != egrptpPART)
2493 "Making dummy/rest group for %s containing %d elements\n",
2494 title, natoms-ntot);
2496 /* Add group name "rest" */
2497 grps->nm_ind[grps->nr] = restnm;
2499 /* Assign the rest name to all atoms not currently assigned to a group */
2500 for (j = 0; (j < natoms); j++)
2502 if (cbuf[j] == NOGID)
2511 if (grps->nr == 1 && (ntot == 0 || ntot == natoms))
2513 /* All atoms are part of one (or no) group, no index required */
2514 groups->ngrpnr[gtype] = 0;
2515 groups->grpnr[gtype] = NULL;
2519 groups->ngrpnr[gtype] = natoms;
2520 snew(groups->grpnr[gtype], natoms);
2521 for (j = 0; (j < natoms); j++)
2523 groups->grpnr[gtype][j] = cbuf[j];
2529 return (bRest && grptp == egrptpPART);
2532 static void calc_nrdf(gmx_mtop_t *mtop, t_inputrec *ir, char **gnames)
2535 gmx_groups_t *groups;
2537 int natoms, ai, aj, i, j, d, g, imin, jmin;
2539 int *nrdf2, *na_vcm, na_tot;
2540 double *nrdf_tc, *nrdf_vcm, nrdf_uc, n_sub = 0;
2541 gmx_mtop_atomloop_all_t aloop;
2543 int mb, mol, ftype, as;
2544 gmx_molblock_t *molb;
2545 gmx_moltype_t *molt;
2548 * First calc 3xnr-atoms for each group
2549 * then subtract half a degree of freedom for each constraint
2551 * Only atoms and nuclei contribute to the degrees of freedom...
2556 groups = &mtop->groups;
2557 natoms = mtop->natoms;
2559 /* Allocate one more for a possible rest group */
2560 /* We need to sum degrees of freedom into doubles,
2561 * since floats give too low nrdf's above 3 million atoms.
2563 snew(nrdf_tc, groups->grps[egcTC].nr+1);
2564 snew(nrdf_vcm, groups->grps[egcVCM].nr+1);
2565 snew(na_vcm, groups->grps[egcVCM].nr+1);
2567 for (i = 0; i < groups->grps[egcTC].nr; i++)
2571 for (i = 0; i < groups->grps[egcVCM].nr+1; i++)
2576 snew(nrdf2, natoms);
2577 aloop = gmx_mtop_atomloop_all_init(mtop);
2578 while (gmx_mtop_atomloop_all_next(aloop, &i, &atom))
2581 if (atom->ptype == eptAtom || atom->ptype == eptNucleus)
2583 g = ggrpnr(groups, egcFREEZE, i);
2584 /* Double count nrdf for particle i */
2585 for (d = 0; d < DIM; d++)
2587 if (opts->nFreeze[g][d] == 0)
2592 nrdf_tc [ggrpnr(groups, egcTC, i)] += 0.5*nrdf2[i];
2593 nrdf_vcm[ggrpnr(groups, egcVCM, i)] += 0.5*nrdf2[i];
2598 for (mb = 0; mb < mtop->nmolblock; mb++)
2600 molb = &mtop->molblock[mb];
2601 molt = &mtop->moltype[molb->type];
2602 atom = molt->atoms.atom;
2603 for (mol = 0; mol < molb->nmol; mol++)
2605 for (ftype = F_CONSTR; ftype <= F_CONSTRNC; ftype++)
2607 ia = molt->ilist[ftype].iatoms;
2608 for (i = 0; i < molt->ilist[ftype].nr; )
2610 /* Subtract degrees of freedom for the constraints,
2611 * if the particles still have degrees of freedom left.
2612 * If one of the particles is a vsite or a shell, then all
2613 * constraint motion will go there, but since they do not
2614 * contribute to the constraints the degrees of freedom do not
2619 if (((atom[ia[1]].ptype == eptNucleus) ||
2620 (atom[ia[1]].ptype == eptAtom)) &&
2621 ((atom[ia[2]].ptype == eptNucleus) ||
2622 (atom[ia[2]].ptype == eptAtom)))
2640 imin = min(imin, nrdf2[ai]);
2641 jmin = min(jmin, nrdf2[aj]);
2644 nrdf_tc [ggrpnr(groups, egcTC, ai)] -= 0.5*imin;
2645 nrdf_tc [ggrpnr(groups, egcTC, aj)] -= 0.5*jmin;
2646 nrdf_vcm[ggrpnr(groups, egcVCM, ai)] -= 0.5*imin;
2647 nrdf_vcm[ggrpnr(groups, egcVCM, aj)] -= 0.5*jmin;
2649 ia += interaction_function[ftype].nratoms+1;
2650 i += interaction_function[ftype].nratoms+1;
2653 ia = molt->ilist[F_SETTLE].iatoms;
2654 for (i = 0; i < molt->ilist[F_SETTLE].nr; )
2656 /* Subtract 1 dof from every atom in the SETTLE */
2657 for (j = 0; j < 3; j++)
2660 imin = min(2, nrdf2[ai]);
2662 nrdf_tc [ggrpnr(groups, egcTC, ai)] -= 0.5*imin;
2663 nrdf_vcm[ggrpnr(groups, egcVCM, ai)] -= 0.5*imin;
2668 as += molt->atoms.nr;
2672 if (ir->ePull == epullCONSTRAINT)
2674 /* Correct nrdf for the COM constraints.
2675 * We correct using the TC and VCM group of the first atom
2676 * in the reference and pull group. If atoms in one pull group
2677 * belong to different TC or VCM groups it is anyhow difficult
2678 * to determine the optimal nrdf assignment.
2682 for (i = 0; i < pull->ncoord; i++)
2686 for (j = 0; j < 2; j++)
2688 const t_pull_group *pgrp;
2690 pgrp = &pull->group[pull->coord[i].group[j]];
2694 /* Subtract 1/2 dof from each group */
2696 nrdf_tc [ggrpnr(groups, egcTC, ai)] -= 0.5*imin;
2697 nrdf_vcm[ggrpnr(groups, egcVCM, ai)] -= 0.5*imin;
2698 if (nrdf_tc[ggrpnr(groups, egcTC, ai)] < 0)
2700 gmx_fatal(FARGS, "Center of mass pulling constraints caused the number of degrees of freedom for temperature coupling group %s to be negative", gnames[groups->grps[egcTC].nm_ind[ggrpnr(groups, egcTC, ai)]]);
2705 /* We need to subtract the whole DOF from group j=1 */
2712 if (ir->nstcomm != 0)
2714 /* Subtract 3 from the number of degrees of freedom in each vcm group
2715 * when com translation is removed and 6 when rotation is removed
2718 switch (ir->comm_mode)
2721 n_sub = ndof_com(ir);
2728 gmx_incons("Checking comm_mode");
2731 for (i = 0; i < groups->grps[egcTC].nr; i++)
2733 /* Count the number of atoms of TC group i for every VCM group */
2734 for (j = 0; j < groups->grps[egcVCM].nr+1; j++)
2739 for (ai = 0; ai < natoms; ai++)
2741 if (ggrpnr(groups, egcTC, ai) == i)
2743 na_vcm[ggrpnr(groups, egcVCM, ai)]++;
2747 /* Correct for VCM removal according to the fraction of each VCM
2748 * group present in this TC group.
2750 nrdf_uc = nrdf_tc[i];
2753 fprintf(debug, "T-group[%d] nrdf_uc = %g, n_sub = %g\n",
2757 for (j = 0; j < groups->grps[egcVCM].nr+1; j++)
2759 if (nrdf_vcm[j] > n_sub)
2761 nrdf_tc[i] += nrdf_uc*((double)na_vcm[j]/(double)na_tot)*
2762 (nrdf_vcm[j] - n_sub)/nrdf_vcm[j];
2766 fprintf(debug, " nrdf_vcm[%d] = %g, nrdf = %g\n",
2767 j, nrdf_vcm[j], nrdf_tc[i]);
2772 for (i = 0; (i < groups->grps[egcTC].nr); i++)
2774 opts->nrdf[i] = nrdf_tc[i];
2775 if (opts->nrdf[i] < 0)
2780 "Number of degrees of freedom in T-Coupling group %s is %.2f\n",
2781 gnames[groups->grps[egcTC].nm_ind[i]], opts->nrdf[i]);
2790 static void decode_cos(char *s, t_cosines *cosine)
2793 char format[STRLEN], f1[STRLEN];
2805 sscanf(t, "%d", &(cosine->n));
2812 snew(cosine->a, cosine->n);
2813 snew(cosine->phi, cosine->n);
2815 sprintf(format, "%%*d");
2816 for (i = 0; (i < cosine->n); i++)
2819 strcat(f1, "%lf%lf");
2820 if (sscanf(t, f1, &a, &phi) < 2)
2822 gmx_fatal(FARGS, "Invalid input for electric field shift: '%s'", t);
2825 cosine->phi[i] = phi;
2826 strcat(format, "%*lf%*lf");
2833 static gmx_bool do_egp_flag(t_inputrec *ir, gmx_groups_t *groups,
2834 const char *option, const char *val, int flag)
2836 /* The maximum number of energy group pairs would be MAXPTR*(MAXPTR+1)/2.
2837 * But since this is much larger than STRLEN, such a line can not be parsed.
2838 * The real maximum is the number of names that fit in a string: STRLEN/2.
2840 #define EGP_MAX (STRLEN/2)
2841 int nelem, i, j, k, nr;
2842 char *names[EGP_MAX];
2846 gnames = groups->grpname;
2848 nelem = str_nelem(val, EGP_MAX, names);
2851 gmx_fatal(FARGS, "The number of groups for %s is odd", option);
2853 nr = groups->grps[egcENER].nr;
2855 for (i = 0; i < nelem/2; i++)
2859 gmx_strcasecmp(names[2*i], *(gnames[groups->grps[egcENER].nm_ind[j]])))
2865 gmx_fatal(FARGS, "%s in %s is not an energy group\n",
2866 names[2*i], option);
2870 gmx_strcasecmp(names[2*i+1], *(gnames[groups->grps[egcENER].nm_ind[k]])))
2876 gmx_fatal(FARGS, "%s in %s is not an energy group\n",
2877 names[2*i+1], option);
2879 if ((j < nr) && (k < nr))
2881 ir->opts.egp_flags[nr*j+k] |= flag;
2882 ir->opts.egp_flags[nr*k+j] |= flag;
2890 void do_index(const char* mdparin, const char *ndx,
2893 t_inputrec *ir, rvec *v,
2897 gmx_groups_t *groups;
2901 char warnbuf[STRLEN], **gnames;
2902 int nr, ntcg, ntau_t, nref_t, nacc, nofg, nSA, nSA_points, nSA_time, nSA_temp;
2905 int nacg, nfreeze, nfrdim, nenergy, nvcm, nuser;
2906 char *ptr1[MAXPTR], *ptr2[MAXPTR], *ptr3[MAXPTR];
2907 int i, j, k, restnm;
2909 gmx_bool bExcl, bTable, bSetTCpar, bAnneal, bRest;
2910 int nQMmethod, nQMbasis, nQMcharge, nQMmult, nbSH, nCASorb, nCASelec,
2911 nSAon, nSAoff, nSAsteps, nQMg, nbOPT, nbTS;
2912 char warn_buf[STRLEN];
2916 fprintf(stderr, "processing index file...\n");
2922 snew(grps->index, 1);
2924 atoms_all = gmx_mtop_global_atoms(mtop);
2925 analyse(&atoms_all, grps, &gnames, FALSE, TRUE);
2926 free_t_atoms(&atoms_all, FALSE);
2930 grps = init_index(ndx, &gnames);
2933 groups = &mtop->groups;
2934 natoms = mtop->natoms;
2935 symtab = &mtop->symtab;
2937 snew(groups->grpname, grps->nr+1);
2939 for (i = 0; (i < grps->nr); i++)
2941 groups->grpname[i] = put_symtab(symtab, gnames[i]);
2943 groups->grpname[i] = put_symtab(symtab, "rest");
2945 srenew(gnames, grps->nr+1);
2946 gnames[restnm] = *(groups->grpname[i]);
2947 groups->ngrpname = grps->nr+1;
2949 set_warning_line(wi, mdparin, -1);
2951 ntau_t = str_nelem(is->tau_t, MAXPTR, ptr1);
2952 nref_t = str_nelem(is->ref_t, MAXPTR, ptr2);
2953 ntcg = str_nelem(is->tcgrps, MAXPTR, ptr3);
2954 if ((ntau_t != ntcg) || (nref_t != ntcg))
2956 gmx_fatal(FARGS, "Invalid T coupling input: %d groups, %d ref-t values and "
2957 "%d tau-t values", ntcg, nref_t, ntau_t);
2960 bSetTCpar = (ir->etc || EI_SD(ir->eI) || ir->eI == eiBD || EI_TPI(ir->eI));
2961 do_numbering(natoms, groups, ntcg, ptr3, grps, gnames, egcTC,
2962 restnm, bSetTCpar ? egrptpALL : egrptpALL_GENREST, bVerbose, wi);
2963 nr = groups->grps[egcTC].nr;
2965 snew(ir->opts.nrdf, nr);
2966 snew(ir->opts.tau_t, nr);
2967 snew(ir->opts.ref_t, nr);
2968 if (ir->eI == eiBD && ir->bd_fric == 0)
2970 fprintf(stderr, "bd-fric=0, so tau-t will be used as the inverse friction constant(s)\n");
2977 gmx_fatal(FARGS, "Not enough ref-t and tau-t values!");
2981 for (i = 0; (i < nr); i++)
2983 ir->opts.tau_t[i] = strtod(ptr1[i], NULL);
2984 if ((ir->eI == eiBD || ir->eI == eiSD2) && ir->opts.tau_t[i] <= 0)
2986 sprintf(warn_buf, "With integrator %s tau-t should be larger than 0", ei_names[ir->eI]);
2987 warning_error(wi, warn_buf);
2990 if (ir->etc != etcVRESCALE && ir->opts.tau_t[i] == 0)
2992 warning_note(wi, "tau-t = -1 is the value to signal that a group should not have temperature coupling. Treating your use of tau-t = 0 as if you used -1.");
2995 if (ir->opts.tau_t[i] >= 0)
2997 tau_min = min(tau_min, ir->opts.tau_t[i]);
3000 if (ir->etc != etcNO && ir->nsttcouple == -1)
3002 ir->nsttcouple = ir_optimal_nsttcouple(ir);
3007 if ((ir->etc == etcNOSEHOOVER) && (ir->epc == epcBERENDSEN))
3009 gmx_fatal(FARGS, "Cannot do Nose-Hoover temperature with Berendsen pressure control with md-vv; use either vrescale temperature with berendsen pressure or Nose-Hoover temperature with MTTK pressure");
3011 if ((ir->epc == epcMTTK) && (ir->etc > etcNO))
3013 if (ir->nstpcouple != ir->nsttcouple)
3015 int mincouple = min(ir->nstpcouple, ir->nsttcouple);
3016 ir->nstpcouple = ir->nsttcouple = mincouple;
3017 sprintf(warn_buf, "for current Trotter decomposition methods with vv, nsttcouple and nstpcouple must be equal. Both have been reset to min(nsttcouple,nstpcouple) = %d", mincouple);
3018 warning_note(wi, warn_buf);
3022 /* velocity verlet with averaged kinetic energy KE = 0.5*(v(t+1/2) - v(t-1/2)) is implemented
3023 primarily for testing purposes, and does not work with temperature coupling other than 1 */
3025 if (ETC_ANDERSEN(ir->etc))
3027 if (ir->nsttcouple != 1)
3030 sprintf(warn_buf, "Andersen temperature control methods assume nsttcouple = 1; there is no need for larger nsttcouple > 1, since no global parameters are computed. nsttcouple has been reset to 1");
3031 warning_note(wi, warn_buf);
3034 nstcmin = tcouple_min_integration_steps(ir->etc);
3037 if (tau_min/(ir->delta_t*ir->nsttcouple) < nstcmin)
3039 sprintf(warn_buf, "For proper integration of the %s thermostat, tau-t (%g) should be at least %d times larger than nsttcouple*dt (%g)",
3040 ETCOUPLTYPE(ir->etc),
3042 ir->nsttcouple*ir->delta_t);
3043 warning(wi, warn_buf);
3046 for (i = 0; (i < nr); i++)
3048 ir->opts.ref_t[i] = strtod(ptr2[i], NULL);
3049 if (ir->opts.ref_t[i] < 0)
3051 gmx_fatal(FARGS, "ref-t for group %d negative", i);
3054 /* set the lambda mc temperature to the md integrator temperature (which should be defined
3055 if we are in this conditional) if mc_temp is negative */
3056 if (ir->expandedvals->mc_temp < 0)
3058 ir->expandedvals->mc_temp = ir->opts.ref_t[0]; /*for now, set to the first reft */
3062 /* Simulated annealing for each group. There are nr groups */
3063 nSA = str_nelem(is->anneal, MAXPTR, ptr1);
3064 if (nSA == 1 && (ptr1[0][0] == 'n' || ptr1[0][0] == 'N'))
3068 if (nSA > 0 && nSA != nr)
3070 gmx_fatal(FARGS, "Not enough annealing values: %d (for %d groups)\n", nSA, nr);
3074 snew(ir->opts.annealing, nr);
3075 snew(ir->opts.anneal_npoints, nr);
3076 snew(ir->opts.anneal_time, nr);
3077 snew(ir->opts.anneal_temp, nr);
3078 for (i = 0; i < nr; i++)
3080 ir->opts.annealing[i] = eannNO;
3081 ir->opts.anneal_npoints[i] = 0;
3082 ir->opts.anneal_time[i] = NULL;
3083 ir->opts.anneal_temp[i] = NULL;
3088 for (i = 0; i < nr; i++)
3090 if (ptr1[i][0] == 'n' || ptr1[i][0] == 'N')
3092 ir->opts.annealing[i] = eannNO;
3094 else if (ptr1[i][0] == 's' || ptr1[i][0] == 'S')
3096 ir->opts.annealing[i] = eannSINGLE;
3099 else if (ptr1[i][0] == 'p' || ptr1[i][0] == 'P')
3101 ir->opts.annealing[i] = eannPERIODIC;
3107 /* Read the other fields too */
3108 nSA_points = str_nelem(is->anneal_npoints, MAXPTR, ptr1);
3109 if (nSA_points != nSA)
3111 gmx_fatal(FARGS, "Found %d annealing-npoints values for %d groups\n", nSA_points, nSA);
3113 for (k = 0, i = 0; i < nr; i++)
3115 ir->opts.anneal_npoints[i] = strtol(ptr1[i], NULL, 10);
3116 if (ir->opts.anneal_npoints[i] == 1)
3118 gmx_fatal(FARGS, "Please specify at least a start and an end point for annealing\n");
3120 snew(ir->opts.anneal_time[i], ir->opts.anneal_npoints[i]);
3121 snew(ir->opts.anneal_temp[i], ir->opts.anneal_npoints[i]);
3122 k += ir->opts.anneal_npoints[i];
3125 nSA_time = str_nelem(is->anneal_time, MAXPTR, ptr1);
3128 gmx_fatal(FARGS, "Found %d annealing-time values, wanter %d\n", nSA_time, k);
3130 nSA_temp = str_nelem(is->anneal_temp, MAXPTR, ptr2);
3133 gmx_fatal(FARGS, "Found %d annealing-temp values, wanted %d\n", nSA_temp, k);
3136 for (i = 0, k = 0; i < nr; i++)
3139 for (j = 0; j < ir->opts.anneal_npoints[i]; j++)
3141 ir->opts.anneal_time[i][j] = strtod(ptr1[k], NULL);
3142 ir->opts.anneal_temp[i][j] = strtod(ptr2[k], NULL);
3145 if (ir->opts.anneal_time[i][0] > (ir->init_t+GMX_REAL_EPS))
3147 gmx_fatal(FARGS, "First time point for annealing > init_t.\n");
3153 if (ir->opts.anneal_time[i][j] < ir->opts.anneal_time[i][j-1])
3155 gmx_fatal(FARGS, "Annealing timepoints out of order: t=%f comes after t=%f\n",
3156 ir->opts.anneal_time[i][j], ir->opts.anneal_time[i][j-1]);
3159 if (ir->opts.anneal_temp[i][j] < 0)
3161 gmx_fatal(FARGS, "Found negative temperature in annealing: %f\n", ir->opts.anneal_temp[i][j]);
3166 /* Print out some summary information, to make sure we got it right */
3167 for (i = 0, k = 0; i < nr; i++)
3169 if (ir->opts.annealing[i] != eannNO)
3171 j = groups->grps[egcTC].nm_ind[i];
3172 fprintf(stderr, "Simulated annealing for group %s: %s, %d timepoints\n",
3173 *(groups->grpname[j]), eann_names[ir->opts.annealing[i]],
3174 ir->opts.anneal_npoints[i]);
3175 fprintf(stderr, "Time (ps) Temperature (K)\n");
3176 /* All terms except the last one */
3177 for (j = 0; j < (ir->opts.anneal_npoints[i]-1); j++)
3179 fprintf(stderr, "%9.1f %5.1f\n", ir->opts.anneal_time[i][j], ir->opts.anneal_temp[i][j]);
3182 /* Finally the last one */
3183 j = ir->opts.anneal_npoints[i]-1;
3184 if (ir->opts.annealing[i] == eannSINGLE)
3186 fprintf(stderr, "%9.1f- %5.1f\n", ir->opts.anneal_time[i][j], ir->opts.anneal_temp[i][j]);
3190 fprintf(stderr, "%9.1f %5.1f\n", ir->opts.anneal_time[i][j], ir->opts.anneal_temp[i][j]);
3191 if (fabs(ir->opts.anneal_temp[i][j]-ir->opts.anneal_temp[i][0]) > GMX_REAL_EPS)
3193 warning_note(wi, "There is a temperature jump when your annealing loops back.\n");
3202 if (ir->ePull != epullNO)
3204 make_pull_groups(ir->pull, is->pull_grp, grps, gnames);
3206 make_pull_coords(ir->pull);
3211 make_rotation_groups(ir->rot, is->rot_grp, grps, gnames);
3214 nacc = str_nelem(is->acc, MAXPTR, ptr1);
3215 nacg = str_nelem(is->accgrps, MAXPTR, ptr2);
3216 if (nacg*DIM != nacc)
3218 gmx_fatal(FARGS, "Invalid Acceleration input: %d groups and %d acc. values",
3221 do_numbering(natoms, groups, nacg, ptr2, grps, gnames, egcACC,
3222 restnm, egrptpALL_GENREST, bVerbose, wi);
3223 nr = groups->grps[egcACC].nr;
3224 snew(ir->opts.acc, nr);
3225 ir->opts.ngacc = nr;
3227 for (i = k = 0; (i < nacg); i++)
3229 for (j = 0; (j < DIM); j++, k++)
3231 ir->opts.acc[i][j] = strtod(ptr1[k], NULL);
3234 for (; (i < nr); i++)
3236 for (j = 0; (j < DIM); j++)
3238 ir->opts.acc[i][j] = 0;
3242 nfrdim = str_nelem(is->frdim, MAXPTR, ptr1);
3243 nfreeze = str_nelem(is->freeze, MAXPTR, ptr2);
3244 if (nfrdim != DIM*nfreeze)
3246 gmx_fatal(FARGS, "Invalid Freezing input: %d groups and %d freeze values",
3249 do_numbering(natoms, groups, nfreeze, ptr2, grps, gnames, egcFREEZE,
3250 restnm, egrptpALL_GENREST, bVerbose, wi);
3251 nr = groups->grps[egcFREEZE].nr;
3252 ir->opts.ngfrz = nr;
3253 snew(ir->opts.nFreeze, nr);
3254 for (i = k = 0; (i < nfreeze); i++)
3256 for (j = 0; (j < DIM); j++, k++)
3258 ir->opts.nFreeze[i][j] = (gmx_strncasecmp(ptr1[k], "Y", 1) == 0);
3259 if (!ir->opts.nFreeze[i][j])
3261 if (gmx_strncasecmp(ptr1[k], "N", 1) != 0)
3263 sprintf(warnbuf, "Please use Y(ES) or N(O) for freezedim only "
3264 "(not %s)", ptr1[k]);
3265 warning(wi, warn_buf);
3270 for (; (i < nr); i++)
3272 for (j = 0; (j < DIM); j++)
3274 ir->opts.nFreeze[i][j] = 0;
3278 nenergy = str_nelem(is->energy, MAXPTR, ptr1);
3279 do_numbering(natoms, groups, nenergy, ptr1, grps, gnames, egcENER,
3280 restnm, egrptpALL_GENREST, bVerbose, wi);
3281 add_wall_energrps(groups, ir->nwall, symtab);
3282 ir->opts.ngener = groups->grps[egcENER].nr;
3283 nvcm = str_nelem(is->vcm, MAXPTR, ptr1);
3285 do_numbering(natoms, groups, nvcm, ptr1, grps, gnames, egcVCM,
3286 restnm, nvcm == 0 ? egrptpALL_GENREST : egrptpPART, bVerbose, wi);
3289 warning(wi, "Some atoms are not part of any center of mass motion removal group.\n"
3290 "This may lead to artifacts.\n"
3291 "In most cases one should use one group for the whole system.");
3294 /* Now we have filled the freeze struct, so we can calculate NRDF */
3295 calc_nrdf(mtop, ir, gnames);
3301 /* Must check per group! */
3302 for (i = 0; (i < ir->opts.ngtc); i++)
3304 ntot += ir->opts.nrdf[i];
3306 if (ntot != (DIM*natoms))
3308 fac = sqrt(ntot/(DIM*natoms));
3311 fprintf(stderr, "Scaling velocities by a factor of %.3f to account for constraints\n"
3312 "and removal of center of mass motion\n", fac);
3314 for (i = 0; (i < natoms); i++)
3316 svmul(fac, v[i], v[i]);
3321 nuser = str_nelem(is->user1, MAXPTR, ptr1);
3322 do_numbering(natoms, groups, nuser, ptr1, grps, gnames, egcUser1,
3323 restnm, egrptpALL_GENREST, bVerbose, wi);
3324 nuser = str_nelem(is->user2, MAXPTR, ptr1);
3325 do_numbering(natoms, groups, nuser, ptr1, grps, gnames, egcUser2,
3326 restnm, egrptpALL_GENREST, bVerbose, wi);
3327 nuser = str_nelem(is->x_compressed_groups, MAXPTR, ptr1);
3328 do_numbering(natoms, groups, nuser, ptr1, grps, gnames, egcCompressedX,
3329 restnm, egrptpONE, bVerbose, wi);
3330 nofg = str_nelem(is->orirefitgrp, MAXPTR, ptr1);
3331 do_numbering(natoms, groups, nofg, ptr1, grps, gnames, egcORFIT,
3332 restnm, egrptpALL_GENREST, bVerbose, wi);
3334 /* QMMM input processing */
3335 nQMg = str_nelem(is->QMMM, MAXPTR, ptr1);
3336 nQMmethod = str_nelem(is->QMmethod, MAXPTR, ptr2);
3337 nQMbasis = str_nelem(is->QMbasis, MAXPTR, ptr3);
3338 if ((nQMmethod != nQMg) || (nQMbasis != nQMg))
3340 gmx_fatal(FARGS, "Invalid QMMM input: %d groups %d basissets"
3341 " and %d methods\n", nQMg, nQMbasis, nQMmethod);
3343 /* group rest, if any, is always MM! */
3344 do_numbering(natoms, groups, nQMg, ptr1, grps, gnames, egcQMMM,
3345 restnm, egrptpALL_GENREST, bVerbose, wi);
3346 nr = nQMg; /*atoms->grps[egcQMMM].nr;*/
3347 ir->opts.ngQM = nQMg;
3348 snew(ir->opts.QMmethod, nr);
3349 snew(ir->opts.QMbasis, nr);
3350 for (i = 0; i < nr; i++)
3352 /* input consists of strings: RHF CASSCF PM3 .. These need to be
3353 * converted to the corresponding enum in names.c
3355 ir->opts.QMmethod[i] = search_QMstring(ptr2[i], eQMmethodNR,
3357 ir->opts.QMbasis[i] = search_QMstring(ptr3[i], eQMbasisNR,
3361 nQMmult = str_nelem(is->QMmult, MAXPTR, ptr1);
3362 nQMcharge = str_nelem(is->QMcharge, MAXPTR, ptr2);
3363 nbSH = str_nelem(is->bSH, MAXPTR, ptr3);
3364 snew(ir->opts.QMmult, nr);
3365 snew(ir->opts.QMcharge, nr);
3366 snew(ir->opts.bSH, nr);
3368 for (i = 0; i < nr; i++)
3370 ir->opts.QMmult[i] = strtol(ptr1[i], NULL, 10);
3371 ir->opts.QMcharge[i] = strtol(ptr2[i], NULL, 10);
3372 ir->opts.bSH[i] = (gmx_strncasecmp(ptr3[i], "Y", 1) == 0);
3375 nCASelec = str_nelem(is->CASelectrons, MAXPTR, ptr1);
3376 nCASorb = str_nelem(is->CASorbitals, MAXPTR, ptr2);
3377 snew(ir->opts.CASelectrons, nr);
3378 snew(ir->opts.CASorbitals, nr);
3379 for (i = 0; i < nr; i++)
3381 ir->opts.CASelectrons[i] = strtol(ptr1[i], NULL, 10);
3382 ir->opts.CASorbitals[i] = strtol(ptr2[i], NULL, 10);
3384 /* special optimization options */
3386 nbOPT = str_nelem(is->bOPT, MAXPTR, ptr1);
3387 nbTS = str_nelem(is->bTS, MAXPTR, ptr2);
3388 snew(ir->opts.bOPT, nr);
3389 snew(ir->opts.bTS, nr);
3390 for (i = 0; i < nr; i++)
3392 ir->opts.bOPT[i] = (gmx_strncasecmp(ptr1[i], "Y", 1) == 0);
3393 ir->opts.bTS[i] = (gmx_strncasecmp(ptr2[i], "Y", 1) == 0);
3395 nSAon = str_nelem(is->SAon, MAXPTR, ptr1);
3396 nSAoff = str_nelem(is->SAoff, MAXPTR, ptr2);
3397 nSAsteps = str_nelem(is->SAsteps, MAXPTR, ptr3);
3398 snew(ir->opts.SAon, nr);
3399 snew(ir->opts.SAoff, nr);
3400 snew(ir->opts.SAsteps, nr);
3402 for (i = 0; i < nr; i++)
3404 ir->opts.SAon[i] = strtod(ptr1[i], NULL);
3405 ir->opts.SAoff[i] = strtod(ptr2[i], NULL);
3406 ir->opts.SAsteps[i] = strtol(ptr3[i], NULL, 10);
3408 /* end of QMMM input */
3412 for (i = 0; (i < egcNR); i++)
3414 fprintf(stderr, "%-16s has %d element(s):", gtypes[i], groups->grps[i].nr);
3415 for (j = 0; (j < groups->grps[i].nr); j++)
3417 fprintf(stderr, " %s", *(groups->grpname[groups->grps[i].nm_ind[j]]));
3419 fprintf(stderr, "\n");
3423 nr = groups->grps[egcENER].nr;
3424 snew(ir->opts.egp_flags, nr*nr);
3426 bExcl = do_egp_flag(ir, groups, "energygrp-excl", is->egpexcl, EGP_EXCL);
3427 if (bExcl && ir->cutoff_scheme == ecutsVERLET)
3429 warning_error(wi, "Energy group exclusions are not (yet) implemented for the Verlet scheme");
3431 if (bExcl && EEL_FULL(ir->coulombtype))
3433 warning(wi, "Can not exclude the lattice Coulomb energy between energy groups");
3436 bTable = do_egp_flag(ir, groups, "energygrp-table", is->egptable, EGP_TABLE);
3437 if (bTable && !(ir->vdwtype == evdwUSER) &&
3438 !(ir->coulombtype == eelUSER) && !(ir->coulombtype == eelPMEUSER) &&
3439 !(ir->coulombtype == eelPMEUSERSWITCH))
3441 gmx_fatal(FARGS, "Can only have energy group pair tables in combination with user tables for VdW and/or Coulomb");
3444 decode_cos(is->efield_x, &(ir->ex[XX]));
3445 decode_cos(is->efield_xt, &(ir->et[XX]));
3446 decode_cos(is->efield_y, &(ir->ex[YY]));
3447 decode_cos(is->efield_yt, &(ir->et[YY]));
3448 decode_cos(is->efield_z, &(ir->ex[ZZ]));
3449 decode_cos(is->efield_zt, &(ir->et[ZZ]));
3453 do_adress_index(ir->adress, groups, gnames, &(ir->opts), wi);
3456 for (i = 0; (i < grps->nr); i++)
3468 static void check_disre(gmx_mtop_t *mtop)
3470 gmx_ffparams_t *ffparams;
3471 t_functype *functype;
3473 int i, ndouble, ftype;
3474 int label, old_label;
3476 if (gmx_mtop_ftype_count(mtop, F_DISRES) > 0)
3478 ffparams = &mtop->ffparams;
3479 functype = ffparams->functype;
3480 ip = ffparams->iparams;
3483 for (i = 0; i < ffparams->ntypes; i++)
3485 ftype = functype[i];
3486 if (ftype == F_DISRES)
3488 label = ip[i].disres.label;
3489 if (label == old_label)
3491 fprintf(stderr, "Distance restraint index %d occurs twice\n", label);
3499 gmx_fatal(FARGS, "Found %d double distance restraint indices,\n"
3500 "probably the parameters for multiple pairs in one restraint "
3501 "are not identical\n", ndouble);
3506 static gmx_bool absolute_reference(t_inputrec *ir, gmx_mtop_t *sys,
3507 gmx_bool posres_only,
3511 gmx_mtop_ilistloop_t iloop;
3521 for (d = 0; d < DIM; d++)
3523 AbsRef[d] = (d < ndof_com(ir) ? 0 : 1);
3525 /* Check for freeze groups */
3526 for (g = 0; g < ir->opts.ngfrz; g++)
3528 for (d = 0; d < DIM; d++)
3530 if (ir->opts.nFreeze[g][d] != 0)
3538 /* Check for position restraints */
3539 iloop = gmx_mtop_ilistloop_init(sys);
3540 while (gmx_mtop_ilistloop_next(iloop, &ilist, &nmol))
3543 (AbsRef[XX] == 0 || AbsRef[YY] == 0 || AbsRef[ZZ] == 0))
3545 for (i = 0; i < ilist[F_POSRES].nr; i += 2)
3547 pr = &sys->ffparams.iparams[ilist[F_POSRES].iatoms[i]];
3548 for (d = 0; d < DIM; d++)
3550 if (pr->posres.fcA[d] != 0)
3556 for (i = 0; i < ilist[F_FBPOSRES].nr; i += 2)
3558 /* Check for flat-bottom posres */
3559 pr = &sys->ffparams.iparams[ilist[F_FBPOSRES].iatoms[i]];
3560 if (pr->fbposres.k != 0)
3562 switch (pr->fbposres.geom)
3564 case efbposresSPHERE:
3565 AbsRef[XX] = AbsRef[YY] = AbsRef[ZZ] = 1;
3567 case efbposresCYLINDER:
3568 AbsRef[XX] = AbsRef[YY] = 1;
3570 case efbposresX: /* d=XX */
3571 case efbposresY: /* d=YY */
3572 case efbposresZ: /* d=ZZ */
3573 d = pr->fbposres.geom - efbposresX;
3577 gmx_fatal(FARGS, " Invalid geometry for flat-bottom position restraint.\n"
3578 "Expected nr between 1 and %d. Found %d\n", efbposresNR-1,
3586 return (AbsRef[XX] != 0 && AbsRef[YY] != 0 && AbsRef[ZZ] != 0);
3590 check_combination_rule_differences(const gmx_mtop_t *mtop, int state,
3591 gmx_bool *bC6ParametersWorkWithGeometricRules,
3592 gmx_bool *bC6ParametersWorkWithLBRules,
3593 gmx_bool *bLBRulesPossible)
3595 int ntypes, tpi, tpj, thisLBdiff, thisgeomdiff;
3598 double geometricdiff, LBdiff;
3599 double c6i, c6j, c12i, c12j;
3600 double c6, c6_geometric, c6_LB;
3601 double sigmai, sigmaj, epsi, epsj;
3602 gmx_bool bCanDoLBRules, bCanDoGeometricRules;
3605 /* A tolerance of 1e-5 seems reasonable for (possibly hand-typed)
3606 * force-field floating point parameters.
3609 ptr = getenv("GMX_LJCOMB_TOL");
3614 sscanf(ptr, "%lf", &dbl);
3618 *bC6ParametersWorkWithLBRules = TRUE;
3619 *bC6ParametersWorkWithGeometricRules = TRUE;
3620 bCanDoLBRules = TRUE;
3621 bCanDoGeometricRules = TRUE;
3622 ntypes = mtop->ffparams.atnr;
3623 snew(typecount, ntypes);
3624 gmx_mtop_count_atomtypes(mtop, state, typecount);
3625 geometricdiff = LBdiff = 0.0;
3626 *bLBRulesPossible = TRUE;
3627 for (tpi = 0; tpi < ntypes; ++tpi)
3629 c6i = mtop->ffparams.iparams[(ntypes + 1) * tpi].lj.c6;
3630 c12i = mtop->ffparams.iparams[(ntypes + 1) * tpi].lj.c12;
3631 for (tpj = tpi; tpj < ntypes; ++tpj)
3633 c6j = mtop->ffparams.iparams[(ntypes + 1) * tpj].lj.c6;
3634 c12j = mtop->ffparams.iparams[(ntypes + 1) * tpj].lj.c12;
3635 c6 = mtop->ffparams.iparams[ntypes * tpi + tpj].lj.c6;
3636 c6_geometric = sqrt(c6i * c6j);
3637 if (!gmx_numzero(c6_geometric))
3639 if (!gmx_numzero(c12i) && !gmx_numzero(c12j))
3641 sigmai = pow(c12i / c6i, 1.0/6.0);
3642 sigmaj = pow(c12j / c6j, 1.0/6.0);
3643 epsi = c6i * c6i /(4.0 * c12i);
3644 epsj = c6j * c6j /(4.0 * c12j);
3645 c6_LB = 4.0 * pow(epsi * epsj, 1.0/2.0) * pow(0.5 * (sigmai + sigmaj), 6);
3649 *bLBRulesPossible = FALSE;
3650 c6_LB = c6_geometric;
3652 bCanDoLBRules = gmx_within_tol(c6_LB, c6, tol);
3655 if (FALSE == bCanDoLBRules)
3657 *bC6ParametersWorkWithLBRules = FALSE;
3660 bCanDoGeometricRules = gmx_within_tol(c6_geometric, c6, tol);
3662 if (FALSE == bCanDoGeometricRules)
3664 *bC6ParametersWorkWithGeometricRules = FALSE;
3672 check_combination_rules(const t_inputrec *ir, const gmx_mtop_t *mtop,
3676 gmx_bool bLBRulesPossible, bC6ParametersWorkWithGeometricRules, bC6ParametersWorkWithLBRules;
3678 check_combination_rule_differences(mtop, 0,
3679 &bC6ParametersWorkWithGeometricRules,
3680 &bC6ParametersWorkWithLBRules,
3682 if (ir->ljpme_combination_rule == eljpmeLB)
3684 if (FALSE == bC6ParametersWorkWithLBRules || FALSE == bLBRulesPossible)
3686 warning(wi, "You are using arithmetic-geometric combination rules "
3687 "in LJ-PME, but your non-bonded C6 parameters do not "
3688 "follow these rules.");
3693 if (FALSE == bC6ParametersWorkWithGeometricRules)
3695 if (ir->eDispCorr != edispcNO)
3697 warning_note(wi, "You are using geometric combination rules in "
3698 "LJ-PME, but your non-bonded C6 parameters do "
3699 "not follow these rules. "
3700 "If your force field uses Lorentz-Berthelot combination rules this "
3701 "will introduce small errors in the forces and energies in "
3702 "your simulations. Dispersion correction will correct total "
3703 "energy and/or pressure, but not forces or surface tensions. "
3704 "Please check the LJ-PME section in the manual "
3705 "before proceeding further.");
3709 warning_note(wi, "You are using geometric combination rules in "
3710 "LJ-PME, but your non-bonded C6 parameters do "
3711 "not follow these rules. "
3712 "If your force field uses Lorentz-Berthelot combination rules this "
3713 "will introduce small errors in the forces and energies in "
3714 "your simulations. Consider using dispersion correction "
3715 "for the total energy and pressure. "
3716 "Please check the LJ-PME section in the manual "
3717 "before proceeding further.");
3723 void triple_check(const char *mdparin, t_inputrec *ir, gmx_mtop_t *sys,
3727 int i, m, c, nmol, npct;
3728 gmx_bool bCharge, bAcc;
3729 real gdt_max, *mgrp, mt;
3731 gmx_mtop_atomloop_block_t aloopb;
3732 gmx_mtop_atomloop_all_t aloop;
3735 char warn_buf[STRLEN];
3737 set_warning_line(wi, mdparin, -1);
3739 if (EI_DYNAMICS(ir->eI) && !EI_SD(ir->eI) && ir->eI != eiBD &&
3740 ir->comm_mode == ecmNO &&
3741 !(absolute_reference(ir, sys, FALSE, AbsRef) || ir->nsteps <= 10))
3743 warning(wi, "You are not using center of mass motion removal (mdp option comm-mode), numerical rounding errors can lead to build up of kinetic energy of the center of mass");
3746 /* Check for pressure coupling with absolute position restraints */
3747 if (ir->epc != epcNO && ir->refcoord_scaling == erscNO)
3749 absolute_reference(ir, sys, TRUE, AbsRef);
3751 for (m = 0; m < DIM; m++)
3753 if (AbsRef[m] && norm2(ir->compress[m]) > 0)
3755 warning(wi, "You are using pressure coupling with absolute position restraints, this will give artifacts. Use the refcoord_scaling option.");
3763 aloopb = gmx_mtop_atomloop_block_init(sys);
3764 while (gmx_mtop_atomloop_block_next(aloopb, &atom, &nmol))
3766 if (atom->q != 0 || atom->qB != 0)
3774 if (EEL_FULL(ir->coulombtype))
3777 "You are using full electrostatics treatment %s for a system without charges.\n"
3778 "This costs a lot of performance for just processing zeros, consider using %s instead.\n",
3779 EELTYPE(ir->coulombtype), EELTYPE(eelCUT));
3780 warning(wi, err_buf);
3785 if (ir->coulombtype == eelCUT && ir->rcoulomb > 0 && !ir->implicit_solvent)
3788 "You are using a plain Coulomb cut-off, which might produce artifacts.\n"
3789 "You might want to consider using %s electrostatics.\n",
3791 warning_note(wi, err_buf);
3795 /* Check if combination rules used in LJ-PME are the same as in the force field */
3796 if (EVDW_PME(ir->vdwtype))
3798 check_combination_rules(ir, sys, wi);
3801 /* Generalized reaction field */
3802 if (ir->opts.ngtc == 0)
3804 sprintf(err_buf, "No temperature coupling while using coulombtype %s",
3806 CHECK(ir->coulombtype == eelGRF);
3810 sprintf(err_buf, "When using coulombtype = %s"
3811 " ref-t for temperature coupling should be > 0",
3813 CHECK((ir->coulombtype == eelGRF) && (ir->opts.ref_t[0] <= 0));
3816 if (ir->eI == eiSD1 &&
3817 (gmx_mtop_ftype_count(sys, F_CONSTR) > 0 ||
3818 gmx_mtop_ftype_count(sys, F_SETTLE) > 0))
3820 sprintf(warn_buf, "With constraints integrator %s is less accurate, consider using %s instead", ei_names[ir->eI], ei_names[eiSD2]);
3821 warning_note(wi, warn_buf);
3825 for (i = 0; (i < sys->groups.grps[egcACC].nr); i++)
3827 for (m = 0; (m < DIM); m++)
3829 if (fabs(ir->opts.acc[i][m]) > 1e-6)
3838 snew(mgrp, sys->groups.grps[egcACC].nr);
3839 aloop = gmx_mtop_atomloop_all_init(sys);
3840 while (gmx_mtop_atomloop_all_next(aloop, &i, &atom))
3842 mgrp[ggrpnr(&sys->groups, egcACC, i)] += atom->m;
3845 for (i = 0; (i < sys->groups.grps[egcACC].nr); i++)
3847 for (m = 0; (m < DIM); m++)
3849 acc[m] += ir->opts.acc[i][m]*mgrp[i];
3853 for (m = 0; (m < DIM); m++)
3855 if (fabs(acc[m]) > 1e-6)
3857 const char *dim[DIM] = { "X", "Y", "Z" };
3859 "Net Acceleration in %s direction, will %s be corrected\n",
3860 dim[m], ir->nstcomm != 0 ? "" : "not");
3861 if (ir->nstcomm != 0 && m < ndof_com(ir))
3864 for (i = 0; (i < sys->groups.grps[egcACC].nr); i++)
3866 ir->opts.acc[i][m] -= acc[m];
3874 if (ir->efep != efepNO && ir->fepvals->sc_alpha != 0 &&
3875 !gmx_within_tol(sys->ffparams.reppow, 12.0, 10*GMX_DOUBLE_EPS))
3877 gmx_fatal(FARGS, "Soft-core interactions are only supported with VdW repulsion power 12");
3880 if (ir->ePull != epullNO)
3882 gmx_bool bPullAbsoluteRef;
3884 bPullAbsoluteRef = FALSE;
3885 for (i = 0; i < ir->pull->ncoord; i++)
3887 bPullAbsoluteRef = bPullAbsoluteRef ||
3888 ir->pull->coord[i].group[0] == 0 ||
3889 ir->pull->coord[i].group[1] == 0;
3891 if (bPullAbsoluteRef)
3893 absolute_reference(ir, sys, FALSE, AbsRef);
3894 for (m = 0; m < DIM; m++)
3896 if (ir->pull->dim[m] && !AbsRef[m])
3898 warning(wi, "You are using an absolute reference for pulling, but the rest of the system does not have an absolute reference. This will lead to artifacts.");
3904 if (ir->pull->eGeom == epullgDIRPBC)
3906 for (i = 0; i < 3; i++)
3908 for (m = 0; m <= i; m++)
3910 if ((ir->epc != epcNO && ir->compress[i][m] != 0) ||
3911 ir->deform[i][m] != 0)
3913 for (c = 0; c < ir->pull->ncoord; c++)
3915 if (ir->pull->coord[c].vec[m] != 0)
3917 gmx_fatal(FARGS, "Can not have dynamic box while using pull geometry '%s' (dim %c)", EPULLGEOM(ir->pull->eGeom), 'x'+m);
3929 void double_check(t_inputrec *ir, matrix box, gmx_bool bConstr, warninp_t wi)
3933 char warn_buf[STRLEN];
3936 ptr = check_box(ir->ePBC, box);
3939 warning_error(wi, ptr);
3942 if (bConstr && ir->eConstrAlg == econtSHAKE)
3944 if (ir->shake_tol <= 0.0)
3946 sprintf(warn_buf, "ERROR: shake-tol must be > 0 instead of %g\n",
3948 warning_error(wi, warn_buf);
3951 if (IR_TWINRANGE(*ir) && ir->nstlist > 1)
3953 sprintf(warn_buf, "With twin-range cut-off's and SHAKE the virial and the pressure are incorrect.");
3954 if (ir->epc == epcNO)
3956 warning(wi, warn_buf);
3960 warning_error(wi, warn_buf);
3965 if ( (ir->eConstrAlg == econtLINCS) && bConstr)
3967 /* If we have Lincs constraints: */
3968 if (ir->eI == eiMD && ir->etc == etcNO &&
3969 ir->eConstrAlg == econtLINCS && ir->nLincsIter == 1)
3971 sprintf(warn_buf, "For energy conservation with LINCS, lincs_iter should be 2 or larger.\n");
3972 warning_note(wi, warn_buf);
3975 if ((ir->eI == eiCG || ir->eI == eiLBFGS) && (ir->nProjOrder < 8))
3977 sprintf(warn_buf, "For accurate %s with LINCS constraints, lincs-order should be 8 or more.", ei_names[ir->eI]);
3978 warning_note(wi, warn_buf);
3980 if (ir->epc == epcMTTK)
3982 warning_error(wi, "MTTK not compatible with lincs -- use shake instead.");
3986 if (ir->LincsWarnAngle > 90.0)
3988 sprintf(warn_buf, "lincs-warnangle can not be larger than 90 degrees, setting it to 90.\n");
3989 warning(wi, warn_buf);
3990 ir->LincsWarnAngle = 90.0;
3993 if (ir->ePBC != epbcNONE)
3995 if (ir->nstlist == 0)
3997 warning(wi, "With nstlist=0 atoms are only put into the box at step 0, therefore drifting atoms might cause the simulation to crash.");
3999 bTWIN = (ir->rlistlong > ir->rlist);
4000 if (ir->ns_type == ensGRID)
4002 if (sqr(ir->rlistlong) >= max_cutoff2(ir->ePBC, box))
4004 sprintf(warn_buf, "ERROR: The cut-off length is longer than half the shortest box vector or longer than the smallest box diagonal element. Increase the box size or decrease %s.\n",
4005 bTWIN ? (ir->rcoulomb == ir->rlistlong ? "rcoulomb" : "rvdw") : "rlist");
4006 warning_error(wi, warn_buf);
4011 min_size = min(box[XX][XX], min(box[YY][YY], box[ZZ][ZZ]));
4012 if (2*ir->rlistlong >= min_size)
4014 sprintf(warn_buf, "ERROR: One of the box lengths is smaller than twice the cut-off length. Increase the box size or decrease rlist.");
4015 warning_error(wi, warn_buf);
4018 fprintf(stderr, "Grid search might allow larger cut-off's than simple search with triclinic boxes.");
4025 void check_chargegroup_radii(const gmx_mtop_t *mtop, const t_inputrec *ir,
4029 real rvdw1, rvdw2, rcoul1, rcoul2;
4030 char warn_buf[STRLEN];
4032 calc_chargegroup_radii(mtop, x, &rvdw1, &rvdw2, &rcoul1, &rcoul2);
4036 printf("Largest charge group radii for Van der Waals: %5.3f, %5.3f nm\n",
4041 printf("Largest charge group radii for Coulomb: %5.3f, %5.3f nm\n",
4047 if (rvdw1 + rvdw2 > ir->rlist ||
4048 rcoul1 + rcoul2 > ir->rlist)
4051 "The sum of the two largest charge group radii (%f) "
4052 "is larger than rlist (%f)\n",
4053 max(rvdw1+rvdw2, rcoul1+rcoul2), ir->rlist);
4054 warning(wi, warn_buf);
4058 /* Here we do not use the zero at cut-off macro,
4059 * since user defined interactions might purposely
4060 * not be zero at the cut-off.
4062 if ((EVDW_IS_ZERO_AT_CUTOFF(ir->vdwtype) ||
4063 ir->vdw_modifier != eintmodNONE) &&
4064 rvdw1 + rvdw2 > ir->rlistlong - ir->rvdw)
4066 sprintf(warn_buf, "The sum of the two largest charge group "
4067 "radii (%f) is larger than %s (%f) - rvdw (%f).\n"
4068 "With exact cut-offs, better performance can be "
4069 "obtained with cutoff-scheme = %s, because it "
4070 "does not use charge groups at all.",
4072 ir->rlistlong > ir->rlist ? "rlistlong" : "rlist",
4073 ir->rlistlong, ir->rvdw,
4074 ecutscheme_names[ecutsVERLET]);
4077 warning(wi, warn_buf);
4081 warning_note(wi, warn_buf);
4084 if ((EEL_IS_ZERO_AT_CUTOFF(ir->coulombtype) ||
4085 ir->coulomb_modifier != eintmodNONE) &&
4086 rcoul1 + rcoul2 > ir->rlistlong - ir->rcoulomb)
4088 sprintf(warn_buf, "The sum of the two largest charge group radii (%f) is larger than %s (%f) - rcoulomb (%f).\n"
4089 "With exact cut-offs, better performance can be obtained with cutoff-scheme = %s, because it does not use charge groups at all.",
4091 ir->rlistlong > ir->rlist ? "rlistlong" : "rlist",
4092 ir->rlistlong, ir->rcoulomb,
4093 ecutscheme_names[ecutsVERLET]);
4096 warning(wi, warn_buf);
4100 warning_note(wi, warn_buf);