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 */
}
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 */
}
