static gmx_bool repl_quantity(const gmx_multisim_t *ms,
struct gmx_repl_ex *re, int ere, real q)
{
real *qall;
gmx_bool bDiff;
int i, s;
snew(qall, ms->nsim);
qall[re->repl] = q;
gmx_sum_sim(ms->nsim, qall, ms);
bDiff = FALSE;
for (s = 1; s < ms->nsim; s++)
{
if (qall[s] != qall[0])
{
bDiff = TRUE;
}
}
if (bDiff)
{
/* Set the replica exchange type and quantities */
re->type = ere;
snew(re->q[ere], re->nrepl);
for (s = 0; s < ms->nsim; s++)
{
re->q[ere][s] = qall[s];
}
}
sfree(qall);
return bDiff;
}
static void repl_quantity(FILE *fplog,const gmx_multisim_t *ms,
struct gmx_repl_ex *re,int ere,real q)
{
real *qall;
gmx_bool bDiff;
int s;
snew(qall,ms->nsim);
qall[re->repl] = q;
gmx_sum_sim(ms->nsim,qall,ms);
bDiff = FALSE;
for(s=1; s<ms->nsim; s++)
{
if (qall[s] != qall[0])
{
bDiff = TRUE;
}
}
if (bDiff)
{
if (re->type >= 0 && re->type < ereNR)
{
gmx_fatal(FARGS,"For replica exchange both %s and %s differ",
erename[re->type],erename[ere]);
}
/* Set the replica exchange type and quantities */
re->type = ere;
snew(re->q,re->nrepl);
for(s=0; s<ms->nsim; s++)
{
re->q[s] = qall[s];
}
}
sfree(qall);
}
void compute_globals(FILE *fplog, gmx_global_stat_t gstat, t_commrec *cr, t_inputrec *ir,
t_forcerec *fr, gmx_ekindata_t *ekind,
t_state *state, t_state *state_global, t_mdatoms *mdatoms,
t_nrnb *nrnb, t_vcm *vcm, gmx_wallcycle_t wcycle,
gmx_enerdata_t *enerd, tensor force_vir, tensor shake_vir, tensor total_vir,
tensor pres, rvec mu_tot, gmx_constr_t constr,
globsig_t *gs, gmx_bool bInterSimGS,
matrix box, gmx_mtop_t *top_global,
gmx_bool *bSumEkinhOld, int flags)
{
int i, gsi;
real gs_buf[eglsNR];
tensor corr_vir, corr_pres;
gmx_bool bEner, bPres, bTemp;
gmx_bool bStopCM, bGStat,
bReadEkin, bEkinAveVel, bScaleEkin, bConstrain;
real prescorr, enercorr, dvdlcorr, dvdl_ekin;
/* translate CGLO flags to gmx_booleans */
bStopCM = flags & CGLO_STOPCM;
bGStat = flags & CGLO_GSTAT;
bReadEkin = (flags & CGLO_READEKIN);
bScaleEkin = (flags & CGLO_SCALEEKIN);
bEner = flags & CGLO_ENERGY;
bTemp = flags & CGLO_TEMPERATURE;
bPres = (flags & CGLO_PRESSURE);
bConstrain = (flags & CGLO_CONSTRAINT);
/* we calculate a full state kinetic energy either with full-step velocity verlet
or half step where we need the pressure */
bEkinAveVel = (ir->eI == eiVV || (ir->eI == eiVVAK && bPres) || bReadEkin);
/* in initalization, it sums the shake virial in vv, and to
sums ekinh_old in leapfrog (or if we are calculating ekinh_old) for other reasons */
/* ########## Kinetic energy ############## */
if (bTemp)
{
/* Non-equilibrium MD: this is parallellized, but only does communication
* when there really is NEMD.
*/
if (PAR(cr) && (ekind->bNEMD))
{
accumulate_u(cr, &(ir->opts), ekind);
}
debug_gmx();
if (bReadEkin)
{
restore_ekinstate_from_state(cr, ekind, &state_global->ekinstate);
}
else
{
calc_ke_part(state, &(ir->opts), mdatoms, ekind, nrnb, bEkinAveVel);
}
debug_gmx();
}
/* Calculate center of mass velocity if necessary, also parallellized */
if (bStopCM)
{
calc_vcm_grp(0, mdatoms->homenr, mdatoms,
state->x, state->v, vcm);
}
if (bTemp || bStopCM || bPres || bEner || bConstrain)
{
if (!bGStat)
{
/* We will not sum ekinh_old,
* so signal that we still have to do it.
*/
*bSumEkinhOld = TRUE;
}
else
{
if (gs != NULL)
{
for (i = 0; i < eglsNR; i++)
{
gs_buf[i] = gs->sig[i];
}
}
if (PAR(cr))
{
wallcycle_start(wcycle, ewcMoveE);
global_stat(fplog, gstat, cr, enerd, force_vir, shake_vir, mu_tot,
ir, ekind, constr, bStopCM ? vcm : NULL,
gs != NULL ? eglsNR : 0, gs_buf,
top_global, state,
*bSumEkinhOld, flags);
wallcycle_stop(wcycle, ewcMoveE);
}
if (gs != NULL)
{
if (MULTISIM(cr) && bInterSimGS)
{
if (MASTER(cr))
{
/* Communicate the signals between the simulations */
gmx_sum_sim(eglsNR, gs_buf, cr->ms);
}
/* Communicate the signals form the master to the others */
gmx_bcast(eglsNR*sizeof(gs_buf[0]), gs_buf, cr);
}
for (i = 0; i < eglsNR; i++)
{
if (bInterSimGS || gs_simlocal[i])
{
/* Set the communicated signal only when it is non-zero,
* since signals might not be processed at each MD step.
*/
gsi = (gs_buf[i] >= 0 ?
(int)(gs_buf[i] + 0.5) :
(int)(gs_buf[i] - 0.5));
if (gsi != 0)
{
gs->set[i] = gsi;
}
/* Turn off the local signal */
gs->sig[i] = 0;
}
}
}
*bSumEkinhOld = FALSE;
}
}
if (!ekind->bNEMD && debug && bTemp && (vcm->nr > 0))
{
correct_ekin(debug,
0, mdatoms->homenr,
state->v, vcm->group_p[0],
mdatoms->massT, mdatoms->tmass, ekind->ekin);
}
/* Do center of mass motion removal */
if (bStopCM)
{
check_cm_grp(fplog, vcm, ir, 1);
do_stopcm_grp(0, mdatoms->homenr, mdatoms->cVCM,
state->x, state->v, vcm);
inc_nrnb(nrnb, eNR_STOPCM, mdatoms->homenr);
}
if (bEner)
{
/* Calculate the amplitude of the cosine velocity profile */
ekind->cosacc.vcos = ekind->cosacc.mvcos/mdatoms->tmass;
}
if (bTemp)
{
/* Sum the kinetic energies of the groups & calc temp */
/* compute full step kinetic energies if vv, or if vv-avek and we are computing the pressure with IR_NPT_TROTTER */
/* three maincase: VV with AveVel (md-vv), vv with AveEkin (md-vv-avek), leap with AveEkin (md).
Leap with AveVel is not supported; it's not clear that it will actually work.
bEkinAveVel: If TRUE, we simply multiply ekin by ekinscale to get a full step kinetic energy.
If FALSE, we average ekinh_old and ekinh*ekinscale_nhc to get an averaged half step kinetic energy.
*/
enerd->term[F_TEMP] = sum_ekin(&(ir->opts), ekind, &dvdl_ekin,
bEkinAveVel, bScaleEkin);
enerd->dvdl_lin[efptMASS] = (double) dvdl_ekin;
enerd->term[F_EKIN] = trace(ekind->ekin);
}
/* ########## Long range energy information ###### */
if (bEner || bPres || bConstrain)
{
calc_dispcorr(ir, fr, top_global->natoms, box, state->lambda[efptVDW],
corr_pres, corr_vir, &prescorr, &enercorr, &dvdlcorr);
}
if (bEner)
{
enerd->term[F_DISPCORR] = enercorr;
enerd->term[F_EPOT] += enercorr;
enerd->term[F_DVDL_VDW] += dvdlcorr;
}
/* ########## Now pressure ############## */
if (bPres || bConstrain)
{
m_add(force_vir, shake_vir, total_vir);
/* Calculate pressure and apply LR correction if PPPM is used.
* Use the box from last timestep since we already called update().
*/
enerd->term[F_PRES] = calc_pres(fr->ePBC, ir->nwall, box, ekind->ekin, total_vir, pres);
/* Calculate long range corrections to pressure and energy */
/* this adds to enerd->term[F_PRES] and enerd->term[F_ETOT],
and computes enerd->term[F_DISPCORR]. Also modifies the
total_vir and pres tesors */
m_add(total_vir, corr_vir, total_vir);
m_add(pres, corr_pres, pres);
enerd->term[F_PDISPCORR] = prescorr;
enerd->term[F_PRES] += prescorr;
}
}
static void
test_for_replica_exchange(FILE *fplog,
const gmx_multisim_t *ms,
struct gmx_repl_ex *re,
gmx_enerdata_t *enerd,
real vol,
gmx_int64_t step,
real time)
{
int m, i, j, a, b, ap, bp, i0, i1, tmp;
real ediff = 0, delta = 0, dpV = 0;
gmx_bool bPrint, bMultiEx;
gmx_bool *bEx = re->bEx;
real *prob = re->prob;
int *pind = re->destinations; /* permuted index */
gmx_bool bEpot = FALSE;
gmx_bool bDLambda = FALSE;
gmx_bool bVol = FALSE;
gmx_rng_t rng;
bMultiEx = (re->nex > 1); /* multiple exchanges at each state */
fprintf(fplog, "Replica exchange at step " "%"GMX_PRId64 " time %g\n", step, time);
if (re->bNPT)
{
for (i = 0; i < re->nrepl; i++)
{
re->Vol[i] = 0;
}
bVol = TRUE;
re->Vol[re->repl] = vol;
}
if ((re->type == ereTEMP || re->type == ereTL))
{
for (i = 0; i < re->nrepl; i++)
{
re->Epot[i] = 0;
}
bEpot = TRUE;
re->Epot[re->repl] = enerd->term[F_EPOT];
/* temperatures of different states*/
for (i = 0; i < re->nrepl; i++)
{
re->beta[i] = 1.0/(re->q[ereTEMP][i]*BOLTZ);
}
}
else
{
for (i = 0; i < re->nrepl; i++)
{
re->beta[i] = 1.0/(re->temp*BOLTZ); /* we have a single temperature */
}
}
if (re->type == ereLAMBDA || re->type == ereTL)
{
bDLambda = TRUE;
/* lambda differences. */
/* de[i][j] is the energy of the jth simulation in the ith Hamiltonian
minus the energy of the jth simulation in the jth Hamiltonian */
for (i = 0; i < re->nrepl; i++)
{
for (j = 0; j < re->nrepl; j++)
{
re->de[i][j] = 0;
}
}
for (i = 0; i < re->nrepl; i++)
{
re->de[i][re->repl] = (enerd->enerpart_lambda[(int)re->q[ereLAMBDA][i]+1]-enerd->enerpart_lambda[0]);
}
}
/* now actually do the communication */
if (bVol)
{
gmx_sum_sim(re->nrepl, re->Vol, ms);
}
if (bEpot)
{
gmx_sum_sim(re->nrepl, re->Epot, ms);
}
if (bDLambda)
{
for (i = 0; i < re->nrepl; i++)
{
gmx_sum_sim(re->nrepl, re->de[i], ms);
}
}
/* make a duplicate set of indices for shuffling */
for (i = 0; i < re->nrepl; i++)
{
pind[i] = re->ind[i];
}
if (bMultiEx)
{
/* multiple random switch exchange */
int nself = 0;
for (i = 0; i < re->nex + nself; i++)
{
double rnd[2];
gmx_rng_cycle_2uniform(step, i*2, re->seed, RND_SEED_REPLEX, rnd);
/* randomly select a pair */
/* in theory, could reduce this by identifying only which switches had a nonneglibible
probability of occurring (log p > -100) and only operate on those switches */
/* find out which state it is from, and what label that state currently has. Likely
more work that useful. */
i0 = (int)(re->nrepl*rnd[0]);
i1 = (int)(re->nrepl*rnd[1]);
if (i0 == i1)
{
nself++;
continue; /* self-exchange, back up and do it again */
}
a = re->ind[i0]; /* what are the indices of these states? */
b = re->ind[i1];
ap = pind[i0];
bp = pind[i1];
bPrint = FALSE; /* too noisy */
/* calculate the energy difference */
/* if the code changes to flip the STATES, rather than the configurations,
use the commented version of the code */
/* delta = calc_delta(fplog,bPrint,re,a,b,ap,bp); */
delta = calc_delta(fplog, bPrint, re, ap, bp, a, b);
/* we actually only use the first space in the prob and bEx array,
since there are actually many switches between pairs. */
if (delta <= 0)
{
/* accepted */
prob[0] = 1;
bEx[0] = TRUE;
}
else
{
if (delta > PROBABILITYCUTOFF)
{
prob[0] = 0;
}
else
{
prob[0] = exp(-delta);
}
/* roll a number to determine if accepted */
gmx_rng_cycle_2uniform(step, i*2+1, re->seed, RND_SEED_REPLEX, rnd);
bEx[0] = rnd[0] < prob[0];
}
re->prob_sum[0] += prob[0];
if (bEx[0])
{
/* swap the states */
tmp = pind[i0];
pind[i0] = pind[i1];
pind[i1] = tmp;
}
}
re->nattempt[0]++; /* keep track of total permutation trials here */
print_allswitchind(fplog, re->nrepl, pind, re->allswaps, re->tmpswap);
}
else
{
/* standard nearest neighbor replica exchange */
m = (step / re->nst) % 2;
for (i = 1; i < re->nrepl; i++)
{
a = re->ind[i-1];
b = re->ind[i];
bPrint = (re->repl == a || re->repl == b);
if (i % 2 == m)
{
delta = calc_delta(fplog, bPrint, re, a, b, a, b);
if (delta <= 0)
{
/* accepted */
prob[i] = 1;
bEx[i] = TRUE;
}
else
{
double rnd[2];
if (delta > PROBABILITYCUTOFF)
{
prob[i] = 0;
}
else
{
prob[i] = exp(-delta);
}
/* roll a number to determine if accepted */
gmx_rng_cycle_2uniform(step, i, re->seed, RND_SEED_REPLEX, rnd);
bEx[i] = rnd[0] < prob[i];
}
re->prob_sum[i] += prob[i];
if (bEx[i])
{
/* swap these two */
tmp = pind[i-1];
pind[i-1] = pind[i];
pind[i] = tmp;
re->nexchange[i]++; /* statistics for back compatibility */
}
}
else
{
prob[i] = -1;
bEx[i] = FALSE;
}
}
/* print some statistics */
print_ind(fplog, "ex", re->nrepl, re->ind, bEx);
print_prob(fplog, "pr", re->nrepl, prob);
fprintf(fplog, "\n");
re->nattempt[m]++;
}
/* record which moves were made and accepted */
for (i = 0; i < re->nrepl; i++)
{
re->nmoves[re->ind[i]][pind[i]] += 1;
re->nmoves[pind[i]][re->ind[i]] += 1;
}
fflush(fplog); /* make sure we can see what the last exchange was */
}
gmx_repl_ex_t init_replica_exchange(FILE *fplog,
const gmx_multisim_t *ms,
const t_state *state,
const t_inputrec *ir,
int nst, int nex, int init_seed)
{
real temp, pres;
int i, j, k;
struct gmx_repl_ex *re;
gmx_bool bTemp;
gmx_bool bLambda = FALSE;
fprintf(fplog, "\nInitializing Replica Exchange\n");
if (ms == NULL || ms->nsim == 1)
{
gmx_fatal(FARGS, "Nothing to exchange with only one replica, maybe you forgot to set the -multi option of mdrun?");
}
if (!EI_DYNAMICS(ir->eI))
{
gmx_fatal(FARGS, "Replica exchange is only supported by dynamical simulations");
/* Note that PAR(cr) is defined by cr->nnodes > 1, which is
* distinct from MULTISIM(cr). A multi-simulation only runs
* with real MPI parallelism, but this does not imply PAR(cr)
* is true!
*
* Since we are using a dynamical integrator, the only
* decomposition is DD, so PAR(cr) and DOMAINDECOMP(cr) are
* synonymous. The only way for cr->nnodes > 1 to be true is
* if we are using DD. */
}
snew(re, 1);
re->repl = ms->sim;
re->nrepl = ms->nsim;
snew(re->q, ereENDSINGLE);
fprintf(fplog, "Repl There are %d replicas:\n", re->nrepl);
check_multi_int(fplog, ms, state->natoms, "the number of atoms", FALSE);
check_multi_int(fplog, ms, ir->eI, "the integrator", FALSE);
check_multi_int64(fplog, ms, ir->init_step+ir->nsteps, "init_step+nsteps", FALSE);
check_multi_int64(fplog, ms, (ir->init_step+nst-1)/nst,
"first exchange step: init_step/-replex", FALSE);
check_multi_int(fplog, ms, ir->etc, "the temperature coupling", FALSE);
check_multi_int(fplog, ms, ir->opts.ngtc,
"the number of temperature coupling groups", FALSE);
check_multi_int(fplog, ms, ir->epc, "the pressure coupling", FALSE);
check_multi_int(fplog, ms, ir->efep, "free energy", FALSE);
check_multi_int(fplog, ms, ir->fepvals->n_lambda, "number of lambda states", FALSE);
re->temp = ir->opts.ref_t[0];
for (i = 1; (i < ir->opts.ngtc); i++)
{
if (ir->opts.ref_t[i] != re->temp)
{
fprintf(fplog, "\nWARNING: The temperatures of the different temperature coupling groups are not identical\n\n");
fprintf(stderr, "\nWARNING: The temperatures of the different temperature coupling groups are not identical\n\n");
}
}
re->type = -1;
bTemp = repl_quantity(ms, re, ereTEMP, re->temp);
if (ir->efep != efepNO)
{
bLambda = repl_quantity(ms, re, ereLAMBDA, (real)ir->fepvals->init_fep_state);
}
if (re->type == -1) /* nothing was assigned */
{
gmx_fatal(FARGS, "The properties of the %d systems are all the same, there is nothing to exchange", re->nrepl);
}
if (bLambda && bTemp)
{
re->type = ereTL;
}
if (bTemp)
{
please_cite(fplog, "Sugita1999a");
if (ir->epc != epcNO)
{
re->bNPT = TRUE;
fprintf(fplog, "Repl Using Constant Pressure REMD.\n");
please_cite(fplog, "Okabe2001a");
}
if (ir->etc == etcBERENDSEN)
{
gmx_fatal(FARGS, "REMD with the %s thermostat does not produce correct potential energy distributions, consider using the %s thermostat instead",
ETCOUPLTYPE(ir->etc), ETCOUPLTYPE(etcVRESCALE));
}
}
if (bLambda)
{
if (ir->fepvals->delta_lambda != 0) /* check this? */
{
gmx_fatal(FARGS, "delta_lambda is not zero");
}
}
if (re->bNPT)
{
snew(re->pres, re->nrepl);
if (ir->epct == epctSURFACETENSION)
{
pres = ir->ref_p[ZZ][ZZ];
}
else
{
pres = 0;
j = 0;
for (i = 0; i < DIM; i++)
{
if (ir->compress[i][i] != 0)
{
pres += ir->ref_p[i][i];
j++;
}
}
pres /= j;
}
re->pres[re->repl] = pres;
gmx_sum_sim(re->nrepl, re->pres, ms);
}
/* Make an index for increasing replica order */
/* only makes sense if one or the other is varying, not both!
if both are varying, we trust the order the person gave. */
snew(re->ind, re->nrepl);
for (i = 0; i < re->nrepl; i++)
{
re->ind[i] = i;
}
if (re->type < ereENDSINGLE)
{
for (i = 0; i < re->nrepl; i++)
{
for (j = i+1; j < re->nrepl; j++)
{
if (re->q[re->type][re->ind[j]] < re->q[re->type][re->ind[i]])
{
k = re->ind[i];
re->ind[i] = re->ind[j];
re->ind[j] = k;
}
else if (re->q[re->type][re->ind[j]] == re->q[re->type][re->ind[i]])
{
gmx_fatal(FARGS, "Two replicas have identical %ss", erename[re->type]);
}
}
}
}
/* keep track of all the swaps, starting with the initial placement. */
snew(re->allswaps, re->nrepl);
for (i = 0; i < re->nrepl; i++)
{
re->allswaps[i] = re->ind[i];
}
switch (re->type)
{
case ereTEMP:
fprintf(fplog, "\nReplica exchange in temperature\n");
for (i = 0; i < re->nrepl; i++)
{
fprintf(fplog, " %5.1f", re->q[re->type][re->ind[i]]);
}
fprintf(fplog, "\n");
break;
case ereLAMBDA:
fprintf(fplog, "\nReplica exchange in lambda\n");
for (i = 0; i < re->nrepl; i++)
{
fprintf(fplog, " %3d", (int)re->q[re->type][re->ind[i]]);
}
fprintf(fplog, "\n");
break;
case ereTL:
fprintf(fplog, "\nReplica exchange in temperature and lambda state\n");
for (i = 0; i < re->nrepl; i++)
{
fprintf(fplog, " %5.1f", re->q[ereTEMP][re->ind[i]]);
}
fprintf(fplog, "\n");
for (i = 0; i < re->nrepl; i++)
{
fprintf(fplog, " %5d", (int)re->q[ereLAMBDA][re->ind[i]]);
}
fprintf(fplog, "\n");
break;
default:
gmx_incons("Unknown replica exchange quantity");
}
if (re->bNPT)
{
fprintf(fplog, "\nRepl p");
for (i = 0; i < re->nrepl; i++)
{
fprintf(fplog, " %5.2f", re->pres[re->ind[i]]);
}
for (i = 0; i < re->nrepl; i++)
{
if ((i > 0) && (re->pres[re->ind[i]] < re->pres[re->ind[i-1]]))
{
fprintf(fplog, "\nWARNING: The reference pressures decrease with increasing temperatures\n\n");
fprintf(stderr, "\nWARNING: The reference pressures decrease with increasing temperatures\n\n");
}
}
}
re->nst = nst;
if (init_seed == -1)
{
if (MASTERSIM(ms))
{
re->seed = (int)gmx_rng_make_seed();
}
else
{
re->seed = 0;
}
gmx_sumi_sim(1, &(re->seed), ms);
}
else
{
re->seed = init_seed;
}
fprintf(fplog, "\nReplica exchange interval: %d\n", re->nst);
fprintf(fplog, "\nReplica random seed: %d\n", re->seed);
re->rng = gmx_rng_init(re->seed);
re->nattempt[0] = 0;
re->nattempt[1] = 0;
snew(re->prob_sum, re->nrepl);
snew(re->nexchange, re->nrepl);
snew(re->nmoves, re->nrepl);
for (i = 0; i < re->nrepl; i++)
{
snew(re->nmoves[i], re->nrepl);
}
fprintf(fplog, "Replica exchange information below: x=exchange, pr=probability\n");
/* generate space for the helper functions so we don't have to snew each time */
snew(re->destinations, re->nrepl);
snew(re->incycle, re->nrepl);
snew(re->tmpswap, re->nrepl);
snew(re->cyclic, re->nrepl);
snew(re->order, re->nrepl);
for (i = 0; i < re->nrepl; i++)
{
snew(re->cyclic[i], re->nrepl);
snew(re->order[i], re->nrepl);
}
/* allocate space for the functions storing the data for the replicas */
/* not all of these arrays needed in all cases, but they don't take
up much space, since the max size is nrepl**2 */
snew(re->prob, re->nrepl);
snew(re->bEx, re->nrepl);
snew(re->beta, re->nrepl);
snew(re->Vol, re->nrepl);
snew(re->Epot, re->nrepl);
snew(re->de, re->nrepl);
for (i = 0; i < re->nrepl; i++)
{
snew(re->de[i], re->nrepl);
}
re->nex = nex;
return re;
}
void calc_listed(const gmx_multisim_t *ms,
gmx_wallcycle *wcycle,
const t_idef *idef,
const rvec x[], history_t *hist,
rvec f[], t_forcerec *fr,
const struct t_pbc *pbc,
const struct t_pbc *pbc_full,
const struct t_graph *g,
gmx_enerdata_t *enerd, t_nrnb *nrnb,
real *lambda,
const t_mdatoms *md,
t_fcdata *fcd, int *global_atom_index,
int force_flags)
{
gmx_bool bCalcEnerVir;
int i;
real dvdl[efptNR]; /* The dummy array is to have a place to store the dhdl at other values
of lambda, which will be thrown away in the end*/
const t_pbc *pbc_null;
int thread;
assert(fr->nthreads == idef->nthreads);
bCalcEnerVir = (force_flags & (GMX_FORCE_VIRIAL | GMX_FORCE_ENERGY));
for (i = 0; i < efptNR; i++)
{
dvdl[i] = 0.0;
}
if (fr->bMolPBC)
{
pbc_null = pbc;
}
else
{
pbc_null = NULL;
}
#ifdef DEBUG
if (g && debug)
{
p_graph(debug, "Bondage is fun", g);
}
#endif
if ((idef->il[F_POSRES].nr > 0) ||
(idef->il[F_FBPOSRES].nr > 0) ||
(idef->il[F_ORIRES].nr > 0) ||
(idef->il[F_DISRES].nr > 0))
{
/* TODO Use of restraints triggers further function calls
inside the loop over calc_one_bond(), but those are too
awkward to account to this subtimer properly in the present
code. We don't test / care much about performance with
restraints, anyway. */
wallcycle_sub_start(wcycle, ewcsRESTRAINTS);
if (idef->il[F_POSRES].nr > 0)
{
posres_wrapper(nrnb, idef, pbc_full, x, enerd, lambda, fr);
}
if (idef->il[F_FBPOSRES].nr > 0)
{
fbposres_wrapper(nrnb, idef, pbc_full, x, enerd, fr);
}
/* Do pre force calculation stuff which might require communication */
if (idef->il[F_ORIRES].nr > 0)
{
enerd->term[F_ORIRESDEV] =
calc_orires_dev(ms, idef->il[F_ORIRES].nr,
idef->il[F_ORIRES].iatoms,
idef->iparams, md, x,
pbc_null, fcd, hist);
}
if (idef->il[F_DISRES].nr)
{
calc_disres_R_6(idef->il[F_DISRES].nr,
idef->il[F_DISRES].iatoms,
idef->iparams, x, pbc_null,
fcd, hist);
#ifdef GMX_MPI
if (fcd->disres.nsystems > 1)
{
gmx_sum_sim(2*fcd->disres.nres, fcd->disres.Rt_6, ms);
}
#endif
}
wallcycle_sub_stop(wcycle, ewcsRESTRAINTS);
}
wallcycle_sub_start(wcycle, ewcsLISTED);
#pragma omp parallel for num_threads(fr->nthreads) schedule(static)
for (thread = 0; thread < fr->nthreads; thread++)
{
int ftype;
real *epot, v;
/* thread stuff */
rvec *ft, *fshift;
real *dvdlt;
gmx_grppairener_t *grpp;
if (thread == 0)
{
ft = f;
fshift = fr->fshift;
epot = enerd->term;
grpp = &enerd->grpp;
dvdlt = dvdl;
}
else
{
zero_thread_forces(&fr->f_t[thread], fr->natoms_force,
fr->red_nblock, 1<<fr->red_ashift);
ft = fr->f_t[thread].f;
fshift = fr->f_t[thread].fshift;
epot = fr->f_t[thread].ener;
grpp = &fr->f_t[thread].grpp;
dvdlt = fr->f_t[thread].dvdl;
}
/* Loop over all bonded force types to calculate the bonded forces */
for (ftype = 0; (ftype < F_NRE); ftype++)
{
if (idef->il[ftype].nr > 0 && ftype_is_bonded_potential(ftype))
{
v = calc_one_bond(thread, ftype, idef, x,
ft, fshift, fr, pbc_null, g, grpp,
nrnb, lambda, dvdlt,
md, fcd, bCalcEnerVir,
global_atom_index);
epot[ftype] += v;
}
}
}
wallcycle_sub_stop(wcycle, ewcsLISTED);
if (fr->nthreads > 1)
{
wallcycle_sub_start(wcycle, ewcsLISTED_BUF_OPS);
reduce_thread_forces(fr->natoms_force, f, fr->fshift,
enerd->term, &enerd->grpp, dvdl,
fr->nthreads, fr->f_t,
fr->red_nblock, 1<<fr->red_ashift,
bCalcEnerVir,
force_flags & GMX_FORCE_DHDL);
wallcycle_sub_stop(wcycle, ewcsLISTED_BUF_OPS);
}
/* Remaining code does not have enough flops to bother counting */
if (force_flags & GMX_FORCE_DHDL)
{
for (i = 0; i < efptNR; i++)
{
enerd->dvdl_nonlin[i] += dvdl[i];
}
}
/* Copy the sum of violations for the distance restraints from fcd */
if (fcd)
{
enerd->term[F_DISRESVIOL] = fcd->disres.sumviol;
}
}
void init_orires(FILE *fplog,const gmx_mtop_t *mtop,
rvec xref[],
const t_inputrec *ir,
const gmx_multisim_t *ms,t_oriresdata *od,
t_state *state)
{
int i,j,d,ex,nmol,nr,*nr_ex;
double mtot;
rvec com;
gmx_mtop_ilistloop_t iloop;
t_ilist *il;
gmx_mtop_atomloop_all_t aloop;
t_atom *atom;
od->fc = ir->orires_fc;
od->nex = 0;
od->S = NULL;
od->nr = gmx_mtop_ftype_count(mtop,F_ORIRES);
if (od->nr == 0)
{
return;
}
nr_ex = NULL;
iloop = gmx_mtop_ilistloop_init(mtop);
while (gmx_mtop_ilistloop_next(iloop,&il,&nmol))
{
for(i=0; i<il[F_ORIRES].nr; i+=3)
{
ex = mtop->ffparams.iparams[il[F_ORIRES].iatoms[i]].orires.ex;
if (ex >= od->nex)
{
srenew(nr_ex,ex+1);
for(j=od->nex; j<ex+1; j++)
{
nr_ex[j] = 0;
}
od->nex = ex+1;
}
nr_ex[ex]++;
}
}
snew(od->S,od->nex);
/* When not doing time averaging, the instaneous and time averaged data
* are indentical and the pointers can point to the same memory.
*/
snew(od->Dinsl,od->nr);
if (ms)
{
snew(od->Dins,od->nr);
}
else
{
od->Dins = od->Dinsl;
}
if (ir->orires_tau == 0)
{
od->Dtav = od->Dins;
od->edt = 0.0;
od->edt1 = 1.0;
}
else
{
snew(od->Dtav,od->nr);
od->edt = exp(-ir->delta_t/ir->orires_tau);
od->edt1 = 1.0 - od->edt;
/* Extend the state with the orires history */
state->flags |= (1<<estORIRE_INITF);
state->hist.orire_initf = 1;
state->flags |= (1<<estORIRE_DTAV);
state->hist.norire_Dtav = od->nr*5;
snew(state->hist.orire_Dtav,state->hist.norire_Dtav);
}
snew(od->oinsl,od->nr);
if (ms)
{
snew(od->oins,od->nr);
}
else
{
od->oins = od->oinsl;
}
if (ir->orires_tau == 0) {
od->otav = od->oins;
}
else
{
snew(od->otav,od->nr);
}
snew(od->tmp,od->nex);
snew(od->TMP,od->nex);
for(ex=0; ex<od->nex; ex++)
{
snew(od->TMP[ex],5);
for(i=0; i<5; i++)
{
snew(od->TMP[ex][i],5);
}
}
od->nref = 0;
for(i=0; i<mtop->natoms; i++)
{
if (ggrpnr(&mtop->groups,egcORFIT,i) == 0)
{
od->nref++;
}
}
snew(od->mref,od->nref);
snew(od->xref,od->nref);
snew(od->xtmp,od->nref);
snew(od->eig,od->nex*12);
/* Determine the reference structure on the master node.
* Copy it to the other nodes after checking multi compatibility,
* so we are sure the subsystems match before copying.
*/
clear_rvec(com);
mtot = 0.0;
j = 0;
aloop = gmx_mtop_atomloop_all_init(mtop);
while(gmx_mtop_atomloop_all_next(aloop,&i,&atom))
{
if (mtop->groups.grpnr[egcORFIT] == NULL ||
mtop->groups.grpnr[egcORFIT][i] == 0)
{
/* Not correct for free-energy with changing masses */
od->mref[j] = atom->m;
if (ms==NULL || MASTERSIM(ms))
{
copy_rvec(xref[i],od->xref[j]);
for(d=0; d<DIM; d++)
{
com[d] += od->mref[j]*xref[i][d];
}
}
mtot += od->mref[j];
j++;
}
}
svmul(1.0/mtot,com,com);
if (ms==NULL || MASTERSIM(ms))
{
for(j=0; j<od->nref; j++)
{
rvec_dec(od->xref[j],com);
}
}
fprintf(fplog,"Found %d orientation experiments\n",od->nex);
for(i=0; i<od->nex; i++)
{
fprintf(fplog," experiment %d has %d restraints\n",i+1,nr_ex[i]);
}
sfree(nr_ex);
fprintf(fplog," the fit group consists of %d atoms and has total mass %g\n",
od->nref,mtot);
if (ms)
{
fprintf(fplog," the orientation restraints are ensemble averaged over %d systems\n",ms->nsim);
check_multi_int(fplog,ms,od->nr,
"the number of orientation restraints");
check_multi_int(fplog,ms,od->nref,
"the number of fit atoms for orientation restraining");
check_multi_int(fplog,ms,ir->nsteps,"nsteps");
/* Copy the reference coordinates from the master to the other nodes */
gmx_sum_sim(DIM*od->nref,od->xref[0],ms);
}
please_cite(fplog,"Hess2003");
}
real calc_orires_dev(const gmx_multisim_t *ms,
int nfa,const t_iatom forceatoms[],const t_iparams ip[],
const t_mdatoms *md,const rvec x[],const t_pbc *pbc,
t_fcdata *fcd,history_t *hist)
{
int fa,d,i,j,type,ex,nref;
real edt,edt1,invn,pfac,r2,invr,corrfac,weight,wsv2,sw,dev;
tensor *S,R,TMP;
rvec5 *Dinsl,*Dins,*Dtav,*rhs;
real *mref,***T;
double mtot;
rvec *xref,*xtmp,com,r_unrot,r;
t_oriresdata *od;
bool bTAV;
const real two_thr=2.0/3.0;
od = &(fcd->orires);
if (od->nr == 0)
{
/* This means that this is not the master node */
gmx_fatal(FARGS,"Orientation restraints are only supported on the master node, use less processors");
}
bTAV = (od->edt != 0);
edt = od->edt;
edt1 = od->edt1;
S = od->S;
Dinsl= od->Dinsl;
Dins = od->Dins;
Dtav = od->Dtav;
T = od->TMP;
rhs = od->tmp;
nref = od->nref;
mref = od->mref;
xref = od->xref;
xtmp = od->xtmp;
if (bTAV)
{
od->exp_min_t_tau = hist->orire_initf*edt;
/* Correction factor to correct for the lack of history
* at short times.
*/
corrfac = 1.0/(1.0 - od->exp_min_t_tau);
}
else
{
corrfac = 1.0;
}
if (ms)
{
invn = 1.0/ms->nsim;
}
else
{
invn = 1.0;
}
clear_rvec(com);
mtot = 0;
j=0;
for(i=0; i<md->nr; i++)
{
if (md->cORF[i] == 0)
{
copy_rvec(x[i],xtmp[j]);
mref[j] = md->massT[i];
for(d=0; d<DIM; d++)
{
com[d] += mref[j]*xref[j][d];
}
mtot += mref[j];
j++;
}
}
svmul(1.0/mtot,com,com);
for(j=0; j<nref; j++)
{
rvec_dec(xtmp[j],com);
}
/* Calculate the rotation matrix to rotate x to the reference orientation */
calc_fit_R(DIM,nref,mref,xref,xtmp,R);
copy_mat(R,od->R);
d = 0;
for(fa=0; fa<nfa; fa+=3)
{
type = forceatoms[fa];
if (pbc)
{
pbc_dx_aiuc(pbc,x[forceatoms[fa+1]],x[forceatoms[fa+2]],r_unrot);
}
else
{
rvec_sub(x[forceatoms[fa+1]],x[forceatoms[fa+2]],r_unrot);
}
mvmul(R,r_unrot,r);
r2 = norm2(r);
invr = invsqrt(r2);
/* Calculate the prefactor for the D tensor, this includes the factor 3! */
pfac = ip[type].orires.c*invr*invr*3;
for(i=0; i<ip[type].orires.power; i++)
{
pfac *= invr;
}
Dinsl[d][0] = pfac*(2*r[0]*r[0] + r[1]*r[1] - r2);
Dinsl[d][1] = pfac*(2*r[0]*r[1]);
Dinsl[d][2] = pfac*(2*r[0]*r[2]);
Dinsl[d][3] = pfac*(2*r[1]*r[1] + r[0]*r[0] - r2);
Dinsl[d][4] = pfac*(2*r[1]*r[2]);
if (ms)
{
for(i=0; i<5; i++)
{
Dins[d][i] = Dinsl[d][i]*invn;
}
}
d++;
}
if (ms)
{
gmx_sum_sim(5*od->nr,Dins[0],ms);
}
/* Calculate the order tensor S for each experiment via optimization */
for(ex=0; ex<od->nex; ex++)
{
for(i=0; i<5; i++)
{
rhs[ex][i] = 0;
for(j=0; j<=i; j++)
{
T[ex][i][j] = 0;
}
}
}
d = 0;
for(fa=0; fa<nfa; fa+=3)
{
if (bTAV)
{
/* Here we update Dtav in t_fcdata using the data in history_t.
* Thus the results stay correct when this routine
* is called multiple times.
*/
for(i=0; i<5; i++)
{
Dtav[d][i] = edt*hist->orire_Dtav[d*5+i] + edt1*Dins[d][i];
}
}
type = forceatoms[fa];
ex = ip[type].orires.ex;
weight = ip[type].orires.kfac;
/* Calculate the vector rhs and half the matrix T for the 5 equations */
for(i=0; i<5; i++) {
rhs[ex][i] += Dtav[d][i]*ip[type].orires.obs*weight;
for(j=0; j<=i; j++)
{
T[ex][i][j] += Dtav[d][i]*Dtav[d][j]*weight;
}
}
d++;
}
/* Now we have all the data we can calculate S */
for(ex=0; ex<od->nex; ex++)
{
/* Correct corrfac and copy one half of T to the other half */
for(i=0; i<5; i++)
{
rhs[ex][i] *= corrfac;
T[ex][i][i] *= sqr(corrfac);
for(j=0; j<i; j++)
{
T[ex][i][j] *= sqr(corrfac);
T[ex][j][i] = T[ex][i][j];
}
}
m_inv_gen(T[ex],5,T[ex]);
/* Calculate the orientation tensor S for this experiment */
S[ex][0][0] = 0;
S[ex][0][1] = 0;
S[ex][0][2] = 0;
S[ex][1][1] = 0;
S[ex][1][2] = 0;
for(i=0; i<5; i++)
{
S[ex][0][0] += 1.5*T[ex][0][i]*rhs[ex][i];
S[ex][0][1] += 1.5*T[ex][1][i]*rhs[ex][i];
S[ex][0][2] += 1.5*T[ex][2][i]*rhs[ex][i];
S[ex][1][1] += 1.5*T[ex][3][i]*rhs[ex][i];
S[ex][1][2] += 1.5*T[ex][4][i]*rhs[ex][i];
}
S[ex][1][0] = S[ex][0][1];
S[ex][2][0] = S[ex][0][2];
S[ex][2][1] = S[ex][1][2];
S[ex][2][2] = -S[ex][0][0] - S[ex][1][1];
}
wsv2 = 0;
sw = 0;
d = 0;
for(fa=0; fa<nfa; fa+=3)
{
type = forceatoms[fa];
ex = ip[type].orires.ex;
od->otav[d] = two_thr*
corrfac*(S[ex][0][0]*Dtav[d][0] + S[ex][0][1]*Dtav[d][1] +
S[ex][0][2]*Dtav[d][2] + S[ex][1][1]*Dtav[d][3] +
S[ex][1][2]*Dtav[d][4]);
if (bTAV)
{
od->oins[d] = two_thr*(S[ex][0][0]*Dins[d][0] + S[ex][0][1]*Dins[d][1] +
S[ex][0][2]*Dins[d][2] + S[ex][1][1]*Dins[d][3] +
S[ex][1][2]*Dins[d][4]);
}
if (ms)
{
/* When ensemble averaging is used recalculate the local orientation
* for output to the energy file.
*/
od->oinsl[d] = two_thr*
(S[ex][0][0]*Dinsl[d][0] + S[ex][0][1]*Dinsl[d][1] +
S[ex][0][2]*Dinsl[d][2] + S[ex][1][1]*Dinsl[d][3] +
S[ex][1][2]*Dinsl[d][4]);
}
dev = od->otav[d] - ip[type].orires.obs;
wsv2 += ip[type].orires.kfac*sqr(dev);
sw += ip[type].orires.kfac;
d++;
}
od->rmsdev = sqrt(wsv2/sw);
/* Rotate the S matrices back, so we get the correct grad(tr(S D)) */
for(ex=0; ex<od->nex; ex++)
{
tmmul(R,S[ex],TMP);
mmul(TMP,R,S[ex]);
}
return od->rmsdev;
/* Approx. 120*nfa/3 flops */
}
static int get_replica_exchange(FILE *fplog,const gmx_multisim_t *ms,
struct gmx_repl_ex *re,real *ener,real vol,
int step,real time)
{
int m,i,a,b;
real *Epot=NULL,*Vol=NULL,*dvdl=NULL,*prob;
real ediff=0,delta=0,dpV=0,betaA=0,betaB=0;
gmx_bool *bEx,bPrint;
int exchange;
fprintf(fplog,"Replica exchange at step %d time %g\n",step,time);
switch (re->type)
{
case ereTEMP:
snew(Epot,re->nrepl);
snew(Vol,re->nrepl);
Epot[re->repl] = ener[F_EPOT];
Vol[re->repl] = vol;
gmx_sum_sim(re->nrepl,Epot,ms);
gmx_sum_sim(re->nrepl,Vol,ms);
break;
case ereLAMBDA:
snew(dvdl,re->nrepl);
dvdl[re->repl] = ener[F_DVDL];
gmx_sum_sim(re->nrepl,dvdl,ms);
break;
}
snew(bEx,re->nrepl);
snew(prob,re->nrepl);
exchange = -1;
m = (step / re->nst) % 2;
for(i=1; i<re->nrepl; i++)
{
a = re->ind[i-1];
b = re->ind[i];
bPrint = (re->repl==a || re->repl==b);
if (i % 2 == m)
{
switch (re->type)
{
case ereTEMP:
/* Use equations from:
* Okabe et. al. Chem. Phys. Lett. 335 (2001) 435-439
*/
ediff = Epot[b] - Epot[a];
betaA = 1.0/(re->q[a]*BOLTZ);
betaB = 1.0/(re->q[b]*BOLTZ);
delta = (betaA - betaB)*ediff;
break;
case ereLAMBDA:
/* Here we exchange based on a linear extrapolation of dV/dlambda.
* We would like to have the real energies
* from foreign lambda calculations.
*/
ediff = (dvdl[a] - dvdl[b])*(re->q[b] - re->q[a]);
delta = ediff/(BOLTZ*re->temp);
break;
default:
gmx_incons("Unknown replica exchange quantity");
}
if (bPrint)
{
fprintf(fplog,"Repl %d <-> %d dE = %10.3e",a,b,delta);
}
if (re->bNPT)
{
dpV = (betaA*re->pres[a]-betaB*re->pres[b])*(Vol[b]-Vol[a])/PRESFAC;
if (bPrint)
{
fprintf(fplog," dpV = %10.3e d = %10.3e",dpV,delta + dpV);
}
delta += dpV;
}
if (bPrint)
{
fprintf(fplog,"\n");
}
if (delta <= 0)
{
prob[i] = 1;
bEx[i] = TRUE;
}
else
{
if (delta > 100)
{
prob[i] = 0;
}
else
{
prob[i] = exp(-delta);
}
bEx[i] = (rando(&(re->seed)) < prob[i]);
}
re->prob_sum[i] += prob[i];
if (bEx[i])
{
if (a == re->repl)
{
exchange = b;
}
else if (b == re->repl)
{
exchange = a;
}
re->nexchange[i]++;
}
}
else
{
prob[i] = -1;
bEx[i] = FALSE;
}
}
print_ind(fplog,"ex",re->nrepl,re->ind,bEx);
print_prob(fplog,"pr",re->nrepl,prob);
fprintf(fplog,"\n");
sfree(bEx);
sfree(prob);
sfree(Epot);
sfree(Vol);
sfree(dvdl);
re->nattempt[m]++;
return exchange;
}
gmx_repl_ex_t init_replica_exchange(FILE *fplog,
const gmx_multisim_t *ms,
const t_state *state,
const t_inputrec *ir,
int nst,int init_seed)
{
real temp,pres;
int i,j,k;
struct gmx_repl_ex *re;
fprintf(fplog,"\nInitializing Replica Exchange\n");
if (ms == NULL || ms->nsim == 1)
{
gmx_fatal(FARGS,"Nothing to exchange with only one replica, maybe you forgot to set the -multi option of mdrun?");
}
snew(re,1);
re->repl = ms->sim;
re->nrepl = ms->nsim;
fprintf(fplog,"Repl There are %d replicas:\n",re->nrepl);
check_multi_int(fplog,ms,state->natoms,"the number of atoms");
check_multi_int(fplog,ms,ir->eI,"the integrator");
check_multi_large_int(fplog,ms,ir->init_step+ir->nsteps,"init_step+nsteps");
check_multi_large_int(fplog,ms,(ir->init_step+nst-1)/nst,
"first exchange step: init_step/-replex");
check_multi_int(fplog,ms,ir->etc,"the temperature coupling");
check_multi_int(fplog,ms,ir->opts.ngtc,
"the number of temperature coupling groups");
check_multi_int(fplog,ms,ir->epc,"the pressure coupling");
check_multi_int(fplog,ms,ir->efep,"free energy");
re->temp = ir->opts.ref_t[0];
for(i=1; (i<ir->opts.ngtc); i++)
{
if (ir->opts.ref_t[i] != re->temp)
{
fprintf(fplog,"\nWARNING: The temperatures of the different temperature coupling groups are not identical\n\n");
fprintf(stderr,"\nWARNING: The temperatures of the different temperature coupling groups are not identical\n\n");
}
}
re->type = -1;
for(i=0; i<ereNR; i++)
{
switch (i)
{
case ereTEMP:
repl_quantity(fplog,ms,re,i,re->temp);
break;
case ereLAMBDA:
if (ir->efep != efepNO)
{
repl_quantity(fplog,ms,re,i,ir->init_lambda);
}
break;
default:
gmx_incons("Unknown replica exchange quantity");
}
}
if (re->type == -1)
{
gmx_fatal(FARGS,"The properties of the %d systems are all the same, there is nothing to exchange",re->nrepl);
}
switch (re->type)
{
case ereTEMP:
please_cite(fplog,"Hukushima96a");
if (ir->epc != epcNO)
{
re->bNPT = TRUE;
fprintf(fplog,"Repl Using Constant Pressure REMD.\n");
please_cite(fplog,"Okabe2001a");
}
if (ir->etc == etcBERENDSEN)
{
gmx_fatal(FARGS,"REMD with the %s thermostat does not produce correct potential energy distributions, consider using the %s thermostat instead",
ETCOUPLTYPE(ir->etc),ETCOUPLTYPE(etcVRESCALE));
}
break;
case ereLAMBDA:
if (ir->delta_lambda != 0)
{
gmx_fatal(FARGS,"delta_lambda is not zero");
}
break;
}
if (re->bNPT)
{
snew(re->pres,re->nrepl);
if (ir->epct == epctSURFACETENSION)
{
pres = ir->ref_p[ZZ][ZZ];
}
else
{
pres = 0;
j = 0;
for(i=0; i<DIM; i++)
{
if (ir->compress[i][i] != 0)
{
pres += ir->ref_p[i][i];
j++;
}
}
pres /= j;
}
re->pres[re->repl] = pres;
gmx_sum_sim(re->nrepl,re->pres,ms);
}
snew(re->ind,re->nrepl);
/* Make an index for increasing temperature order */
for(i=0; i<re->nrepl; i++)
{
re->ind[i] = i;
}
for(i=0; i<re->nrepl; i++)
{
for(j=i+1; j<re->nrepl; j++)
{
if (re->q[re->ind[j]] < re->q[re->ind[i]])
{
k = re->ind[i];
re->ind[i] = re->ind[j];
re->ind[j] = k;
}
else if (re->q[re->ind[j]] == re->q[re->ind[i]])
{
gmx_fatal(FARGS,"Two replicas have identical %ss",erename[re->type]);
}
}
}
fprintf(fplog,"Repl ");
for(i=0; i<re->nrepl; i++)
{
fprintf(fplog," %3d ",re->ind[i]);
}
switch (re->type)
{
case ereTEMP:
fprintf(fplog,"\nRepl T");
for(i=0; i<re->nrepl; i++)
{
fprintf(fplog," %5.1f",re->q[re->ind[i]]);
}
break;
case ereLAMBDA:
fprintf(fplog,"\nRepl l");
for(i=0; i<re->nrepl; i++)
{
fprintf(fplog," %5.3f",re->q[re->ind[i]]);
}
break;
default:
gmx_incons("Unknown replica exchange quantity");
}
if (re->bNPT)
{
fprintf(fplog,"\nRepl p");
for(i=0; i<re->nrepl; i++)
{
fprintf(fplog," %5.2f",re->pres[re->ind[i]]);
}
for(i=0; i<re->nrepl; i++)
{
if ((i > 0) && (re->pres[re->ind[i]] < re->pres[re->ind[i-1]]))
{
gmx_fatal(FARGS,"The reference pressure decreases with increasing temperature");
}
}
}
fprintf(fplog,"\nRepl ");
re->nst = nst;
if (init_seed == -1)
{
if (MASTERSIM(ms))
{
re->seed = make_seed();
}
else
{
re->seed = 0;
}
gmx_sumi_sim(1,&(re->seed),ms);
}
else
{
re->seed = init_seed;
}
fprintf(fplog,"\nRepl exchange interval: %d\n",re->nst);
fprintf(fplog,"\nRepl random seed: %d\n",re->seed);
re->nattempt[0] = 0;
re->nattempt[1] = 0;
snew(re->prob_sum,re->nrepl);
snew(re->nexchange,re->nrepl);
fprintf(fplog,"Repl below: x=exchange, pr=probability\n");
return re;
}
static void
test_for_replica_exchange(FILE *fplog,
const gmx_multisim_t *ms,
struct gmx_repl_ex *re,
const gmx_enerdata_t *enerd,
real vol,
gmx_int64_t step,
real time)
{
int m, i, j, a, b, ap, bp, i0, i1, tmp;
real delta = 0;
gmx_bool bPrint, bMultiEx;
gmx_bool *bEx = re->bEx;
real *prob = re->prob;
int *pind = re->destinations; /* permuted index */
gmx_bool bEpot = FALSE;
gmx_bool bDLambda = FALSE;
gmx_bool bVol = FALSE;
gmx::ThreeFry2x64<64> rng(re->seed, gmx::RandomDomain::ReplicaExchange);
gmx::UniformRealDistribution<real> uniformRealDist;
gmx::UniformIntDistribution<int> uniformNreplDist(0, re->nrepl-1);
bMultiEx = (re->nex > 1); /* multiple exchanges at each state */
fprintf(fplog, "Replica exchange at step %" GMX_PRId64 " time %.5f\n", step, time);
if (re->bNPT)
{
for (i = 0; i < re->nrepl; i++)
{
re->Vol[i] = 0;
}
bVol = TRUE;
re->Vol[re->repl] = vol;
}
if ((re->type == ereTEMP || re->type == ereTL))
{
for (i = 0; i < re->nrepl; i++)
{
re->Epot[i] = 0;
}
bEpot = TRUE;
re->Epot[re->repl] = enerd->term[F_EPOT];
/* temperatures of different states*/
for (i = 0; i < re->nrepl; i++)
{
re->beta[i] = 1.0/(re->q[ereTEMP][i]*BOLTZ);
}
}
else
{
for (i = 0; i < re->nrepl; i++)
{
re->beta[i] = 1.0/(re->temp*BOLTZ); /* we have a single temperature */
}
}
if (re->type == ereLAMBDA || re->type == ereTL)
{
bDLambda = TRUE;
/* lambda differences. */
/* de[i][j] is the energy of the jth simulation in the ith Hamiltonian
minus the energy of the jth simulation in the jth Hamiltonian */
for (i = 0; i < re->nrepl; i++)
{
for (j = 0; j < re->nrepl; j++)
{
re->de[i][j] = 0;
}
}
for (i = 0; i < re->nrepl; i++)
{
re->de[i][re->repl] = (enerd->enerpart_lambda[(int)re->q[ereLAMBDA][i]+1]-enerd->enerpart_lambda[0]);
}
}
/* now actually do the communication */
if (bVol)
{
gmx_sum_sim(re->nrepl, re->Vol, ms);
}
if (bEpot)
{
gmx_sum_sim(re->nrepl, re->Epot, ms);
}
if (bDLambda)
{
for (i = 0; i < re->nrepl; i++)
{
gmx_sum_sim(re->nrepl, re->de[i], ms);
}
}
/* make a duplicate set of indices for shuffling */
for (i = 0; i < re->nrepl; i++)
{
pind[i] = re->ind[i];
}
rng.restart( step, 0 );
/* PLUMED */
int plumed_test_exchange_pattern=0;
if(plumed_test_exchange_pattern && plumed_hrex) gmx_fatal(FARGS,"hrex not compatible with ad hoc exchange patterns");
/* END PLUMED */
if (bMultiEx)
{
/* multiple random switch exchange */
int nself = 0;
for (i = 0; i < re->nex + nself; i++)
{
// For now this is superfluous, but just in case we ever add more
// calls in different branches it is safer to always reset the distribution.
uniformNreplDist.reset();
/* randomly select a pair */
/* in theory, could reduce this by identifying only which switches had a nonneglibible
probability of occurring (log p > -100) and only operate on those switches */
/* find out which state it is from, and what label that state currently has. Likely
more work that useful. */
i0 = uniformNreplDist(rng);
i1 = uniformNreplDist(rng);
if (i0 == i1)
{
nself++;
continue; /* self-exchange, back up and do it again */
}
a = re->ind[i0]; /* what are the indices of these states? */
b = re->ind[i1];
ap = pind[i0];
bp = pind[i1];
bPrint = FALSE; /* too noisy */
/* calculate the energy difference */
/* if the code changes to flip the STATES, rather than the configurations,
use the commented version of the code */
/* delta = calc_delta(fplog,bPrint,re,a,b,ap,bp); */
delta = calc_delta(fplog, bPrint, re, ap, bp, a, b);
/* we actually only use the first space in the prob and bEx array,
since there are actually many switches between pairs. */
if (delta <= 0)
{
/* accepted */
prob[0] = 1;
bEx[0] = TRUE;
}
else
{
if (delta > PROBABILITYCUTOFF)
{
prob[0] = 0;
}
else
{
prob[0] = exp(-delta);
}
// roll a number to determine if accepted. For now it is superfluous to
// reset, but just in case we ever add more calls in different branches
// it is safer to always reset the distribution.
uniformRealDist.reset();
bEx[0] = uniformRealDist(rng) < prob[0];
}
re->prob_sum[0] += prob[0];
if (bEx[0])
{
/* swap the states */
tmp = pind[i0];
pind[i0] = pind[i1];
pind[i1] = tmp;
}
}
re->nattempt[0]++; /* keep track of total permutation trials here */
print_allswitchind(fplog, re->nrepl, pind, re->allswaps, re->tmpswap);
}
else
{
/* standard nearest neighbor replica exchange */
m = (step / re->nst) % 2;
/* PLUMED */
if(plumedswitch){
int partner=re->repl;
plumed_cmd(plumedmain,"getExchangesFlag",&plumed_test_exchange_pattern);
if(plumed_test_exchange_pattern>0){
int *list;
snew(list,re->nrepl);
plumed_cmd(plumedmain,"setNumberOfReplicas",&(re->nrepl));
plumed_cmd(plumedmain,"getExchangesList",list);
for(i=0; i<re->nrepl; i++) re->ind[i]=list[i];
sfree(list);
}
for(i=1; i<re->nrepl; i++) {
if (i % 2 != m) continue;
a = re->ind[i-1];
b = re->ind[i];
if(re->repl==a) partner=b;
if(re->repl==b) partner=a;
}
plumed_cmd(plumedmain,"GREX setPartner",&partner);
plumed_cmd(plumedmain,"GREX calculate",NULL);
plumed_cmd(plumedmain,"GREX shareAllDeltaBias",NULL);
}
/* END PLUMED */
for (i = 1; i < re->nrepl; i++)
{
a = re->ind[i-1];
b = re->ind[i];
bPrint = (re->repl == a || re->repl == b);
if (i % 2 == m)
{
delta = calc_delta(fplog, bPrint, re, a, b, a, b);
/* PLUMED */
if(plumedswitch){
real adb,bdb,dplumed;
char buf[300];
sprintf(buf,"GREX getDeltaBias %d",a); plumed_cmd(plumedmain,buf,&adb);
sprintf(buf,"GREX getDeltaBias %d",b); plumed_cmd(plumedmain,buf,&bdb);
dplumed=adb*re->beta[a]+bdb*re->beta[b];
delta+=dplumed;
if (bPrint)
fprintf(fplog,"dplumed = %10.3e dE_Term = %10.3e (kT)\n",dplumed,delta);
}
/* END PLUMED */
if (delta <= 0)
{
/* accepted */
prob[i] = 1;
bEx[i] = TRUE;
}
else
{
if (delta > PROBABILITYCUTOFF)
{
prob[i] = 0;
}
else
{
prob[i] = exp(-delta);
}
// roll a number to determine if accepted. For now it is superfluous to
// reset, but just in case we ever add more calls in different branches
// it is safer to always reset the distribution.
uniformRealDist.reset();
bEx[i] = uniformRealDist(rng) < prob[i];
}
re->prob_sum[i] += prob[i];
if (bEx[i])
{
/* PLUMED */
if(!plumed_test_exchange_pattern) {
/* standard neighbour swapping */
/* swap these two */
tmp = pind[i-1];
pind[i-1] = pind[i];
pind[i] = tmp;
re->nexchange[i]++; /* statistics for back compatibility */
} else {
/* alternative swapping patterns */
tmp = pind[a];
pind[a] = pind[b];
pind[b] = tmp;
re->nexchange[i]++; /* statistics for back compatibility */
}
/* END PLUMED */
}
}
else
{
prob[i] = -1;
bEx[i] = FALSE;
}
}
/* print some statistics */
print_ind(fplog, "ex", re->nrepl, re->ind, bEx);
print_prob(fplog, "pr", re->nrepl, prob);
fprintf(fplog, "\n");
re->nattempt[m]++;
}
/* PLUMED */
if(plumed_test_exchange_pattern>0) {
for (i = 0; i < re->nrepl; i++)
{
re->ind[i] = i;
}
}
/* END PLUMED */
/* record which moves were made and accepted */
for (i = 0; i < re->nrepl; i++)
{
re->nmoves[re->ind[i]][pind[i]] += 1;
re->nmoves[pind[i]][re->ind[i]] += 1;
}
fflush(fplog); /* make sure we can see what the last exchange was */
}
