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; }