static int enter_params(gmx_ffparams_t *ffparams, t_functype ftype,
real forceparams[MAXFORCEPARAM], int comb, real reppow,
int start, gmx_bool bAppend)
{
t_iparams newparam;
int type;
int rc;
if ( (rc = assign_param(ftype, &newparam, forceparams, comb, reppow)) < 0)
{
/* -1 means this interaction is all-zero and should not be added */
return rc;
}
if (!bAppend)
{
for (type = start; (type < ffparams->ntypes); type++)
{
if (ffparams->functype[type] == ftype)
{
if (F_GB13 == ftype)
{
/* Occasionally, the way the 1-3 reference distance is
* computed can lead to non-binary-identical results, but I
* don't know why. */
if ((gmx_within_tol(newparam.gb.sar, ffparams->iparams[type].gb.sar, 1e-6)) &&
(gmx_within_tol(newparam.gb.st, ffparams->iparams[type].gb.st, 1e-6)) &&
(gmx_within_tol(newparam.gb.pi, ffparams->iparams[type].gb.pi, 1e-6)) &&
(gmx_within_tol(newparam.gb.gbr, ffparams->iparams[type].gb.gbr, 1e-6)) &&
(gmx_within_tol(newparam.gb.bmlt, ffparams->iparams[type].gb.bmlt, 1e-6)))
{
return type;
}
}
else
{
if (memcmp(&newparam, &ffparams->iparams[type], (size_t)sizeof(newparam)) == 0)
{
return type;
}
}
}
}
}
else
{
type = ffparams->ntypes;
}
if (debug)
{
fprintf(debug, "copying newparam to ffparams->iparams[%d] (ntypes=%d)\n",
type, ffparams->ntypes);
}
memcpy(&ffparams->iparams[type], &newparam, (size_t)sizeof(newparam));
ffparams->ntypes++;
ffparams->functype[type] = ftype;
return type;
}
void
AnalysisDataDisplacementModule::frameStarted(const AnalysisDataFrameHeader &header)
{
// Initialize times.
if (_impl->bFirst)
{
_impl->t0 = header.x();
}
else if (_impl->dt <= 0)
{
_impl->dt = header.x() - _impl->t0;
if (_impl->dt < 0 || gmx_within_tol(_impl->dt, 0.0, GMX_REAL_EPS))
{
GMX_THROW(APIError("Identical or decreasing frame times"));
}
}
else
{
if (!gmx_within_tol(header.x() - _impl->t, _impl->dt, GMX_REAL_EPS))
{
GMX_THROW(APIError("Frames not evenly spaced"));
}
}
_impl->t = header.x();
// Allocate memory for all the positions once it is possible.
if (_impl->max_store == -1 && !_impl->bFirst)
{
_impl->max_store = _impl->nmax * (int)(_impl->tmax/_impl->dt + 1);
srenew(_impl->oldval, _impl->max_store);
}
// Increment the index where current positions are stored.
_impl->ci += _impl->nmax;
if (_impl->ci >= _impl->max_store)
{
_impl->ci = 0;
}
/*
for (int i = 0; i < _impl->nmax; ++i)
{
_impl->p[_impl->ci + i].bPres = false;
}
*/
_impl->nstored++;
_impl->bFirst = false;
}
/*! \brief
* Does a type conversion on a \c t_selexpr_value.
*
* \param[in,out] value Value to convert.
* \param[in] type Type to convert to.
* \param[in] scanner Scanner data structure.
* \returns 0 on success, a non-zero value on error.
*/
static int
convert_value(t_selexpr_value *value, e_selvalue_t type, void *scanner)
{
if (value->type == type || type == NO_VALUE)
{
return 0;
}
if (value->bExpr)
{
/* Conversion from atom selection to position using default
* reference positions. */
if (value->type == GROUP_VALUE && type == POS_VALUE)
{
value->u.expr =
_gmx_sel_init_position(value->u.expr, NULL, scanner);
if (value->u.expr == NULL)
{
return -1;
}
value->type = type;
return 0;
}
return -1;
}
else
{
/* Integers to floating point are easy */
if (value->type == INT_VALUE && type == REAL_VALUE)
{
value->u.r.r1 = (real)value->u.i.i1;
value->u.r.r2 = (real)value->u.i.i2;
value->type = type;
return 0;
}
/* Reals that are integer-valued can also be converted */
if (value->type == REAL_VALUE && type == INT_VALUE
&& gmx_within_tol(value->u.r.r1, (int)value->u.r.r1, GMX_REAL_EPS)
&& gmx_within_tol(value->u.r.r2, (int)value->u.r.r2, GMX_REAL_EPS))
{
value->u.i.i1 = (int)value->u.r.r1;
value->u.i.i2 = (int)value->u.r.r2;
value->type = type;
return 0;
}
}
return -1;
}
/*! \brief
* Implementation for evaluate_compare() if either value is non-integer.
*
* \param[in] top Not used.
* \param[in] fr Not used.
* \param[in] pbc Not used.
* \param[in] g Evaluation index group.
* \param[out] out Output data structure (\p out->u.g is used).
* \param[in] data Should point to a \c t_methoddata_compare.
*
* Left value is assumed to be real-valued; right value can be either.
* This is ensured by the initialization method.
*/
static void
evaluate_compare_real(t_topology *top, t_trxframe *fr, t_pbc *pbc,
gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_compare *d = (t_methoddata_compare *)data;
int i, i1, i2, ig;
real a, b;
bool bAccept;
GMX_UNUSED_VALUE(top);
GMX_UNUSED_VALUE(fr);
GMX_UNUSED_VALUE(pbc);
for (i = i1 = i2 = ig = 0; i < g->isize; ++i)
{
a = d->left.r[i1];
b = (d->right.flags & CMP_REALVAL) ? d->right.r[i2] : d->right.i[i2];
bAccept = false;
switch (d->cmpt)
{
case CMP_INVALID: break;
case CMP_LESS: bAccept = a < b; break;
case CMP_LEQ: bAccept = a <= b; break;
case CMP_GTR: bAccept = a > b; break;
case CMP_GEQ: bAccept = a >= b; break;
case CMP_EQUAL: bAccept = gmx_within_tol(a, b, GMX_REAL_EPS); break;
case CMP_NEQ: bAccept = !gmx_within_tol(a, b, GMX_REAL_EPS); break;
}
if (bAccept)
{
out->u.g->index[ig++] = g->index[i];
}
if (!(d->left.flags & CMP_SINGLEVAL))
{
++i1;
}
if (!(d->right.flags & CMP_SINGLEVAL))
{
++i2;
}
}
out->u.g->isize = ig;
}
gmx_shellfc_t init_shell_flexcon(FILE *fplog,
gmx_bool bCutoffSchemeIsVerlet,
gmx_mtop_t *mtop, int nflexcon,
rvec *x)
{
struct gmx_shellfc *shfc;
t_shell *shell;
int *shell_index = NULL, *at2cg;
t_atom *atom;
int n[eptNR], ns, nshell, nsi;
int i, j, nmol, type, mb, mt, a_offset, cg, mol, ftype, nra;
real qS, alpha;
int aS, aN = 0; /* Shell and nucleus */
int bondtypes[] = { F_BONDS, F_HARMONIC, F_CUBICBONDS, F_POLARIZATION, F_ANHARM_POL, F_WATER_POL };
#define NBT asize(bondtypes)
t_iatom *ia;
gmx_mtop_atomloop_block_t aloopb;
gmx_mtop_atomloop_all_t aloop;
gmx_ffparams_t *ffparams;
gmx_molblock_t *molb;
gmx_moltype_t *molt;
t_block *cgs;
/* Count number of shells, and find their indices */
for (i = 0; (i < eptNR); i++)
{
n[i] = 0;
}
aloopb = gmx_mtop_atomloop_block_init(mtop);
while (gmx_mtop_atomloop_block_next(aloopb, &atom, &nmol))
{
n[atom->ptype] += nmol;
}
if (fplog)
{
/* Print the number of each particle type */
for (i = 0; (i < eptNR); i++)
{
if (n[i] != 0)
{
fprintf(fplog, "There are: %d %ss\n", n[i], ptype_str[i]);
}
}
}
nshell = n[eptShell];
if (nshell == 0 && nflexcon == 0)
{
/* We're not doing shells or flexible constraints */
return NULL;
}
if (bCutoffSchemeIsVerlet)
{
gmx_fatal(FARGS, "The shell code does not work with the Verlet cut-off scheme.\n");
}
snew(shfc, 1);
shfc->nflexcon = nflexcon;
if (nshell == 0)
{
return shfc;
}
/* We have shells: fill the shell data structure */
/* Global system sized array, this should be avoided */
snew(shell_index, mtop->natoms);
aloop = gmx_mtop_atomloop_all_init(mtop);
nshell = 0;
while (gmx_mtop_atomloop_all_next(aloop, &i, &atom))
{
if (atom->ptype == eptShell)
{
shell_index[i] = nshell++;
}
}
snew(shell, nshell);
/* Initiate the shell structures */
for (i = 0; (i < nshell); i++)
{
shell[i].shell = NO_ATID;
shell[i].nnucl = 0;
shell[i].nucl1 = NO_ATID;
shell[i].nucl2 = NO_ATID;
shell[i].nucl3 = NO_ATID;
/* shell[i].bInterCG=FALSE; */
shell[i].k_1 = 0;
shell[i].k = 0;
}
ffparams = &mtop->ffparams;
/* Now fill the structures */
shfc->bInterCG = FALSE;
ns = 0;
a_offset = 0;
for (mb = 0; mb < mtop->nmolblock; mb++)
{
molb = &mtop->molblock[mb];
molt = &mtop->moltype[molb->type];
cgs = &molt->cgs;
snew(at2cg, molt->atoms.nr);
for (cg = 0; cg < cgs->nr; cg++)
{
for (i = cgs->index[cg]; i < cgs->index[cg+1]; i++)
{
at2cg[i] = cg;
}
}
atom = molt->atoms.atom;
for (mol = 0; mol < molb->nmol; mol++)
{
for (j = 0; (j < NBT); j++)
{
ia = molt->ilist[bondtypes[j]].iatoms;
for (i = 0; (i < molt->ilist[bondtypes[j]].nr); )
{
type = ia[0];
ftype = ffparams->functype[type];
nra = interaction_function[ftype].nratoms;
/* Check whether we have a bond with a shell */
aS = NO_ATID;
switch (bondtypes[j])
{
case F_BONDS:
case F_HARMONIC:
case F_CUBICBONDS:
case F_POLARIZATION:
case F_ANHARM_POL:
if (atom[ia[1]].ptype == eptShell)
{
aS = ia[1];
aN = ia[2];
}
else if (atom[ia[2]].ptype == eptShell)
{
aS = ia[2];
aN = ia[1];
}
break;
case F_WATER_POL:
aN = ia[4]; /* Dummy */
aS = ia[5]; /* Shell */
break;
default:
gmx_fatal(FARGS, "Death Horror: %s, %d", __FILE__, __LINE__);
}
if (aS != NO_ATID)
{
qS = atom[aS].q;
/* Check whether one of the particles is a shell... */
nsi = shell_index[a_offset+aS];
if ((nsi < 0) || (nsi >= nshell))
{
gmx_fatal(FARGS, "nsi is %d should be within 0 - %d. aS = %d",
nsi, nshell, aS);
}
if (shell[nsi].shell == NO_ATID)
{
shell[nsi].shell = a_offset + aS;
ns++;
}
else if (shell[nsi].shell != a_offset+aS)
{
gmx_fatal(FARGS, "Weird stuff in %s, %d", __FILE__, __LINE__);
}
if (shell[nsi].nucl1 == NO_ATID)
{
shell[nsi].nucl1 = a_offset + aN;
}
else if (shell[nsi].nucl2 == NO_ATID)
{
shell[nsi].nucl2 = a_offset + aN;
}
else if (shell[nsi].nucl3 == NO_ATID)
{
shell[nsi].nucl3 = a_offset + aN;
}
else
{
if (fplog)
{
pr_shell(fplog, ns, shell);
}
gmx_fatal(FARGS, "Can not handle more than three bonds per shell\n");
}
if (at2cg[aS] != at2cg[aN])
{
/* shell[nsi].bInterCG = TRUE; */
shfc->bInterCG = TRUE;
}
switch (bondtypes[j])
{
case F_BONDS:
case F_HARMONIC:
shell[nsi].k += ffparams->iparams[type].harmonic.krA;
break;
case F_CUBICBONDS:
shell[nsi].k += ffparams->iparams[type].cubic.kb;
break;
case F_POLARIZATION:
case F_ANHARM_POL:
if (!gmx_within_tol(qS, atom[aS].qB, GMX_REAL_EPS*10))
{
gmx_fatal(FARGS, "polarize can not be used with qA(%e) != qB(%e) for atom %d of molecule block %d", qS, atom[aS].qB, aS+1, mb+1);
}
shell[nsi].k += sqr(qS)*ONE_4PI_EPS0/
ffparams->iparams[type].polarize.alpha;
break;
case F_WATER_POL:
if (!gmx_within_tol(qS, atom[aS].qB, GMX_REAL_EPS*10))
{
gmx_fatal(FARGS, "water_pol can not be used with qA(%e) != qB(%e) for atom %d of molecule block %d", qS, atom[aS].qB, aS+1, mb+1);
}
alpha = (ffparams->iparams[type].wpol.al_x+
ffparams->iparams[type].wpol.al_y+
ffparams->iparams[type].wpol.al_z)/3.0;
shell[nsi].k += sqr(qS)*ONE_4PI_EPS0/alpha;
break;
default:
gmx_fatal(FARGS, "Death Horror: %s, %d", __FILE__, __LINE__);
}
shell[nsi].nnucl++;
}
ia += nra+1;
i += nra+1;
}
}
a_offset += molt->atoms.nr;
}
/* Done with this molecule type */
sfree(at2cg);
}
/* Verify whether it's all correct */
if (ns != nshell)
{
gmx_fatal(FARGS, "Something weird with shells. They may not be bonded to something");
}
for (i = 0; (i < ns); i++)
{
shell[i].k_1 = 1.0/shell[i].k;
}
if (debug)
{
pr_shell(debug, ns, shell);
}
shfc->nshell_gl = ns;
shfc->shell_gl = shell;
shfc->shell_index_gl = shell_index;
shfc->bPredict = (getenv("GMX_NOPREDICT") == NULL);
shfc->bRequireInit = FALSE;
if (!shfc->bPredict)
{
if (fplog)
{
fprintf(fplog, "\nWill never predict shell positions\n");
}
}
else
{
shfc->bRequireInit = (getenv("GMX_REQUIRE_SHELL_INIT") != NULL);
if (shfc->bRequireInit && fplog)
{
fprintf(fplog, "\nWill always initiate shell positions\n");
}
}
if (shfc->bPredict)
{
if (x)
{
predict_shells(fplog, x, NULL, 0, shfc->nshell_gl, shfc->shell_gl,
NULL, mtop, TRUE);
}
if (shfc->bInterCG)
{
if (fplog)
{
fprintf(fplog, "\nNOTE: there all shells that are connected to particles outside thier own charge group, will not predict shells positions during the run\n\n");
}
shfc->bPredict = FALSE;
}
}
return shfc;
}
static void fill_table(t_tabledata *td,int tp,const t_forcerec *fr)
{
/* Fill the table according to the formulas in the manual.
* In principle, we only need the potential and the second
* derivative, but then we would have to do lots of calculations
* in the inner loop. By precalculating some terms (see manual)
* we get better eventual performance, despite a larger table.
*
* Since some of these higher-order terms are very small,
* we always use double precision to calculate them here, in order
* to avoid unnecessary loss of precision.
*/
#ifdef DEBUG_SWITCH
FILE *fp;
#endif
int i;
double reppow,p;
double r1,rc,r12,r13;
double r,r2,r6,rc6;
double expr,Vtab,Ftab;
/* Parameters for David's function */
double A=0,B=0,C=0,A_3=0,B_4=0;
/* Parameters for the switching function */
double ksw,swi,swi1;
/* Temporary parameters */
gmx_bool bSwitch,bShift;
double ewc=fr->ewaldcoeff;
double isp= 0.564189583547756;
bSwitch = ((tp == etabLJ6Switch) || (tp == etabLJ12Switch) ||
(tp == etabCOULSwitch) ||
(tp == etabEwaldSwitch) || (tp == etabEwaldUserSwitch));
bShift = ((tp == etabLJ6Shift) || (tp == etabLJ12Shift) ||
(tp == etabShift));
reppow = fr->reppow;
if (tprops[tp].bCoulomb) {
r1 = fr->rcoulomb_switch;
rc = fr->rcoulomb;
}
else {
r1 = fr->rvdw_switch;
rc = fr->rvdw;
}
if (bSwitch)
ksw = 1.0/(pow5(rc-r1));
else
ksw = 0.0;
if (bShift) {
if (tp == etabShift)
p = 1;
else if (tp == etabLJ6Shift)
p = 6;
else
p = reppow;
A = p * ((p+1)*r1-(p+4)*rc)/(pow(rc,p+2)*pow2(rc-r1));
B = -p * ((p+1)*r1-(p+3)*rc)/(pow(rc,p+2)*pow3(rc-r1));
C = 1.0/pow(rc,p)-A/3.0*pow3(rc-r1)-B/4.0*pow4(rc-r1);
if (tp == etabLJ6Shift) {
A=-A;
B=-B;
C=-C;
}
A_3=A/3.0;
B_4=B/4.0;
}
if (debug) { fprintf(debug,"Setting up tables\n"); fflush(debug); }
#ifdef DEBUG_SWITCH
fp=xvgropen("switch.xvg","switch","r","s");
#endif
for(i=td->nx0; (i<td->nx); i++) {
r = td->x[i];
r2 = r*r;
r6 = 1.0/(r2*r2*r2);
if (gmx_within_tol(reppow,12.0,10*GMX_DOUBLE_EPS)) {
r12 = r6*r6;
} else {
r12 = pow(r,-reppow);
}
Vtab = 0.0;
Ftab = 0.0;
if (bSwitch) {
/* swi is function, swi1 1st derivative and swi2 2nd derivative */
/* The switch function is 1 for r<r1, 0 for r>rc, and smooth for
* r1<=r<=rc. The 1st and 2nd derivatives are both zero at
* r1 and rc.
* ksw is just the constant 1/(rc-r1)^5, to save some calculations...
*/
if(r<=r1) {
swi = 1.0;
swi1 = 0.0;
} else if (r>=rc) {
swi = 0.0;
swi1 = 0.0;
} else {
swi = 1 - 10*pow3(r-r1)*ksw*pow2(rc-r1)
+ 15*pow4(r-r1)*ksw*(rc-r1) - 6*pow5(r-r1)*ksw;
swi1 = -30*pow2(r-r1)*ksw*pow2(rc-r1)
+ 60*pow3(r-r1)*ksw*(rc-r1) - 30*pow4(r-r1)*ksw;
}
}
else { /* not really needed, but avoids compiler warnings... */
swi = 1.0;
swi1 = 0.0;
}
#ifdef DEBUG_SWITCH
fprintf(fp,"%10g %10g %10g %10g\n",r,swi,swi1,swi2);
#endif
rc6 = rc*rc*rc;
rc6 = 1.0/(rc6*rc6);
switch (tp) {
case etabLJ6:
/* Dispersion */
Vtab = -r6;
Ftab = 6.0*Vtab/r;
break;
case etabLJ6Switch:
case etabLJ6Shift:
/* Dispersion */
if (r < rc) {
Vtab = -r6;
Ftab = 6.0*Vtab/r;
}
break;
case etabLJ12:
/* Repulsion */
Vtab = r12;
Ftab = reppow*Vtab/r;
break;
case etabLJ12Switch:
case etabLJ12Shift:
/* Repulsion */
if (r < rc) {
Vtab = r12;
Ftab = reppow*Vtab/r;
}
break;
case etabLJ6Encad:
if(r < rc) {
Vtab = -(r6-6.0*(rc-r)*rc6/rc-rc6);
Ftab = -(6.0*r6/r-6.0*rc6/rc);
} else { /* r>rc */
Vtab = 0;
Ftab = 0;
}
break;
case etabLJ12Encad:
if(r < rc) {
Vtab = r12-12.0*(rc-r)*rc6*rc6/rc-1.0*rc6*rc6;
Ftab = 12.0*r12/r-12.0*rc6*rc6/rc;
} else { /* r>rc */
Vtab = 0;
Ftab = 0;
}
break;
case etabCOUL:
Vtab = 1.0/r;
Ftab = 1.0/r2;
break;
case etabCOULSwitch:
case etabShift:
if (r < rc) {
Vtab = 1.0/r;
Ftab = 1.0/r2;
}
break;
case etabEwald:
case etabEwaldSwitch:
Vtab = gmx_erfc(ewc*r)/r;
Ftab = gmx_erfc(ewc*r)/r2+2*exp(-(ewc*ewc*r2))*ewc*isp/r;
break;
case etabEwaldUser:
case etabEwaldUserSwitch:
/* Only calculate minus the reciprocal space contribution */
Vtab = -gmx_erf(ewc*r)/r;
Ftab = -gmx_erf(ewc*r)/r2+2*exp(-(ewc*ewc*r2))*ewc*isp/r;
break;
case etabRF:
case etabRF_ZERO:
Vtab = 1.0/r + fr->k_rf*r2 - fr->c_rf;
Ftab = 1.0/r2 - 2*fr->k_rf*r;
if (tp == etabRF_ZERO && r >= rc) {
Vtab = 0;
Ftab = 0;
}
break;
case etabEXPMIN:
expr = exp(-r);
Vtab = expr;
Ftab = expr;
break;
case etabCOULEncad:
if(r < rc) {
Vtab = 1.0/r-(rc-r)/(rc*rc)-1.0/rc;
Ftab = 1.0/r2-1.0/(rc*rc);
} else { /* r>rc */
Vtab = 0;
Ftab = 0;
}
break;
default:
gmx_fatal(FARGS,"Table type %d not implemented yet. (%s,%d)",
tp,__FILE__,__LINE__);
}
if (bShift) {
/* Normal coulomb with cut-off correction for potential */
if (r < rc) {
Vtab -= C;
/* If in Shifting range add something to it */
if (r > r1) {
r12 = (r-r1)*(r-r1);
r13 = (r-r1)*r12;
Vtab += - A_3*r13 - B_4*r12*r12;
Ftab += A*r12 + B*r13;
}
}
}
if (ETAB_USER(tp)) {
Vtab += td->v[i];
Ftab += td->f[i];
}
if ((r > r1) && bSwitch) {
Ftab = Ftab*swi - Vtab*swi1;
Vtab = Vtab*swi;
}
/* Convert to single precision when we store to mem */
td->v[i] = Vtab;
td->f[i] = Ftab;
}
/* Continue the table linearly from nx0 to 0.
* These values are only required for energy minimization with overlap or TPI.
*/
for(i=td->nx0-1; i>=0; i--) {
td->v[i] = td->v[i+1] + td->f[i+1]*(td->x[i+1] - td->x[i]);
td->f[i] = td->f[i+1];
}
#ifdef DEBUG_SWITCH
gmx_fio_fclose(fp);
#endif
}
void mapGridToDataGrid(std::vector<int> *gridpointToDatapoint,
const double* const *data,
int numDataPoints,
const std::string &dataFilename,
const Grid &grid,
const std::string &correctFormatMessage)
{
/* Transform the data into a grid in order to map each grid point to a data point
using the grid functions. */
std::vector<GridAxis> axis_;
/* Count the number of points for each dimension. Each dimension
has its own stride. */
int stride = 1;
int numPointsCounted = 0;
std::vector<int> numPoints(grid.numDimensions());
for (int d = grid.numDimensions() - 1; d >= 0; d--)
{
int numPointsInDim = 0;
int pointIndex = 0;
double firstValue = data[d][pointIndex];
do
{
numPointsInDim++;
pointIndex += stride;
}
while (pointIndex < numDataPoints &&
!gmx_within_tol(firstValue, data[d][pointIndex], GMX_REAL_EPS));
/* The stride in dimension dimension d - 1 equals the number of points
dimension d. */
stride = numPointsInDim;
numPointsCounted = (numPointsCounted == 0) ? numPointsInDim : numPointsCounted*numPointsInDim;
numPoints[d] = numPointsInDim;
}
if (numPointsCounted != numDataPoints)
{
std::string mesg = gmx::formatString("Could not extract data properly from %s. Wrong data format?"
"\n\n%s",
dataFilename.c_str(), correctFormatMessage.c_str());
GMX_THROW(InvalidInputError(mesg));
}
/* The data grid has the data that was read and the properties of the AWH grid */
for (int d = 0; d < grid.numDimensions(); d++)
{
axis_.push_back(GridAxis(data[d][0], data[d][numDataPoints - 1],
grid.axis(d).period(), numPoints[d]));
}
/* Map each grid point to a data point. No interpolation, just pick the nearest one.
* It is assumed that the given data is uniformly spaced for each dimension.
*/
for (size_t m = 0; m < grid.numPoints(); m++)
{
/* We only define what we need for the datagrid since it's not needed here which is a bit ugly */
if (!valueIsInGrid(grid.point(m).coordValue, axis_))
{
std::string mesg =
gmx::formatString("%s does not contain data for all coordinate values. "
"Make sure your input data covers the whole sampling domain "
"and is correctly formatted. \n\n%s",
dataFilename.c_str(), correctFormatMessage.c_str());
GMX_THROW(InvalidInputError(mesg));
}
(*gridpointToDatapoint)[m] = getNearestIndexInGrid(grid.point(m).coordValue, axis_);
}
}
/*! \brief
* Read parameters of an AWH bias dimension.
*
* \param[in,out] ninp_p Number of read input file entries.
* \param[in,out] inp_p Input file entries.
* \param[in] prefix Prefix for dimension parameters.
* \param[in,out] dimParams AWH dimensional parameters.
* \param[in] pull_params Pull parameters.
* \param[in,out] wi Struct for bookeeping warnings.
* \param[in] bComment True if comments should be printed.
*/
static void readDimParams(int *ninp_p, t_inpfile **inp_p, const char *prefix,
AwhDimParams *dimParams, const pull_params_t *pull_params,
warninp_t wi, bool bComment)
{
char warningmsg[STRLEN];
int ninp = *ninp_p;
t_inpfile *inp = *inp_p;
if (bComment)
{
CTYPE("The provider of the reaction coordinate, currently only pull is supported");
}
char opt[STRLEN];
sprintf(opt, "%s-coord-provider", prefix);
EETYPE(opt, dimParams->eCoordProvider, eawhcoordprovider_names);
if (bComment)
{
CTYPE("The coordinate index for this dimension");
}
sprintf(opt, "%s-coord-index", prefix);
int coordIndexInput;
ITYPE(opt, coordIndexInput, 1);
if (coordIndexInput < 1)
{
gmx_fatal(FARGS, "Failed to read a valid coordinate index for %s. "
"Note that the pull coordinate indexing starts at 1.", opt);
}
/* The pull coordinate indices start at 1 in the input file, at 0 internally */
dimParams->coordIndex = coordIndexInput - 1;
/* The pull settings need to be consistent with the AWH settings */
if (!(pull_params->coord[dimParams->coordIndex].eType == epullEXTERNAL) )
{
gmx_fatal(FARGS, "AWH biasing can only be applied to pull type %s",
EPULLTYPE(epullEXTERNAL));
}
if (dimParams->coordIndex >= pull_params->ncoord)
{
gmx_fatal(FARGS, "The given AWH coordinate index (%d) is larger than the number of pull coordinates (%d)",
coordIndexInput, pull_params->ncoord);
}
if (pull_params->coord[dimParams->coordIndex].rate != 0)
{
sprintf(warningmsg, "Setting pull-coord%d-rate (%g) is incompatible with AWH biasing this coordinate", coordIndexInput, pull_params->coord[dimParams->coordIndex].rate);
warning_error(wi, warningmsg);
}
/* Grid params for each axis */
int eGeom = pull_params->coord[dimParams->coordIndex].eGeom;
if (bComment)
{
CTYPE("Start and end values for each coordinate dimension");
}
sprintf(opt, "%s-start", prefix);
RTYPE(opt, dimParams->origin, 0.);
sprintf(opt, "%s-end", prefix);
RTYPE(opt, dimParams->end, 0.);
if (gmx_within_tol(dimParams->end - dimParams->origin, 0, GMX_REAL_EPS))
{
sprintf(warningmsg, "The given interval length given by %s-start (%g) and %s-end (%g) is zero. "
"This will result in only one point along this axis in the coordinate value grid.",
prefix, dimParams->origin, prefix, dimParams->end);
warning(wi, warningmsg);
}
/* Check that the requested interval is in allowed range */
if (eGeom == epullgDIST)
{
if (dimParams->origin < 0 || dimParams->end < 0)
{
gmx_fatal(FARGS, "%s-start (%g) or %s-end (%g) set to a negative value. With pull geometry distance coordinate values are non-negative. "
"Perhaps you want to use geometry %s instead?",
prefix, dimParams->origin, prefix, dimParams->end, EPULLGEOM(epullgDIR));
}
}
else if (eGeom == epullgANGLE || eGeom == epullgANGLEAXIS)
{
if (dimParams->origin < 0 || dimParams->end > 180)
{
gmx_fatal(FARGS, "%s-start (%g) and %s-end (%g) are outside of the allowed range 0 to 180 deg for pull geometries %s and %s ",
prefix, dimParams->origin, prefix, dimParams->end, EPULLGEOM(epullgANGLE), EPULLGEOM(epullgANGLEAXIS));
}
}
else if (eGeom == epullgDIHEDRAL)
{
if (dimParams->origin < -180 || dimParams->end > 180)
{
gmx_fatal(FARGS, "%s-start (%g) and %s-end (%g) are outside of the allowed range -180 to 180 deg for pull geometry %s. ",
prefix, dimParams->origin, prefix, dimParams->end, EPULLGEOM(epullgDIHEDRAL));
}
}
if (bComment)
{
CTYPE("The force constant for this coordinate (kJ/mol/nm^2 or kJ/mol/rad^2)");
}
sprintf(opt, "%s-force-constant", prefix);
RTYPE(opt, dimParams->forceConstant, 0);
if (dimParams->forceConstant <= 0)
{
warning_error(wi, "The force AWH bias force constant should be > 0");
}
if (bComment)
{
CTYPE("Estimated diffusion constant (nm^2/ps or rad^2/ps)");
}
sprintf(opt, "%s-diffusion", prefix);
RTYPE(opt, dimParams->diffusion, 0);
if (dimParams->diffusion <= 0)
{
const double diffusion_default = 1e-5;
sprintf(warningmsg, "%s not explicitly set by user."
" You can choose to use a default value (%g nm^2/ps or rad^2/ps) but this may very well be non-optimal for your system!",
opt, diffusion_default);
warning(wi, warningmsg);
dimParams->diffusion = diffusion_default;
}
if (bComment)
{
CTYPE("Diameter that needs to be sampled around a point before it is considered covered.");
}
sprintf(opt, "%s-cover-diameter", prefix);
RTYPE(opt, dimParams->coverDiameter, 0);
if (dimParams->coverDiameter < 0)
{
gmx_fatal(FARGS, "%s (%g) cannot be negative.",
opt, dimParams->coverDiameter);
}
*ninp_p = ninp;
*inp_p = inp;
}
static int ChooseNewLambda(int nlim, t_expanded *expand, df_history_t *dfhist, int fep_state, real *weighted_lamee, double *p_k,
gmx_int64_t seed, gmx_int64_t step)
{
/* Choose new lambda value, and update transition matrix */
int i, ifep, minfep, maxfep, lamnew, lamtrial, starting_fep_state;
real r1, r2, de, trialprob, tprob = 0;
double *propose, *accept, *remainder;
double pks;
real pnorm;
starting_fep_state = fep_state;
lamnew = fep_state; /* so that there is a default setting -- stays the same */
if (!EWL(expand->elamstats)) /* ignore equilibrating the weights if using WL */
{
if ((expand->lmc_forced_nstart > 0) && (dfhist->n_at_lam[nlim-1] <= expand->lmc_forced_nstart))
{
/* Use a marching method to run through the lambdas and get preliminary free energy data,
before starting 'free' sampling. We start free sampling when we have enough at each lambda */
/* if we have enough at this lambda, move on to the next one */
if (dfhist->n_at_lam[fep_state] == expand->lmc_forced_nstart)
{
lamnew = fep_state+1;
if (lamnew == nlim) /* whoops, stepped too far! */
{
lamnew -= 1;
}
}
else
{
lamnew = fep_state;
}
return lamnew;
}
}
snew(propose, nlim);
snew(accept, nlim);
snew(remainder, nlim);
for (i = 0; i < expand->lmc_repeats; i++)
{
double rnd[2];
gmx_rng_cycle_2uniform(step, i, seed, RND_SEED_EXPANDED, rnd);
for (ifep = 0; ifep < nlim; ifep++)
{
propose[ifep] = 0;
accept[ifep] = 0;
}
if ((expand->elmcmove == elmcmoveGIBBS) || (expand->elmcmove == elmcmoveMETGIBBS))
{
/* use the Gibbs sampler, with restricted range */
if (expand->gibbsdeltalam < 0)
{
minfep = 0;
maxfep = nlim-1;
}
else
{
minfep = fep_state - expand->gibbsdeltalam;
maxfep = fep_state + expand->gibbsdeltalam;
if (minfep < 0)
{
minfep = 0;
}
if (maxfep > nlim-1)
{
maxfep = nlim-1;
}
}
GenerateGibbsProbabilities(weighted_lamee, p_k, &pks, minfep, maxfep);
if (expand->elmcmove == elmcmoveGIBBS)
{
for (ifep = minfep; ifep <= maxfep; ifep++)
{
propose[ifep] = p_k[ifep];
accept[ifep] = 1.0;
}
/* Gibbs sampling */
r1 = rnd[0];
for (lamnew = minfep; lamnew <= maxfep; lamnew++)
{
if (r1 <= p_k[lamnew])
{
break;
}
r1 -= p_k[lamnew];
}
}
else if (expand->elmcmove == elmcmoveMETGIBBS)
{
/* Metropolized Gibbs sampling */
for (ifep = minfep; ifep <= maxfep; ifep++)
{
remainder[ifep] = 1 - p_k[ifep];
}
/* find the proposal probabilities */
if (remainder[fep_state] == 0)
{
/* only the current state has any probability */
/* we have to stay at the current state */
lamnew = fep_state;
}
else
{
for (ifep = minfep; ifep <= maxfep; ifep++)
{
if (ifep != fep_state)
{
propose[ifep] = p_k[ifep]/remainder[fep_state];
}
else
{
propose[ifep] = 0;
}
}
r1 = rnd[0];
for (lamtrial = minfep; lamtrial <= maxfep; lamtrial++)
{
pnorm = p_k[lamtrial]/remainder[fep_state];
if (lamtrial != fep_state)
{
if (r1 <= pnorm)
{
break;
}
r1 -= pnorm;
}
}
/* we have now selected lamtrial according to p(lamtrial)/1-p(fep_state) */
tprob = 1.0;
/* trial probability is min{1,\frac{1 - p(old)}{1-p(new)} MRS 1/8/2008 */
trialprob = (remainder[fep_state])/(remainder[lamtrial]);
if (trialprob < tprob)
{
tprob = trialprob;
}
r2 = rnd[1];
if (r2 < tprob)
{
lamnew = lamtrial;
}
else
{
lamnew = fep_state;
}
}
/* now figure out the acceptance probability for each */
for (ifep = minfep; ifep <= maxfep; ifep++)
{
tprob = 1.0;
if (remainder[ifep] != 0)
{
trialprob = (remainder[fep_state])/(remainder[ifep]);
}
else
{
trialprob = 1.0; /* this state is the only choice! */
}
if (trialprob < tprob)
{
tprob = trialprob;
}
/* probability for fep_state=0, but that's fine, it's never proposed! */
accept[ifep] = tprob;
}
}
if (lamnew > maxfep)
{
/* it's possible some rounding is failing */
if (gmx_within_tol(remainder[fep_state], 0, 50*GMX_DOUBLE_EPS))
{
/* numerical rounding error -- no state other than the original has weight */
lamnew = fep_state;
}
else
{
/* probably not a numerical issue */
int loc = 0;
int nerror = 200+(maxfep-minfep+1)*60;
char *errorstr;
snew(errorstr, nerror);
/* if its greater than maxfep, then something went wrong -- probably underflow in the calculation
of sum weights. Generated detailed info for failure */
loc += sprintf(errorstr, "Something wrong in choosing new lambda state with a Gibbs move -- probably underflow in weight determination.\nDenominator is: %3d%17.10e\n i dE numerator weights\n", 0, pks);
for (ifep = minfep; ifep <= maxfep; ifep++)
{
loc += sprintf(&errorstr[loc], "%3d %17.10e%17.10e%17.10e\n", ifep, weighted_lamee[ifep], p_k[ifep], dfhist->sum_weights[ifep]);
}
gmx_fatal(FARGS, errorstr);
}
}
}
else if ((expand->elmcmove == elmcmoveMETROPOLIS) || (expand->elmcmove == elmcmoveBARKER))
{
/* use the metropolis sampler with trial +/- 1 */
r1 = rnd[0];
if (r1 < 0.5)
{
if (fep_state == 0)
{
lamtrial = fep_state;
}
else
{
lamtrial = fep_state-1;
}
}
else
{
if (fep_state == nlim-1)
{
lamtrial = fep_state;
}
else
{
lamtrial = fep_state+1;
}
}
de = weighted_lamee[lamtrial] - weighted_lamee[fep_state];
if (expand->elmcmove == elmcmoveMETROPOLIS)
{
tprob = 1.0;
trialprob = std::exp(de);
if (trialprob < tprob)
{
tprob = trialprob;
}
propose[fep_state] = 0;
propose[lamtrial] = 1.0; /* note that this overwrites the above line if fep_state = ntrial, which only occurs at the ends */
accept[fep_state] = 1.0; /* doesn't actually matter, never proposed unless fep_state = ntrial, in which case it's 1.0 anyway */
accept[lamtrial] = tprob;
}
else if (expand->elmcmove == elmcmoveBARKER)
{
tprob = 1.0/(1.0+std::exp(-de));
propose[fep_state] = (1-tprob);
propose[lamtrial] += tprob; /* we add, to account for the fact that at the end, they might be the same point */
accept[fep_state] = 1.0;
accept[lamtrial] = 1.0;
}
r2 = rnd[1];
if (r2 < tprob)
{
lamnew = lamtrial;
}
else
{
lamnew = fep_state;
}
}
for (ifep = 0; ifep < nlim; ifep++)
{
dfhist->Tij[fep_state][ifep] += propose[ifep]*accept[ifep];
dfhist->Tij[fep_state][fep_state] += propose[ifep]*(1.0-accept[ifep]);
}
fep_state = lamnew;
}
dfhist->Tij_empirical[starting_fep_state][lamnew] += 1.0;
sfree(propose);
sfree(accept);
sfree(remainder);
return lamnew;
}
gmx_shellfc_t *init_shell_flexcon(FILE *fplog,
gmx_mtop_t *mtop, int nflexcon,
int nstcalcenergy,
bool usingDomainDecomposition)
{
gmx_shellfc_t *shfc;
t_shell *shell;
int *shell_index = NULL, *at2cg;
t_atom *atom;
int ns, nshell, nsi;
int i, j, type, mb, a_offset, cg, mol, ftype, nra;
real qS, alpha;
int aS, aN = 0; /* Shell and nucleus */
int bondtypes[] = { F_BONDS, F_HARMONIC, F_CUBICBONDS, F_POLARIZATION, F_ANHARM_POL, F_WATER_POL };
#define NBT asize(bondtypes)
t_iatom *ia;
gmx_mtop_atomloop_all_t aloop;
gmx_ffparams_t *ffparams;
gmx_molblock_t *molb;
gmx_moltype_t *molt;
t_block *cgs;
std::array<int, eptNR> n = countPtypes(fplog, mtop);
nshell = n[eptShell];
if (nshell == 0 && nflexcon == 0)
{
/* We're not doing shells or flexible constraints */
return NULL;
}
snew(shfc, 1);
shfc->nflexcon = nflexcon;
if (nshell == 0)
{
/* Only flexible constraints, no shells.
* Note that make_local_shells() does not need to be called.
*/
shfc->nshell = 0;
shfc->bPredict = FALSE;
return shfc;
}
if (nstcalcenergy != 1)
{
gmx_fatal(FARGS, "You have nstcalcenergy set to a value (%d) that is different from 1.\nThis is not supported in combination with shell particles.\nPlease make a new tpr file.", nstcalcenergy);
}
if (usingDomainDecomposition)
{
gmx_fatal(FARGS, "Shell particles are not implemented with domain decomposition, use a single rank");
}
/* We have shells: fill the shell data structure */
/* Global system sized array, this should be avoided */
snew(shell_index, mtop->natoms);
aloop = gmx_mtop_atomloop_all_init(mtop);
nshell = 0;
while (gmx_mtop_atomloop_all_next(aloop, &i, &atom))
{
if (atom->ptype == eptShell)
{
shell_index[i] = nshell++;
}
}
snew(shell, nshell);
/* Initiate the shell structures */
for (i = 0; (i < nshell); i++)
{
shell[i].shell = -1;
shell[i].nnucl = 0;
shell[i].nucl1 = -1;
shell[i].nucl2 = -1;
shell[i].nucl3 = -1;
/* shell[i].bInterCG=FALSE; */
shell[i].k_1 = 0;
shell[i].k = 0;
}
ffparams = &mtop->ffparams;
/* Now fill the structures */
shfc->bInterCG = FALSE;
ns = 0;
a_offset = 0;
for (mb = 0; mb < mtop->nmolblock; mb++)
{
molb = &mtop->molblock[mb];
molt = &mtop->moltype[molb->type];
cgs = &molt->cgs;
snew(at2cg, molt->atoms.nr);
for (cg = 0; cg < cgs->nr; cg++)
{
for (i = cgs->index[cg]; i < cgs->index[cg+1]; i++)
{
at2cg[i] = cg;
}
}
atom = molt->atoms.atom;
for (mol = 0; mol < molb->nmol; mol++)
{
for (j = 0; (j < NBT); j++)
{
ia = molt->ilist[bondtypes[j]].iatoms;
for (i = 0; (i < molt->ilist[bondtypes[j]].nr); )
{
type = ia[0];
ftype = ffparams->functype[type];
nra = interaction_function[ftype].nratoms;
/* Check whether we have a bond with a shell */
aS = -1;
switch (bondtypes[j])
{
case F_BONDS:
case F_HARMONIC:
case F_CUBICBONDS:
case F_POLARIZATION:
case F_ANHARM_POL:
if (atom[ia[1]].ptype == eptShell)
{
aS = ia[1];
aN = ia[2];
}
else if (atom[ia[2]].ptype == eptShell)
{
aS = ia[2];
aN = ia[1];
}
break;
case F_WATER_POL:
aN = ia[4]; /* Dummy */
aS = ia[5]; /* Shell */
break;
default:
gmx_fatal(FARGS, "Death Horror: %s, %d", __FILE__, __LINE__);
}
if (aS != -1)
{
qS = atom[aS].q;
/* Check whether one of the particles is a shell... */
nsi = shell_index[a_offset+aS];
if ((nsi < 0) || (nsi >= nshell))
{
gmx_fatal(FARGS, "nsi is %d should be within 0 - %d. aS = %d",
nsi, nshell, aS);
}
if (shell[nsi].shell == -1)
{
shell[nsi].shell = a_offset + aS;
ns++;
}
else if (shell[nsi].shell != a_offset+aS)
{
gmx_fatal(FARGS, "Weird stuff in %s, %d", __FILE__, __LINE__);
}
if (shell[nsi].nucl1 == -1)
{
shell[nsi].nucl1 = a_offset + aN;
}
else if (shell[nsi].nucl2 == -1)
{
shell[nsi].nucl2 = a_offset + aN;
}
else if (shell[nsi].nucl3 == -1)
{
shell[nsi].nucl3 = a_offset + aN;
}
else
{
if (fplog)
{
pr_shell(fplog, ns, shell);
}
gmx_fatal(FARGS, "Can not handle more than three bonds per shell\n");
}
if (at2cg[aS] != at2cg[aN])
{
/* shell[nsi].bInterCG = TRUE; */
shfc->bInterCG = TRUE;
}
switch (bondtypes[j])
{
case F_BONDS:
case F_HARMONIC:
shell[nsi].k += ffparams->iparams[type].harmonic.krA;
break;
case F_CUBICBONDS:
shell[nsi].k += ffparams->iparams[type].cubic.kb;
break;
case F_POLARIZATION:
case F_ANHARM_POL:
if (!gmx_within_tol(qS, atom[aS].qB, GMX_REAL_EPS*10))
{
gmx_fatal(FARGS, "polarize can not be used with qA(%e) != qB(%e) for atom %d of molecule block %d", qS, atom[aS].qB, aS+1, mb+1);
}
shell[nsi].k += gmx::square(qS)*ONE_4PI_EPS0/
ffparams->iparams[type].polarize.alpha;
break;
case F_WATER_POL:
if (!gmx_within_tol(qS, atom[aS].qB, GMX_REAL_EPS*10))
{
gmx_fatal(FARGS, "water_pol can not be used with qA(%e) != qB(%e) for atom %d of molecule block %d", qS, atom[aS].qB, aS+1, mb+1);
}
alpha = (ffparams->iparams[type].wpol.al_x+
ffparams->iparams[type].wpol.al_y+
ffparams->iparams[type].wpol.al_z)/3.0;
shell[nsi].k += gmx::square(qS)*ONE_4PI_EPS0/alpha;
break;
default:
gmx_fatal(FARGS, "Death Horror: %s, %d", __FILE__, __LINE__);
}
shell[nsi].nnucl++;
}
ia += nra+1;
i += nra+1;
}
}
a_offset += molt->atoms.nr;
}
/* Done with this molecule type */
sfree(at2cg);
}
/* Verify whether it's all correct */
if (ns != nshell)
{
gmx_fatal(FARGS, "Something weird with shells. They may not be bonded to something");
}
for (i = 0; (i < ns); i++)
{
shell[i].k_1 = 1.0/shell[i].k;
}
if (debug)
{
pr_shell(debug, ns, shell);
}
shfc->nshell_gl = ns;
shfc->shell_gl = shell;
shfc->shell_index_gl = shell_index;
shfc->bPredict = (getenv("GMX_NOPREDICT") == NULL);
shfc->bRequireInit = FALSE;
if (!shfc->bPredict)
{
if (fplog)
{
fprintf(fplog, "\nWill never predict shell positions\n");
}
}
else
{
shfc->bRequireInit = (getenv("GMX_REQUIRE_SHELL_INIT") != NULL);
if (shfc->bRequireInit && fplog)
{
fprintf(fplog, "\nWill always initiate shell positions\n");
}
}
if (shfc->bPredict)
{
if (shfc->bInterCG)
{
if (fplog)
{
fprintf(fplog, "\nNOTE: there all shells that are connected to particles outside thier own charge group, will not predict shells positions during the run\n\n");
}
/* Prediction improves performance, so we should implement either:
* 1. communication for the atoms needed for prediction
* 2. prediction using the velocities of shells; currently the
* shell velocities are zeroed, it's a bit tricky to keep
* track of the shell displacements and thus the velocity.
*/
shfc->bPredict = FALSE;
}
}
return shfc;
}
