void
TrajectoryAnalysisRunnerCommon::initFirstFrame()
{
// Return if we have already initialized the trajectory.
if (impl_->fr)
{
return;
}
time_unit_t time_unit
= static_cast<time_unit_t>(impl_->settings_.timeUnit() + 1);
output_env_init(&impl_->oenv_, getProgramContext(), time_unit, FALSE, exvgNONE, 0);
int frflags = impl_->settings_.frflags();
frflags |= TRX_NEED_X;
snew(impl_->fr, 1);
const TopologyInformation &top = impl_->topInfo_;
if (hasTrajectory())
{
if (!read_first_frame(impl_->oenv_, &impl_->status_,
impl_->trjfile_.c_str(), impl_->fr, frflags))
{
GMX_THROW(FileIOError("Could not read coordinates from trajectory"));
}
impl_->bTrajOpen_ = true;
if (top.hasTopology() && impl_->fr->natoms > top.topology()->atoms.nr)
{
GMX_THROW(InconsistentInputError(formatString(
"Trajectory (%d atoms) does not match topology (%d atoms)",
impl_->fr->natoms, top.topology()->atoms.nr)));
}
}
else
{
// Prepare a frame from topology information.
// TODO: Initialize more of the fields.
if (frflags & (TRX_NEED_V))
{
GMX_THROW(NotImplementedError("Velocity reading from a topology not implemented"));
}
if (frflags & (TRX_NEED_F))
{
GMX_THROW(InvalidInputError("Forces cannot be read from a topology"));
}
impl_->fr->flags = frflags;
impl_->fr->natoms = top.topology()->atoms.nr;
impl_->fr->bX = TRUE;
snew(impl_->fr->x, impl_->fr->natoms);
memcpy(impl_->fr->x, top.xtop_,
sizeof(*impl_->fr->x) * impl_->fr->natoms);
impl_->fr->bBox = TRUE;
copy_mat(const_cast<rvec *>(top.boxtop_), impl_->fr->box);
}
set_trxframe_ePBC(impl_->fr, top.ePBC());
if (top.hasTopology() && impl_->settings_.hasRmPBC())
{
impl_->gpbc_ = gmx_rmpbc_init(&top.topology()->idef, top.ePBC(),
impl_->fr->natoms);
}
}
void set_deform_reference_box(int step,matrix box)
{
deformref_step = step;
copy_mat(box,deformref_box);
}
gmx_bool print_ga(FILE *fp, t_genalg *ga, real msf, tensor pres, rvec scale,
real energy, t_range range[], real tol)
{
static int nfeval = 0; /* number of function evaluations */
static gmx_bool bImproved;
real trial_cost;
real cvar; /* computes the cost variance */
real cmean; /* mean cost */
int i, j;
real **pswap;
trial_cost = cost(pres, msf, energy);
if (nfeval < ga->NP)
{
ga->cost[nfeval] = trial_cost;
ga->msf[nfeval] = msf;
ga->energy[nfeval] = energy;
copy_mat(pres, ga->pres[nfeval]);
copy_rvec(scale, ga->scale[nfeval]);
if (debug)
{
pr_rvec(debug, 0, "scale", scale, DIM, TRUE);
pr_rvec(debug, 0, "pold ", ga->pold[nfeval]+4, DIM, TRUE);
}
nfeval++;
return FALSE;
}
/* When we get here we have done an initial evaluation for all
* animals in the population
*/
if (ga->ipop == 0)
{
bImproved = FALSE;
}
/* First iteration after first round of trials */
if (nfeval == ga->NP)
{
/* Evaluate who is ga->best */
ga->imin = 0;
for (j = 1; (j < ga->NP); j++)
{
if (ga->cost[j] < ga->cost[ga->imin])
{
ga->imin = j;
}
}
assignd(ga->D, ga->best, ga->pold[ga->imin]);
/* save best member ever */
assignd(ga->D, ga->bestit, ga->pold[ga->imin]);
/* save best member of generation */
}
if (trial_cost < ga->cost[ga->ipop])
{
if (trial_cost < ga->cost[ga->imin])
{
/* Was this a new minimum? */
/* if so, reset cmin to new low...*/
ga->imin = ga->ipop;
assignd(ga->D, ga->best, ga->tmp);
bImproved = TRUE;
}
/* improved objective function value ? */
ga->cost[ga->ipop] = trial_cost;
ga->msf[ga->ipop] = msf;
ga->energy[ga->ipop] = energy;
copy_mat(pres, ga->pres[ga->ipop]);
copy_rvec(scale, ga->scale[ga->ipop]);
assignd(ga->D, ga->pnew[ga->ipop], ga->tmp);
}
else
{
/* replace target with old value */
assignd(ga->D, ga->pnew[ga->ipop], ga->pold[ga->ipop]);
}
/* #define SCALE_DEBUG*/
#ifdef SCALE_DEBUG
if (ga->D > 5)
{
rvec dscale;
rvec_sub(ga->scale[ga->imin], &(ga->best[ga->D-3]), dscale);
if (norm(dscale) > 0)
{
pr_rvec(fp, 0, "scale", scale, DIM, TRUE);
pr_rvec(fp, 0, "best ", &(ga->best[ga->D-3]), DIM, TRUE);
fprintf(fp, "imin = %d, ipop = %d, nfeval = %d\n", ga->imin,
ga->ipop, nfeval);
gmx_fatal(FARGS, "Scale inconsistency");
}
}
#endif
/* Increase population member count */
ga->ipop++;
/* End mutation loop through population? */
if (ga->ipop == ga->NP)
{
/* Save ga->best population member of current iteration */
assignd(ga->D, ga->bestit, ga->best);
/* swap population arrays. New generation becomes old one */
pswap = ga->pold;
ga->pold = ga->pnew;
ga->pnew = pswap;
/*----Compute the energy variance (just for monitoring purposes)-----------*/
/* compute the mean value first */
cmean = 0.0;
for (j = 0; (j < ga->NP); j++)
{
cmean += ga->cost[j];
}
cmean = cmean/ga->NP;
/* now the variance */
cvar = 0.0;
for (j = 0; (j < ga->NP); j++)
{
cvar += sqr(ga->cost[j] - cmean);
}
cvar = cvar/(ga->NP-1);
/*----Output part----------------------------------------------------------*/
if (1 || bImproved || (nfeval == ga->NP))
{
fprintf(fp, "\nGen: %5d\n Cost: %12.3e <Cost>: %12.3e\n"
" Ener: %8.4f RMSF: %8.3f Pres: %8.1f %8.1f %8.1f (%8.1f)\n"
" Box-Scale: %15.10f %15.10f %15.10f\n",
ga->gen, ga->cost[ga->imin], cmean, ga->energy[ga->imin],
sqrt(ga->msf[ga->imin]), ga->pres[ga->imin][XX][XX],
ga->pres[ga->imin][YY][YY], ga->pres[ga->imin][ZZ][ZZ],
trace(ga->pres[ga->imin])/3.0,
ga->scale[ga->imin][XX], ga->scale[ga->imin][YY],
ga->scale[ga->imin][ZZ]);
for (j = 0; (j < ga->D); j++)
{
fprintf(fp, "\tbest[%d]=%-15.10f\n", j, ga->best[j]);
}
if (ga->cost[ga->imin] < tol)
{
for (i = 0; (i < ga->NP); i++)
{
fprintf(fp, "Animal: %3d Cost:%8.3f Ener: %8.3f RMSF: %8.3f%s\n",
i, ga->cost[i], ga->energy[i], sqrt(ga->msf[i]),
(i == ga->imin) ? " ***" : "");
for (j = 0; (j < ga->D); j++)
{
fprintf(fp, "\tParam[%d][%d]=%15.10g\n", i, j, ga->pold[i][j]);
}
}
return TRUE;
}
fflush(fp);
}
}
nfeval++;
return FALSE;
}
void do_force(FILE *fplog,t_commrec *cr,
t_inputrec *inputrec,
int step,t_nrnb *nrnb,gmx_wallcycle_t wcycle,
gmx_localtop_t *top,
gmx_groups_t *groups,
matrix box,rvec x[],history_t *hist,
rvec f[],rvec buf[],
tensor vir_force,
t_mdatoms *mdatoms,
gmx_enerdata_t *enerd,t_fcdata *fcd,
real lambda,t_graph *graph,
t_forcerec *fr,gmx_vsite_t *vsite,rvec mu_tot,
real t,FILE *field,gmx_edsam_t ed,
int flags)
{
static rvec box_size;
int cg0,cg1,i,j;
int start,homenr;
static double mu[2*DIM];
rvec mu_tot_AB[2];
bool bSepDVDL,bStateChanged,bNS,bFillGrid,bCalcCGCM,bBS,bDoForces;
matrix boxs;
real e,v,dvdl;
t_pbc pbc;
float cycles_ppdpme,cycles_pme,cycles_force;
start = mdatoms->start;
homenr = mdatoms->homenr;
bSepDVDL = (fr->bSepDVDL && do_per_step(step,inputrec->nstlog));
clear_mat(vir_force);
if (PARTDECOMP(cr)) {
pd_cg_range(cr,&cg0,&cg1);
} else {
cg0 = 0;
if (DOMAINDECOMP(cr))
cg1 = cr->dd->ncg_tot;
else
cg1 = top->cgs.nr;
if (fr->n_tpi > 0)
cg1--;
}
bStateChanged = (flags & GMX_FORCE_STATECHANGED);
bNS = (flags & GMX_FORCE_NS);
bFillGrid = (bNS && bStateChanged);
bCalcCGCM = (bFillGrid && !DOMAINDECOMP(cr));
bDoForces = (flags & GMX_FORCE_FORCES);
if (bStateChanged) {
update_forcerec(fplog,fr,box);
/* Calculate total (local) dipole moment in a temporary common array.
* This makes it possible to sum them over nodes faster.
*/
calc_mu(start,homenr,
x,mdatoms->chargeA,mdatoms->chargeB,mdatoms->nChargePerturbed,
mu,mu+DIM);
}
if (fr->ePBC != epbcNONE) {
/* Compute shift vectors every step,
* because of pressure coupling or box deformation!
*/
if (DYNAMIC_BOX(*inputrec) && bStateChanged)
calc_shifts(box,fr->shift_vec);
if (bCalcCGCM) {
put_charge_groups_in_box(fplog,cg0,cg1,fr->ePBC,box,
&(top->cgs),x,fr->cg_cm);
inc_nrnb(nrnb,eNR_CGCM,homenr);
inc_nrnb(nrnb,eNR_RESETX,cg1-cg0);
}
else if (EI_ENERGY_MINIMIZATION(inputrec->eI) && graph) {
unshift_self(graph,box,x);
}
}
else if (bCalcCGCM) {
calc_cgcm(fplog,cg0,cg1,&(top->cgs),x,fr->cg_cm);
inc_nrnb(nrnb,eNR_CGCM,homenr);
}
if (bCalcCGCM) {
if (PAR(cr)) {
move_cgcm(fplog,cr,fr->cg_cm);
}
if (gmx_debug_at)
pr_rvecs(debug,0,"cgcm",fr->cg_cm,top->cgs.nr);
}
#ifdef GMX_MPI
if (!(cr->duty & DUTY_PME)) {
/* Send particle coordinates to the pme nodes.
* Since this is only implemented for domain decomposition
* and domain decomposition does not use the graph,
* we do not need to worry about shifting.
*/
wallcycle_start(wcycle,ewcPP_PMESENDX);
GMX_MPE_LOG(ev_send_coordinates_start);
bBS = (inputrec->nwall == 2);
if (bBS) {
copy_mat(box,boxs);
svmul(inputrec->wall_ewald_zfac,boxs[ZZ],boxs[ZZ]);
}
gmx_pme_send_x(cr,bBS ? boxs : box,x,mdatoms->nChargePerturbed,lambda);
GMX_MPE_LOG(ev_send_coordinates_finish);
wallcycle_stop(wcycle,ewcPP_PMESENDX);
}
#endif /* GMX_MPI */
/* Communicate coordinates and sum dipole if necessary */
if (PAR(cr)) {
wallcycle_start(wcycle,ewcMOVEX);
if (DOMAINDECOMP(cr)) {
dd_move_x(cr->dd,box,x,buf);
} else {
move_x(fplog,cr,GMX_LEFT,GMX_RIGHT,x,nrnb);
}
/* When we don't need the total dipole we sum it in global_stat */
if (NEED_MUTOT(*inputrec))
gmx_sumd(2*DIM,mu,cr);
wallcycle_stop(wcycle,ewcMOVEX);
}
for(i=0; i<2; i++)
for(j=0;j<DIM;j++)
mu_tot_AB[i][j] = mu[i*DIM + j];
if (fr->efep == efepNO)
copy_rvec(mu_tot_AB[0],mu_tot);
else
for(j=0; j<DIM; j++)
mu_tot[j] = (1.0 - lambda)*mu_tot_AB[0][j] + lambda*mu_tot_AB[1][j];
/* Reset energies */
reset_energies(&(inputrec->opts),fr,bNS,enerd,MASTER(cr));
if (bNS) {
wallcycle_start(wcycle,ewcNS);
if (graph && bStateChanged)
/* Calculate intramolecular shift vectors to make molecules whole */
mk_mshift(fplog,graph,fr->ePBC,box,x);
/* Reset long range forces if necessary */
if (fr->bTwinRange) {
clear_rvecs(fr->f_twin_n,fr->f_twin);
clear_rvecs(SHIFTS,fr->fshift_twin);
}
/* Do the actual neighbour searching and if twin range electrostatics
* also do the calculation of long range forces and energies.
*/
dvdl = 0;
ns(fplog,fr,x,f,box,groups,&(inputrec->opts),top,mdatoms,
cr,nrnb,step,lambda,&dvdl,&enerd->grpp,bFillGrid,bDoForces);
if (bSepDVDL)
fprintf(fplog,sepdvdlformat,"LR non-bonded",0,dvdl);
enerd->dvdl_lr = dvdl;
enerd->term[F_DVDL] += dvdl;
wallcycle_stop(wcycle,ewcNS);
}
if (DOMAINDECOMP(cr)) {
if (!(cr->duty & DUTY_PME)) {
wallcycle_start(wcycle,ewcPPDURINGPME);
dd_force_flop_start(cr->dd,nrnb);
}
}
/* Start the force cycle counter.
* This counter is stopped in do_forcelow_level.
* No parallel communication should occur while this counter is running,
* since that will interfere with the dynamic load balancing.
*/
wallcycle_start(wcycle,ewcFORCE);
if (bDoForces) {
/* Reset PME/Ewald forces if necessary */
if (fr->bF_NoVirSum)
{
GMX_BARRIER(cr->mpi_comm_mygroup);
if (fr->bDomDec)
clear_rvecs(fr->f_novirsum_n,fr->f_novirsum);
else
clear_rvecs(homenr,fr->f_novirsum+start);
GMX_BARRIER(cr->mpi_comm_mygroup);
}
/* Copy long range forces into normal buffers */
if (fr->bTwinRange) {
for(i=0; i<fr->f_twin_n; i++)
copy_rvec(fr->f_twin[i],f[i]);
for(i=0; i<SHIFTS; i++)
copy_rvec(fr->fshift_twin[i],fr->fshift[i]);
}
else {
if (DOMAINDECOMP(cr))
clear_rvecs(cr->dd->nat_tot,f);
else
clear_rvecs(mdatoms->nr,f);
clear_rvecs(SHIFTS,fr->fshift);
}
clear_rvec(fr->vir_diag_posres);
GMX_BARRIER(cr->mpi_comm_mygroup);
}
if (inputrec->ePull == epullCONSTRAINT)
clear_pull_forces(inputrec->pull);
/* update QMMMrec, if necessary */
if(fr->bQMMM)
update_QMMMrec(cr,fr,x,mdatoms,box,top);
if ((flags & GMX_FORCE_BONDED) && top->idef.il[F_POSRES].nr > 0) {
/* Position restraints always require full pbc */
set_pbc(&pbc,inputrec->ePBC,box);
v = posres(top->idef.il[F_POSRES].nr,top->idef.il[F_POSRES].iatoms,
top->idef.iparams_posres,
(const rvec*)x,fr->f_novirsum,fr->vir_diag_posres,
inputrec->ePBC==epbcNONE ? NULL : &pbc,lambda,&dvdl,
fr->rc_scaling,fr->ePBC,fr->posres_com,fr->posres_comB);
if (bSepDVDL) {
fprintf(fplog,sepdvdlformat,
interaction_function[F_POSRES].longname,v,dvdl);
}
enerd->term[F_POSRES] += v;
enerd->term[F_DVDL] += dvdl;
inc_nrnb(nrnb,eNR_POSRES,top->idef.il[F_POSRES].nr/2);
}
/* Compute the bonded and non-bonded forces */
do_force_lowlevel(fplog,step,fr,inputrec,&(top->idef),
cr,nrnb,wcycle,mdatoms,&(inputrec->opts),
x,hist,f,enerd,fcd,box,lambda,graph,&(top->excls),mu_tot_AB,
flags,&cycles_force);
GMX_BARRIER(cr->mpi_comm_mygroup);
if (ed) {
do_flood(fplog,cr,x,f,ed,box,step);
}
if (DOMAINDECOMP(cr)) {
dd_force_flop_stop(cr->dd,nrnb);
if (wcycle)
dd_cycles_add(cr->dd,cycles_force,ddCyclF);
}
if (bDoForces) {
/* Compute forces due to electric field */
calc_f_el(MASTER(cr) ? field : NULL,
start,homenr,mdatoms->chargeA,x,f,inputrec->ex,inputrec->et,t);
/* When using PME/Ewald we compute the long range virial there.
* otherwise we do it based on long range forces from twin range
* cut-off based calculation (or not at all).
*/
/* Communicate the forces */
if (PAR(cr)) {
wallcycle_start(wcycle,ewcMOVEF);
if (DOMAINDECOMP(cr)) {
dd_move_f(cr->dd,f,buf,fr->fshift);
/* Position restraint do not introduce inter-cg forces */
if (EEL_FULL(fr->eeltype) && cr->dd->n_intercg_excl)
dd_move_f(cr->dd,fr->f_novirsum,buf,NULL);
} else {
move_f(fplog,cr,GMX_LEFT,GMX_RIGHT,f,buf,nrnb);
}
wallcycle_stop(wcycle,ewcMOVEF);
}
}
if (bDoForces) {
if (vsite) {
wallcycle_start(wcycle,ewcVSITESPREAD);
spread_vsite_f(fplog,vsite,x,f,fr->fshift,nrnb,
&top->idef,fr->ePBC,fr->bMolPBC,graph,box,cr);
wallcycle_stop(wcycle,ewcVSITESPREAD);
}
/* Calculation of the virial must be done after vsites! */
calc_virial(fplog,mdatoms->start,mdatoms->homenr,x,f,
vir_force,graph,box,nrnb,fr,inputrec->ePBC);
}
if (inputrec->ePull == epullUMBRELLA || inputrec->ePull == epullCONST_F) {
/* Calculate the center of mass forces, this requires communication,
* which is why pull_potential is called close to other communication.
* The virial contribution is calculated directly,
* which is why we call pull_potential after calc_virial.
*/
set_pbc(&pbc,inputrec->ePBC,box);
dvdl = 0;
enerd->term[F_COM_PULL] =
pull_potential(inputrec->ePull,inputrec->pull,mdatoms,&pbc,
cr,t,lambda,x,f,vir_force,&dvdl);
if (bSepDVDL)
fprintf(fplog,sepdvdlformat,"Com pull",enerd->term[F_COM_PULL],dvdl);
enerd->term[F_DVDL] += dvdl;
}
if (!(cr->duty & DUTY_PME)) {
cycles_ppdpme = wallcycle_stop(wcycle,ewcPPDURINGPME);
dd_cycles_add(cr->dd,cycles_ppdpme,ddCyclPPduringPME);
}
#ifdef GMX_MPI
if (PAR(cr) && !(cr->duty & DUTY_PME)) {
/* In case of node-splitting, the PP nodes receive the long-range
* forces, virial and energy from the PME nodes here.
*/
wallcycle_start(wcycle,ewcPP_PMEWAITRECVF);
dvdl = 0;
gmx_pme_receive_f(cr,fr->f_novirsum,fr->vir_el_recip,&e,&dvdl,
&cycles_pme);
if (bSepDVDL)
fprintf(fplog,sepdvdlformat,"PME mesh",e,dvdl);
enerd->term[F_COUL_RECIP] += e;
enerd->term[F_DVDL] += dvdl;
if (wcycle)
dd_cycles_add(cr->dd,cycles_pme,ddCyclPME);
wallcycle_stop(wcycle,ewcPP_PMEWAITRECVF);
}
#endif
if (bDoForces && fr->bF_NoVirSum) {
if (vsite) {
/* Spread the mesh force on virtual sites to the other particles...
* This is parallellized. MPI communication is performed
* if the constructing atoms aren't local.
*/
wallcycle_start(wcycle,ewcVSITESPREAD);
spread_vsite_f(fplog,vsite,x,fr->f_novirsum,NULL,nrnb,
&top->idef,fr->ePBC,fr->bMolPBC,graph,box,cr);
wallcycle_stop(wcycle,ewcVSITESPREAD);
}
/* Now add the forces, this is local */
if (fr->bDomDec) {
sum_forces(0,fr->f_novirsum_n,f,fr->f_novirsum);
} else {
sum_forces(start,start+homenr,f,fr->f_novirsum);
}
if (EEL_FULL(fr->eeltype)) {
/* Add the mesh contribution to the virial */
m_add(vir_force,fr->vir_el_recip,vir_force);
}
if (debug)
pr_rvecs(debug,0,"vir_force",vir_force,DIM);
}
/* Sum the potential energy terms from group contributions */
sum_epot(&(inputrec->opts),enerd);
if (fr->print_force >= 0 && bDoForces)
print_large_forces(stderr,mdatoms,cr,step,fr->print_force,x,f);
}
void pme_loadbal_init(pme_load_balancing_t *pme_lb_p,
const t_inputrec *ir, matrix box,
const interaction_const_t *ic,
gmx_pme_t pmedata)
{
pme_load_balancing_t pme_lb;
real spm, sp;
int d;
snew(pme_lb, 1);
/* Any number of stages >= 2 is supported */
pme_lb->nstage = 2;
pme_lb->cutoff_scheme = ir->cutoff_scheme;
if (pme_lb->cutoff_scheme == ecutsVERLET)
{
pme_lb->rbuf_coulomb = ic->rlist - ic->rcoulomb;
pme_lb->rbuf_vdw = pme_lb->rbuf_coulomb;
}
else
{
if (ic->rcoulomb > ic->rlist)
{
pme_lb->rbuf_coulomb = ic->rlistlong - ic->rcoulomb;
}
else
{
pme_lb->rbuf_coulomb = ic->rlist - ic->rcoulomb;
}
if (ic->rvdw > ic->rlist)
{
pme_lb->rbuf_vdw = ic->rlistlong - ic->rvdw;
}
else
{
pme_lb->rbuf_vdw = ic->rlist - ic->rvdw;
}
}
copy_mat(box, pme_lb->box_start);
if (ir->ePBC == epbcXY && ir->nwall == 2)
{
svmul(ir->wall_ewald_zfac, pme_lb->box_start[ZZ], pme_lb->box_start[ZZ]);
}
pme_lb->n = 1;
snew(pme_lb->setup, pme_lb->n);
pme_lb->rcut_vdw = ic->rvdw;
pme_lb->rcut_coulomb_start = ir->rcoulomb;
pme_lb->nstcalclr_start = ir->nstcalclr;
pme_lb->cur = 0;
pme_lb->setup[0].rcut_coulomb = ic->rcoulomb;
pme_lb->setup[0].rlist = ic->rlist;
pme_lb->setup[0].rlistlong = ic->rlistlong;
pme_lb->setup[0].nstcalclr = ir->nstcalclr;
pme_lb->setup[0].grid[XX] = ir->nkx;
pme_lb->setup[0].grid[YY] = ir->nky;
pme_lb->setup[0].grid[ZZ] = ir->nkz;
pme_lb->setup[0].ewaldcoeff = ic->ewaldcoeff;
pme_lb->setup[0].pmedata = pmedata;
spm = 0;
for (d = 0; d < DIM; d++)
{
sp = norm(pme_lb->box_start[d])/pme_lb->setup[0].grid[d];
if (sp > spm)
{
spm = sp;
}
}
pme_lb->setup[0].spacing = spm;
if (ir->fourier_spacing > 0)
{
pme_lb->cut_spacing = ir->rcoulomb/ir->fourier_spacing;
}
else
{
pme_lb->cut_spacing = ir->rcoulomb/pme_lb->setup[0].spacing;
}
pme_lb->stage = 0;
pme_lb->fastest = 0;
pme_lb->start = 0;
pme_lb->end = 0;
pme_lb->elimited = epmelblimNO;
*pme_lb_p = pme_lb;
}
static gmx_bool pdb_next_x(t_trxstatus *status, FILE *fp, t_trxframe *fr)
{
t_atoms atoms;
matrix boxpdb;
int ePBC, model_nr, na;
char title[STRLEN], *time;
double dbl;
atoms.nr = fr->natoms;
atoms.atom = NULL;
atoms.pdbinfo = NULL;
/* the other pointers in atoms should not be accessed if these are NULL */
model_nr = NOTSET;
na = read_pdbfile(fp, title, &model_nr, &atoms, fr->x, &ePBC, boxpdb, TRUE, NULL);
set_trxframe_ePBC(fr, ePBC);
if (nframes_read(status) == 0)
{
fprintf(stderr, " '%s', %d atoms\n", title, fr->natoms);
}
fr->bPrec = TRUE;
fr->prec = 10000;
fr->bX = TRUE;
fr->bBox = (boxpdb[XX][XX] != 0.0);
if (fr->bBox)
{
copy_mat(boxpdb, fr->box);
}
if (model_nr != NOTSET)
{
fr->bStep = TRUE;
fr->step = model_nr;
}
time = strstr(title, " t= ");
if (time)
{
fr->bTime = TRUE;
sscanf(time+4, "%lf", &dbl);
fr->time = (real)dbl;
}
else
{
fr->bTime = FALSE;
/* this is a bit dirty, but it will work: if no time is read from
comment line in pdb file, set time to current frame number */
if (fr->bStep)
{
fr->time = (real)fr->step;
}
else
{
fr->time = (real)nframes_read(status);
}
}
if (na == 0)
{
return FALSE;
}
else
{
if (na != fr->natoms)
{
gmx_fatal(FARGS, "Number of atoms in pdb frame %d is %d instead of %d",
nframes_read(status), na, fr->natoms);
}
return TRUE;
}
}
void pme_loadbal_init(pme_load_balancing_t **pme_lb_p,
const t_inputrec *ir, matrix box,
const interaction_const_t *ic,
struct gmx_pme_t *pmedata,
gmx_bool bUseGPU, gmx_bool bSepPMERanks,
gmx_bool *bPrinting)
{
pme_load_balancing_t *pme_lb;
real spm, sp;
int d;
snew(pme_lb, 1);
pme_lb->bSepPMERanks = bSepPMERanks;
/* Any number of stages >= 2 is supported */
pme_lb->nstage = 2;
pme_lb->cutoff_scheme = ir->cutoff_scheme;
if (pme_lb->cutoff_scheme == ecutsVERLET)
{
pme_lb->rbuf_coulomb = ic->rlist - ic->rcoulomb;
pme_lb->rbuf_vdw = pme_lb->rbuf_coulomb;
}
else
{
if (ic->rcoulomb > ic->rlist)
{
pme_lb->rbuf_coulomb = ic->rlistlong - ic->rcoulomb;
}
else
{
pme_lb->rbuf_coulomb = ic->rlist - ic->rcoulomb;
}
if (ic->rvdw > ic->rlist)
{
pme_lb->rbuf_vdw = ic->rlistlong - ic->rvdw;
}
else
{
pme_lb->rbuf_vdw = ic->rlist - ic->rvdw;
}
}
copy_mat(box, pme_lb->box_start);
if (ir->ePBC == epbcXY && ir->nwall == 2)
{
svmul(ir->wall_ewald_zfac, pme_lb->box_start[ZZ], pme_lb->box_start[ZZ]);
}
pme_lb->n = 1;
snew(pme_lb->setup, pme_lb->n);
pme_lb->rcut_vdw = ic->rvdw;
pme_lb->rcut_coulomb_start = ir->rcoulomb;
pme_lb->nstcalclr_start = ir->nstcalclr;
pme_lb->cur = 0;
pme_lb->setup[0].rcut_coulomb = ic->rcoulomb;
pme_lb->setup[0].rlist = ic->rlist;
pme_lb->setup[0].rlistlong = ic->rlistlong;
pme_lb->setup[0].nstcalclr = ir->nstcalclr;
pme_lb->setup[0].grid[XX] = ir->nkx;
pme_lb->setup[0].grid[YY] = ir->nky;
pme_lb->setup[0].grid[ZZ] = ir->nkz;
pme_lb->setup[0].ewaldcoeff_q = ic->ewaldcoeff_q;
pme_lb->setup[0].ewaldcoeff_lj = ic->ewaldcoeff_lj;
pme_lb->setup[0].pmedata = pmedata;
spm = 0;
for (d = 0; d < DIM; d++)
{
sp = norm(pme_lb->box_start[d])/pme_lb->setup[0].grid[d];
if (sp > spm)
{
spm = sp;
}
}
pme_lb->setup[0].spacing = spm;
if (ir->fourier_spacing > 0)
{
pme_lb->cut_spacing = ir->rcoulomb/ir->fourier_spacing;
}
else
{
pme_lb->cut_spacing = ir->rcoulomb/pme_lb->setup[0].spacing;
}
pme_lb->stage = 0;
pme_lb->fastest = 0;
pme_lb->start = 0;
pme_lb->end = 0;
pme_lb->elimited = epmelblimNO;
pme_lb->cycles_n = 0;
pme_lb->cycles_c = 0;
/* Tune with GPUs and/or separate PME ranks.
* When running only on a CPU without PME ranks, PME tuning will only help
* with small numbers of atoms in the cut-off sphere.
*/
pme_lb->bActive = (wallcycle_have_counter() && (bUseGPU || bSepPMERanks));
/* With GPUs and no separate PME ranks we can't measure the PP/PME
* imbalance, so we start balancing right away.
* Otherwise we only start balancing after we observe imbalance.
*/
pme_lb->bBalance = (pme_lb->bActive && (bUseGPU && !bSepPMERanks));
*pme_lb_p = pme_lb;
*bPrinting = pme_lb->bBalance;
}
void settle_proj(gmx_settledata_t settled, int econq,
int nsettle, t_iatom iatoms[],
const t_pbc *pbc,
rvec x[],
rvec *der, rvec *derp,
int calcvir_atom_end, tensor vir_r_m_dder)
{
/* Settle for projection out constraint components
* of derivatives of the coordinates.
* Berk Hess 2008-1-10
*/
settleparam_t *p;
real imO, imH, dOH, dHH, invdOH, invdHH;
matrix invmat;
int i, m, m2, ow1, hw2, hw3;
rvec roh2, roh3, rhh, dc, fc;
calcvir_atom_end *= DIM;
if (econq == econqForce)
{
p = &settled->mass1;
}
else
{
p = &settled->massw;
}
imO = p->imO;
imH = p->imH;
copy_mat(p->invmat, invmat);
dOH = p->dOH;
dHH = p->dHH;
invdOH = p->invdOH;
invdHH = p->invdHH;
#ifdef PRAGMAS
#pragma ivdep
#endif
for (i = 0; i < nsettle; i++)
{
ow1 = iatoms[i*4+1];
hw2 = iatoms[i*4+2];
hw3 = iatoms[i*4+3];
if (pbc == NULL)
{
rvec_sub(x[ow1], x[hw2], roh2);
rvec_sub(x[ow1], x[hw3], roh3);
rvec_sub(x[hw2], x[hw3], rhh);
}
else
{
pbc_dx_aiuc(pbc, x[ow1], x[hw2], roh2);
pbc_dx_aiuc(pbc, x[ow1], x[hw3], roh3);
pbc_dx_aiuc(pbc, x[hw2], x[hw3], rhh);
}
svmul(invdOH, roh2, roh2);
svmul(invdOH, roh3, roh3);
svmul(invdHH, rhh, rhh);
/* 18 flops */
/* Determine the projections of der on the bonds */
clear_rvec(dc);
for (m = 0; m < DIM; m++)
{
dc[0] += (der[ow1][m] - der[hw2][m])*roh2[m];
dc[1] += (der[ow1][m] - der[hw3][m])*roh3[m];
dc[2] += (der[hw2][m] - der[hw3][m])*rhh [m];
}
/* 27 flops */
/* Determine the correction for the three bonds */
mvmul(invmat, dc, fc);
/* 15 flops */
/* Subtract the corrections from derp */
for (m = 0; m < DIM; m++)
{
derp[ow1][m] -= imO*( fc[0]*roh2[m] + fc[1]*roh3[m]);
derp[hw2][m] -= imH*(-fc[0]*roh2[m] + fc[2]*rhh [m]);
derp[hw3][m] -= imH*(-fc[1]*roh3[m] - fc[2]*rhh [m]);
}
/* 45 flops */
if (ow1 < calcvir_atom_end)
{
/* Determining r \dot m der is easy,
* since fc contains the mass weighted corrections for der.
*/
for (m = 0; m < DIM; m++)
{
for (m2 = 0; m2 < DIM; m2++)
{
vir_r_m_dder[m][m2] +=
dOH*roh2[m]*roh2[m2]*fc[0] +
dOH*roh3[m]*roh3[m2]*fc[1] +
dHH*rhh [m]*rhh [m2]*fc[2];
}
}
}
}
}
static void low_set_pbc(t_pbc *pbc, int ePBC, ivec *dd_nc, matrix box)
{
int order[5] = {0, -1, 1, -2, 2};
int ii, jj, kk, i, j, k, d, dd, jc, kc, npbcdim, shift;
ivec bPBC;
real d2old, d2new, d2new_c;
rvec trial, pos;
gmx_bool bXY, bUse;
const char *ptr;
pbc->ndim_ePBC = ePBC2npbcdim(ePBC);
copy_mat(box, pbc->box);
pbc->bLimitDistance = FALSE;
pbc->max_cutoff2 = 0;
pbc->dim = -1;
for (i = 0; (i < DIM); i++)
{
pbc->fbox_diag[i] = box[i][i];
pbc->hbox_diag[i] = pbc->fbox_diag[i]*0.5;
pbc->mhbox_diag[i] = -pbc->hbox_diag[i];
}
ptr = check_box(ePBC, box);
if (ePBC == epbcNONE)
{
pbc->ePBCDX = epbcdxNOPBC;
}
else if (ptr)
{
fprintf(stderr, "Warning: %s\n", ptr);
pr_rvecs(stderr, 0, " Box", box, DIM);
fprintf(stderr, " Can not fix pbc.\n");
pbc->ePBCDX = epbcdxUNSUPPORTED;
pbc->bLimitDistance = TRUE;
pbc->limit_distance2 = 0;
}
else
{
if (ePBC == epbcSCREW && dd_nc)
{
/* This combinated should never appear here */
gmx_incons("low_set_pbc called with screw pbc and dd_nc != NULL");
}
npbcdim = 0;
for (i = 0; i < DIM; i++)
{
if ((dd_nc && (*dd_nc)[i] > 1) || (ePBC == epbcXY && i == ZZ))
{
bPBC[i] = 0;
}
else
{
bPBC[i] = 1;
npbcdim++;
}
}
switch (npbcdim)
{
case 1:
/* 1D pbc is not an mdp option and it is therefore only used
* with single shifts.
*/
pbc->ePBCDX = epbcdx1D_RECT;
for (i = 0; i < DIM; i++)
{
if (bPBC[i])
{
pbc->dim = i;
}
}
for (i = 0; i < pbc->dim; i++)
{
if (pbc->box[pbc->dim][i] != 0)
{
pbc->ePBCDX = epbcdx1D_TRIC;
}
}
break;
case 2:
pbc->ePBCDX = epbcdx2D_RECT;
for (i = 0; i < DIM; i++)
{
if (!bPBC[i])
{
pbc->dim = i;
}
}
for (i = 0; i < DIM; i++)
{
if (bPBC[i])
{
for (j = 0; j < i; j++)
{
if (pbc->box[i][j] != 0)
{
pbc->ePBCDX = epbcdx2D_TRIC;
}
}
}
}
break;
case 3:
if (ePBC != epbcSCREW)
{
if (TRICLINIC(box))
{
pbc->ePBCDX = epbcdxTRICLINIC;
}
else
{
pbc->ePBCDX = epbcdxRECTANGULAR;
}
}
else
{
pbc->ePBCDX = (box[ZZ][YY] == 0 ? epbcdxSCREW_RECT : epbcdxSCREW_TRIC);
if (pbc->ePBCDX == epbcdxSCREW_TRIC)
{
fprintf(stderr,
"Screw pbc is not yet implemented for triclinic boxes.\n"
"Can not fix pbc.\n");
pbc->ePBCDX = epbcdxUNSUPPORTED;
}
}
break;
default:
gmx_fatal(FARGS, "Incorrect number of pbc dimensions with DD: %d",
npbcdim);
}
pbc->max_cutoff2 = max_cutoff2(ePBC, box);
if (pbc->ePBCDX == epbcdxTRICLINIC ||
pbc->ePBCDX == epbcdx2D_TRIC ||
pbc->ePBCDX == epbcdxSCREW_TRIC)
{
if (debug)
{
pr_rvecs(debug, 0, "Box", box, DIM);
fprintf(debug, "max cutoff %.3f\n", sqrt(pbc->max_cutoff2));
}
pbc->ntric_vec = 0;
/* We will only use single shifts, but we will check a few
* more shifts to see if there is a limiting distance
* above which we can not be sure of the correct distance.
*/
for (kk = 0; kk < 5; kk++)
{
k = order[kk];
if (!bPBC[ZZ] && k != 0)
{
continue;
}
for (jj = 0; jj < 5; jj++)
{
j = order[jj];
if (!bPBC[YY] && j != 0)
{
continue;
}
for (ii = 0; ii < 3; ii++)
{
i = order[ii];
if (!bPBC[XX] && i != 0)
{
continue;
}
/* A shift is only useful when it is trilinic */
if (j != 0 || k != 0)
{
d2old = 0;
d2new = 0;
for (d = 0; d < DIM; d++)
{
trial[d] = i*box[XX][d] + j*box[YY][d] + k*box[ZZ][d];
/* Choose the vector within the brick around 0,0,0 that
* will become the shortest due to shift try.
*/
if (d == pbc->dim)
{
trial[d] = 0;
pos[d] = 0;
}
else
{
if (trial[d] < 0)
{
pos[d] = min( pbc->hbox_diag[d], -trial[d]);
}
else
{
pos[d] = max(-pbc->hbox_diag[d], -trial[d]);
}
}
d2old += sqr(pos[d]);
d2new += sqr(pos[d] + trial[d]);
}
if (BOX_MARGIN*d2new < d2old)
{
if (j < -1 || j > 1 || k < -1 || k > 1)
{
/* Check if there is a single shift vector
* that decreases this distance even more.
*/
jc = 0;
kc = 0;
if (j < -1 || j > 1)
{
jc = j/2;
}
if (k < -1 || k > 1)
{
kc = k/2;
}
d2new_c = 0;
for (d = 0; d < DIM; d++)
{
d2new_c += sqr(pos[d] + trial[d]
- jc*box[YY][d] - kc*box[ZZ][d]);
}
if (d2new_c > BOX_MARGIN*d2new)
{
/* Reject this shift vector, as there is no a priori limit
* to the number of shifts that decrease distances.
*/
if (!pbc->bLimitDistance || d2new < pbc->limit_distance2)
{
pbc->limit_distance2 = d2new;
}
pbc->bLimitDistance = TRUE;
}
}
else
{
/* Check if shifts with one box vector less do better */
bUse = TRUE;
for (dd = 0; dd < DIM; dd++)
{
shift = (dd == 0 ? i : (dd == 1 ? j : k));
if (shift)
{
d2new_c = 0;
for (d = 0; d < DIM; d++)
{
d2new_c += sqr(pos[d] + trial[d] - shift*box[dd][d]);
}
if (d2new_c <= BOX_MARGIN*d2new)
{
bUse = FALSE;
}
}
}
if (bUse)
{
/* Accept this shift vector. */
if (pbc->ntric_vec >= MAX_NTRICVEC)
{
fprintf(stderr, "\nWARNING: Found more than %d triclinic correction vectors, ignoring some.\n"
" There is probably something wrong with your box.\n", MAX_NTRICVEC);
pr_rvecs(stderr, 0, " Box", box, DIM);
}
else
{
copy_rvec(trial, pbc->tric_vec[pbc->ntric_vec]);
pbc->tric_shift[pbc->ntric_vec][XX] = i;
pbc->tric_shift[pbc->ntric_vec][YY] = j;
pbc->tric_shift[pbc->ntric_vec][ZZ] = k;
pbc->ntric_vec++;
}
}
}
if (debug)
{
fprintf(debug, " tricvec %2d = %2d %2d %2d %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f\n",
pbc->ntric_vec, i, j, k,
sqrt(d2old), sqrt(d2new),
trial[XX], trial[YY], trial[ZZ],
pos[XX], pos[YY], pos[ZZ]);
}
}
}
}
}
}
}
}
}
//! Do the real arithmetic for filling the pbc struct
static void low_set_pbc(t_pbc *pbc, int ePBC,
const ivec dd_pbc, const matrix box)
{
int order[3] = { 0, -1, 1 };
ivec bPBC;
const char *ptr;
pbc->ePBC = ePBC;
pbc->ndim_ePBC = ePBC2npbcdim(ePBC);
copy_mat(box, pbc->box);
pbc->max_cutoff2 = 0;
pbc->dim = -1;
pbc->ntric_vec = 0;
for (int i = 0; (i < DIM); i++)
{
pbc->fbox_diag[i] = box[i][i];
pbc->hbox_diag[i] = pbc->fbox_diag[i]*0.5;
pbc->mhbox_diag[i] = -pbc->hbox_diag[i];
}
ptr = check_box(ePBC, box);
if (ePBC == epbcNONE)
{
pbc->ePBCDX = epbcdxNOPBC;
}
else if (ptr)
{
fprintf(stderr, "Warning: %s\n", ptr);
pr_rvecs(stderr, 0, " Box", box, DIM);
fprintf(stderr, " Can not fix pbc.\n\n");
pbc->ePBCDX = epbcdxUNSUPPORTED;
}
else
{
if (ePBC == epbcSCREW && NULL != dd_pbc)
{
/* This combinated should never appear here */
gmx_incons("low_set_pbc called with screw pbc and dd_nc != NULL");
}
int npbcdim = 0;
for (int i = 0; i < DIM; i++)
{
if ((dd_pbc && dd_pbc[i] == 0) || (ePBC == epbcXY && i == ZZ))
{
bPBC[i] = 0;
}
else
{
bPBC[i] = 1;
npbcdim++;
}
}
switch (npbcdim)
{
case 1:
/* 1D pbc is not an mdp option and it is therefore only used
* with single shifts.
*/
pbc->ePBCDX = epbcdx1D_RECT;
for (int i = 0; i < DIM; i++)
{
if (bPBC[i])
{
pbc->dim = i;
}
}
GMX_ASSERT(pbc->dim < DIM, "Dimension for PBC incorrect");
for (int i = 0; i < pbc->dim; i++)
{
if (pbc->box[pbc->dim][i] != 0)
{
pbc->ePBCDX = epbcdx1D_TRIC;
}
}
break;
case 2:
pbc->ePBCDX = epbcdx2D_RECT;
for (int i = 0; i < DIM; i++)
{
if (!bPBC[i])
{
pbc->dim = i;
}
}
for (int i = 0; i < DIM; i++)
{
if (bPBC[i])
{
for (int j = 0; j < i; j++)
{
if (pbc->box[i][j] != 0)
{
pbc->ePBCDX = epbcdx2D_TRIC;
}
}
}
}
break;
case 3:
if (ePBC != epbcSCREW)
{
if (TRICLINIC(box))
{
pbc->ePBCDX = epbcdxTRICLINIC;
}
else
{
pbc->ePBCDX = epbcdxRECTANGULAR;
}
}
else
{
pbc->ePBCDX = (box[ZZ][YY] == 0 ? epbcdxSCREW_RECT : epbcdxSCREW_TRIC);
if (pbc->ePBCDX == epbcdxSCREW_TRIC)
{
fprintf(stderr,
"Screw pbc is not yet implemented for triclinic boxes.\n"
"Can not fix pbc.\n");
pbc->ePBCDX = epbcdxUNSUPPORTED;
}
}
break;
default:
gmx_fatal(FARGS, "Incorrect number of pbc dimensions with DD: %d",
npbcdim);
}
pbc->max_cutoff2 = max_cutoff2(ePBC, box);
if (pbc->ePBCDX == epbcdxTRICLINIC ||
pbc->ePBCDX == epbcdx2D_TRIC ||
pbc->ePBCDX == epbcdxSCREW_TRIC)
{
if (debug)
{
pr_rvecs(debug, 0, "Box", box, DIM);
fprintf(debug, "max cutoff %.3f\n", sqrt(pbc->max_cutoff2));
}
/* We will only need single shifts here */
for (int kk = 0; kk < 3; kk++)
{
int k = order[kk];
if (!bPBC[ZZ] && k != 0)
{
continue;
}
for (int jj = 0; jj < 3; jj++)
{
int j = order[jj];
if (!bPBC[YY] && j != 0)
{
continue;
}
for (int ii = 0; ii < 3; ii++)
{
int i = order[ii];
if (!bPBC[XX] && i != 0)
{
continue;
}
/* A shift is only useful when it is trilinic */
if (j != 0 || k != 0)
{
rvec trial;
rvec pos;
real d2old = 0;
real d2new = 0;
for (int d = 0; d < DIM; d++)
{
trial[d] = i*box[XX][d] + j*box[YY][d] + k*box[ZZ][d];
/* Choose the vector within the brick around 0,0,0 that
* will become the shortest due to shift try.
*/
if (d == pbc->dim)
{
trial[d] = 0;
pos[d] = 0;
}
else
{
if (trial[d] < 0)
{
pos[d] = std::min( pbc->hbox_diag[d], -trial[d]);
}
else
{
pos[d] = std::max(-pbc->hbox_diag[d], -trial[d]);
}
}
d2old += gmx::square(pos[d]);
d2new += gmx::square(pos[d] + trial[d]);
}
if (BOX_MARGIN*d2new < d2old)
{
/* Check if shifts with one box vector less do better */
gmx_bool bUse = TRUE;
for (int dd = 0; dd < DIM; dd++)
{
int shift = (dd == 0 ? i : (dd == 1 ? j : k));
if (shift)
{
real d2new_c = 0;
for (int d = 0; d < DIM; d++)
{
d2new_c += gmx::square(pos[d] + trial[d] - shift*box[dd][d]);
}
if (d2new_c <= BOX_MARGIN*d2new)
{
bUse = FALSE;
}
}
}
if (bUse)
{
/* Accept this shift vector. */
if (pbc->ntric_vec >= MAX_NTRICVEC)
{
fprintf(stderr, "\nWARNING: Found more than %d triclinic correction vectors, ignoring some.\n"
" There is probably something wrong with your box.\n", MAX_NTRICVEC);
pr_rvecs(stderr, 0, " Box", box, DIM);
}
else
{
copy_rvec(trial, pbc->tric_vec[pbc->ntric_vec]);
pbc->tric_shift[pbc->ntric_vec][XX] = i;
pbc->tric_shift[pbc->ntric_vec][YY] = j;
pbc->tric_shift[pbc->ntric_vec][ZZ] = k;
pbc->ntric_vec++;
if (debug)
{
fprintf(debug, " tricvec %2d = %2d %2d %2d %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f\n",
pbc->ntric_vec, i, j, k,
sqrt(d2old), sqrt(d2new),
trial[XX], trial[YY], trial[ZZ],
pos[XX], pos[YY], pos[ZZ]);
}
}
}
}
}
}
}
}
}
}
}
void read_stx_conf(const char *infile, char *title, t_atoms *atoms,
rvec x[], rvec *v, int *ePBC, matrix box)
{
FILE *in;
char buf[256];
gmx_mtop_t *mtop;
t_topology top;
t_trxframe fr;
int i, ftp, natoms;
real d;
char g96_line[STRLEN+1];
if (atoms->nr == 0)
{
fprintf(stderr, "Warning: Number of atoms in %s is 0\n", infile);
}
else if (atoms->atom == NULL)
{
gmx_mem("Uninitialized array atom");
}
if (ePBC)
{
*ePBC = -1;
}
ftp = fn2ftp(infile);
switch (ftp)
{
case efGRO:
read_whole_conf(infile, title, atoms, x, v, box);
break;
case efG96:
fr.title = NULL;
fr.natoms = atoms->nr;
fr.atoms = atoms;
fr.x = x;
fr.v = v;
fr.f = NULL;
in = gmx_fio_fopen(infile, "r");
read_g96_conf(in, infile, &fr, g96_line);
gmx_fio_fclose(in);
copy_mat(fr.box, box);
strncpy(title, fr.title, STRLEN);
break;
case efPDB:
case efBRK:
case efENT:
read_pdb_conf(infile, title, atoms, x, ePBC, box, TRUE, NULL);
break;
case efESP:
read_espresso_conf(infile, atoms, x, v, box);
break;
case efTPR:
case efTPB:
case efTPA:
snew(mtop, 1);
i = read_tpx(infile, NULL, box, &natoms, x, v, NULL, mtop);
if (ePBC)
{
*ePBC = i;
}
strcpy(title, *(mtop->name));
/* Free possibly allocated memory */
done_atom(atoms);
*atoms = gmx_mtop_global_atoms(mtop);
top = gmx_mtop_t_to_t_topology(mtop);
tpx_make_chain_identifiers(atoms, &top.mols);
sfree(mtop);
/* The strings in the symtab are still in use in the returned t_atoms
* structure, so we should not free them. But there is no place to put the
* symbols; the only choice is to leak the memory...
* So we clear the symbol table before freeing the topology structure. */
free_symtab(&top.symtab);
done_top(&top);
break;
default:
gmx_incons("Not supported in read_stx_conf");
}
}
void read_stx_conf(char *infile, char *title,t_atoms *atoms,
rvec x[],rvec *v,int *ePBC,matrix box)
{
FILE *in;
char buf[256];
gmx_mtop_t *mtop;
t_topology top;
t_trxframe fr;
int i,ftp,natoms,i1;
real d,r1,r2;
if (atoms->nr == 0)
fprintf(stderr,"Warning: Number of atoms in %s is 0\n",infile);
else if (atoms->atom == NULL)
gmx_mem("Uninitialized array atom");
if (ePBC)
*ePBC = -1;
ftp=fn2ftp(infile);
switch (ftp) {
case efGRO:
read_whole_conf(infile, title, atoms, x, v, box);
break;
case efG96:
fr.title = title;
fr.natoms = atoms->nr;
fr.atoms = atoms;
fr.x = x;
fr.v = v;
fr.f = NULL;
in = gmx_fio_fopen(infile,"r");
read_g96_conf(in, infile, &fr);
gmx_fio_fclose(in);
copy_mat(fr.box,box);
break;
case efPDB:
case efBRK:
case efENT:
read_pdb_conf(infile, title, atoms, x, ePBC, box, TRUE, NULL);
break;
case efESP:
read_espresso_conf(infile,atoms,x,v,box);
break;
case efTPR:
case efTPB:
case efTPA:
snew(mtop,1);
i = read_tpx(infile,&i1,&r1,&r2,NULL,box,&natoms,x,v,NULL,mtop);
if (ePBC)
*ePBC = i;
strcpy(title,*(mtop->name));
/* Free possibly allocated memory */
done_atom(atoms);
*atoms = gmx_mtop_global_atoms(mtop);
top = gmx_mtop_t_to_t_topology(mtop);
tpx_make_chain_identifiers(atoms,&top.mols);
sfree(mtop);
done_top(&top);
break;
default:
gmx_incons("Not supported in read_stx_conf");
}
}
int mdrunner(gmx_hw_opt_t *hw_opt,
FILE *fplog, t_commrec *cr, int nfile,
const t_filenm fnm[], const output_env_t oenv, gmx_bool bVerbose,
gmx_bool bCompact, int nstglobalcomm,
ivec ddxyz, int dd_node_order, real rdd, real rconstr,
const char *dddlb_opt, real dlb_scale,
const char *ddcsx, const char *ddcsy, const char *ddcsz,
const char *nbpu_opt, int nstlist_cmdline,
gmx_int64_t nsteps_cmdline, int nstepout, int resetstep,
int gmx_unused nmultisim, int repl_ex_nst, int repl_ex_nex,
int repl_ex_seed, real pforce, real cpt_period, real max_hours,
int imdport, unsigned long Flags)
{
gmx_bool bForceUseGPU, bTryUseGPU, bRerunMD;
t_inputrec *inputrec;
t_state *state = NULL;
matrix box;
gmx_ddbox_t ddbox = {0};
int npme_major, npme_minor;
t_nrnb *nrnb;
gmx_mtop_t *mtop = NULL;
t_mdatoms *mdatoms = NULL;
t_forcerec *fr = NULL;
t_fcdata *fcd = NULL;
real ewaldcoeff_q = 0;
real ewaldcoeff_lj = 0;
struct gmx_pme_t **pmedata = NULL;
gmx_vsite_t *vsite = NULL;
gmx_constr_t constr;
int nChargePerturbed = -1, nTypePerturbed = 0, status;
gmx_wallcycle_t wcycle;
gmx_bool bReadEkin;
gmx_walltime_accounting_t walltime_accounting = NULL;
int rc;
gmx_int64_t reset_counters;
gmx_edsam_t ed = NULL;
int nthreads_pme = 1;
int nthreads_pp = 1;
gmx_membed_t membed = NULL;
gmx_hw_info_t *hwinfo = NULL;
/* The master rank decides early on bUseGPU and broadcasts this later */
gmx_bool bUseGPU = FALSE;
/* CAUTION: threads may be started later on in this function, so
cr doesn't reflect the final parallel state right now */
snew(inputrec, 1);
snew(mtop, 1);
if (Flags & MD_APPENDFILES)
{
fplog = NULL;
}
bRerunMD = (Flags & MD_RERUN);
bForceUseGPU = (strncmp(nbpu_opt, "gpu", 3) == 0);
bTryUseGPU = (strncmp(nbpu_opt, "auto", 4) == 0) || bForceUseGPU;
/* Detect hardware, gather information. This is an operation that is
* global for this process (MPI rank). */
hwinfo = gmx_detect_hardware(fplog, cr, bTryUseGPU);
gmx_print_detected_hardware(fplog, cr, hwinfo);
if (fplog != NULL)
{
/* Print references after all software/hardware printing */
please_cite(fplog, "Abraham2015");
please_cite(fplog, "Pall2015");
please_cite(fplog, "Pronk2013");
please_cite(fplog, "Hess2008b");
please_cite(fplog, "Spoel2005a");
please_cite(fplog, "Lindahl2001a");
please_cite(fplog, "Berendsen95a");
}
snew(state, 1);
if (SIMMASTER(cr))
{
/* Read (nearly) all data required for the simulation */
read_tpx_state(ftp2fn(efTPR, nfile, fnm), inputrec, state, NULL, mtop);
if (inputrec->cutoff_scheme == ecutsVERLET)
{
/* Here the master rank decides if all ranks will use GPUs */
bUseGPU = (hwinfo->gpu_info.n_dev_compatible > 0 ||
getenv("GMX_EMULATE_GPU") != NULL);
/* TODO add GPU kernels for this and replace this check by:
* (bUseGPU && (ir->vdwtype == evdwPME &&
* ir->ljpme_combination_rule == eljpmeLB))
* update the message text and the content of nbnxn_acceleration_supported.
*/
if (bUseGPU &&
!nbnxn_gpu_acceleration_supported(fplog, cr, inputrec, bRerunMD))
{
/* Fallback message printed by nbnxn_acceleration_supported */
if (bForceUseGPU)
{
gmx_fatal(FARGS, "GPU acceleration requested, but not supported with the given input settings");
}
bUseGPU = FALSE;
}
prepare_verlet_scheme(fplog, cr,
inputrec, nstlist_cmdline, mtop, state->box,
bUseGPU);
}
else
{
if (nstlist_cmdline > 0)
{
gmx_fatal(FARGS, "Can not set nstlist with the group cut-off scheme");
}
if (hwinfo->gpu_info.n_dev_compatible > 0)
{
md_print_warn(cr, fplog,
"NOTE: GPU(s) found, but the current simulation can not use GPUs\n"
" To use a GPU, set the mdp option: cutoff-scheme = Verlet\n");
}
if (bForceUseGPU)
{
gmx_fatal(FARGS, "GPU requested, but can't be used without cutoff-scheme=Verlet");
}
#ifdef GMX_TARGET_BGQ
md_print_warn(cr, fplog,
"NOTE: There is no SIMD implementation of the group scheme kernels on\n"
" BlueGene/Q. You will observe better performance from using the\n"
" Verlet cut-off scheme.\n");
#endif
}
if (inputrec->eI == eiSD2)
{
md_print_warn(cr, fplog, "The stochastic dynamics integrator %s is deprecated, since\n"
"it is slower than integrator %s and is slightly less accurate\n"
"with constraints. Use the %s integrator.",
ei_names[inputrec->eI], ei_names[eiSD1], ei_names[eiSD1]);
}
}
/* Check and update the hardware options for internal consistency */
check_and_update_hw_opt_1(hw_opt, cr);
/* Early check for externally set process affinity. */
gmx_check_thread_affinity_set(fplog, cr,
hw_opt, hwinfo->nthreads_hw_avail, FALSE);
#ifdef GMX_THREAD_MPI
if (SIMMASTER(cr))
{
if (cr->npmenodes > 0 && hw_opt->nthreads_tmpi <= 0)
{
gmx_fatal(FARGS, "You need to explicitly specify the number of MPI threads (-ntmpi) when using separate PME ranks");
}
/* Since the master knows the cut-off scheme, update hw_opt for this.
* This is done later for normal MPI and also once more with tMPI
* for all tMPI ranks.
*/
check_and_update_hw_opt_2(hw_opt, inputrec->cutoff_scheme);
/* NOW the threads will be started: */
hw_opt->nthreads_tmpi = get_nthreads_mpi(hwinfo,
hw_opt,
inputrec, mtop,
cr, fplog, bUseGPU);
if (hw_opt->nthreads_tmpi > 1)
{
t_commrec *cr_old = cr;
/* now start the threads. */
cr = mdrunner_start_threads(hw_opt, fplog, cr_old, nfile, fnm,
oenv, bVerbose, bCompact, nstglobalcomm,
ddxyz, dd_node_order, rdd, rconstr,
dddlb_opt, dlb_scale, ddcsx, ddcsy, ddcsz,
nbpu_opt, nstlist_cmdline,
nsteps_cmdline, nstepout, resetstep, nmultisim,
repl_ex_nst, repl_ex_nex, repl_ex_seed, pforce,
cpt_period, max_hours,
Flags);
/* the main thread continues here with a new cr. We don't deallocate
the old cr because other threads may still be reading it. */
if (cr == NULL)
{
gmx_comm("Failed to spawn threads");
}
}
}
#endif
/* END OF CAUTION: cr is now reliable */
/* g_membed initialisation *
* Because we change the mtop, init_membed is called before the init_parallel *
* (in case we ever want to make it run in parallel) */
if (opt2bSet("-membed", nfile, fnm))
{
if (MASTER(cr))
{
fprintf(stderr, "Initializing membed");
}
membed = init_membed(fplog, nfile, fnm, mtop, inputrec, state, cr, &cpt_period);
}
if (PAR(cr))
{
/* now broadcast everything to the non-master nodes/threads: */
init_parallel(cr, inputrec, mtop);
/* The master rank decided on the use of GPUs,
* broadcast this information to all ranks.
*/
gmx_bcast_sim(sizeof(bUseGPU), &bUseGPU, cr);
}
if (fplog != NULL)
{
pr_inputrec(fplog, 0, "Input Parameters", inputrec, FALSE);
fprintf(fplog, "\n");
}
/* now make sure the state is initialized and propagated */
set_state_entries(state, inputrec);
/* A parallel command line option consistency check that we can
only do after any threads have started. */
if (!PAR(cr) &&
(ddxyz[XX] > 1 || ddxyz[YY] > 1 || ddxyz[ZZ] > 1 || cr->npmenodes > 0))
{
gmx_fatal(FARGS,
"The -dd or -npme option request a parallel simulation, "
#ifndef GMX_MPI
"but %s was compiled without threads or MPI enabled"
#else
#ifdef GMX_THREAD_MPI
"but the number of threads (option -nt) is 1"
#else
"but %s was not started through mpirun/mpiexec or only one rank was requested through mpirun/mpiexec"
#endif
#endif
, output_env_get_program_display_name(oenv)
);
}
if (bRerunMD &&
(EI_ENERGY_MINIMIZATION(inputrec->eI) || eiNM == inputrec->eI))
{
gmx_fatal(FARGS, "The .mdp file specified an energy mininization or normal mode algorithm, and these are not compatible with mdrun -rerun");
}
if (can_use_allvsall(inputrec, TRUE, cr, fplog) && DOMAINDECOMP(cr))
{
gmx_fatal(FARGS, "All-vs-all loops do not work with domain decomposition, use a single MPI rank");
}
if (!(EEL_PME(inputrec->coulombtype) || EVDW_PME(inputrec->vdwtype)))
{
if (cr->npmenodes > 0)
{
gmx_fatal_collective(FARGS, cr, NULL,
"PME-only ranks are requested, but the system does not use PME for electrostatics or LJ");
}
cr->npmenodes = 0;
}
if (bUseGPU && cr->npmenodes < 0)
{
/* With GPUs we don't automatically use PME-only ranks. PME ranks can
* improve performance with many threads per GPU, since our OpenMP
* scaling is bad, but it's difficult to automate the setup.
*/
cr->npmenodes = 0;
}
#ifdef GMX_FAHCORE
if (MASTER(cr))
{
fcRegisterSteps(inputrec->nsteps, inputrec->init_step);
}
#endif
/* NMR restraints must be initialized before load_checkpoint,
* since with time averaging the history is added to t_state.
* For proper consistency check we therefore need to extend
* t_state here.
* So the PME-only nodes (if present) will also initialize
* the distance restraints.
*/
snew(fcd, 1);
/* This needs to be called before read_checkpoint to extend the state */
init_disres(fplog, mtop, inputrec, cr, fcd, state, repl_ex_nst > 0);
init_orires(fplog, mtop, state->x, inputrec, cr, &(fcd->orires),
state);
if (DEFORM(*inputrec))
{
/* Store the deform reference box before reading the checkpoint */
if (SIMMASTER(cr))
{
copy_mat(state->box, box);
}
if (PAR(cr))
{
gmx_bcast(sizeof(box), box, cr);
}
/* Because we do not have the update struct available yet
* in which the reference values should be stored,
* we store them temporarily in static variables.
* This should be thread safe, since they are only written once
* and with identical values.
*/
tMPI_Thread_mutex_lock(&deform_init_box_mutex);
deform_init_init_step_tpx = inputrec->init_step;
copy_mat(box, deform_init_box_tpx);
tMPI_Thread_mutex_unlock(&deform_init_box_mutex);
}
if (opt2bSet("-cpi", nfile, fnm))
{
/* Check if checkpoint file exists before doing continuation.
* This way we can use identical input options for the first and subsequent runs...
*/
if (gmx_fexist_master(opt2fn_master("-cpi", nfile, fnm, cr), cr) )
{
load_checkpoint(opt2fn_master("-cpi", nfile, fnm, cr), &fplog,
cr, ddxyz,
inputrec, state, &bReadEkin,
(Flags & MD_APPENDFILES),
(Flags & MD_APPENDFILESSET));
if (bReadEkin)
{
Flags |= MD_READ_EKIN;
}
}
}
if (MASTER(cr) && (Flags & MD_APPENDFILES))
{
gmx_log_open(ftp2fn(efLOG, nfile, fnm), cr,
Flags, &fplog);
}
/* override nsteps with value from cmdline */
override_nsteps_cmdline(fplog, nsteps_cmdline, inputrec, cr);
if (SIMMASTER(cr))
{
copy_mat(state->box, box);
}
if (PAR(cr))
{
gmx_bcast(sizeof(box), box, cr);
}
/* Essential dynamics */
if (opt2bSet("-ei", nfile, fnm))
{
/* Open input and output files, allocate space for ED data structure */
ed = ed_open(mtop->natoms, &state->edsamstate, nfile, fnm, Flags, oenv, cr);
}
if (PAR(cr) && !(EI_TPI(inputrec->eI) ||
inputrec->eI == eiNM))
{
cr->dd = init_domain_decomposition(fplog, cr, Flags, ddxyz, rdd, rconstr,
dddlb_opt, dlb_scale,
ddcsx, ddcsy, ddcsz,
mtop, inputrec,
box, state->x,
&ddbox, &npme_major, &npme_minor);
make_dd_communicators(fplog, cr, dd_node_order);
/* Set overallocation to avoid frequent reallocation of arrays */
set_over_alloc_dd(TRUE);
}
else
{
/* PME, if used, is done on all nodes with 1D decomposition */
cr->npmenodes = 0;
cr->duty = (DUTY_PP | DUTY_PME);
npme_major = 1;
npme_minor = 1;
if (inputrec->ePBC == epbcSCREW)
{
gmx_fatal(FARGS,
"pbc=%s is only implemented with domain decomposition",
epbc_names[inputrec->ePBC]);
}
}
if (PAR(cr))
{
/* After possible communicator splitting in make_dd_communicators.
* we can set up the intra/inter node communication.
*/
gmx_setup_nodecomm(fplog, cr);
}
/* Initialize per-physical-node MPI process/thread ID and counters. */
gmx_init_intranode_counters(cr);
#ifdef GMX_MPI
if (MULTISIM(cr))
{
md_print_info(cr, fplog,
"This is simulation %d out of %d running as a composite GROMACS\n"
"multi-simulation job. Setup for this simulation:\n\n",
cr->ms->sim, cr->ms->nsim);
}
md_print_info(cr, fplog, "Using %d MPI %s\n",
cr->nnodes,
#ifdef GMX_THREAD_MPI
cr->nnodes == 1 ? "thread" : "threads"
#else
cr->nnodes == 1 ? "process" : "processes"
#endif
);
fflush(stderr);
#endif
/* Check and update hw_opt for the cut-off scheme */
check_and_update_hw_opt_2(hw_opt, inputrec->cutoff_scheme);
/* Check and update hw_opt for the number of MPI ranks */
check_and_update_hw_opt_3(hw_opt);
gmx_omp_nthreads_init(fplog, cr,
hwinfo->nthreads_hw_avail,
hw_opt->nthreads_omp,
hw_opt->nthreads_omp_pme,
(cr->duty & DUTY_PP) == 0,
inputrec->cutoff_scheme == ecutsVERLET);
#ifndef NDEBUG
if (integrator[inputrec->eI].func != do_tpi &&
inputrec->cutoff_scheme == ecutsVERLET)
{
gmx_feenableexcept();
}
#endif
if (bUseGPU)
{
/* Select GPU id's to use */
gmx_select_gpu_ids(fplog, cr, &hwinfo->gpu_info, bForceUseGPU,
&hw_opt->gpu_opt);
}
else
{
/* Ignore (potentially) manually selected GPUs */
hw_opt->gpu_opt.n_dev_use = 0;
}
/* check consistency across ranks of things like SIMD
* support and number of GPUs selected */
gmx_check_hw_runconf_consistency(fplog, hwinfo, cr, hw_opt, bUseGPU);
/* Now that we know the setup is consistent, check for efficiency */
check_resource_division_efficiency(hwinfo, hw_opt, Flags & MD_NTOMPSET,
cr, fplog);
if (DOMAINDECOMP(cr))
{
/* When we share GPUs over ranks, we need to know this for the DLB */
dd_setup_dlb_resource_sharing(cr, hwinfo, hw_opt);
}
/* getting number of PP/PME threads
PME: env variable should be read only on one node to make sure it is
identical everywhere;
*/
/* TODO nthreads_pp is only used for pinning threads.
* This is a temporary solution until we have a hw topology library.
*/
nthreads_pp = gmx_omp_nthreads_get(emntNonbonded);
nthreads_pme = gmx_omp_nthreads_get(emntPME);
wcycle = wallcycle_init(fplog, resetstep, cr, nthreads_pp, nthreads_pme);
if (PAR(cr))
{
/* Master synchronizes its value of reset_counters with all nodes
* including PME only nodes */
reset_counters = wcycle_get_reset_counters(wcycle);
gmx_bcast_sim(sizeof(reset_counters), &reset_counters, cr);
wcycle_set_reset_counters(wcycle, reset_counters);
}
snew(nrnb, 1);
if (cr->duty & DUTY_PP)
{
bcast_state(cr, state);
/* Initiate forcerecord */
fr = mk_forcerec();
fr->hwinfo = hwinfo;
fr->gpu_opt = &hw_opt->gpu_opt;
init_forcerec(fplog, oenv, fr, fcd, inputrec, mtop, cr, box,
opt2fn("-table", nfile, fnm),
opt2fn("-tabletf", nfile, fnm),
opt2fn("-tablep", nfile, fnm),
opt2fn("-tableb", nfile, fnm),
nbpu_opt,
FALSE,
pforce);
/* version for PCA_NOT_READ_NODE (see md.c) */
/*init_forcerec(fplog,fr,fcd,inputrec,mtop,cr,box,FALSE,
"nofile","nofile","nofile","nofile",FALSE,pforce);
*/
/* Initialize QM-MM */
if (fr->bQMMM)
{
init_QMMMrec(cr, mtop, inputrec, fr);
}
/* Initialize the mdatoms structure.
* mdatoms is not filled with atom data,
* as this can not be done now with domain decomposition.
*/
mdatoms = init_mdatoms(fplog, mtop, inputrec->efep != efepNO);
/* Initialize the virtual site communication */
vsite = init_vsite(mtop, cr, FALSE);
calc_shifts(box, fr->shift_vec);
/* With periodic molecules the charge groups should be whole at start up
* and the virtual sites should not be far from their proper positions.
*/
if (!inputrec->bContinuation && MASTER(cr) &&
!(inputrec->ePBC != epbcNONE && inputrec->bPeriodicMols))
{
/* Make molecules whole at start of run */
if (fr->ePBC != epbcNONE)
{
do_pbc_first_mtop(fplog, inputrec->ePBC, box, mtop, state->x);
}
if (vsite)
{
/* Correct initial vsite positions are required
* for the initial distribution in the domain decomposition
* and for the initial shell prediction.
*/
construct_vsites_mtop(vsite, mtop, state->x);
}
}
if (EEL_PME(fr->eeltype) || EVDW_PME(fr->vdwtype))
{
ewaldcoeff_q = fr->ewaldcoeff_q;
ewaldcoeff_lj = fr->ewaldcoeff_lj;
pmedata = &fr->pmedata;
}
else
{
pmedata = NULL;
}
}
else
{
/* This is a PME only node */
/* We don't need the state */
done_state(state);
ewaldcoeff_q = calc_ewaldcoeff_q(inputrec->rcoulomb, inputrec->ewald_rtol);
ewaldcoeff_lj = calc_ewaldcoeff_lj(inputrec->rvdw, inputrec->ewald_rtol_lj);
snew(pmedata, 1);
}
if (hw_opt->thread_affinity != threadaffOFF)
{
/* Before setting affinity, check whether the affinity has changed
* - which indicates that probably the OpenMP library has changed it
* since we first checked).
*/
gmx_check_thread_affinity_set(fplog, cr,
hw_opt, hwinfo->nthreads_hw_avail, TRUE);
/* Set the CPU affinity */
gmx_set_thread_affinity(fplog, cr, hw_opt, hwinfo);
}
/* Initiate PME if necessary,
* either on all nodes or on dedicated PME nodes only. */
if (EEL_PME(inputrec->coulombtype) || EVDW_PME(inputrec->vdwtype))
{
if (mdatoms)
{
nChargePerturbed = mdatoms->nChargePerturbed;
if (EVDW_PME(inputrec->vdwtype))
{
nTypePerturbed = mdatoms->nTypePerturbed;
}
}
if (cr->npmenodes > 0)
{
/* The PME only nodes need to know nChargePerturbed(FEP on Q) and nTypePerturbed(FEP on LJ)*/
gmx_bcast_sim(sizeof(nChargePerturbed), &nChargePerturbed, cr);
gmx_bcast_sim(sizeof(nTypePerturbed), &nTypePerturbed, cr);
}
if (cr->duty & DUTY_PME)
{
status = gmx_pme_init(pmedata, cr, npme_major, npme_minor, inputrec,
mtop ? mtop->natoms : 0, nChargePerturbed, nTypePerturbed,
(Flags & MD_REPRODUCIBLE), nthreads_pme);
if (status != 0)
{
gmx_fatal(FARGS, "Error %d initializing PME", status);
}
}
}
if (integrator[inputrec->eI].func == do_md)
{
/* Turn on signal handling on all nodes */
/*
* (A user signal from the PME nodes (if any)
* is communicated to the PP nodes.
*/
signal_handler_install();
}
if (cr->duty & DUTY_PP)
{
/* Assumes uniform use of the number of OpenMP threads */
walltime_accounting = walltime_accounting_init(gmx_omp_nthreads_get(emntDefault));
if (inputrec->bPull)
{
/* Initialize pull code */
inputrec->pull_work =
init_pull(fplog, inputrec->pull, inputrec, nfile, fnm,
mtop, cr, oenv, inputrec->fepvals->init_lambda,
EI_DYNAMICS(inputrec->eI) && MASTER(cr), Flags);
}
if (inputrec->bRot)
{
/* Initialize enforced rotation code */
init_rot(fplog, inputrec, nfile, fnm, cr, state->x, box, mtop, oenv,
bVerbose, Flags);
}
if (inputrec->eSwapCoords != eswapNO)
{
/* Initialize ion swapping code */
init_swapcoords(fplog, bVerbose, inputrec, opt2fn_master("-swap", nfile, fnm, cr),
mtop, state->x, state->box, &state->swapstate, cr, oenv, Flags);
}
constr = init_constraints(fplog, mtop, inputrec, ed, state, cr);
if (DOMAINDECOMP(cr))
{
GMX_RELEASE_ASSERT(fr, "fr was NULL while cr->duty was DUTY_PP");
dd_init_bondeds(fplog, cr->dd, mtop, vsite, inputrec,
Flags & MD_DDBONDCHECK, fr->cginfo_mb);
set_dd_parameters(fplog, cr->dd, dlb_scale, inputrec, &ddbox);
setup_dd_grid(fplog, cr->dd);
}
/* Now do whatever the user wants us to do (how flexible...) */
integrator[inputrec->eI].func(fplog, cr, nfile, fnm,
oenv, bVerbose, bCompact,
nstglobalcomm,
vsite, constr,
nstepout, inputrec, mtop,
fcd, state,
mdatoms, nrnb, wcycle, ed, fr,
repl_ex_nst, repl_ex_nex, repl_ex_seed,
membed,
cpt_period, max_hours,
imdport,
Flags,
walltime_accounting);
if (inputrec->bPull)
{
finish_pull(inputrec->pull_work);
}
if (inputrec->bRot)
{
finish_rot(inputrec->rot);
}
}
else
{
GMX_RELEASE_ASSERT(pmedata, "pmedata was NULL while cr->duty was not DUTY_PP");
/* do PME only */
walltime_accounting = walltime_accounting_init(gmx_omp_nthreads_get(emntPME));
gmx_pmeonly(*pmedata, cr, nrnb, wcycle, walltime_accounting, ewaldcoeff_q, ewaldcoeff_lj, inputrec);
}
wallcycle_stop(wcycle, ewcRUN);
/* Finish up, write some stuff
* if rerunMD, don't write last frame again
*/
finish_run(fplog, cr,
inputrec, nrnb, wcycle, walltime_accounting,
fr ? fr->nbv : NULL,
EI_DYNAMICS(inputrec->eI) && !MULTISIM(cr));
/* Free GPU memory and context */
free_gpu_resources(fr, cr, &hwinfo->gpu_info, fr ? fr->gpu_opt : NULL);
if (opt2bSet("-membed", nfile, fnm))
{
sfree(membed);
}
gmx_hardware_info_free(hwinfo);
/* Does what it says */
print_date_and_time(fplog, cr->nodeid, "Finished mdrun", gmx_gettime());
walltime_accounting_destroy(walltime_accounting);
/* PLUMED */
if(plumedswitch){
plumed_finalize(plumedmain);
}
/* END PLUMED */
/* Close logfile already here if we were appending to it */
if (MASTER(cr) && (Flags & MD_APPENDFILES))
{
gmx_log_close(fplog);
}
rc = (int)gmx_get_stop_condition();
done_ed(&ed);
#ifdef GMX_THREAD_MPI
/* we need to join all threads. The sub-threads join when they
exit this function, but the master thread needs to be told to
wait for that. */
if (PAR(cr) && MASTER(cr))
{
tMPI_Finalize();
}
#endif
return rc;
}
/* Try to increase nstlist when using the Verlet cut-off scheme */
static void increase_nstlist(FILE *fp, t_commrec *cr,
t_inputrec *ir, int nstlist_cmdline,
const gmx_mtop_t *mtop, matrix box,
gmx_bool bGPU)
{
float listfac_ok, listfac_max;
int nstlist_orig, nstlist_prev;
verletbuf_list_setup_t ls;
real rlistWithReferenceNstlist, rlist_inc, rlist_ok, rlist_max;
real rlist_new, rlist_prev;
size_t nstlist_ind = 0;
t_state state_tmp;
gmx_bool bBox, bDD, bCont;
const char *nstl_gpu = "\nFor optimal performance with a GPU nstlist (now %d) should be larger.\nThe optimum depends on your CPU and GPU resources.\nYou might want to try several nstlist values.\n";
const char *nve_err = "Can not increase nstlist because an NVE ensemble is used";
const char *vbd_err = "Can not increase nstlist because verlet-buffer-tolerance is not set or used";
const char *box_err = "Can not increase nstlist because the box is too small";
const char *dd_err = "Can not increase nstlist because of domain decomposition limitations";
char buf[STRLEN];
const float oneThird = 1.0f / 3.0f;
if (nstlist_cmdline <= 0)
{
if (ir->nstlist == 1)
{
/* The user probably set nstlist=1 for a reason,
* don't mess with the settings.
*/
return;
}
if (fp != NULL && bGPU && ir->nstlist < nstlist_try[0])
{
fprintf(fp, nstl_gpu, ir->nstlist);
}
nstlist_ind = 0;
while (nstlist_ind < NNSTL && ir->nstlist >= nstlist_try[nstlist_ind])
{
nstlist_ind++;
}
if (nstlist_ind == NNSTL)
{
/* There are no larger nstlist value to try */
return;
}
}
if (EI_MD(ir->eI) && ir->etc == etcNO)
{
if (MASTER(cr))
{
fprintf(stderr, "%s\n", nve_err);
}
if (fp != NULL)
{
fprintf(fp, "%s\n", nve_err);
}
return;
}
if (ir->verletbuf_tol == 0 && bGPU)
{
gmx_fatal(FARGS, "You are using an old tpr file with a GPU, please generate a new tpr file with an up to date version of grompp");
}
if (ir->verletbuf_tol < 0)
{
if (MASTER(cr))
{
fprintf(stderr, "%s\n", vbd_err);
}
if (fp != NULL)
{
fprintf(fp, "%s\n", vbd_err);
}
return;
}
if (bGPU)
{
listfac_ok = nbnxn_gpu_listfac_ok;
listfac_max = nbnxn_gpu_listfac_max;
}
else
{
listfac_ok = nbnxn_cpu_listfac_ok;
listfac_max = nbnxn_cpu_listfac_max;
}
nstlist_orig = ir->nstlist;
if (nstlist_cmdline > 0)
{
if (fp)
{
sprintf(buf, "Getting nstlist=%d from command line option",
nstlist_cmdline);
}
ir->nstlist = nstlist_cmdline;
}
verletbuf_get_list_setup(TRUE, bGPU, &ls);
/* Allow rlist to make the list a given factor larger than the list
* would be with the reference value for nstlist (10).
*/
nstlist_prev = ir->nstlist;
ir->nstlist = nbnxnReferenceNstlist;
calc_verlet_buffer_size(mtop, det(box), ir, -1, &ls, NULL,
&rlistWithReferenceNstlist);
ir->nstlist = nstlist_prev;
/* Determine the pair list size increase due to zero interactions */
rlist_inc = nbnxn_get_rlist_effective_inc(ls.cluster_size_j,
mtop->natoms/det(box));
rlist_ok = (rlistWithReferenceNstlist + rlist_inc)*pow(listfac_ok, oneThird) - rlist_inc;
rlist_max = (rlistWithReferenceNstlist + rlist_inc)*pow(listfac_max, oneThird) - rlist_inc;
if (debug)
{
fprintf(debug, "nstlist tuning: rlist_inc %.3f rlist_ok %.3f rlist_max %.3f\n",
rlist_inc, rlist_ok, rlist_max);
}
nstlist_prev = nstlist_orig;
rlist_prev = ir->rlist;
do
{
if (nstlist_cmdline <= 0)
{
ir->nstlist = nstlist_try[nstlist_ind];
}
/* Set the pair-list buffer size in ir */
calc_verlet_buffer_size(mtop, det(box), ir, -1, &ls, NULL, &rlist_new);
/* Does rlist fit in the box? */
bBox = (sqr(rlist_new) < max_cutoff2(ir->ePBC, box));
bDD = TRUE;
if (bBox && DOMAINDECOMP(cr))
{
/* Check if rlist fits in the domain decomposition */
if (inputrec2nboundeddim(ir) < DIM)
{
gmx_incons("Changing nstlist with domain decomposition and unbounded dimensions is not implemented yet");
}
copy_mat(box, state_tmp.box);
bDD = change_dd_cutoff(cr, &state_tmp, ir, rlist_new);
}
if (debug)
{
fprintf(debug, "nstlist %d rlist %.3f bBox %d bDD %d\n",
ir->nstlist, rlist_new, bBox, bDD);
}
bCont = FALSE;
if (nstlist_cmdline <= 0)
{
if (bBox && bDD && rlist_new <= rlist_max)
{
/* Increase nstlist */
nstlist_prev = ir->nstlist;
rlist_prev = rlist_new;
bCont = (nstlist_ind+1 < NNSTL && rlist_new < rlist_ok);
}
else
{
/* Stick with the previous nstlist */
ir->nstlist = nstlist_prev;
rlist_new = rlist_prev;
bBox = TRUE;
bDD = TRUE;
}
}
nstlist_ind++;
}
while (bCont);
if (!bBox || !bDD)
{
gmx_warning(!bBox ? box_err : dd_err);
if (fp != NULL)
{
fprintf(fp, "\n%s\n", bBox ? box_err : dd_err);
}
ir->nstlist = nstlist_orig;
}
else if (ir->nstlist != nstlist_orig || rlist_new != ir->rlist)
{
sprintf(buf, "Changing nstlist from %d to %d, rlist from %g to %g",
nstlist_orig, ir->nstlist,
ir->rlist, rlist_new);
if (MASTER(cr))
{
fprintf(stderr, "%s\n\n", buf);
}
if (fp != NULL)
{
fprintf(fp, "%s\n\n", buf);
}
ir->rlist = rlist_new;
ir->rlistlong = rlist_new;
}
}
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, edt_1, 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;
gmx_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 rank, use fewer ranks");
}
bTAV = (od->edt != 0);
edt = od->edt;
edt_1 = od->edt_1;
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 = gmx_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] + edt_1*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 = std::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 void read_posres(gmx_mtop_t *mtop,t_molinfo *molinfo,bool bTopB,
char *fn,
int rc_scaling, int ePBC,
rvec com)
{
bool bFirst = TRUE;
rvec *x,*v,*xp;
dvec sum;
double totmass;
t_atoms dumat;
matrix box,invbox;
int natoms,npbcdim=0;
char title[STRLEN];
int a,i,ai,j,k,mb,nat_molb;
gmx_molblock_t *molb;
t_params *pr;
t_atom *atom;
get_stx_coordnum(fn,&natoms);
if (natoms != mtop->natoms) {
sprintf(warn_buf,"The number of atoms in %s (%d) does not match the number of atoms in the topology (%d). Will assume that the first %d atoms in the topology and %s match.",fn,natoms,mtop->natoms,min(mtop->natoms,natoms),fn);
warning(NULL);
}
snew(x,natoms);
snew(v,natoms);
init_t_atoms(&dumat,natoms,FALSE);
read_stx_conf(fn,title,&dumat,x,v,NULL,box);
npbcdim = ePBC2npbcdim(ePBC);
clear_rvec(com);
if (rc_scaling != erscNO) {
copy_mat(box,invbox);
for(j=npbcdim; j<DIM; j++) {
clear_rvec(invbox[j]);
invbox[j][j] = 1;
}
m_inv_ur0(invbox,invbox);
}
/* Copy the reference coordinates to mtop */
clear_dvec(sum);
totmass = 0;
a = 0;
for(mb=0; mb<mtop->nmolblock; mb++) {
molb = &mtop->molblock[mb];
nat_molb = molb->nmol*mtop->moltype[molb->type].atoms.nr;
pr = &(molinfo[molb->type].plist[F_POSRES]);
if (pr->nr > 0) {
atom = mtop->moltype[molb->type].atoms.atom;
for(i=0; (i<pr->nr); i++) {
ai=pr->param[i].AI;
if (ai >= natoms) {
gmx_fatal(FARGS,"Position restraint atom index (%d) in moltype '%s' is larger than number of atoms in %s (%d).\n",
ai+1,*molinfo[molb->type].name,fn,natoms);
}
if (rc_scaling == erscCOM) {
/* Determine the center of mass of the posres reference coordinates */
for(j=0; j<npbcdim; j++) {
sum[j] += atom[ai].m*x[a+ai][j];
}
totmass += atom[ai].m;
}
}
if (!bTopB) {
molb->nposres_xA = nat_molb;
snew(molb->posres_xA,molb->nposres_xA);
for(i=0; i<nat_molb; i++) {
copy_rvec(x[a+i],molb->posres_xA[i]);
}
} else {
molb->nposres_xB = nat_molb;
snew(molb->posres_xB,molb->nposres_xB);
for(i=0; i<nat_molb; i++) {
copy_rvec(x[a+i],molb->posres_xB[i]);
}
}
}
a += nat_molb;
}
if (rc_scaling == erscCOM) {
if (totmass == 0)
gmx_fatal(FARGS,"The total mass of the position restraint atoms is 0");
for(j=0; j<npbcdim; j++)
com[j] = sum[j]/totmass;
fprintf(stderr,"The center of mass of the position restraint coord's is %6.3f %6.3f %6.3f\n",com[XX],com[YY],com[ZZ]);
}
if (rc_scaling != erscNO) {
for(mb=0; mb<mtop->nmolblock; mb++) {
molb = &mtop->molblock[mb];
nat_molb = molb->nmol*mtop->moltype[molb->type].atoms.nr;
if (molb->nposres_xA > 0 || molb->nposres_xB > 0) {
xp = (!bTopB ? molb->posres_xA : molb->posres_xB);
for(i=0; i<nat_molb; i++) {
for(j=0; j<npbcdim; j++) {
if (rc_scaling == erscALL) {
/* Convert from Cartesian to crystal coordinates */
xp[i][j] *= invbox[j][j];
for(k=j+1; k<npbcdim; k++) {
xp[i][j] += invbox[k][j]*xp[i][k];
}
} else if (rc_scaling == erscCOM) {
/* Subtract the center of mass */
xp[i][j] -= com[j];
}
}
}
}
}
if (rc_scaling == erscCOM) {
/* Convert the COM from Cartesian to crystal coordinates */
for(j=0; j<npbcdim; j++) {
com[j] *= invbox[j][j];
for(k=j+1; k<npbcdim; k++) {
com[j] += invbox[k][j]*com[k];
}
}
}
}
free_t_atoms(&dumat,TRUE);
sfree(x);
sfree(v);
}
void pme_loadbal_init(pme_load_balancing_t **pme_lb_p,
t_commrec *cr,
FILE *fp_log,
const t_inputrec *ir,
matrix box,
const interaction_const_t *ic,
struct gmx_pme_t *pmedata,
gmx_bool bUseGPU,
gmx_bool *bPrinting)
{
pme_load_balancing_t *pme_lb;
real spm, sp;
int d;
snew(pme_lb, 1);
pme_lb->bSepPMERanks = !(cr->duty & DUTY_PME);
/* Initially we turn on balancing directly on based on PP/PME imbalance */
pme_lb->bTriggerOnDLB = FALSE;
/* Any number of stages >= 2 is supported */
pme_lb->nstage = 2;
pme_lb->cutoff_scheme = ir->cutoff_scheme;
if (pme_lb->cutoff_scheme == ecutsVERLET)
{
pme_lb->rbuf_coulomb = ic->rlist - ic->rcoulomb;
pme_lb->rbuf_vdw = pme_lb->rbuf_coulomb;
}
else
{
if (ic->rcoulomb > ic->rlist)
{
pme_lb->rbuf_coulomb = ic->rlistlong - ic->rcoulomb;
}
else
{
pme_lb->rbuf_coulomb = ic->rlist - ic->rcoulomb;
}
if (ic->rvdw > ic->rlist)
{
pme_lb->rbuf_vdw = ic->rlistlong - ic->rvdw;
}
else
{
pme_lb->rbuf_vdw = ic->rlist - ic->rvdw;
}
}
copy_mat(box, pme_lb->box_start);
if (ir->ePBC == epbcXY && ir->nwall == 2)
{
svmul(ir->wall_ewald_zfac, pme_lb->box_start[ZZ], pme_lb->box_start[ZZ]);
}
pme_lb->n = 1;
snew(pme_lb->setup, pme_lb->n);
pme_lb->rcut_vdw = ic->rvdw;
pme_lb->rcut_coulomb_start = ir->rcoulomb;
pme_lb->nstcalclr_start = ir->nstcalclr;
pme_lb->cur = 0;
pme_lb->setup[0].rcut_coulomb = ic->rcoulomb;
pme_lb->setup[0].rlist = ic->rlist;
pme_lb->setup[0].rlistlong = ic->rlistlong;
pme_lb->setup[0].nstcalclr = ir->nstcalclr;
pme_lb->setup[0].grid[XX] = ir->nkx;
pme_lb->setup[0].grid[YY] = ir->nky;
pme_lb->setup[0].grid[ZZ] = ir->nkz;
pme_lb->setup[0].ewaldcoeff_q = ic->ewaldcoeff_q;
pme_lb->setup[0].ewaldcoeff_lj = ic->ewaldcoeff_lj;
pme_lb->setup[0].pmedata = pmedata;
spm = 0;
for (d = 0; d < DIM; d++)
{
sp = norm(pme_lb->box_start[d])/pme_lb->setup[0].grid[d];
if (sp > spm)
{
spm = sp;
}
}
pme_lb->setup[0].spacing = spm;
if (ir->fourier_spacing > 0)
{
pme_lb->cut_spacing = ir->rcoulomb/ir->fourier_spacing;
}
else
{
pme_lb->cut_spacing = ir->rcoulomb/pme_lb->setup[0].spacing;
}
pme_lb->stage = 0;
pme_lb->fastest = 0;
pme_lb->lower_limit = 0;
pme_lb->start = 0;
pme_lb->end = 0;
pme_lb->elimited = epmelblimNO;
pme_lb->cycles_n = 0;
pme_lb->cycles_c = 0;
/* Tune with GPUs and/or separate PME ranks.
* When running only on a CPU without PME ranks, PME tuning will only help
* with small numbers of atoms in the cut-off sphere.
*/
pme_lb->bActive = (wallcycle_have_counter() && (bUseGPU ||
pme_lb->bSepPMERanks));
/* With GPUs and no separate PME ranks we can't measure the PP/PME
* imbalance, so we start balancing right away.
* Otherwise we only start balancing after we observe imbalance.
*/
pme_lb->bBalance = (pme_lb->bActive && (bUseGPU && !pme_lb->bSepPMERanks));
pme_lb->step_rel_stop = PMETunePeriod*ir->nstlist;
/* Delay DD load balancing when GPUs are used */
if (pme_lb->bActive && DOMAINDECOMP(cr) && cr->dd->nnodes > 1 && bUseGPU)
{
/* Lock DLB=auto to off (does nothing when DLB=yes/no.
* With GPUs and separate PME nodes, we want to first
* do PME tuning without DLB, since DLB might limit
* the cut-off, which never improves performance.
* We allow for DLB + PME tuning after a first round of tuning.
*/
dd_dlb_lock(cr->dd);
if (dd_dlb_is_locked(cr->dd))
{
md_print_warn(cr, fp_log, "NOTE: DLB will not turn on during the first phase of PME tuning\n");
}
}
*pme_lb_p = pme_lb;
*bPrinting = pme_lb->bBalance;
}
int main (int argc, char *argv[])
{
static const char *desc[] = {
"The gromacs preprocessor",
"reads a molecular topology file, checks the validity of the",
"file, expands the topology from a molecular description to an atomic",
"description. The topology file contains information about",
"molecule types and the number of molecules, the preprocessor",
"copies each molecule as needed. ",
"There is no limitation on the number of molecule types. ",
"Bonds and bond-angles can be converted into constraints, separately",
"for hydrogens and heavy atoms.",
"Then a coordinate file is read and velocities can be generated",
"from a Maxwellian distribution if requested.",
"grompp also reads parameters for the mdrun ",
"(eg. number of MD steps, time step, cut-off), and others such as",
"NEMD parameters, which are corrected so that the net acceleration",
"is zero.",
"Eventually a binary file is produced that can serve as the sole input",
"file for the MD program.[PAR]",
"grompp uses the atom names from the topology file. The atom names",
"in the coordinate file (option [TT]-c[tt]) are only read to generate",
"warnings when they do not match the atom names in the topology.",
"Note that the atom names are irrelevant for the simulation as",
"only the atom types are used for generating interaction parameters.[PAR]",
"grompp calls a preprocessor to resolve includes, macros ",
"etcetera. By default we use the cpp in your path. To specify a "
"different macro-preprocessor (e.g. m4) or alternative location",
"you can put a line in your parameter file specifying the path",
"to that program. Specifying [TT]-pp[tt] will get the pre-processed",
"topology file written out.[PAR]",
"If your system does not have a c-preprocessor, you can still",
"use grompp, but you do not have access to the features ",
"from the cpp. Command line options to the c-preprocessor can be given",
"in the [TT].mdp[tt] file. See your local manual (man cpp).[PAR]",
"When using position restraints a file with restraint coordinates",
"can be supplied with [TT]-r[tt], otherwise restraining will be done",
"with respect to the conformation from the [TT]-c[tt] option.",
"For free energy calculation the the coordinates for the B topology",
"can be supplied with [TT]-rb[tt], otherwise they will be equal to",
"those of the A topology.[PAR]",
"Starting coordinates can be read from trajectory with [TT]-t[tt].",
"The last frame with coordinates and velocities will be read,",
"unless the [TT]-time[tt] option is used.",
"Note that these velocities will not be used when [TT]gen_vel = yes[tt]",
"in your [TT].mdp[tt] file. An energy file can be supplied with",
"[TT]-e[tt] to have exact restarts when using pressure and/or",
"Nose-Hoover temperature coupling. For an exact restart do not forget",
"to turn off velocity generation and turn on unconstrained starting",
"when constraints are present in the system.",
"If you want to continue a crashed run, it is",
"easier to use [TT]tpbconv[tt].[PAR]",
"Using the [TT]-morse[tt] option grompp can convert the harmonic bonds",
"in your topology to morse potentials. This makes it possible to break",
"bonds. For this option to work you need an extra file in your $GMXLIB",
"with dissociation energy. Use the -debug option to get more information",
"on the workings of this option (look for MORSE in the grompp.log file",
"using less or something like that).[PAR]",
"By default all bonded interactions which have constant energy due to",
"virtual site constructions will be removed. If this constant energy is",
"not zero, this will result in a shift in the total energy. All bonded",
"interactions can be kept by turning off [TT]-rmvsbds[tt]. Additionally,",
"all constraints for distances which will be constant anyway because",
"of virtual site constructions will be removed. If any constraints remain",
"which involve virtual sites, a fatal error will result.[PAR]"
"To verify your run input file, please make notice of all warnings",
"on the screen, and correct where necessary. Do also look at the contents",
"of the [TT]mdout.mdp[tt] file, this contains comment lines, as well as",
"the input that [TT]grompp[tt] has read. If in doubt you can start grompp",
"with the [TT]-debug[tt] option which will give you more information",
"in a file called grompp.log (along with real debug info). Finally, you",
"can see the contents of the run input file with the [TT]gmxdump[tt]",
"program."
};
t_gromppopts *opts;
gmx_mtop_t *sys;
int nmi;
t_molinfo *mi;
gpp_atomtype_t atype;
t_inputrec *ir;
int natoms,nvsite,comb,mt;
t_params *plist;
t_state state;
matrix box;
real max_spacing,fudgeQQ;
double reppow;
char fn[STRLEN],fnB[STRLEN],*mdparin;
int nerror,ntype;
bool bNeedVel,bGenVel;
bool have_radius,have_vol,have_surftens,have_gb_radius,have_S_hct;
bool have_atomnumber;
int n12,n13,n14;
t_params *gb_plist = NULL;
gmx_genborn_t *born = NULL;
t_filenm fnm[] = {
{ efMDP, NULL, NULL, ffOPTRD },
{ efMDP, "-po", "mdout", ffWRITE },
{ efSTX, "-c", NULL, ffREAD },
{ efSTX, "-r", NULL, ffOPTRD },
{ efSTX, "-rb", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTOP, NULL, NULL, ffREAD },
{ efTOP, "-pp", "processed", ffOPTWR },
{ efTPX, "-o", NULL, ffWRITE },
{ efTRN, "-t", NULL, ffOPTRD },
{ efEDR, "-e", NULL, ffOPTRD }
};
#define NFILE asize(fnm)
/* Command line options */
static bool bVerbose=TRUE,bRenum=TRUE;
static bool bRmVSBds=TRUE,bZero=FALSE;
static int i,maxwarn=0;
static real fr_time=-1;
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"Be loud and noisy" },
{ "-time", FALSE, etREAL, {&fr_time},
"Take frame at or first after this time." },
{ "-rmvsbds",FALSE, etBOOL, {&bRmVSBds},
"Remove constant bonded interactions with virtual sites" },
{ "-maxwarn", FALSE, etINT, {&maxwarn},
"Number of allowed warnings during input processing" },
{ "-zero", FALSE, etBOOL, {&bZero},
"Set parameters for bonded interactions without defaults to zero instead of generating an error" },
{ "-renum", FALSE, etBOOL, {&bRenum},
"Renumber atomtypes and minimize number of atomtypes" }
};
CopyRight(stdout,argv[0]);
/* Initiate some variables */
nerror=0;
snew(ir,1);
snew(opts,1);
init_ir(ir,opts);
/* Parse the command line */
parse_common_args(&argc,argv,0,NFILE,fnm,asize(pa),pa,
asize(desc),desc,0,NULL);
init_warning(maxwarn);
/* PARAMETER file processing */
mdparin = opt2fn("-f",NFILE,fnm);
set_warning_line(mdparin,-1);
get_ir(mdparin,opt2fn("-po",NFILE,fnm),ir,opts,&nerror);
if (bVerbose)
fprintf(stderr,"checking input for internal consistency...\n");
check_ir(mdparin,ir,opts,&nerror);
if (ir->ld_seed == -1) {
ir->ld_seed = make_seed();
fprintf(stderr,"Setting the LD random seed to %d\n",ir->ld_seed);
}
bNeedVel = EI_STATE_VELOCITY(ir->eI);
bGenVel = (bNeedVel && opts->bGenVel);
snew(plist,F_NRE);
init_plist(plist);
snew(sys,1);
atype = init_atomtype();
if (debug)
pr_symtab(debug,0,"Just opened",&sys->symtab);
strcpy(fn,ftp2fn(efTOP,NFILE,fnm));
if (!gmx_fexist(fn))
gmx_fatal(FARGS,"%s does not exist",fn);
new_status(fn,opt2fn_null("-pp",NFILE,fnm),opt2fn("-c",NFILE,fnm),
opts,ir,bZero,bGenVel,bVerbose,&state,
atype,sys,&nmi,&mi,plist,&comb,&reppow,&fudgeQQ,
opts->bMorse,
&nerror);
if (debug)
pr_symtab(debug,0,"After new_status",&sys->symtab);
if (count_constraints(sys,mi) && (ir->eConstrAlg == econtSHAKE)) {
if (ir->eI == eiCG || ir->eI == eiLBFGS) {
fprintf(stderr,
"ERROR: Can not do %s with %s, use %s\n",
EI(ir->eI),econstr_names[econtSHAKE],econstr_names[econtLINCS]);
nerror++;
}
if (ir->bPeriodicMols) {
fprintf(stderr,
"ERROR: can not do periodic molecules with %s, use %s\n",
econstr_names[econtSHAKE],econstr_names[econtLINCS]);
nerror++;
}
}
/* If we are doing GBSA, check that we got the parameters we need
* This checking is to see if there are GBSA paratmeters for all
* atoms in the force field. To go around this for testing purposes
* comment out the nerror++ counter temporarliy
*/
have_radius=have_vol=have_surftens=have_gb_radius=have_S_hct=TRUE;
for(i=0;i<get_atomtype_ntypes(atype);i++) {
have_radius=have_radius && (get_atomtype_radius(i,atype) > 0);
have_vol=have_vol && (get_atomtype_vol(i,atype) > 0);
have_surftens=have_surftens && (get_atomtype_surftens(i,atype) > 0);
have_gb_radius=have_gb_radius && (get_atomtype_gb_radius(i,atype) > 0);
have_S_hct=have_S_hct && (get_atomtype_S_hct(i,atype) > 0);
}
if(!have_radius && ir->implicit_solvent==eisGBSA) {
fprintf(stderr,"Can't do GB electrostatics; the forcefield is missing values for\n"
"atomtype radii, or they might be zero\n.");
/* nerror++; */
}
/*
if(!have_surftens && ir->implicit_solvent!=eisNO) {
fprintf(stderr,"Can't do implicit solvent; the forcefield is missing values\n"
" for atomtype surface tension\n.");
nerror++;
}
*/
/* If we are doing QM/MM, check that we got the atom numbers */
have_atomnumber = TRUE;
for (i=0; i<get_atomtype_ntypes(atype); i++) {
have_atomnumber = have_atomnumber && (get_atomtype_atomnumber(i,atype) >= 0);
}
if (!have_atomnumber && ir->bQMMM)
{
fprintf(stderr,"\n"
"It appears as if you are trying to run a QM/MM calculation, but the force\n"
"field you are using does not contain atom numbers fields. This is an\n"
"optional field (introduced in Gromacs 3.3) for general runs, but mandatory\n"
"for QM/MM. The good news is that it is easy to add - put the atom number as\n"
"an integer just before the mass column in ffXXXnb.itp.\n"
"NB: United atoms have the same atom numbers as normal ones.\n\n");
nerror++;
}
if (nerror) {
print_warn_num(FALSE);
gmx_fatal(FARGS,"There were %d error(s) processing your input",nerror);
}
if (opt2bSet("-r",NFILE,fnm))
sprintf(fn,"%s",opt2fn("-r",NFILE,fnm));
else
sprintf(fn,"%s",opt2fn("-c",NFILE,fnm));
if (opt2bSet("-rb",NFILE,fnm))
sprintf(fnB,"%s",opt2fn("-rb",NFILE,fnm));
else
strcpy(fnB,fn);
if (nint_ftype(sys,mi,F_POSRES) > 0) {
if (bVerbose) {
fprintf(stderr,"Reading position restraint coords from %s",fn);
if (strcmp(fn,fnB) == 0) {
fprintf(stderr,"\n");
} else {
fprintf(stderr," and %s\n",fnB);
if (ir->efep != efepNO && ir->n_flambda > 0) {
fprintf(stderr,"ERROR: can not change the position restraint reference coordinates with lambda togther with foreign lambda calculation.\n");
nerror++;
}
}
}
gen_posres(sys,mi,fn,fnB,
ir->refcoord_scaling,ir->ePBC,
ir->posres_com,ir->posres_comB);
}
nvsite = 0;
/* set parameters for virtual site construction (not for vsiten) */
for(mt=0; mt<sys->nmoltype; mt++) {
nvsite +=
set_vsites(bVerbose, &sys->moltype[mt].atoms, atype, mi[mt].plist);
}
/* now throw away all obsolete bonds, angles and dihedrals: */
/* note: constraints are ALWAYS removed */
if (nvsite) {
for(mt=0; mt<sys->nmoltype; mt++) {
clean_vsite_bondeds(mi[mt].plist,sys->moltype[mt].atoms.nr,bRmVSBds);
}
}
/* If we are using CMAP, setup the pre-interpolation grid */
if(plist->ncmap>0)
{
init_cmap_grid(&sys->cmap_grid, plist->nc, plist->grid_spacing);
setup_cmap(plist->grid_spacing, plist->nc, plist->cmap,&sys->cmap_grid);
}
set_wall_atomtype(atype,opts,ir);
if (bRenum) {
renum_atype(plist, sys, ir->wall_atomtype, atype, bVerbose);
ntype = get_atomtype_ntypes(atype);
}
/* PELA: Copy the atomtype data to the topology atomtype list */
copy_atomtype_atomtypes(atype,&(sys->atomtypes));
if (debug)
pr_symtab(debug,0,"After renum_atype",&sys->symtab);
if (bVerbose)
fprintf(stderr,"converting bonded parameters...\n");
ntype = get_atomtype_ntypes(atype);
convert_params(ntype, plist, mi, comb, reppow, fudgeQQ, sys);
if(ir->implicit_solvent)
{
printf("Constructing Generalized Born topology...\n");
/* Check for -normvsbds switch to grompp, necessary for gb together with vsites */
if(bRmVSBds && nvsite)
{
fprintf(stderr, "ERROR: Must use -normvsbds switch to grompp when doing Generalized Born\n"
"together with virtual sites\n");
nerror++;
}
if (nerror)
{
print_warn_num(FALSE);
gmx_fatal(FARGS,"There were %d error(s) processing your input",nerror);
}
generate_gb_topology(sys,mi);
}
if (debug)
pr_symtab(debug,0,"After convert_params",&sys->symtab);
/* set ptype to VSite for virtual sites */
for(mt=0; mt<sys->nmoltype; mt++) {
set_vsites_ptype(FALSE,&sys->moltype[mt]);
}
if (debug) {
pr_symtab(debug,0,"After virtual sites",&sys->symtab);
}
/* Check velocity for virtual sites and shells */
if (bGenVel) {
check_vel(sys,state.v);
}
/* check masses */
check_mol(sys);
for(i=0; i<sys->nmoltype; i++) {
check_cg_sizes(ftp2fn(efTOP,NFILE,fnm),&sys->moltype[i].cgs);
}
check_warning_error(FARGS);
if (bVerbose)
fprintf(stderr,"initialising group options...\n");
do_index(mdparin,ftp2fn_null(efNDX,NFILE,fnm),
sys,bVerbose,ir,
bGenVel ? state.v : NULL);
/* Init the temperature coupling state */
init_gtc_state(&state,ir->opts.ngtc);
if (bVerbose)
fprintf(stderr,"Checking consistency between energy and charge groups...\n");
check_eg_vs_cg(sys);
if (debug)
pr_symtab(debug,0,"After index",&sys->symtab);
triple_check(mdparin,ir,sys,&nerror);
close_symtab(&sys->symtab);
if (debug)
pr_symtab(debug,0,"After close",&sys->symtab);
/* make exclusions between QM atoms */
if (ir->bQMMM) {
generate_qmexcl(sys,ir);
}
if (ftp2bSet(efTRN,NFILE,fnm)) {
if (bVerbose)
fprintf(stderr,"getting data from old trajectory ...\n");
cont_status(ftp2fn(efTRN,NFILE,fnm),ftp2fn_null(efEDR,NFILE,fnm),
bNeedVel,bGenVel,fr_time,ir,&state,sys);
}
if (ir->ePBC==epbcXY && ir->nwall!=2)
clear_rvec(state.box[ZZ]);
if (EEL_FULL(ir->coulombtype)) {
/* Calculate the optimal grid dimensions */
copy_mat(state.box,box);
if (ir->ePBC==epbcXY && ir->nwall==2)
svmul(ir->wall_ewald_zfac,box[ZZ],box[ZZ]);
max_spacing = calc_grid(stdout,box,opts->fourierspacing,
&(ir->nkx),&(ir->nky),&(ir->nkz),1);
if ((ir->coulombtype == eelPPPM) && (max_spacing > 0.1)) {
set_warning_line(mdparin,-1);
sprintf(warn_buf,"Grid spacing larger then 0.1 while using PPPM.");
warning_note(NULL);
}
}
if (ir->ePull != epullNO)
set_pull_init(ir,sys,state.x,state.box,opts->pull_start);
/* reset_multinr(sys); */
if (EEL_PME(ir->coulombtype)) {
float ratio = pme_load_estimate(sys,ir,state.box);
fprintf(stderr,"Estimate for the relative computational load of the PME mesh part: %.2f\n",ratio);
if (ratio > 0.5)
warning_note("The optimal PME mesh load for parallel simulations is below 0.5\n"
"and for highly parallel simulations between 0.25 and 0.33,\n"
"for higher performance, increase the cut-off and the PME grid spacing");
}
{
double cio = compute_io(ir,sys->natoms,&sys->groups,F_NRE,1);
sprintf(warn_buf,"This run will generate roughly %.0f Mb of data",cio);
if (cio > 2000) {
set_warning_line(mdparin,-1);
warning_note(NULL);
} else {
printf("%s\n",warn_buf);
}
}
if (bVerbose)
fprintf(stderr,"writing run input file...\n");
print_warn_num(TRUE);
state.lambda = ir->init_lambda;
write_tpx_state(ftp2fn(efTPX,NFILE,fnm),ir,&state,sys);
thanx(stderr);
return 0;
}
int gmx_vanhove(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes the Van Hove correlation function.",
"The Van Hove G(r,t) is the probability that a particle that is at r[SUB]0[sub]",
"at time zero can be found at position r[SUB]0[sub]+r at time t.",
"[THISMODULE] determines G not for a vector r, but for the length of r.",
"Thus it gives the probability that a particle moves a distance of r",
"in time t.",
"Jumps across the periodic boundaries are removed.",
"Corrections are made for scaling due to isotropic",
"or anisotropic pressure coupling.",
"[PAR]",
"With option [TT]-om[tt] the whole matrix can be written as a function",
"of t and r or as a function of [SQRT]t[sqrt] and r (option [TT]-sqrt[tt]).",
"[PAR]",
"With option [TT]-or[tt] the Van Hove function is plotted for one",
"or more values of t. Option [TT]-nr[tt] sets the number of times,",
"option [TT]-fr[tt] the number spacing between the times.",
"The binwidth is set with option [TT]-rbin[tt]. The number of bins",
"is determined automatically.",
"[PAR]",
"With option [TT]-ot[tt] the integral up to a certain distance",
"(option [TT]-rt[tt]) is plotted as a function of time.",
"[PAR]",
"For all frames that are read the coordinates of the selected particles",
"are stored in memory. Therefore the program may use a lot of memory.",
"For options [TT]-om[tt] and [TT]-ot[tt] the program may be slow.",
"This is because the calculation scales as the number of frames times",
"[TT]-fm[tt] or [TT]-ft[tt].",
"Note that with the [TT]-dt[tt] option the memory usage and calculation",
"time can be reduced."
};
static int fmmax = 0, ftmax = 0, nlev = 81, nr = 1, fshift = 0;
static real sbin = 0, rmax = 2, rbin = 0.01, mmax = 0, rint = 0;
t_pargs pa[] = {
{ "-sqrt", FALSE, etREAL, {&sbin},
"Use [SQRT]t[sqrt] on the matrix axis which binspacing # in [SQRT]ps[sqrt]" },
{ "-fm", FALSE, etINT, {&fmmax},
"Number of frames in the matrix, 0 is plot all" },
{ "-rmax", FALSE, etREAL, {&rmax},
"Maximum r in the matrix (nm)" },
{ "-rbin", FALSE, etREAL, {&rbin},
"Binwidth in the matrix and for [TT]-or[tt] (nm)" },
{ "-mmax", FALSE, etREAL, {&mmax},
"Maximum density in the matrix, 0 is calculate (1/nm)" },
{ "-nlevels", FALSE, etINT, {&nlev},
"Number of levels in the matrix" },
{ "-nr", FALSE, etINT, {&nr},
"Number of curves for the [TT]-or[tt] output" },
{ "-fr", FALSE, etINT, {&fshift},
"Frame spacing for the [TT]-or[tt] output" },
{ "-rt", FALSE, etREAL, {&rint},
"Integration limit for the [TT]-ot[tt] output (nm)" },
{ "-ft", FALSE, etINT, {&ftmax},
"Number of frames in the [TT]-ot[tt] output, 0 is plot all" }
};
#define NPA asize(pa)
t_filenm fnm[] = {
{ efTRX, NULL, NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXPM, "-om", "vanhove", ffOPTWR },
{ efXVG, "-or", "vanhove_r", ffOPTWR },
{ efXVG, "-ot", "vanhove_t", ffOPTWR }
};
#define NFILE asize(fnm)
output_env_t oenv;
const char *matfile, *otfile, *orfile;
char title[256];
t_topology top;
int ePBC;
matrix boxtop, box, *sbox, avbox, corr;
rvec *xtop, *x, **sx;
int isize, nalloc, nallocn, natom;
t_trxstatus *status;
atom_id *index;
char *grpname;
int nfr, f, ff, i, m, mat_nx = 0, nbin = 0, bin, mbin, fbin;
real *time, t, invbin = 0, rmax2 = 0, rint2 = 0, d2;
real invsbin = 0, matmax, normfac, dt, *tickx, *ticky;
char buf[STRLEN], **legend;
real **mat = NULL;
int *pt = NULL, **pr = NULL, *mcount = NULL, *tcount = NULL, *rcount = NULL;
FILE *fp;
t_rgb rlo = {1, 1, 1}, rhi = {0, 0, 0};
if (!parse_common_args(&argc, argv, PCA_CAN_VIEW | PCA_CAN_TIME | PCA_BE_NICE,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
matfile = opt2fn_null("-om", NFILE, fnm);
if (opt2parg_bSet("-fr", NPA, pa))
{
orfile = opt2fn("-or", NFILE, fnm);
}
else
{
orfile = opt2fn_null("-or", NFILE, fnm);
}
if (opt2parg_bSet("-rt", NPA, pa))
{
otfile = opt2fn("-ot", NFILE, fnm);
}
else
{
otfile = opt2fn_null("-ot", NFILE, fnm);
}
if (!matfile && !otfile && !orfile)
{
fprintf(stderr,
"For output set one (or more) of the output file options\n");
exit(0);
}
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC, &xtop, NULL, boxtop,
FALSE);
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &isize, &index, &grpname);
nalloc = 0;
time = NULL;
sbox = NULL;
sx = NULL;
clear_mat(avbox);
natom = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
nfr = 0;
do
{
if (nfr >= nalloc)
{
nalloc += 100;
srenew(time, nalloc);
srenew(sbox, nalloc);
srenew(sx, nalloc);
}
time[nfr] = t;
copy_mat(box, sbox[nfr]);
/* This assumes that the off-diagonal box elements
* are not affected by jumps across the periodic boundaries.
*/
m_add(avbox, box, avbox);
snew(sx[nfr], isize);
for (i = 0; i < isize; i++)
{
copy_rvec(x[index[i]], sx[nfr][i]);
}
nfr++;
}
while (read_next_x(oenv, status, &t, x, box));
/* clean up */
sfree(x);
close_trj(status);
fprintf(stderr, "Read %d frames\n", nfr);
dt = (time[nfr-1] - time[0])/(nfr - 1);
/* Some ugly rounding to get nice nice times in the output */
dt = (int)(10000.0*dt + 0.5)/10000.0;
invbin = 1.0/rbin;
if (matfile)
{
if (fmmax <= 0 || fmmax >= nfr)
{
fmmax = nfr - 1;
}
snew(mcount, fmmax);
nbin = (int)(rmax*invbin + 0.5);
if (sbin == 0)
{
mat_nx = fmmax + 1;
}
else
{
invsbin = 1.0/sbin;
mat_nx = sqrt(fmmax*dt)*invsbin + 1;
}
snew(mat, mat_nx);
for (f = 0; f < mat_nx; f++)
{
snew(mat[f], nbin);
}
rmax2 = sqr(nbin*rbin);
/* Initialize time zero */
mat[0][0] = nfr*isize;
mcount[0] += nfr;
}
else
{
fmmax = 0;
}
if (orfile)
{
snew(pr, nr);
nalloc = 0;
snew(rcount, nr);
}
if (otfile)
{
if (ftmax <= 0)
{
ftmax = nfr - 1;
}
snew(tcount, ftmax);
snew(pt, nfr);
rint2 = rint*rint;
/* Initialize time zero */
pt[0] = nfr*isize;
tcount[0] += nfr;
}
else
{
ftmax = 0;
}
msmul(avbox, 1.0/nfr, avbox);
for (f = 0; f < nfr; f++)
{
if (f % 100 == 0)
{
fprintf(stderr, "\rProcessing frame %d", f);
}
/* Scale all the configuration to the average box */
m_inv_ur0(sbox[f], corr);
mmul_ur0(avbox, corr, corr);
for (i = 0; i < isize; i++)
{
mvmul_ur0(corr, sx[f][i], sx[f][i]);
if (f > 0)
{
/* Correct for periodic jumps */
for (m = DIM-1; m >= 0; m--)
{
while (sx[f][i][m] - sx[f-1][i][m] > 0.5*avbox[m][m])
{
rvec_dec(sx[f][i], avbox[m]);
}
while (sx[f][i][m] - sx[f-1][i][m] <= -0.5*avbox[m][m])
{
rvec_inc(sx[f][i], avbox[m]);
}
}
}
}
for (ff = 0; ff < f; ff++)
{
fbin = f - ff;
if (fbin <= fmmax || fbin <= ftmax)
{
if (sbin == 0)
{
mbin = fbin;
}
else
{
mbin = (int)(sqrt(fbin*dt)*invsbin + 0.5);
}
for (i = 0; i < isize; i++)
{
d2 = distance2(sx[f][i], sx[ff][i]);
if (mbin < mat_nx && d2 < rmax2)
{
bin = (int)(sqrt(d2)*invbin + 0.5);
if (bin < nbin)
{
mat[mbin][bin] += 1;
}
}
if (fbin <= ftmax && d2 <= rint2)
{
pt[fbin]++;
}
}
if (matfile)
{
mcount[mbin]++;
}
if (otfile)
{
tcount[fbin]++;
}
}
}
if (orfile)
{
for (fbin = 0; fbin < nr; fbin++)
{
ff = f - (fbin + 1)*fshift;
if (ff >= 0)
{
for (i = 0; i < isize; i++)
{
d2 = distance2(sx[f][i], sx[ff][i]);
bin = (int)(sqrt(d2)*invbin + 0.5);
if (bin >= nalloc)
{
nallocn = 10*(bin/10) + 11;
for (m = 0; m < nr; m++)
{
srenew(pr[m], nallocn);
for (i = nalloc; i < nallocn; i++)
{
pr[m][i] = 0;
}
}
nalloc = nallocn;
}
pr[fbin][bin]++;
}
rcount[fbin]++;
}
}
}
}
fprintf(stderr, "\n");
if (matfile)
{
matmax = 0;
for (f = 0; f < mat_nx; f++)
{
normfac = 1.0/(mcount[f]*isize*rbin);
for (i = 0; i < nbin; i++)
{
mat[f][i] *= normfac;
if (mat[f][i] > matmax && (f != 0 || i != 0))
{
matmax = mat[f][i];
}
}
}
fprintf(stdout, "Value at (0,0): %.3f, maximum of the rest %.3f\n",
mat[0][0], matmax);
if (mmax > 0)
{
matmax = mmax;
}
snew(tickx, mat_nx);
for (f = 0; f < mat_nx; f++)
{
if (sbin == 0)
{
tickx[f] = f*dt;
}
else
{
tickx[f] = f*sbin;
}
}
snew(ticky, nbin+1);
for (i = 0; i <= nbin; i++)
{
ticky[i] = i*rbin;
}
fp = gmx_ffopen(matfile, "w");
write_xpm(fp, MAT_SPATIAL_Y, "Van Hove function", "G (1/nm)",
sbin == 0 ? "time (ps)" : "sqrt(time) (ps^1/2)", "r (nm)",
mat_nx, nbin, tickx, ticky, mat, 0, matmax, rlo, rhi, &nlev);
gmx_ffclose(fp);
}
if (orfile)
{
fp = xvgropen(orfile, "Van Hove function", "r (nm)", "G (nm\\S-1\\N)", oenv);
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"for particles in group %s\"\n", grpname);
}
snew(legend, nr);
for (fbin = 0; fbin < nr; fbin++)
{
sprintf(buf, "%g ps", (fbin + 1)*fshift*dt);
legend[fbin] = strdup(buf);
}
xvgr_legend(fp, nr, (const char**)legend, oenv);
for (i = 0; i < nalloc; i++)
{
fprintf(fp, "%g", i*rbin);
for (fbin = 0; fbin < nr; fbin++)
{
fprintf(fp, " %g",
(real)pr[fbin][i]/(rcount[fbin]*isize*rbin*(i == 0 ? 0.5 : 1)));
}
fprintf(fp, "\n");
}
gmx_ffclose(fp);
}
if (otfile)
{
sprintf(buf, "Probability of moving less than %g nm", rint);
fp = xvgropen(otfile, buf, "t (ps)", "", oenv);
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"for particles in group %s\"\n", grpname);
}
for (f = 0; f <= ftmax; f++)
{
fprintf(fp, "%g %g\n", f*dt, (real)pt[f]/(tcount[f]*isize));
}
gmx_ffclose(fp);
}
do_view(oenv, matfile, NULL);
do_view(oenv, orfile, NULL);
do_view(oenv, otfile, NULL);
return 0;
}
int gmx_filter(int argc,char *argv[])
{
const char *desc[] = {
"[TT]g_filter[tt] performs frequency filtering on a trajectory.",
"The filter shape is cos([GRK]pi[grk] t/A) + 1 from -A to +A, where A is given",
"by the option [TT]-nf[tt] times the time step in the input trajectory.",
"This filter reduces fluctuations with period A by 85%, with period",
"2*A by 50% and with period 3*A by 17% for low-pass filtering.",
"Both a low-pass and high-pass filtered trajectory can be written.[PAR]",
"Option [TT]-ol[tt] writes a low-pass filtered trajectory.",
"A frame is written every [TT]-nf[tt] input frames.",
"This ratio of filter length and output interval ensures a good",
"suppression of aliasing of high-frequency motion, which is useful for",
"making smooth movies. Also averages of properties which are linear",
"in the coordinates are preserved, since all input frames are weighted",
"equally in the output.",
"When all frames are needed, use the [TT]-all[tt] option.[PAR]",
"Option [TT]-oh[tt] writes a high-pass filtered trajectory.",
"The high-pass filtered coordinates are added to the coordinates",
"from the structure file. When using high-pass filtering use [TT]-fit[tt]",
"or make sure you use a trajectory that has been fitted on",
"the coordinates in the structure file."
};
static int nf=10;
static gmx_bool bNoJump = TRUE,bFit = FALSE,bLowAll = FALSE;
t_pargs pa[] = {
{ "-nf", FALSE, etINT, {&nf},
"Sets the filter length as well as the output interval for low-pass filtering" },
{ "-all", FALSE, etBOOL, {&bLowAll},
"Write all low-pass filtered frames" },
{ "-nojump", FALSE, etBOOL, {&bNoJump},
"Remove jumps of atoms across the box" },
{ "-fit", FALSE, etBOOL, {&bFit},
"Fit all frames to a reference structure" }
};
const char *topfile,*lowfile,*highfile;
gmx_bool bTop=FALSE;
t_topology top;
int ePBC=-1;
rvec *xtop;
matrix topbox,*box,boxf;
char title[256],*grpname;
int isize;
atom_id *index;
real *w_rls=NULL;
t_trxstatus *in;
t_trxstatus *outl,*outh;
int nffr,i,fr,nat,j,d,m;
atom_id *ind;
real flen,*filt,sum,*t;
rvec xcmtop,xcm,**x,*ptr,*xf,*xn,*xp,hbox;
output_env_t oenv;
gmx_rmpbc_t gpbc=NULL;
#define NLEG asize(leg)
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTRO, "-ol", "lowpass", ffOPTWR },
{ efTRO, "-oh", "highpass", ffOPTWR }
};
#define NFILE asize(fnm)
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL,&oenv);
highfile = opt2fn_null("-oh",NFILE,fnm);
if (highfile) {
topfile = ftp2fn(efTPS,NFILE,fnm);
lowfile = opt2fn_null("-ol",NFILE,fnm);
} else {
topfile = ftp2fn_null(efTPS,NFILE,fnm);
lowfile = opt2fn("-ol",NFILE,fnm);
}
if (topfile) {
bTop = read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,
&xtop,NULL,topbox,TRUE);
if (bTop) {
gpbc = gmx_rmpbc_init(&top.idef,ePBC,top.atoms.nr,topbox);
gmx_rmpbc(gpbc,top.atoms.nr,topbox,xtop);
}
}
clear_rvec(xcmtop);
if (bFit) {
fprintf(stderr,"Select group for least squares fit\n");
get_index(&top.atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&isize,&index,&grpname);
/* Set the weight */
snew(w_rls,top.atoms.nr);
for(i=0; i<isize; i++)
w_rls[index[i]] = top.atoms.atom[index[i]].m;
calc_xcm(xtop,isize,index,top.atoms.atom,xcmtop,FALSE);
for(j=0; j<top.atoms.nr; j++)
rvec_dec(xtop[j],xcmtop);
}
/* The actual filter length flen can actually be any real number */
flen = 2*nf;
/* nffr is the number of frames that we filter over */
nffr = 2*nf - 1;
snew(filt,nffr);
sum = 0;
for(i=0; i<nffr; i++) {
filt[i] = cos(2*M_PI*(i - nf + 1)/(real)flen) + 1;
sum += filt[i];
}
fprintf(stdout,"filter weights:");
for(i=0; i<nffr; i++) {
filt[i] /= sum;
fprintf(stdout," %5.3f",filt[i]);
}
fprintf(stdout,"\n");
snew(t,nffr);
snew(x,nffr);
snew(box,nffr);
nat = read_first_x(oenv,&in,opt2fn("-f",NFILE,fnm),
&(t[nffr - 1]),&(x[nffr - 1]),box[nffr - 1]);
snew(ind,nat);
for(i=0; i<nat; i++)
ind[i] = i;
/* x[nffr - 1] was already allocated by read_first_x */
for(i=0; i<nffr-1; i++)
snew(x[i],nat);
snew(xf,nat);
if (lowfile)
outl = open_trx(lowfile,"w");
else
outl = 0;
if (highfile)
outh = open_trx(highfile,"w");
else
outh = 0;
fr = 0;
do {
xn = x[nffr - 1];
if (bNoJump && fr > 0) {
xp = x[nffr - 2];
for(j=0; j<nat; j++)
for(d=0; d<DIM; d++)
hbox[d] = 0.5*box[nffr - 1][d][d];
for(i=0; i<nat; i++)
for(m=DIM-1; m>=0; m--)
if (hbox[m] > 0) {
while (xn[i][m] - xp[i][m] <= -hbox[m])
for(d=0; d<=m; d++)
xn[i][d] += box[nffr - 1][m][d];
while (xn[i][m] - xp[i][m] > hbox[m])
for(d=0; d<=m; d++)
xn[i][d] -= box[nffr - 1][m][d];
}
}
if (bTop) {
gmx_rmpbc(gpbc,nat,box[nffr - 1],xn);
}
if (bFit) {
calc_xcm(xn,isize,index,top.atoms.atom,xcm,FALSE);
for(j=0; j<nat; j++)
rvec_dec(xn[j],xcm);
do_fit(nat,w_rls,xtop,xn);
for(j=0; j<nat; j++)
rvec_inc(xn[j],xcmtop);
}
if (fr >= nffr && (outh || bLowAll || fr % nf == nf - 1)) {
/* Lowpass filtering */
for(j=0; j<nat; j++)
clear_rvec(xf[j]);
clear_mat(boxf);
for(i=0; i<nffr; i++) {
for(j=0; j<nat; j++)
for(d=0; d<DIM; d++)
xf[j][d] += filt[i]*x[i][j][d];
for(j=0; j<DIM; j++)
for(d=0; d<DIM; d++)
boxf[j][d] += filt[i]*box[i][j][d];
}
if (outl && (bLowAll || fr % nf == nf - 1))
write_trx(outl,nat,ind,topfile ? &(top.atoms) : NULL,
0,t[nf - 1],bFit ? topbox : boxf,xf,NULL,NULL);
if (outh) {
/* Highpass filtering */
for(j=0; j<nat; j++)
for(d=0; d<DIM; d++)
xf[j][d] = xtop[j][d] + x[nf - 1][j][d] - xf[j][d];
if (bFit)
for(j=0; j<nat; j++)
rvec_inc(xf[j],xcmtop);
for(j=0; j<DIM; j++)
for(d=0; d<DIM; d++)
boxf[j][d] = topbox[j][d] + box[nf - 1][j][d] - boxf[j][d];
write_trx(outh,nat,ind,topfile ? &(top.atoms) : NULL,
0,t[nf - 1],bFit ? topbox : boxf,xf,NULL,NULL);
}
}
/* Cycle all the pointer and the box by one */
ptr = x[0];
for(i=0; i<nffr-1; i++) {
t[i] = t[i+1];
x[i] = x[i+1];
copy_mat(box[i+1],box[i]);
}
x[nffr - 1] = ptr;
fr++;
} while (read_next_x(oenv,in,&(t[nffr - 1]),nat,x[nffr - 1],box[nffr - 1]));
if (bTop)
gmx_rmpbc_done(gpbc);
if (outh)
close_trx(outh);
if (outl)
close_trx(outl);
close_trx(in);
return 0;
}
static void do_rdf(char *fnNDX,char *fnTPS,char *fnTRX,
char *fnRDF,char *fnCNRDF, char *fnHQ,
bool bCM,char **rdft,bool bXY,bool bPBC,bool bNormalize,
real cutoff,real binwidth,real fade,int ng)
{
FILE *fp;
int status;
char outf1[STRLEN],outf2[STRLEN];
char title[STRLEN],gtitle[STRLEN];
int g,natoms,i,j,k,nbin,j0,j1,n,nframes;
int **count;
char **grpname;
int *isize,isize_cm=0,nrdf=0,max_i,isize0,isize_g;
atom_id **index,*index_cm=NULL;
#if (defined SIZEOF_LONG_LONG_INT) && (SIZEOF_LONG_LONG_INT >= 8)
long long int *sum;
#else
double *sum;
#endif
real t,rmax2,cut2,r,r2,invhbinw,normfac;
real segvol,spherevol,prev_spherevol,**rdf;
rvec *x,dx,*x0=NULL,*x_i1,xi;
real *inv_segvol,invvol,invvol_sum,rho;
bool *bExcl,bTop,bNonSelfExcl;
matrix box,box_pbc;
int **npairs;
atom_id ix,jx,***pairs;
t_topology *top=NULL;
int ePBC=-1;
t_block *mols=NULL;
t_blocka *excl;
t_atom *atom=NULL;
t_pbc pbc;
int *is=NULL,**coi=NULL,cur,mol,i1,res,a;
excl=NULL;
if (fnTPS) {
snew(top,1);
bTop=read_tps_conf(fnTPS,title,top,&ePBC,&x,NULL,box,TRUE);
if (bTop && !bCM)
/* get exclusions from topology */
excl = &(top->excls);
}
snew(grpname,ng+1);
snew(isize,ng+1);
snew(index,ng+1);
fprintf(stderr,"\nSelect a reference group and %d group%s\n",
ng,ng==1?"":"s");
if (fnTPS) {
get_index(&(top->atoms),fnNDX,ng+1,isize,index,grpname);
atom = top->atoms.atom;
} else {
rd_index(fnNDX,ng+1,isize,index,grpname);
}
if (rdft[0][0] != 'a') {
/* Split up all the groups in molecules or residues */
switch (rdft[0][0]) {
case 'm':
mols = &top->mols;
break;
case 'r':
atom = top->atoms.atom;
break;
default:
gmx_fatal(FARGS,"Unknown rdf option '%s'",rdft[0]);
}
snew(is,ng+1);
snew(coi,ng+1);
for(g=(bCM ? 1 : 0); g<ng+1; g++) {
snew(coi[g],isize[g]+1);
is[g] = 0;
cur = -1;
mol = 0;
for(i=0; i<isize[g]; i++) {
a = index[g][i];
if (rdft[0][0] == 'm') {
/* Check if the molecule number has changed */
i1 = mols->index[mol+1];
while(a >= i1) {
mol++;
i1 = mols->index[mol+1];
}
if (mol != cur) {
coi[g][is[g]++] = i;
cur = mol;
}
} else if (rdft[0][0] == 'r') {
/* Check if the residue number has changed */
res = atom[a].resnr;
if (res != cur) {
coi[g][is[g]++] = i;
cur = res;
}
}
}
coi[g][is[g]] = i;
srenew(coi[g],is[g]+1);
printf("Group '%s' of %d atoms consists of %d %s\n",
grpname[g],isize[g],is[g],
(rdft[0][0]=='m' ? "molecules" : "residues"));
}
} else if (bCM) {
snew(is,1);
snew(coi,1);
}
if (bCM) {
is[0] = 1;
snew(coi[0],is[0]+1);
coi[0][0] = 0;
coi[0][1] = isize[0];
isize0 = is[0];
snew(x0,isize0);
} else if (rdft[0][0] != 'a') {
isize0 = is[0];
snew(x0,isize0);
} else {
isize0 = isize[0];
}
natoms=read_first_x(&status,fnTRX,&t,&x,box);
if ( !natoms )
gmx_fatal(FARGS,"Could not read coordinates from statusfile\n");
if (fnTPS)
/* check with topology */
if ( natoms > top->atoms.nr )
gmx_fatal(FARGS,"Trajectory (%d atoms) does not match topology (%d atoms)",
natoms,top->atoms.nr);
/* check with index groups */
for (i=0; i<ng+1; i++)
for (j=0; j<isize[i]; j++)
if ( index[i][j] >= natoms )
gmx_fatal(FARGS,"Atom index (%d) in index group %s (%d atoms) larger "
"than number of atoms in trajectory (%d atoms)",
index[i][j],grpname[i],isize[i],natoms);
/* initialize some handy things */
copy_mat(box,box_pbc);
if (bXY) {
check_box_c(box);
/* Make sure the z-height does not influence the cut-off */
box_pbc[ZZ][ZZ] = 2*max(box[XX][XX],box[YY][YY]);
}
if (bPBC)
rmax2 = 0.99*0.99*max_cutoff2(bXY ? epbcXY : epbcXYZ,box_pbc);
else
rmax2 = sqr(3*max(box[XX][XX],max(box[YY][YY],box[ZZ][ZZ])));
if (debug)
fprintf(debug,"rmax2 = %g\n",rmax2);
/* We use the double amount of bins, so we can correctly
* write the rdf and rdf_cn output at i*binwidth values.
*/
nbin = (int)(sqrt(rmax2) * 2 / binwidth);
invhbinw = 2.0 / binwidth;
cut2 = sqr(cutoff);
snew(count,ng);
snew(pairs,ng);
snew(npairs,ng);
snew(bExcl,natoms);
max_i = 0;
for(g=0; g<ng; g++) {
if (isize[g+1] > max_i)
max_i = isize[g+1];
/* this is THE array */
snew(count[g],nbin+1);
/* make pairlist array for groups and exclusions */
snew(pairs[g],isize[0]);
snew(npairs[g],isize[0]);
for(i=0; i<isize[0]; i++) {
/* We can only have exclusions with atomic rdfs */
if (!(bCM || rdft[0][0] != 'a')) {
ix = index[0][i];
for(j=0; j < natoms; j++)
bExcl[j] = FALSE;
/* exclusions? */
if (excl)
for( j = excl->index[ix]; j < excl->index[ix+1]; j++)
bExcl[excl->a[j]]=TRUE;
k = 0;
snew(pairs[g][i], isize[g+1]);
bNonSelfExcl = FALSE;
for(j=0; j<isize[g+1]; j++) {
jx = index[g+1][j];
if (!bExcl[jx])
pairs[g][i][k++]=jx;
else if (ix != jx)
/* Check if we have exclusions other than self exclusions */
bNonSelfExcl = TRUE;
}
if (bNonSelfExcl) {
npairs[g][i]=k;
srenew(pairs[g][i],npairs[g][i]);
} else {
/* Save a LOT of memory and some cpu cycles */
npairs[g][i]=-1;
sfree(pairs[g][i]);
}
} else {
npairs[g][i]=-1;
}
}
}
sfree(bExcl);
snew(x_i1,max_i);
nframes = 0;
invvol_sum = 0;
do {
/* Must init pbc every step because of pressure coupling */
copy_mat(box,box_pbc);
if (bPBC) {
if (top != NULL)
rm_pbc(&top->idef,ePBC,natoms,box,x,x);
if (bXY) {
check_box_c(box);
clear_rvec(box_pbc[ZZ]);
}
set_pbc(&pbc,ePBC,box_pbc);
if (bXY)
/* Set z-size to 1 so we get the surface iso the volume */
box_pbc[ZZ][ZZ] = 1;
}
invvol = 1/det(box_pbc);
invvol_sum += invvol;
if (bCM) {
/* Calculate center of mass of the whole group */
calc_comg(is[0],coi[0],index[0],TRUE ,atom,x,x0);
} else if (rdft[0][0] != 'a') {
calc_comg(is[0],coi[0],index[0],rdft[0][6]=='m',atom,x,x0);
}
for(g=0; g<ng; g++) {
if (rdft[0][0] == 'a') {
/* Copy the indexed coordinates to a continuous array */
for(i=0; i<isize[g+1]; i++)
copy_rvec(x[index[g+1][i]],x_i1[i]);
} else {
/* Calculate the COMs/COGs and store in x_i1 */
calc_comg(is[g+1],coi[g+1],index[g+1],rdft[0][6]=='m',atom,x,x_i1);
}
for(i=0; i<isize0; i++) {
if (bCM || rdft[0][0] != 'a') {
copy_rvec(x0[i],xi);
} else {
copy_rvec(x[index[0][i]],xi);
}
if (rdft[0][0] == 'a' && npairs[g][i] >= 0) {
/* Expensive loop, because of indexing */
for(j=0; j<npairs[g][i]; j++) {
jx=pairs[g][i][j];
if (bPBC)
pbc_dx(&pbc,xi,x[jx],dx);
else
rvec_sub(xi,x[jx],dx);
if (bXY)
r2 = dx[XX]*dx[XX] + dx[YY]*dx[YY];
else
r2=iprod(dx,dx);
if (r2>cut2 && r2<=rmax2)
count[g][(int)(sqrt(r2)*invhbinw)]++;
}
} else {
/* Cheaper loop, no exclusions */
if (rdft[0][0] == 'a')
isize_g = isize[g+1];
else
isize_g = is[g+1];
for(j=0; j<isize_g; j++) {
if (bPBC)
pbc_dx(&pbc,xi,x_i1[j],dx);
else
rvec_sub(xi,x_i1[j],dx);
if (bXY)
r2 = dx[XX]*dx[XX] + dx[YY]*dx[YY];
else
r2=iprod(dx,dx);
if (r2>cut2 && r2<=rmax2)
count[g][(int)(sqrt(r2)*invhbinw)]++;
}
}
}
}
nframes++;
} while (read_next_x(status,&t,natoms,x,box));
fprintf(stderr,"\n");
close_trj(status);
sfree(x);
/* Average volume */
invvol = invvol_sum/nframes;
/* Calculate volume of sphere segments or length of circle segments */
snew(inv_segvol,(nbin+1)/2);
prev_spherevol=0;
for(i=0; (i<(nbin+1)/2); i++) {
r = (i + 0.5)*binwidth;
if (bXY) {
spherevol=M_PI*r*r;
} else {
spherevol=(4.0/3.0)*M_PI*r*r*r;
}
segvol=spherevol-prev_spherevol;
inv_segvol[i]=1.0/segvol;
prev_spherevol=spherevol;
}
snew(rdf,ng);
for(g=0; g<ng; g++) {
/* We have to normalize by dividing by the number of frames */
if (rdft[0][0] == 'a')
normfac = 1.0/(nframes*invvol*isize0*isize[g+1]);
else
normfac = 1.0/(nframes*invvol*isize0*is[g+1]);
/* Do the normalization */
nrdf = max((nbin+1)/2,1+2*fade/binwidth);
snew(rdf[g],nrdf);
for(i=0; i<(nbin+1)/2; i++) {
r = i*binwidth;
if (i == 0)
j = count[g][0];
else
j = count[g][i*2-1] + count[g][i*2];
if ((fade > 0) && (r >= fade))
rdf[g][i] = 1 + (j*inv_segvol[i]*normfac-1)*exp(-16*sqr(r/fade-1));
else {
if (bNormalize)
rdf[g][i] = j*inv_segvol[i]*normfac;
else
rdf[g][i] = j/(binwidth*isize0*nframes);
}
}
for( ; (i<nrdf); i++)
rdf[g][i] = 1.0;
}
if (rdft[0][0] == 'a') {
sprintf(gtitle,"Radial distribution");
} else {
sprintf(gtitle,"Radial distribution of %s %s",
rdft[0][0]=='m' ? "molecule" : "residue",
rdft[0][6]=='m' ? "COM" : "COG");
}
fp=xvgropen(fnRDF,gtitle,"r","");
if (ng==1) {
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"%s%s - %s\"\n",
grpname[0],bCM ? " COM" : "",grpname[1]);
}
else {
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"reference %s%s\"\n",
grpname[0],bCM ? " COM" : "");
xvgr_legend(fp,ng,grpname+1);
}
for(i=0; (i<nrdf); i++) {
fprintf(fp,"%10g",i*binwidth);
for(g=0; g<ng; g++)
fprintf(fp," %10g",rdf[g][i]);
fprintf(fp,"\n");
}
ffclose(fp);
do_view(fnRDF,NULL);
/* h(Q) function: fourier transform of rdf */
if (fnHQ) {
int nhq = 401;
real *hq,*integrand,Q;
/* Get a better number density later! */
rho = isize[1]*invvol;
snew(hq,nhq);
snew(integrand,nrdf);
for(i=0; (i<nhq); i++) {
Q = i*0.5;
integrand[0] = 0;
for(j=1; (j<nrdf); j++) {
r = j*binwidth;
integrand[j] = (Q == 0) ? 1.0 : sin(Q*r)/(Q*r);
integrand[j] *= 4.0*M_PI*rho*r*r*(rdf[0][j]-1.0);
}
hq[i] = print_and_integrate(debug,nrdf,binwidth,integrand,NULL,0);
}
fp=xvgropen(fnHQ,"h(Q)","Q(/nm)","h(Q)");
for(i=0; (i<nhq); i++)
fprintf(fp,"%10g %10g\n",i*0.5,hq[i]);
ffclose(fp);
do_view(fnHQ,NULL);
sfree(hq);
sfree(integrand);
}
if (fnCNRDF) {
normfac = 1.0/(isize0*nframes);
fp=xvgropen(fnCNRDF,"Cumulative Number RDF","r","number");
if (ng==1) {
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"%s-%s\"\n",grpname[0],grpname[1]);
}
else {
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"reference %s\"\n",grpname[0]);
xvgr_legend(fp,ng,grpname+1);
}
snew(sum,ng);
for(i=0; (i<=nbin/2); i++) {
fprintf(fp,"%10g",i*binwidth);
for(g=0; g<ng; g++) {
fprintf(fp," %10g",(real)((double)sum[g]*normfac));
if (i*2+1 < nbin)
sum[g] += count[g][i*2] + count[g][i*2+1];
}
fprintf(fp,"\n");
}
ffclose(fp);
sfree(sum);
do_view(fnCNRDF,NULL);
}
for(g=0; g<ng; g++)
sfree(rdf[g]);
sfree(rdf);
}
void
TrajectoryAnalysisRunnerCommon::Impl::initFirstFrame()
{
// Return if we have already initialized the trajectory.
if (fr != NULL)
{
return;
}
time_unit_t time_unit
= static_cast<time_unit_t>(settings_.timeUnit() + 1);
output_env_init(&oenv_, getProgramContext(), time_unit, FALSE, exvgNONE, 0);
int frflags = settings_.frflags();
frflags |= TRX_NEED_X;
snew(fr, 1);
if (hasTrajectory())
{
if (!read_first_frame(oenv_, &status_, trjfile_.c_str(), fr, frflags))
{
GMX_THROW(FileIOError("Could not read coordinates from trajectory"));
}
bTrajOpen_ = true;
if (topInfo_.hasTopology())
{
const int topologyAtomCount = topInfo_.topology()->atoms.nr;
if (fr->natoms > topologyAtomCount)
{
const std::string message
= formatString("Trajectory (%d atoms) does not match topology (%d atoms)",
fr->natoms, topologyAtomCount);
GMX_THROW(InconsistentInputError(message));
}
}
}
else
{
// Prepare a frame from topology information.
// TODO: Initialize more of the fields.
if (frflags & (TRX_NEED_V))
{
GMX_THROW(NotImplementedError("Velocity reading from a topology not implemented"));
}
if (frflags & (TRX_NEED_F))
{
GMX_THROW(InvalidInputError("Forces cannot be read from a topology"));
}
fr->natoms = topInfo_.topology()->atoms.nr;
fr->bX = TRUE;
snew(fr->x, fr->natoms);
memcpy(fr->x, topInfo_.xtop_,
sizeof(*fr->x) * fr->natoms);
fr->bBox = TRUE;
copy_mat(topInfo_.boxtop_, fr->box);
}
set_trxframe_ePBC(fr, topInfo_.ePBC());
if (topInfo_.hasTopology() && settings_.hasRmPBC())
{
gpbc_ = gmx_rmpbc_init(&topInfo_.topology()->idef, topInfo_.ePBC(),
fr->natoms);
}
}
void mdoutf_write_to_trajectory_files(FILE *fplog, t_commrec *cr,
gmx_mdoutf_t of,
int mdof_flags,
gmx_mtop_t *top_global,
gmx_int64_t step, double t,
t_state *state_local, t_state *state_global,
rvec *f_local, rvec *f_global)
{
rvec *local_v;
rvec *global_v;
/* MRS -- defining these variables is to manage the difference
* between half step and full step velocities, but there must be a better way . . . */
local_v = state_local->v;
global_v = state_global->v;
if (DOMAINDECOMP(cr))
{
if (mdof_flags & MDOF_CPT)
{
dd_collect_state(cr->dd, state_local, state_global);
}
else
{
if (mdof_flags & (MDOF_X | MDOF_X_COMPRESSED))
{
dd_collect_vec(cr->dd, state_local, state_local->x,
state_global->x);
}
if (mdof_flags & MDOF_V)
{
dd_collect_vec(cr->dd, state_local, local_v,
global_v);
}
}
if (mdof_flags & MDOF_F)
{
dd_collect_vec(cr->dd, state_local, f_local, f_global);
}
}
else
{
if (mdof_flags & MDOF_CPT)
{
/* All pointers in state_local are equal to state_global,
* but we need to copy the non-pointer entries.
*/
state_global->lambda = state_local->lambda;
state_global->veta = state_local->veta;
state_global->vol0 = state_local->vol0;
copy_mat(state_local->box, state_global->box);
copy_mat(state_local->boxv, state_global->boxv);
copy_mat(state_local->svir_prev, state_global->svir_prev);
copy_mat(state_local->fvir_prev, state_global->fvir_prev);
copy_mat(state_local->pres_prev, state_global->pres_prev);
}
}
if (MASTER(cr))
{
if (mdof_flags & MDOF_CPT)
{
fflush_tng(of->tng);
fflush_tng(of->tng_low_prec);
write_checkpoint(of->fn_cpt, of->bKeepAndNumCPT,
fplog, cr, of->eIntegrator, of->simulation_part,
of->bExpanded, of->elamstats, step, t, state_global);
}
if (mdof_flags & (MDOF_X | MDOF_V | MDOF_F))
{
if (of->fp_trn)
{
fwrite_trn(of->fp_trn, step, t, state_local->lambda[efptFEP],
state_local->box, top_global->natoms,
(mdof_flags & MDOF_X) ? state_global->x : NULL,
(mdof_flags & MDOF_V) ? global_v : NULL,
(mdof_flags & MDOF_F) ? f_global : NULL);
if (gmx_fio_flush(of->fp_trn) != 0)
{
gmx_file("Cannot write trajectory; maybe you are out of disk space?");
}
}
gmx_fwrite_tng(of->tng, FALSE, step, t, state_local->lambda[efptFEP],
(const rvec *) state_local->box,
top_global->natoms,
(mdof_flags & MDOF_X) ? (const rvec *) state_global->x : NULL,
(mdof_flags & MDOF_V) ? (const rvec *) global_v : NULL,
(mdof_flags & MDOF_F) ? (const rvec *) f_global : NULL);
}
if (mdof_flags & MDOF_X_COMPRESSED)
{
rvec *xxtc = NULL;
if (of->natoms_x_compressed == of->natoms_global)
{
/* We are writing the positions of all of the atoms to
the compressed output */
xxtc = state_global->x;
}
else
{
/* We are writing the positions of only a subset of
the atoms to the compressed output, so we have to
make a copy of the subset of coordinates. */
int i, j;
snew(xxtc, of->natoms_x_compressed);
for (i = 0, j = 0; (i < of->natoms_x_compressed); i++)
{
if (ggrpnr(of->groups, egcCompressedX, i) == 0)
{
copy_rvec(state_global->x[i], xxtc[j++]);
}
}
}
if (write_xtc(of->fp_xtc, of->natoms_x_compressed, step, t,
state_local->box, xxtc, of->x_compression_precision) == 0)
{
gmx_fatal(FARGS, "XTC error - maybe you are out of disk space?");
}
gmx_fwrite_tng(of->tng_low_prec,
TRUE,
step,
t,
state_local->lambda[efptFEP],
(const rvec *) state_local->box,
of->natoms_x_compressed,
(const rvec *) xxtc,
NULL,
NULL);
if (of->natoms_x_compressed != of->natoms_global)
{
sfree(xxtc);
}
}
}
}
int gmx_spatial(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] calculates the spatial distribution function and",
"outputs it in a form that can be read by VMD as Gaussian98 cube format.",
"For a system of 32,000 atoms and a 50 ns trajectory, the SDF can be generated",
"in about 30 minutes, with most of the time dedicated to the two runs through",
"[TT]trjconv[tt] that are required to center everything properly.",
"This also takes a whole bunch of space (3 copies of the trajectory file).",
"Still, the pictures are pretty and very informative when the fitted selection is properly made.",
"3-4 atoms in a widely mobile group (like a free amino acid in solution) works",
"well, or select the protein backbone in a stable folded structure to get the SDF",
"of solvent and look at the time-averaged solvation shell.",
"It is also possible using this program to generate the SDF based on some arbitrary",
"Cartesian coordinate. To do that, simply omit the preliminary [gmx-trjconv] steps.",
"",
"Usage:",
"",
"1. Use [gmx-make_ndx] to create a group containing the atoms around which you want the SDF",
"2. [TT]gmx trjconv -s a.tpr -f a.tng -o b.tng -boxcenter tric -ur compact -pbc none[tt]",
"3. [TT]gmx trjconv -s a.tpr -f b.tng -o c.tng -fit rot+trans[tt]",
"4. run [THISMODULE] on the [TT]c.tng[tt] output of step #3.",
"5. Load [TT]grid.cube[tt] into VMD and view as an isosurface.",
"",
"[BB]Note[bb] that systems such as micelles will require [TT]gmx trjconv -pbc cluster[tt] between steps 1 and 2.",
"",
"Warnings",
"^^^^^^^^",
"",
"The SDF will be generated for a cube that contains all bins that have some non-zero occupancy.",
"However, the preparatory [TT]-fit rot+trans[tt] option to [gmx-trjconv] implies that your system will be rotating",
"and translating in space (in order that the selected group does not). Therefore the values that are",
"returned will only be valid for some region around your central group/coordinate that has full overlap",
"with system volume throughout the entire translated/rotated system over the course of the trajectory.",
"It is up to the user to ensure that this is the case.",
"",
"Risky options",
"^^^^^^^^^^^^^",
"",
"To reduce the amount of space and time required, you can output only the coords",
"that are going to be used in the first and subsequent run through [gmx-trjconv].",
"However, be sure to set the [TT]-nab[tt] option to a sufficiently high value since",
"memory is allocated for cube bins based on the initial coordinates and the [TT]-nab[tt]",
"option value."
};
const char *bugs[] = {
"When the allocated memory is not large enough, a segmentation fault may occur. This is usually detected "
"and the program is halted prior to the fault while displaying a warning message suggesting the use of the [TT]-nab[tt] (Number of Additional Bins) "
"option. However, the program does not detect all such events. If you encounter a segmentation fault, run it again "
"with an increased [TT]-nab[tt] value."
};
static gmx_bool bPBC = FALSE;
static int iIGNOREOUTER = -1; /*Positive values may help if the surface is spikey */
static gmx_bool bCUTDOWN = TRUE;
static real rBINWIDTH = 0.05; /* nm */
static gmx_bool bCALCDIV = TRUE;
static int iNAB = 4;
t_pargs pa[] = {
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Use periodic boundary conditions for computing distances" },
{ "-div", FALSE, etBOOL, {&bCALCDIV},
"Calculate and apply the divisor for bin occupancies based on atoms/minimal cube size. Set as TRUE for visualization and as FALSE ([TT]-nodiv[tt]) to get accurate counts per frame" },
{ "-ign", FALSE, etINT, {&iIGNOREOUTER},
"Do not display this number of outer cubes (positive values may reduce boundary speckles; -1 ensures outer surface is visible)" },
/* { "-cut", bCUTDOWN, etBOOL, {&bCUTDOWN},*/
/* "Display a total cube that is of minimal size" }, */
{ "-bin", FALSE, etREAL, {&rBINWIDTH},
"Width of the bins (nm)" },
{ "-nab", FALSE, etINT, {&iNAB},
"Number of additional bins to ensure proper memory allocation" }
};
double MINBIN[3];
double MAXBIN[3];
t_topology top;
int ePBC;
t_trxframe fr;
rvec *xtop;
matrix box, box_pbc;
t_trxstatus *status;
int flags = TRX_READ_X;
t_pbc pbc;
t_atoms *atoms;
int natoms;
char *grpnm, *grpnmp;
int *index, *indexp;
int i, nidx, nidxp;
int v;
int j, k;
int ***bin = NULL;
int nbin[3];
FILE *flp;
int x, y, z, minx, miny, minz, maxx, maxy, maxz;
int numfr, numcu;
int tot, maxval, minval;
double norm;
gmx_output_env_t *oenv;
gmx_rmpbc_t gpbc = NULL;
t_filenm fnm[] = {
{ efTPS, NULL, NULL, ffREAD }, /* this is for the topology */
{ efTRX, "-f", NULL, ffREAD }, /* and this for the trajectory */
{ efNDX, NULL, NULL, ffOPTRD }
};
#define NFILE asize(fnm)
/* This is the routine responsible for adding default options,
* calling the X/motif interface, etc. */
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_CAN_VIEW,
NFILE, fnm, asize(pa), pa, asize(desc), desc, asize(bugs), bugs, &oenv))
{
return 0;
}
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, &xtop, NULL, box, TRUE);
sfree(xtop);
atoms = &(top.atoms);
printf("Select group to generate SDF:\n");
get_index(atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &nidx, &index, &grpnm);
printf("Select group to output coords (e.g. solute):\n");
get_index(atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &nidxp, &indexp, &grpnmp);
/* The first time we read data is a little special */
natoms = read_first_frame(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &fr, flags);
/* Memory Allocation */
MINBIN[XX] = MAXBIN[XX] = fr.x[0][XX];
MINBIN[YY] = MAXBIN[YY] = fr.x[0][YY];
MINBIN[ZZ] = MAXBIN[ZZ] = fr.x[0][ZZ];
for (i = 1; i < top.atoms.nr; ++i)
{
if (fr.x[i][XX] < MINBIN[XX])
{
MINBIN[XX] = fr.x[i][XX];
}
if (fr.x[i][XX] > MAXBIN[XX])
{
MAXBIN[XX] = fr.x[i][XX];
}
if (fr.x[i][YY] < MINBIN[YY])
{
MINBIN[YY] = fr.x[i][YY];
}
if (fr.x[i][YY] > MAXBIN[YY])
{
MAXBIN[YY] = fr.x[i][YY];
}
if (fr.x[i][ZZ] < MINBIN[ZZ])
{
MINBIN[ZZ] = fr.x[i][ZZ];
}
if (fr.x[i][ZZ] > MAXBIN[ZZ])
{
MAXBIN[ZZ] = fr.x[i][ZZ];
}
}
for (i = ZZ; i >= XX; --i)
{
MAXBIN[i] = (std::ceil((MAXBIN[i]-MINBIN[i])/rBINWIDTH)+iNAB)*rBINWIDTH+MINBIN[i];
MINBIN[i] -= iNAB*rBINWIDTH;
nbin[i] = static_cast<int>(std::ceil((MAXBIN[i]-MINBIN[i])/rBINWIDTH));
}
snew(bin, nbin[XX]);
for (i = 0; i < nbin[XX]; ++i)
{
snew(bin[i], nbin[YY]);
for (j = 0; j < nbin[YY]; ++j)
{
snew(bin[i][j], nbin[ZZ]);
}
}
copy_mat(box, box_pbc);
numfr = 0;
minx = miny = minz = 999;
maxx = maxy = maxz = 0;
if (bPBC)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
}
/* This is the main loop over frames */
do
{
/* Must init pbc every step because of pressure coupling */
copy_mat(box, box_pbc);
if (bPBC)
{
gmx_rmpbc_trxfr(gpbc, &fr);
set_pbc(&pbc, ePBC, box_pbc);
}
for (i = 0; i < nidx; i++)
{
if (fr.x[index[i]][XX] < MINBIN[XX] || fr.x[index[i]][XX] > MAXBIN[XX] ||
fr.x[index[i]][YY] < MINBIN[YY] || fr.x[index[i]][YY] > MAXBIN[YY] ||
fr.x[index[i]][ZZ] < MINBIN[ZZ] || fr.x[index[i]][ZZ] > MAXBIN[ZZ])
{
printf("There was an item outside of the allocated memory. Increase the value given with the -nab option.\n");
printf("Memory was allocated for [%f,%f,%f]\tto\t[%f,%f,%f]\n", MINBIN[XX], MINBIN[YY], MINBIN[ZZ], MAXBIN[XX], MAXBIN[YY], MAXBIN[ZZ]);
printf("Memory was required for [%f,%f,%f]\n", fr.x[index[i]][XX], fr.x[index[i]][YY], fr.x[index[i]][ZZ]);
exit(1);
}
x = static_cast<int>(std::ceil((fr.x[index[i]][XX]-MINBIN[XX])/rBINWIDTH));
y = static_cast<int>(std::ceil((fr.x[index[i]][YY]-MINBIN[YY])/rBINWIDTH));
z = static_cast<int>(std::ceil((fr.x[index[i]][ZZ]-MINBIN[ZZ])/rBINWIDTH));
++bin[x][y][z];
if (x < minx)
{
minx = x;
}
if (x > maxx)
{
maxx = x;
}
if (y < miny)
{
miny = y;
}
if (y > maxy)
{
maxy = y;
}
if (z < minz)
{
minz = z;
}
if (z > maxz)
{
maxz = z;
}
}
numfr++;
/* printf("%f\t%f\t%f\n",box[XX][XX],box[YY][YY],box[ZZ][ZZ]); */
}
while (read_next_frame(oenv, status, &fr));
if (bPBC)
{
gmx_rmpbc_done(gpbc);
}
if (!bCUTDOWN)
{
minx = miny = minz = 0;
maxx = nbin[XX];
maxy = nbin[YY];
maxz = nbin[ZZ];
}
/* OUTPUT */
flp = gmx_ffopen("grid.cube", "w");
fprintf(flp, "Spatial Distribution Function\n");
fprintf(flp, "test\n");
fprintf(flp, "%5d%12.6f%12.6f%12.6f\n", nidxp, (MINBIN[XX]+(minx+iIGNOREOUTER)*rBINWIDTH)*10./bohr, (MINBIN[YY]+(miny+iIGNOREOUTER)*rBINWIDTH)*10./bohr, (MINBIN[ZZ]+(minz+iIGNOREOUTER)*rBINWIDTH)*10./bohr);
fprintf(flp, "%5d%12.6f%12.6f%12.6f\n", maxx-minx+1-(2*iIGNOREOUTER), rBINWIDTH*10./bohr, 0., 0.);
fprintf(flp, "%5d%12.6f%12.6f%12.6f\n", maxy-miny+1-(2*iIGNOREOUTER), 0., rBINWIDTH*10./bohr, 0.);
fprintf(flp, "%5d%12.6f%12.6f%12.6f\n", maxz-minz+1-(2*iIGNOREOUTER), 0., 0., rBINWIDTH*10./bohr);
for (i = 0; i < nidxp; i++)
{
v = 2;
if (*(top.atoms.atomname[indexp[i]][0]) == 'C')
{
v = 6;
}
if (*(top.atoms.atomname[indexp[i]][0]) == 'N')
{
v = 7;
}
if (*(top.atoms.atomname[indexp[i]][0]) == 'O')
{
v = 8;
}
if (*(top.atoms.atomname[indexp[i]][0]) == 'H')
{
v = 1;
}
if (*(top.atoms.atomname[indexp[i]][0]) == 'S')
{
v = 16;
}
fprintf(flp, "%5d%12.6f%12.6f%12.6f%12.6f\n", v, 0., fr.x[indexp[i]][XX]*10.0/bohr, fr.x[indexp[i]][YY]*10.0/bohr, fr.x[indexp[i]][ZZ]*10.0/bohr);
}
tot = 0;
for (k = 0; k < nbin[XX]; k++)
{
if (!(k < minx || k > maxx))
{
continue;
}
for (j = 0; j < nbin[YY]; j++)
{
if (!(j < miny || j > maxy))
{
continue;
}
for (i = 0; i < nbin[ZZ]; i++)
{
if (!(i < minz || i > maxz))
{
continue;
}
if (bin[k][j][i] != 0)
{
printf("A bin was not empty when it should have been empty. Programming error.\n");
printf("bin[%d][%d][%d] was = %d\n", k, j, i, bin[k][j][i]);
exit(1);
}
}
}
}
minval = 999;
maxval = 0;
for (k = 0; k < nbin[XX]; k++)
{
if (k < minx+iIGNOREOUTER || k > maxx-iIGNOREOUTER)
{
continue;
}
for (j = 0; j < nbin[YY]; j++)
{
if (j < miny+iIGNOREOUTER || j > maxy-iIGNOREOUTER)
{
continue;
}
for (i = 0; i < nbin[ZZ]; i++)
{
if (i < minz+iIGNOREOUTER || i > maxz-iIGNOREOUTER)
{
continue;
}
tot += bin[k][j][i];
if (bin[k][j][i] > maxval)
{
maxval = bin[k][j][i];
}
if (bin[k][j][i] < minval)
{
minval = bin[k][j][i];
}
}
}
}
numcu = (maxx-minx+1-(2*iIGNOREOUTER))*(maxy-miny+1-(2*iIGNOREOUTER))*(maxz-minz+1-(2*iIGNOREOUTER));
if (bCALCDIV)
{
norm = static_cast<double>(numcu*numfr)/tot;
}
else
{
norm = 1.0;
}
for (k = 0; k < nbin[XX]; k++)
{
if (k < minx+iIGNOREOUTER || k > maxx-iIGNOREOUTER)
{
continue;
}
for (j = 0; j < nbin[YY]; j++)
{
if (j < miny+iIGNOREOUTER || j > maxy-iIGNOREOUTER)
{
continue;
}
for (i = 0; i < nbin[ZZ]; i++)
{
if (i < minz+iIGNOREOUTER || i > maxz-iIGNOREOUTER)
{
continue;
}
fprintf(flp, "%12.6f ", static_cast<double>(norm*bin[k][j][i])/numfr);
}
fprintf(flp, "\n");
}
fprintf(flp, "\n");
}
gmx_ffclose(flp);
if (bCALCDIV)
{
printf("Counts per frame in all %d cubes divided by %le\n", numcu, 1.0/norm);
printf("Normalized data: average %le, min %le, max %le\n", 1.0, minval*norm/numfr, maxval*norm/numfr);
}
else
{
printf("grid.cube contains counts per frame in all %d cubes\n", numcu);
printf("Raw data: average %le, min %le, max %le\n", 1.0/norm, static_cast<double>(minval)/numfr, static_cast<double>(maxval)/numfr);
}
return 0;
}
void do_force_lowlevel(t_forcerec *fr, t_inputrec *ir,
t_idef *idef, t_commrec *cr,
t_nrnb *nrnb, gmx_wallcycle_t wcycle,
t_mdatoms *md,
rvec x[], history_t *hist,
rvec f[],
rvec f_longrange[],
gmx_enerdata_t *enerd,
t_fcdata *fcd,
gmx_localtop_t *top,
gmx_genborn_t *born,
gmx_bool bBornRadii,
matrix box,
t_lambda *fepvals,
real *lambda,
t_graph *graph,
t_blocka *excl,
rvec mu_tot[],
int flags,
float *cycles_pme)
{
int i, j;
int donb_flags;
gmx_bool bSB;
int pme_flags;
matrix boxs;
rvec box_size;
t_pbc pbc;
real dvdl_dum[efptNR], dvdl_nb[efptNR];
#ifdef GMX_MPI
double t0 = 0.0, t1, t2, t3; /* time measurement for coarse load balancing */
#endif
set_pbc(&pbc, fr->ePBC, box);
/* reset free energy components */
for (i = 0; i < efptNR; i++)
{
dvdl_nb[i] = 0;
dvdl_dum[i] = 0;
}
/* Reset box */
for (i = 0; (i < DIM); i++)
{
box_size[i] = box[i][i];
}
debug_gmx();
/* do QMMM first if requested */
if (fr->bQMMM)
{
enerd->term[F_EQM] = calculate_QMMM(cr, x, f, fr);
}
/* Call the short range functions all in one go. */
#ifdef GMX_MPI
/*#define TAKETIME ((cr->npmenodes) && (fr->timesteps < 12))*/
#define TAKETIME FALSE
if (TAKETIME)
{
MPI_Barrier(cr->mpi_comm_mygroup);
t0 = MPI_Wtime();
}
#endif
if (ir->nwall)
{
/* foreign lambda component for walls */
real dvdl_walls = do_walls(ir, fr, box, md, x, f, lambda[efptVDW],
enerd->grpp.ener[egLJSR], nrnb);
enerd->dvdl_lin[efptVDW] += dvdl_walls;
}
/* If doing GB, reset dvda and calculate the Born radii */
if (ir->implicit_solvent)
{
wallcycle_sub_start(wcycle, ewcsNONBONDED);
for (i = 0; i < born->nr; i++)
{
fr->dvda[i] = 0;
}
if (bBornRadii)
{
calc_gb_rad(cr, fr, ir, top, x, &(fr->gblist), born, md, nrnb);
}
wallcycle_sub_stop(wcycle, ewcsNONBONDED);
}
where();
/* We only do non-bonded calculation with group scheme here, the verlet
* calls are done from do_force_cutsVERLET(). */
if (fr->cutoff_scheme == ecutsGROUP && (flags & GMX_FORCE_NONBONDED))
{
donb_flags = 0;
/* Add short-range interactions */
donb_flags |= GMX_NONBONDED_DO_SR;
/* Currently all group scheme kernels always calculate (shift-)forces */
if (flags & GMX_FORCE_FORCES)
{
donb_flags |= GMX_NONBONDED_DO_FORCE;
}
if (flags & GMX_FORCE_VIRIAL)
{
donb_flags |= GMX_NONBONDED_DO_SHIFTFORCE;
}
if (flags & GMX_FORCE_ENERGY)
{
donb_flags |= GMX_NONBONDED_DO_POTENTIAL;
}
if (flags & GMX_FORCE_DO_LR)
{
donb_flags |= GMX_NONBONDED_DO_LR;
}
wallcycle_sub_start(wcycle, ewcsNONBONDED);
do_nonbonded(fr, x, f, f_longrange, md, excl,
&enerd->grpp, nrnb,
lambda, dvdl_nb, -1, -1, donb_flags);
/* If we do foreign lambda and we have soft-core interactions
* we have to recalculate the (non-linear) energies contributions.
*/
if (fepvals->n_lambda > 0 && (flags & GMX_FORCE_DHDL) && fepvals->sc_alpha != 0)
{
for (i = 0; i < enerd->n_lambda; i++)
{
real lam_i[efptNR];
for (j = 0; j < efptNR; j++)
{
lam_i[j] = (i == 0 ? lambda[j] : fepvals->all_lambda[j][i-1]);
}
reset_foreign_enerdata(enerd);
do_nonbonded(fr, x, f, f_longrange, md, excl,
&(enerd->foreign_grpp), nrnb,
lam_i, dvdl_dum, -1, -1,
(donb_flags & ~GMX_NONBONDED_DO_FORCE) | GMX_NONBONDED_DO_FOREIGNLAMBDA);
sum_epot(&(enerd->foreign_grpp), enerd->foreign_term);
enerd->enerpart_lambda[i] += enerd->foreign_term[F_EPOT];
}
}
wallcycle_sub_stop(wcycle, ewcsNONBONDED);
where();
}
/* If we are doing GB, calculate bonded forces and apply corrections
* to the solvation forces */
/* MRS: Eventually, many need to include free energy contribution here! */
if (ir->implicit_solvent)
{
wallcycle_sub_start(wcycle, ewcsLISTED);
calc_gb_forces(cr, md, born, top, x, f, fr, idef,
ir->gb_algorithm, ir->sa_algorithm, nrnb, &pbc, graph, enerd);
wallcycle_sub_stop(wcycle, ewcsLISTED);
}
#ifdef GMX_MPI
if (TAKETIME)
{
t1 = MPI_Wtime();
fr->t_fnbf += t1-t0;
}
#endif
if (fepvals->sc_alpha != 0)
{
enerd->dvdl_nonlin[efptVDW] += dvdl_nb[efptVDW];
}
else
{
enerd->dvdl_lin[efptVDW] += dvdl_nb[efptVDW];
}
if (fepvals->sc_alpha != 0)
/* even though coulomb part is linear, we already added it, beacuse we
need to go through the vdw calculation anyway */
{
enerd->dvdl_nonlin[efptCOUL] += dvdl_nb[efptCOUL];
}
else
{
enerd->dvdl_lin[efptCOUL] += dvdl_nb[efptCOUL];
}
debug_gmx();
if (debug)
{
pr_rvecs(debug, 0, "fshift after SR", fr->fshift, SHIFTS);
}
/* Shift the coordinates. Must be done before listed forces and PPPM,
* but is also necessary for SHAKE and update, therefore it can NOT
* go when no listed forces have to be evaluated.
*
* The shifting and PBC code is deliberately not timed, since with
* the Verlet scheme it only takes non-zero time with triclinic
* boxes, and even then the time is around a factor of 100 less
* than the next smallest counter.
*/
/* Here sometimes we would not need to shift with NBFonly,
* but we do so anyhow for consistency of the returned coordinates.
*/
if (graph)
{
shift_self(graph, box, x);
if (TRICLINIC(box))
{
inc_nrnb(nrnb, eNR_SHIFTX, 2*graph->nnodes);
}
else
{
inc_nrnb(nrnb, eNR_SHIFTX, graph->nnodes);
}
}
/* Check whether we need to do listed interactions or correct for exclusions */
if (fr->bMolPBC &&
((flags & GMX_FORCE_LISTED)
|| EEL_RF(fr->eeltype) || EEL_FULL(fr->eeltype) || EVDW_PME(fr->vdwtype)))
{
/* TODO There are no electrostatics methods that require this
transformation, when using the Verlet scheme, so update the
above conditional. */
/* Since all atoms are in the rectangular or triclinic unit-cell,
* only single box vector shifts (2 in x) are required.
*/
set_pbc_dd(&pbc, fr->ePBC, cr->dd, TRUE, box);
}
debug_gmx();
do_force_listed(wcycle, box, ir->fepvals, cr->ms,
idef, (const rvec *) x, hist, f, fr,
&pbc, graph, enerd, nrnb, lambda, md, fcd,
DOMAINDECOMP(cr) ? cr->dd->gatindex : NULL,
flags);
where();
*cycles_pme = 0;
clear_mat(fr->vir_el_recip);
clear_mat(fr->vir_lj_recip);
/* Do long-range electrostatics and/or LJ-PME, including related short-range
* corrections.
*/
if (EEL_FULL(fr->eeltype) || EVDW_PME(fr->vdwtype))
{
int status = 0;
real Vlr_q = 0, Vlr_lj = 0, Vcorr_q = 0, Vcorr_lj = 0;
real dvdl_long_range_q = 0, dvdl_long_range_lj = 0;
bSB = (ir->nwall == 2);
if (bSB)
{
copy_mat(box, boxs);
svmul(ir->wall_ewald_zfac, boxs[ZZ], boxs[ZZ]);
box_size[ZZ] *= ir->wall_ewald_zfac;
}
if (EEL_PME_EWALD(fr->eeltype) || EVDW_PME(fr->vdwtype))
{
real dvdl_long_range_correction_q = 0;
real dvdl_long_range_correction_lj = 0;
/* With the Verlet scheme exclusion forces are calculated
* in the non-bonded kernel.
*/
/* The TPI molecule does not have exclusions with the rest
* of the system and no intra-molecular PME grid
* contributions will be calculated in
* gmx_pme_calc_energy.
*/
if ((ir->cutoff_scheme == ecutsGROUP && fr->n_tpi == 0) ||
ir->ewald_geometry != eewg3D ||
ir->epsilon_surface != 0)
{
int nthreads, t;
wallcycle_sub_start(wcycle, ewcsEWALD_CORRECTION);
if (fr->n_tpi > 0)
{
gmx_fatal(FARGS, "TPI with PME currently only works in a 3D geometry with tin-foil boundary conditions");
}
nthreads = gmx_omp_nthreads_get(emntBonded);
#pragma omp parallel for num_threads(nthreads) schedule(static)
for (t = 0; t < nthreads; t++)
{
int i;
rvec *fnv;
tensor *vir_q, *vir_lj;
real *Vcorrt_q, *Vcorrt_lj, *dvdlt_q, *dvdlt_lj;
if (t == 0)
{
fnv = fr->f_novirsum;
vir_q = &fr->vir_el_recip;
vir_lj = &fr->vir_lj_recip;
Vcorrt_q = &Vcorr_q;
Vcorrt_lj = &Vcorr_lj;
dvdlt_q = &dvdl_long_range_correction_q;
dvdlt_lj = &dvdl_long_range_correction_lj;
}
else
{
fnv = fr->f_t[t].f;
vir_q = &fr->f_t[t].vir_q;
vir_lj = &fr->f_t[t].vir_lj;
Vcorrt_q = &fr->f_t[t].Vcorr_q;
Vcorrt_lj = &fr->f_t[t].Vcorr_lj;
dvdlt_q = &fr->f_t[t].dvdl[efptCOUL];
dvdlt_lj = &fr->f_t[t].dvdl[efptVDW];
for (i = 0; i < fr->natoms_force; i++)
{
clear_rvec(fnv[i]);
}
clear_mat(*vir_q);
clear_mat(*vir_lj);
}
*dvdlt_q = 0;
*dvdlt_lj = 0;
ewald_LRcorrection(fr->excl_load[t], fr->excl_load[t+1],
cr, t, fr,
md->chargeA, md->chargeB,
md->sqrt_c6A, md->sqrt_c6B,
md->sigmaA, md->sigmaB,
md->sigma3A, md->sigma3B,
md->nChargePerturbed || md->nTypePerturbed,
ir->cutoff_scheme != ecutsVERLET,
excl, x, bSB ? boxs : box, mu_tot,
ir->ewald_geometry,
ir->epsilon_surface,
fnv, *vir_q, *vir_lj,
Vcorrt_q, Vcorrt_lj,
lambda[efptCOUL], lambda[efptVDW],
dvdlt_q, dvdlt_lj);
}
if (nthreads > 1)
{
reduce_thread_forces(fr->natoms_force, fr->f_novirsum,
fr->vir_el_recip, fr->vir_lj_recip,
&Vcorr_q, &Vcorr_lj,
&dvdl_long_range_correction_q,
&dvdl_long_range_correction_lj,
nthreads, fr->f_t);
}
wallcycle_sub_stop(wcycle, ewcsEWALD_CORRECTION);
}
if (EEL_PME_EWALD(fr->eeltype) && fr->n_tpi == 0)
{
/* This is not in a subcounter because it takes a
negligible and constant-sized amount of time */
Vcorr_q += ewald_charge_correction(cr, fr, lambda[efptCOUL], box,
&dvdl_long_range_correction_q,
fr->vir_el_recip);
}
enerd->dvdl_lin[efptCOUL] += dvdl_long_range_correction_q;
enerd->dvdl_lin[efptVDW] += dvdl_long_range_correction_lj;
if ((EEL_PME(fr->eeltype) || EVDW_PME(fr->vdwtype)) && (cr->duty & DUTY_PME))
{
/* Do reciprocal PME for Coulomb and/or LJ. */
assert(fr->n_tpi >= 0);
if (fr->n_tpi == 0 || (flags & GMX_FORCE_STATECHANGED))
{
pme_flags = GMX_PME_SPREAD | GMX_PME_SOLVE;
if (EEL_PME(fr->eeltype))
{
pme_flags |= GMX_PME_DO_COULOMB;
}
if (EVDW_PME(fr->vdwtype))
{
pme_flags |= GMX_PME_DO_LJ;
}
if (flags & GMX_FORCE_FORCES)
{
pme_flags |= GMX_PME_CALC_F;
}
if (flags & GMX_FORCE_VIRIAL)
{
pme_flags |= GMX_PME_CALC_ENER_VIR;
}
if (fr->n_tpi > 0)
{
/* We don't calculate f, but we do want the potential */
pme_flags |= GMX_PME_CALC_POT;
}
wallcycle_start(wcycle, ewcPMEMESH);
status = gmx_pme_do(fr->pmedata,
0, md->homenr - fr->n_tpi,
x, fr->f_novirsum,
md->chargeA, md->chargeB,
md->sqrt_c6A, md->sqrt_c6B,
md->sigmaA, md->sigmaB,
bSB ? boxs : box, cr,
DOMAINDECOMP(cr) ? dd_pme_maxshift_x(cr->dd) : 0,
DOMAINDECOMP(cr) ? dd_pme_maxshift_y(cr->dd) : 0,
nrnb, wcycle,
fr->vir_el_recip, fr->ewaldcoeff_q,
fr->vir_lj_recip, fr->ewaldcoeff_lj,
&Vlr_q, &Vlr_lj,
lambda[efptCOUL], lambda[efptVDW],
&dvdl_long_range_q, &dvdl_long_range_lj, pme_flags);
*cycles_pme = wallcycle_stop(wcycle, ewcPMEMESH);
if (status != 0)
{
gmx_fatal(FARGS, "Error %d in reciprocal PME routine", status);
}
/* We should try to do as little computation after
* this as possible, because parallel PME synchronizes
* the nodes, so we want all load imbalance of the
* rest of the force calculation to be before the PME
* call. DD load balancing is done on the whole time
* of the force call (without PME).
*/
}
if (fr->n_tpi > 0)
{
if (EVDW_PME(ir->vdwtype))
{
gmx_fatal(FARGS, "Test particle insertion not implemented with LJ-PME");
}
/* Determine the PME grid energy of the test molecule
* with the PME grid potential of the other charges.
*/
gmx_pme_calc_energy(fr->pmedata, fr->n_tpi,
x + md->homenr - fr->n_tpi,
md->chargeA + md->homenr - fr->n_tpi,
&Vlr_q);
}
}
}
if (!EEL_PME(fr->eeltype) && EEL_PME_EWALD(fr->eeltype))
{
Vlr_q = do_ewald(ir, x, fr->f_novirsum,
md->chargeA, md->chargeB,
box_size, cr, md->homenr,
fr->vir_el_recip, fr->ewaldcoeff_q,
lambda[efptCOUL], &dvdl_long_range_q, fr->ewald_table);
}
/* Note that with separate PME nodes we get the real energies later */
enerd->dvdl_lin[efptCOUL] += dvdl_long_range_q;
enerd->dvdl_lin[efptVDW] += dvdl_long_range_lj;
enerd->term[F_COUL_RECIP] = Vlr_q + Vcorr_q;
enerd->term[F_LJ_RECIP] = Vlr_lj + Vcorr_lj;
if (debug)
{
fprintf(debug, "Vlr_q = %g, Vcorr_q = %g, Vlr_corr_q = %g\n",
Vlr_q, Vcorr_q, enerd->term[F_COUL_RECIP]);
pr_rvecs(debug, 0, "vir_el_recip after corr", fr->vir_el_recip, DIM);
pr_rvecs(debug, 0, "fshift after LR Corrections", fr->fshift, SHIFTS);
fprintf(debug, "Vlr_lj: %g, Vcorr_lj = %g, Vlr_corr_lj = %g\n",
Vlr_lj, Vcorr_lj, enerd->term[F_LJ_RECIP]);
pr_rvecs(debug, 0, "vir_lj_recip after corr", fr->vir_lj_recip, DIM);
}
}
else
{
/* Is there a reaction-field exclusion correction needed? */
if (EEL_RF(fr->eeltype) && eelRF_NEC != fr->eeltype)
{
/* With the Verlet scheme, exclusion forces are calculated
* in the non-bonded kernel.
*/
if (ir->cutoff_scheme != ecutsVERLET)
{
real dvdl_rf_excl = 0;
enerd->term[F_RF_EXCL] =
RF_excl_correction(fr, graph, md, excl, x, f,
fr->fshift, &pbc, lambda[efptCOUL], &dvdl_rf_excl);
enerd->dvdl_lin[efptCOUL] += dvdl_rf_excl;
}
}
}
where();
debug_gmx();
if (debug)
{
print_nrnb(debug, nrnb);
}
debug_gmx();
#ifdef GMX_MPI
if (TAKETIME)
{
t2 = MPI_Wtime();
MPI_Barrier(cr->mpi_comm_mygroup);
t3 = MPI_Wtime();
fr->t_wait += t3-t2;
if (fr->timesteps == 11)
{
char buf[22];
fprintf(stderr, "* PP load balancing info: rank %d, step %s, rel wait time=%3.0f%% , load string value: %7.2f\n",
cr->nodeid, gmx_step_str(fr->timesteps, buf),
100*fr->t_wait/(fr->t_wait+fr->t_fnbf),
(fr->t_fnbf+fr->t_wait)/fr->t_fnbf);
}
fr->timesteps++;
}
#endif
if (debug)
{
pr_rvecs(debug, 0, "fshift after bondeds", fr->fshift, SHIFTS);
}
}
int gmx_rmsf(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes the root mean square fluctuation (RMSF, i.e. standard ",
"deviation) of atomic positions in the trajectory (supplied with [TT]-f[tt])",
"after (optionally) fitting to a reference frame (supplied with [TT]-s[tt]).[PAR]",
"With option [TT]-oq[tt] the RMSF values are converted to B-factor",
"values, which are written to a [TT].pdb[tt] file with the coordinates, of the",
"structure file, or of a [TT].pdb[tt] file when [TT]-q[tt] is specified.",
"Option [TT]-ox[tt] writes the B-factors to a file with the average",
"coordinates.[PAR]",
"With the option [TT]-od[tt] the root mean square deviation with",
"respect to the reference structure is calculated.[PAR]",
"With the option [TT]-aniso[tt], [THISMODULE] will compute anisotropic",
"temperature factors and then it will also output average coordinates",
"and a [TT].pdb[tt] file with ANISOU records (corresonding to the [TT]-oq[tt]",
"or [TT]-ox[tt] option). Please note that the U values",
"are orientation-dependent, so before comparison with experimental data",
"you should verify that you fit to the experimental coordinates.[PAR]",
"When a [TT].pdb[tt] input file is passed to the program and the [TT]-aniso[tt]",
"flag is set",
"a correlation plot of the Uij will be created, if any anisotropic",
"temperature factors are present in the [TT].pdb[tt] file.[PAR]",
"With option [TT]-dir[tt] the average MSF (3x3) matrix is diagonalized.",
"This shows the directions in which the atoms fluctuate the most and",
"the least."
};
static gmx_bool bRes = FALSE, bAniso = FALSE, bdevX = FALSE, bFit = TRUE;
t_pargs pargs[] = {
{ "-res", FALSE, etBOOL, {&bRes},
"Calculate averages for each residue" },
{ "-aniso", FALSE, etBOOL, {&bAniso},
"Compute anisotropic termperature factors" },
{ "-fit", FALSE, etBOOL, {&bFit},
"Do a least squares superposition before computing RMSF. Without this you must make sure that the reference structure and the trajectory match." }
};
int natom;
int step, nre, natoms, i, g, m, teller = 0;
real t, lambda, *w_rls, *w_rms;
t_tpxheader header;
t_inputrec ir;
t_topology top;
int ePBC;
t_atoms *pdbatoms, *refatoms;
gmx_bool bCont;
matrix box, pdbbox;
rvec *x, *pdbx, *xref;
t_trxstatus *status;
int npdbatoms, res0;
char buf[256];
const char *label;
char title[STRLEN];
FILE *fp; /* the graphics file */
const char *devfn, *dirfn;
int resind;
gmx_bool bReadPDB;
atom_id *index;
int isize;
char *grpnames;
real bfac, pdb_bfac, *Uaver;
double **U, *xav;
atom_id aid;
rvec *rmsd_x = NULL;
double *rmsf, invcount, totmass;
int d;
real count = 0;
rvec xcm;
gmx_rmpbc_t gpbc = NULL;
output_env_t oenv;
const char *leg[2] = { "MD", "X-Ray" };
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efPDB, "-q", NULL, ffOPTRD },
{ efPDB, "-oq", "bfac", ffOPTWR },
{ efPDB, "-ox", "xaver", ffOPTWR },
{ efXVG, "-o", "rmsf", ffWRITE },
{ efXVG, "-od", "rmsdev", ffOPTWR },
{ efXVG, "-oc", "correl", ffOPTWR },
{ efLOG, "-dir", "rmsf", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_CAN_VIEW | PCA_BE_NICE,
NFILE, fnm, asize(pargs), pargs, asize(desc), desc, 0, NULL,
&oenv))
{
return 0;
}
bReadPDB = ftp2bSet(efPDB, NFILE, fnm);
devfn = opt2fn_null("-od", NFILE, fnm);
dirfn = opt2fn_null("-dir", NFILE, fnm);
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC, &xref, NULL, box, TRUE);
snew(w_rls, top.atoms.nr);
fprintf(stderr, "Select group(s) for root mean square calculation\n");
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &isize, &index, &grpnames);
/* Set the weight */
for (i = 0; i < isize; i++)
{
w_rls[index[i]] = top.atoms.atom[index[i]].m;
}
/* Malloc the rmsf arrays */
snew(xav, isize*DIM);
snew(U, isize);
for (i = 0; i < isize; i++)
{
snew(U[i], DIM*DIM);
}
snew(rmsf, isize);
if (devfn)
{
snew(rmsd_x, isize);
}
if (bReadPDB)
{
get_stx_coordnum(opt2fn("-q", NFILE, fnm), &npdbatoms);
snew(pdbatoms, 1);
snew(refatoms, 1);
init_t_atoms(pdbatoms, npdbatoms, TRUE);
init_t_atoms(refatoms, npdbatoms, TRUE);
snew(pdbx, npdbatoms);
/* Read coordinates twice */
read_stx_conf(opt2fn("-q", NFILE, fnm), title, pdbatoms, pdbx, NULL, NULL, pdbbox);
read_stx_conf(opt2fn("-q", NFILE, fnm), title, refatoms, pdbx, NULL, NULL, pdbbox);
}
else
{
pdbatoms = &top.atoms;
refatoms = &top.atoms;
pdbx = xref;
npdbatoms = pdbatoms->nr;
snew(pdbatoms->pdbinfo, npdbatoms);
copy_mat(box, pdbbox);
}
if (bFit)
{
sub_xcm(xref, isize, index, top.atoms.atom, xcm, FALSE);
}
natom = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
if (bFit)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, natom);
}
/* Now read the trj again to compute fluctuations */
teller = 0;
do
{
if (bFit)
{
/* Remove periodic boundary */
gmx_rmpbc(gpbc, natom, box, x);
/* Set center of mass to zero */
sub_xcm(x, isize, index, top.atoms.atom, xcm, FALSE);
/* Fit to reference structure */
do_fit(natom, w_rls, xref, x);
}
/* Calculate Anisotropic U Tensor */
for (i = 0; i < isize; i++)
{
aid = index[i];
for (d = 0; d < DIM; d++)
{
xav[i*DIM + d] += x[aid][d];
for (m = 0; m < DIM; m++)
{
U[i][d*DIM + m] += x[aid][d]*x[aid][m];
}
}
}
if (devfn)
{
/* Calculate RMS Deviation */
for (i = 0; (i < isize); i++)
{
aid = index[i];
for (d = 0; (d < DIM); d++)
{
rmsd_x[i][d] += sqr(x[aid][d]-xref[aid][d]);
}
}
}
count += 1.0;
teller++;
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (bFit)
{
gmx_rmpbc_done(gpbc);
}
invcount = 1.0/count;
snew(Uaver, DIM*DIM);
totmass = 0;
for (i = 0; i < isize; i++)
{
for (d = 0; d < DIM; d++)
{
xav[i*DIM + d] *= invcount;
}
for (d = 0; d < DIM; d++)
{
for (m = 0; m < DIM; m++)
{
U[i][d*DIM + m] = U[i][d*DIM + m]*invcount
- xav[i*DIM + d]*xav[i*DIM + m];
Uaver[3*d+m] += top.atoms.atom[index[i]].m*U[i][d*DIM + m];
}
}
totmass += top.atoms.atom[index[i]].m;
}
for (d = 0; d < DIM*DIM; d++)
{
Uaver[d] /= totmass;
}
if (bRes)
{
for (d = 0; d < DIM*DIM; d++)
{
average_residues(NULL, U, d, isize, index, w_rls, &top.atoms);
}
}
if (bAniso)
{
for (i = 0; i < isize; i++)
{
aid = index[i];
pdbatoms->pdbinfo[aid].bAnisotropic = TRUE;
pdbatoms->pdbinfo[aid].uij[U11] = 1e6*U[i][XX*DIM + XX];
pdbatoms->pdbinfo[aid].uij[U22] = 1e6*U[i][YY*DIM + YY];
pdbatoms->pdbinfo[aid].uij[U33] = 1e6*U[i][ZZ*DIM + ZZ];
pdbatoms->pdbinfo[aid].uij[U12] = 1e6*U[i][XX*DIM + YY];
pdbatoms->pdbinfo[aid].uij[U13] = 1e6*U[i][XX*DIM + ZZ];
pdbatoms->pdbinfo[aid].uij[U23] = 1e6*U[i][YY*DIM + ZZ];
}
}
if (bRes)
{
label = "Residue";
}
else
{
label = "Atom";
}
for (i = 0; i < isize; i++)
{
rmsf[i] = U[i][XX*DIM + XX] + U[i][YY*DIM + YY] + U[i][ZZ*DIM + ZZ];
}
if (dirfn)
{
fprintf(stdout, "\n");
print_dir(stdout, Uaver);
fp = gmx_ffopen(dirfn, "w");
print_dir(fp, Uaver);
gmx_ffclose(fp);
}
for (i = 0; i < isize; i++)
{
sfree(U[i]);
}
sfree(U);
/* Write RMSF output */
if (bReadPDB)
{
bfac = 8.0*M_PI*M_PI/3.0*100;
fp = xvgropen(ftp2fn(efXVG, NFILE, fnm), "B-Factors",
label, "(A\\b\\S\\So\\N\\S2\\N)", oenv);
xvgr_legend(fp, 2, leg, oenv);
for (i = 0; (i < isize); i++)
{
if (!bRes || i+1 == isize ||
top.atoms.atom[index[i]].resind != top.atoms.atom[index[i+1]].resind)
{
resind = top.atoms.atom[index[i]].resind;
pdb_bfac = find_pdb_bfac(pdbatoms, &top.atoms.resinfo[resind],
*(top.atoms.atomname[index[i]]));
fprintf(fp, "%5d %10.5f %10.5f\n",
bRes ? top.atoms.resinfo[top.atoms.atom[index[i]].resind].nr : index[i]+1, rmsf[i]*bfac,
pdb_bfac);
}
}
gmx_ffclose(fp);
}
else
{
fp = xvgropen(ftp2fn(efXVG, NFILE, fnm), "RMS fluctuation", label, "(nm)", oenv);
for (i = 0; i < isize; i++)
{
if (!bRes || i+1 == isize ||
top.atoms.atom[index[i]].resind != top.atoms.atom[index[i+1]].resind)
{
fprintf(fp, "%5d %8.4f\n",
bRes ? top.atoms.resinfo[top.atoms.atom[index[i]].resind].nr : index[i]+1, sqrt(rmsf[i]));
}
}
gmx_ffclose(fp);
}
for (i = 0; i < isize; i++)
{
pdbatoms->pdbinfo[index[i]].bfac = 800*M_PI*M_PI/3.0*rmsf[i];
}
if (devfn)
{
for (i = 0; i < isize; i++)
{
rmsf[i] = (rmsd_x[i][XX]+rmsd_x[i][YY]+rmsd_x[i][ZZ])/count;
}
if (bRes)
{
average_residues(rmsf, NULL, 0, isize, index, w_rls, &top.atoms);
}
/* Write RMSD output */
fp = xvgropen(devfn, "RMS Deviation", label, "(nm)", oenv);
for (i = 0; i < isize; i++)
{
if (!bRes || i+1 == isize ||
top.atoms.atom[index[i]].resind != top.atoms.atom[index[i+1]].resind)
{
fprintf(fp, "%5d %8.4f\n",
bRes ? top.atoms.resinfo[top.atoms.atom[index[i]].resind].nr : index[i]+1, sqrt(rmsf[i]));
}
}
gmx_ffclose(fp);
}
if (opt2bSet("-oq", NFILE, fnm))
{
/* Write a .pdb file with B-factors and optionally anisou records */
for (i = 0; i < isize; i++)
{
rvec_inc(xref[index[i]], xcm);
}
write_sto_conf_indexed(opt2fn("-oq", NFILE, fnm), title, pdbatoms, pdbx,
NULL, ePBC, pdbbox, isize, index);
}
if (opt2bSet("-ox", NFILE, fnm))
{
/* Misuse xref as a temporary array */
for (i = 0; i < isize; i++)
{
for (d = 0; d < DIM; d++)
{
xref[index[i]][d] = xcm[d] + xav[i*DIM + d];
}
}
/* Write a .pdb file with B-factors and optionally anisou records */
write_sto_conf_indexed(opt2fn("-ox", NFILE, fnm), title, pdbatoms, xref, NULL,
ePBC, pdbbox, isize, index);
}
if (bAniso)
{
correlate_aniso(opt2fn("-oc", NFILE, fnm), refatoms, pdbatoms, oenv);
do_view(oenv, opt2fn("-oc", NFILE, fnm), "-nxy");
}
do_view(oenv, opt2fn("-o", NFILE, fnm), "-nxy");
if (devfn)
{
do_view(oenv, opt2fn("-od", NFILE, fnm), "-nxy");
}
return 0;
}
int gmx_convert_tpr(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] can edit run input files in four ways.[PAR]",
"[BB]1.[bb] by modifying the number of steps in a run input file",
"with options [TT]-extend[tt], [TT]-until[tt] or [TT]-nsteps[tt]",
"(nsteps=-1 means unlimited number of steps)[PAR]",
"[BB]2.[bb] (OBSOLETE) by creating a run input file",
"for a continuation run when your simulation has crashed due to e.g.",
"a full disk, or by making a continuation run input file.",
"This option is obsolete, since mdrun now writes and reads",
"checkpoint files.",
"[BB]Note[bb] that a frame with coordinates and velocities is needed.",
"When pressure and/or Nose-Hoover temperature coupling is used",
"an energy file can be supplied to get an exact continuation",
"of the original run.[PAR]",
"[BB]3.[bb] by creating a [REF].tpx[ref] file for a subset of your original",
"tpx file, which is useful when you want to remove the solvent from",
"your [REF].tpx[ref] file, or when you want to make e.g. a pure C[GRK]alpha[grk] [REF].tpx[ref] file.",
"Note that you may need to use [TT]-nsteps -1[tt] (or similar) to get",
"this to work.",
"[BB]WARNING: this [REF].tpx[ref] file is not fully functional[bb].[PAR]",
"[BB]4.[bb] by setting the charges of a specified group",
"to zero. This is useful when doing free energy estimates",
"using the LIE (Linear Interaction Energy) method."
};
const char *top_fn, *frame_fn;
struct t_fileio *fp;
ener_file_t fp_ener = NULL;
gmx_trr_header_t head;
int i;
gmx_int64_t nsteps_req, run_step, frame;
double run_t, state_t;
gmx_bool bOK, bNsteps, bExtend, bUntil, bTime, bTraj;
gmx_bool bFrame, bUse, bSel, bNeedEner, bReadEner, bScanEner, bFepState;
gmx_mtop_t mtop;
t_atoms atoms;
t_inputrec *ir;
t_state state;
rvec *newx = NULL, *newv = NULL, *tmpx, *tmpv;
matrix newbox;
int gnx;
char *grpname;
atom_id *index = NULL;
int nre;
gmx_enxnm_t *enm = NULL;
t_enxframe *fr_ener = NULL;
char buf[200], buf2[200];
output_env_t oenv;
t_filenm fnm[] = {
{ efTPR, NULL, NULL, ffREAD },
{ efTRN, "-f", NULL, ffOPTRD },
{ efEDR, "-e", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTPR, "-o", "tprout", ffWRITE }
};
#define NFILE asize(fnm)
/* Command line options */
static int nsteps_req_int = 0;
static real start_t = -1.0, extend_t = 0.0, until_t = 0.0;
static int init_fep_state = 0;
static gmx_bool bContinuation = TRUE, bZeroQ = FALSE, bVel = TRUE;
static t_pargs pa[] = {
{ "-extend", FALSE, etREAL, {&extend_t},
"Extend runtime by this amount (ps)" },
{ "-until", FALSE, etREAL, {&until_t},
"Extend runtime until this ending time (ps)" },
{ "-nsteps", FALSE, etINT, {&nsteps_req_int},
"Change the number of steps" },
{ "-time", FALSE, etREAL, {&start_t},
"Continue from frame at this time (ps) instead of the last frame" },
{ "-zeroq", FALSE, etBOOL, {&bZeroQ},
"Set the charges of a group (from the index) to zero" },
{ "-vel", FALSE, etBOOL, {&bVel},
"Require velocities from trajectory" },
{ "-cont", FALSE, etBOOL, {&bContinuation},
"For exact continuation, the constraints should not be applied before the first step" },
{ "-init_fep_state", FALSE, etINT, {&init_fep_state},
"fep state to initialize from" },
};
/* Parse the command line */
if (!parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
/* Convert int to gmx_int64_t */
nsteps_req = nsteps_req_int;
bNsteps = opt2parg_bSet("-nsteps", asize(pa), pa);
bExtend = opt2parg_bSet("-extend", asize(pa), pa);
bUntil = opt2parg_bSet("-until", asize(pa), pa);
bFepState = opt2parg_bSet("-init_fep_state", asize(pa), pa);
bTime = opt2parg_bSet("-time", asize(pa), pa);
bTraj = (opt2bSet("-f", NFILE, fnm) || bTime);
top_fn = ftp2fn(efTPR, NFILE, fnm);
fprintf(stderr, "Reading toplogy and stuff from %s\n", top_fn);
snew(ir, 1);
read_tpx_state(top_fn, ir, &state, &mtop);
run_step = ir->init_step;
run_t = ir->init_step*ir->delta_t + ir->init_t;
if (!EI_STATE_VELOCITY(ir->eI))
{
bVel = FALSE;
}
if (bTraj)
{
fprintf(stderr, "\n"
"NOTE: Reading the state from trajectory is an obsolete feature of gmx convert-tpr.\n"
" Continuation should be done by loading a checkpoint file with mdrun -cpi\n"
" This guarantees that all state variables are transferred.\n"
" gmx convert-tpr is now only useful for increasing nsteps,\n"
" but even that can often be avoided by using mdrun -maxh\n"
"\n");
if (ir->bContinuation != bContinuation)
{
fprintf(stderr, "Modifying ir->bContinuation to %s\n",
bool_names[bContinuation]);
}
ir->bContinuation = bContinuation;
bNeedEner = (ir->epc == epcPARRINELLORAHMAN || ir->etc == etcNOSEHOOVER);
bReadEner = (bNeedEner && ftp2bSet(efEDR, NFILE, fnm));
bScanEner = (bReadEner && !bTime);
if (ir->epc != epcNO || EI_SD(ir->eI) || ir->eI == eiBD)
{
fprintf(stderr, "NOTE: The simulation uses pressure coupling and/or stochastic dynamics.\n"
"gmx convert-tpr can not provide binary identical continuation.\n"
"If you want that, supply a checkpoint file to mdrun\n\n");
}
if (EI_SD(ir->eI) || ir->eI == eiBD)
{
fprintf(stderr, "\nChanging ld-seed from %" GMX_PRId64 " ", ir->ld_seed);
ir->ld_seed = (gmx_int64_t)gmx_rng_make_seed();
fprintf(stderr, "to %" GMX_PRId64 "\n\n", ir->ld_seed);
}
frame_fn = ftp2fn(efTRN, NFILE, fnm);
if (fn2ftp(frame_fn) == efCPT)
{
int sim_part;
fprintf(stderr,
"\nREADING STATE FROM CHECKPOINT %s...\n\n",
frame_fn);
read_checkpoint_state(frame_fn, &sim_part,
&run_step, &run_t, &state);
}
else
{
fprintf(stderr,
"\nREADING COORDS, VELS AND BOX FROM TRAJECTORY %s...\n\n",
frame_fn);
fp = gmx_trr_open(frame_fn, "r");
if (bScanEner)
{
fp_ener = open_enx(ftp2fn(efEDR, NFILE, fnm), "r");
do_enxnms(fp_ener, &nre, &enm);
snew(fr_ener, 1);
fr_ener->t = -1e-12;
}
/* Now scan until the last set of x and v (step == 0)
* or the ones at step step.
*/
bFrame = TRUE;
frame = 0;
while (bFrame)
{
bFrame = gmx_trr_read_frame_header(fp, &head, &bOK);
if (bOK && frame == 0)
{
if (mtop.natoms != head.natoms)
{
gmx_fatal(FARGS, "Number of atoms in Topology (%d) "
"is not the same as in Trajectory (%d)\n",
mtop.natoms, head.natoms);
}
snew(newx, head.natoms);
snew(newv, head.natoms);
}
bFrame = bFrame && bOK;
if (bFrame)
{
bOK = gmx_trr_read_frame_data(fp, &head, newbox, newx, newv, NULL);
}
bFrame = bFrame && bOK;
bUse = FALSE;
if (bFrame &&
(head.x_size) && (head.v_size || !bVel))
{
bUse = TRUE;
if (bScanEner)
{
/* Read until the energy time is >= the trajectory time */
while (fr_ener->t < head.t && do_enx(fp_ener, fr_ener))
{
;
}
bUse = (fr_ener->t == head.t);
}
if (bUse)
{
tmpx = newx;
newx = state.x;
state.x = tmpx;
tmpv = newv;
newv = state.v;
state.v = tmpv;
run_t = head.t;
run_step = head.step;
state.fep_state = head.fep_state;
state.lambda[efptFEP] = head.lambda;
copy_mat(newbox, state.box);
}
}
if (bFrame || !bOK)
{
sprintf(buf, "\r%s %s frame %s%s: step %s%s time %s",
"%s", "%s", "%6", GMX_PRId64, "%6", GMX_PRId64, " %8.3f");
fprintf(stderr, buf,
bUse ? "Read " : "Skipped", ftp2ext(fn2ftp(frame_fn)),
frame, head.step, head.t);
frame++;
if (bTime && (head.t >= start_t))
{
bFrame = FALSE;
}
}
}
if (bScanEner)
{
close_enx(fp_ener);
free_enxframe(fr_ener);
free_enxnms(nre, enm);
}
gmx_trr_close(fp);
fprintf(stderr, "\n");
if (!bOK)
{
fprintf(stderr, "%s frame %s (step %s, time %g) is incomplete\n",
ftp2ext(fn2ftp(frame_fn)), gmx_step_str(frame-1, buf2),
gmx_step_str(head.step, buf), head.t);
}
fprintf(stderr, "\nUsing frame of step %s time %g\n",
gmx_step_str(run_step, buf), run_t);
if (bNeedEner)
{
if (bReadEner)
{
get_enx_state(ftp2fn(efEDR, NFILE, fnm), run_t, &mtop.groups, ir, &state);
}
else
{
fprintf(stderr, "\nWARNING: The simulation uses %s temperature and/or %s pressure coupling,\n"
" the continuation will only be exact when an energy file is supplied\n\n",
ETCOUPLTYPE(etcNOSEHOOVER),
EPCOUPLTYPE(epcPARRINELLORAHMAN));
}
}
if (bFepState)
{
ir->fepvals->init_fep_state = init_fep_state;
}
}
}
if (bNsteps)
{
fprintf(stderr, "Setting nsteps to %s\n", gmx_step_str(nsteps_req, buf));
ir->nsteps = nsteps_req;
}
else
{
/* Determine total number of steps remaining */
if (bExtend)
{
ir->nsteps = ir->nsteps - (run_step - ir->init_step) + (gmx_int64_t)(extend_t/ir->delta_t + 0.5);
printf("Extending remaining runtime of by %g ps (now %s steps)\n",
extend_t, gmx_step_str(ir->nsteps, buf));
}
else if (bUntil)
{
printf("nsteps = %s, run_step = %s, current_t = %g, until = %g\n",
gmx_step_str(ir->nsteps, buf),
gmx_step_str(run_step, buf2),
run_t, until_t);
ir->nsteps = (gmx_int64_t)((until_t - run_t)/ir->delta_t + 0.5);
printf("Extending remaining runtime until %g ps (now %s steps)\n",
until_t, gmx_step_str(ir->nsteps, buf));
}
else
{
ir->nsteps -= run_step - ir->init_step;
/* Print message */
printf("%s steps (%g ps) remaining from first run.\n",
gmx_step_str(ir->nsteps, buf), ir->nsteps*ir->delta_t);
}
}
if (bNsteps || bZeroQ || (ir->nsteps > 0))
{
ir->init_step = run_step;
if (ftp2bSet(efNDX, NFILE, fnm) ||
!(bNsteps || bExtend || bUntil || bTraj))
{
atoms = gmx_mtop_global_atoms(&mtop);
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm), 1,
&gnx, &index, &grpname);
if (!bZeroQ)
{
bSel = (gnx != state.natoms);
for (i = 0; ((i < gnx) && (!bSel)); i++)
{
bSel = (i != index[i]);
}
}
else
{
bSel = FALSE;
}
if (bSel)
{
fprintf(stderr, "Will write subset %s of original tpx containing %d "
"atoms\n", grpname, gnx);
reduce_topology_x(gnx, index, &mtop, state.x, state.v);
state.natoms = gnx;
}
else if (bZeroQ)
{
zeroq(index, &mtop);
fprintf(stderr, "Zero-ing charges for group %s\n", grpname);
}
else
{
fprintf(stderr, "Will write full tpx file (no selection)\n");
}
}
state_t = ir->init_t + ir->init_step*ir->delta_t;
sprintf(buf, "Writing statusfile with starting step %s%s and length %s%s steps...\n", "%10", GMX_PRId64, "%10", GMX_PRId64);
fprintf(stderr, buf, ir->init_step, ir->nsteps);
fprintf(stderr, " time %10.3f and length %10.3f ps\n",
state_t, ir->nsteps*ir->delta_t);
write_tpx_state(opt2fn("-o", NFILE, fnm), ir, &state, &mtop);
}
else
{
printf("You've simulated long enough. Not writing tpr file\n");
}
return 0;
}
void do_force_lowlevel(t_forcerec *fr, t_inputrec *ir,
t_idef *idef, t_commrec *cr,
t_nrnb *nrnb, gmx_wallcycle_t wcycle,
t_mdatoms *md,
rvec x[], history_t *hist,
rvec f[],
rvec f_longrange[],
gmx_enerdata_t *enerd,
t_fcdata *fcd,
gmx_localtop_t *top,
gmx_genborn_t *born,
gmx_bool bBornRadii,
matrix box,
t_lambda *fepvals,
real *lambda,
t_graph *graph,
t_blocka *excl,
rvec mu_tot[],
int flags,
float *cycles_pme)
{
int i, j;
int donb_flags;
gmx_bool bSB;
int pme_flags;
matrix boxs;
rvec box_size;
t_pbc pbc;
real dvdl_dum[efptNR], dvdl_nb[efptNR];
#ifdef GMX_MPI
double t0 = 0.0, t1, t2, t3; /* time measurement for coarse load balancing */
#endif
set_pbc(&pbc, fr->ePBC, box);
/* reset free energy components */
for (i = 0; i < efptNR; i++)
{
dvdl_nb[i] = 0;
dvdl_dum[i] = 0;
}
/* Reset box */
for (i = 0; (i < DIM); i++)
{
box_size[i] = box[i][i];
}
debug_gmx();
/* do QMMM first if requested */
if (fr->bQMMM)
{
enerd->term[F_EQM] = calculate_QMMM(cr, x, f, fr);
}
/* Call the short range functions all in one go. */
#ifdef GMX_MPI
/*#define TAKETIME ((cr->npmenodes) && (fr->timesteps < 12))*/
#define TAKETIME FALSE
if (TAKETIME)
{
MPI_Barrier(cr->mpi_comm_mygroup);
t0 = MPI_Wtime();
}
#endif
if (ir->nwall)
{
/* foreign lambda component for walls */
real dvdl_walls = do_walls(ir, fr, box, md, x, f, lambda[efptVDW],
enerd->grpp.ener[egLJSR], nrnb);
enerd->dvdl_lin[efptVDW] += dvdl_walls;
}
/* If doing GB, reset dvda and calculate the Born radii */
if (ir->implicit_solvent)
{
wallcycle_sub_start(wcycle, ewcsNONBONDED);
for (i = 0; i < born->nr; i++)
{
fr->dvda[i] = 0;
}
if (bBornRadii)
{
calc_gb_rad(cr, fr, ir, top, x, &(fr->gblist), born, md, nrnb);
}
wallcycle_sub_stop(wcycle, ewcsNONBONDED);
}
where();
/* We only do non-bonded calculation with group scheme here, the verlet
* calls are done from do_force_cutsVERLET(). */
if (fr->cutoff_scheme == ecutsGROUP && (flags & GMX_FORCE_NONBONDED))
{
donb_flags = 0;
/* Add short-range interactions */
donb_flags |= GMX_NONBONDED_DO_SR;
/* Currently all group scheme kernels always calculate (shift-)forces */
if (flags & GMX_FORCE_FORCES)
{
donb_flags |= GMX_NONBONDED_DO_FORCE;
}
if (flags & GMX_FORCE_VIRIAL)
{
donb_flags |= GMX_NONBONDED_DO_SHIFTFORCE;
}
if (flags & GMX_FORCE_ENERGY)
{
donb_flags |= GMX_NONBONDED_DO_POTENTIAL;
}
if (flags & GMX_FORCE_DO_LR)
{
donb_flags |= GMX_NONBONDED_DO_LR;
}
wallcycle_sub_start(wcycle, ewcsNONBONDED);
do_nonbonded(fr, x, f, f_longrange, md, excl,
&enerd->grpp, nrnb,
lambda, dvdl_nb, -1, -1, donb_flags);
/* If we do foreign lambda and we have soft-core interactions
* we have to recalculate the (non-linear) energies contributions.
*/
if (fepvals->n_lambda > 0 && (flags & GMX_FORCE_DHDL) && fepvals->sc_alpha != 0)
{
for (i = 0; i < enerd->n_lambda; i++)
{
real lam_i[efptNR];
for (j = 0; j < efptNR; j++)
{
lam_i[j] = (i == 0 ? lambda[j] : fepvals->all_lambda[j][i-1]);
}
reset_foreign_enerdata(enerd);
do_nonbonded(fr, x, f, f_longrange, md, excl,
&(enerd->foreign_grpp), nrnb,
lam_i, dvdl_dum, -1, -1,
(donb_flags & ~GMX_NONBONDED_DO_FORCE) | GMX_NONBONDED_DO_FOREIGNLAMBDA);
sum_epot(&(enerd->foreign_grpp), enerd->foreign_term);
enerd->enerpart_lambda[i] += enerd->foreign_term[F_EPOT];
}
}
wallcycle_sub_stop(wcycle, ewcsNONBONDED);
where();
}
/* If we are doing GB, calculate bonded forces and apply corrections
* to the solvation forces */
/* MRS: Eventually, many need to include free energy contribution here! */
if (ir->implicit_solvent)
{
wallcycle_sub_start(wcycle, ewcsLISTED);
calc_gb_forces(cr, md, born, top, x, f, fr, idef,
ir->gb_algorithm, ir->sa_algorithm, nrnb, &pbc, graph, enerd);
wallcycle_sub_stop(wcycle, ewcsLISTED);
}
#ifdef GMX_MPI
if (TAKETIME)
{
t1 = MPI_Wtime();
fr->t_fnbf += t1-t0;
}
#endif
if (fepvals->sc_alpha != 0)
{
enerd->dvdl_nonlin[efptVDW] += dvdl_nb[efptVDW];
}
else
{
enerd->dvdl_lin[efptVDW] += dvdl_nb[efptVDW];
}
if (fepvals->sc_alpha != 0)
/* even though coulomb part is linear, we already added it, beacuse we
need to go through the vdw calculation anyway */
{
enerd->dvdl_nonlin[efptCOUL] += dvdl_nb[efptCOUL];
}
else
{
enerd->dvdl_lin[efptCOUL] += dvdl_nb[efptCOUL];
}
debug_gmx();
if (debug)
{
pr_rvecs(debug, 0, "fshift after SR", fr->fshift, SHIFTS);
}
/* Shift the coordinates. Must be done before listed forces and PPPM,
* but is also necessary for SHAKE and update, therefore it can NOT
* go when no listed forces have to be evaluated.
*
* The shifting and PBC code is deliberately not timed, since with
* the Verlet scheme it only takes non-zero time with triclinic
* boxes, and even then the time is around a factor of 100 less
* than the next smallest counter.
*/
/* Here sometimes we would not need to shift with NBFonly,
* but we do so anyhow for consistency of the returned coordinates.
*/
if (graph)
{
shift_self(graph, box, x);
if (TRICLINIC(box))
{
inc_nrnb(nrnb, eNR_SHIFTX, 2*graph->nnodes);
}
else
{
inc_nrnb(nrnb, eNR_SHIFTX, graph->nnodes);
}
}
/* Check whether we need to do listed interactions or correct for exclusions */
if (fr->bMolPBC &&
((flags & GMX_FORCE_LISTED)
|| EEL_RF(fr->eeltype) || EEL_FULL(fr->eeltype) || EVDW_PME(fr->vdwtype)))
{
/* TODO There are no electrostatics methods that require this
transformation, when using the Verlet scheme, so update the
above conditional. */
/* Since all atoms are in the rectangular or triclinic unit-cell,
* only single box vector shifts (2 in x) are required.
*/
set_pbc_dd(&pbc, fr->ePBC, cr->dd, TRUE, box);
}
debug_gmx();
do_force_listed(wcycle, box, ir->fepvals, cr->ms,
idef, (const rvec *) x, hist, f, fr,
&pbc, graph, enerd, nrnb, lambda, md, fcd,
DOMAINDECOMP(cr) ? cr->dd->gatindex : NULL,
flags);
where();
*cycles_pme = 0;
clear_mat(fr->vir_el_recip);
clear_mat(fr->vir_lj_recip);
/* Do long-range electrostatics and/or LJ-PME, including related short-range
* corrections.
*/
if (EEL_FULL(fr->eeltype) || EVDW_PME(fr->vdwtype))
{
int status = 0;
real Vlr_q = 0, Vlr_lj = 0, Vcorr_q = 0, Vcorr_lj = 0;
real dvdl_long_range_q = 0, dvdl_long_range_lj = 0;
bSB = (ir->nwall == 2);
if (bSB)
{
copy_mat(box, boxs);
svmul(ir->wall_ewald_zfac, boxs[ZZ], boxs[ZZ]);
box_size[ZZ] *= ir->wall_ewald_zfac;
}
if (EEL_PME_EWALD(fr->eeltype) || EVDW_PME(fr->vdwtype))
{
real dvdl_long_range_correction_q = 0;
real dvdl_long_range_correction_lj = 0;
/* With the Verlet scheme exclusion forces are calculated
* in the non-bonded kernel.
*/
/* The TPI molecule does not have exclusions with the rest
* of the system and no intra-molecular PME grid
* contributions will be calculated in
* gmx_pme_calc_energy.
*/
if ((ir->cutoff_scheme == ecutsGROUP && fr->n_tpi == 0) ||
ir->ewald_geometry != eewg3D ||
ir->epsilon_surface != 0)
{
int nthreads, t;
wallcycle_sub_start(wcycle, ewcsEWALD_CORRECTION);
if (fr->n_tpi > 0)
{
gmx_fatal(FARGS, "TPI with PME currently only works in a 3D geometry with tin-foil boundary conditions");
}
nthreads = fr->nthread_ewc;
#pragma omp parallel for num_threads(nthreads) schedule(static)
for (t = 0; t < nthreads; t++)
{
try
{
tensor *vir_q, *vir_lj;
real *Vcorrt_q, *Vcorrt_lj, *dvdlt_q, *dvdlt_lj;
if (t == 0)
{
vir_q = &fr->vir_el_recip;
vir_lj = &fr->vir_lj_recip;
Vcorrt_q = &Vcorr_q;
Vcorrt_lj = &Vcorr_lj;
dvdlt_q = &dvdl_long_range_correction_q;
dvdlt_lj = &dvdl_long_range_correction_lj;
}
else
{
vir_q = &fr->ewc_t[t].vir_q;
vir_lj = &fr->ewc_t[t].vir_lj;
Vcorrt_q = &fr->ewc_t[t].Vcorr_q;
Vcorrt_lj = &fr->ewc_t[t].Vcorr_lj;
dvdlt_q = &fr->ewc_t[t].dvdl[efptCOUL];
dvdlt_lj = &fr->ewc_t[t].dvdl[efptVDW];
clear_mat(*vir_q);
clear_mat(*vir_lj);
}
*dvdlt_q = 0;
*dvdlt_lj = 0;
/* Threading is only supported with the Verlet cut-off
* scheme and then only single particle forces (no
* exclusion forces) are calculated, so we can store
* the forces in the normal, single fr->f_novirsum array.
*/
ewald_LRcorrection(fr->excl_load[t], fr->excl_load[t+1],
cr, t, fr,
md->chargeA, md->chargeB,
md->sqrt_c6A, md->sqrt_c6B,
md->sigmaA, md->sigmaB,
md->sigma3A, md->sigma3B,
md->nChargePerturbed || md->nTypePerturbed,
ir->cutoff_scheme != ecutsVERLET,
excl, x, bSB ? boxs : box, mu_tot,
ir->ewald_geometry,
ir->epsilon_surface,
fr->f_novirsum, *vir_q, *vir_lj,
Vcorrt_q, Vcorrt_lj,
lambda[efptCOUL], lambda[efptVDW],
dvdlt_q, dvdlt_lj);
}
GMX_CATCH_ALL_AND_EXIT_WITH_FATAL_ERROR;
}
if (nthreads > 1)
{
reduce_thread_energies(fr->vir_el_recip, fr->vir_lj_recip,
&Vcorr_q, &Vcorr_lj,
&dvdl_long_range_correction_q,
&dvdl_long_range_correction_lj,
nthreads, fr->ewc_t);
}
wallcycle_sub_stop(wcycle, ewcsEWALD_CORRECTION);
}
/* this is the main loop for the correlation type functions
* fx and nx are file pointers to things like read_first_x and
* read_next_x
*/
int corr_loop(t_corr *curr, const char *fn, t_topology *top, int ePBC,
gmx_bool bMol, int gnx[], atom_id *index[],
t_calc_func *calc1, gmx_bool bTen, int *gnx_com, atom_id *index_com[],
real dt, real t_pdb, rvec **x_pdb, matrix box_pdb,
const output_env_t oenv)
{
rvec *x[2]; /* the coordinates to read */
rvec *xa[2]; /* the coordinates to calculate displacements for */
rvec com = {0};
real t, t_prev = 0;
int natoms, i, j, cur = 0, maxframes = 0;
t_trxstatus *status;
#define prev (1-cur)
matrix box;
gmx_bool bFirst;
gmx_rmpbc_t gpbc = NULL;
natoms = read_first_x(oenv, &status, fn, &curr->t0, &(x[cur]), box);
#ifdef DEBUG
fprintf(stderr, "Read %d atoms for first frame\n", natoms);
#endif
if ((gnx_com != NULL) && natoms < top->atoms.nr)
{
fprintf(stderr, "WARNING: The trajectory only contains part of the system (%d of %d atoms) and therefore the COM motion of only this part of the system will be removed\n", natoms, top->atoms.nr);
}
snew(x[prev], natoms);
if (bMol)
{
curr->ncoords = curr->nmol;
snew(xa[0], curr->ncoords);
snew(xa[1], curr->ncoords);
}
else
{
curr->ncoords = natoms;
xa[0] = x[0];
xa[1] = x[1];
}
bFirst = TRUE;
t = curr->t0;
if (x_pdb)
{
*x_pdb = NULL;
}
if (bMol)
{
gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
}
/* the loop over all frames */
do
{
if (x_pdb && ((bFirst && t_pdb < t) ||
(!bFirst &&
t_pdb > t - 0.5*(t - t_prev) &&
t_pdb < t + 0.5*(t - t_prev))))
{
if (*x_pdb == NULL)
{
snew(*x_pdb, natoms);
}
for (i = 0; i < natoms; i++)
{
copy_rvec(x[cur][i], (*x_pdb)[i]);
}
copy_mat(box, box_pdb);
}
/* check whether we've reached a restart point */
if (bRmod(t, curr->t0, dt))
{
curr->nrestart++;
srenew(curr->x0, curr->nrestart);
snew(curr->x0[curr->nrestart-1], curr->ncoords);
srenew(curr->com, curr->nrestart);
srenew(curr->n_offs, curr->nrestart);
srenew(curr->lsq, curr->nrestart);
snew(curr->lsq[curr->nrestart-1], curr->nmol);
for (i = 0; i < curr->nmol; i++)
{
curr->lsq[curr->nrestart-1][i] = gmx_stats_init();
}
if (debug)
{
fprintf(debug, "Extended data structures because of new restart %d\n",
curr->nrestart);
}
}
/* create or extend the frame-based arrays */
if (curr->nframes >= maxframes-1)
{
if (maxframes == 0)
{
for (i = 0; (i < curr->ngrp); i++)
{
curr->ndata[i] = NULL;
curr->data[i] = NULL;
if (bTen)
{
curr->datam[i] = NULL;
}
}
curr->time = NULL;
}
maxframes += 10;
for (i = 0; (i < curr->ngrp); i++)
{
srenew(curr->ndata[i], maxframes);
srenew(curr->data[i], maxframes);
if (bTen)
{
srenew(curr->datam[i], maxframes);
}
for (j = maxframes-10; j < maxframes; j++)
{
curr->ndata[i][j] = 0;
curr->data[i][j] = 0;
if (bTen)
{
clear_mat(curr->datam[i][j]);
}
}
}
srenew(curr->time, maxframes);
}
/* set the time */
curr->time[curr->nframes] = t - curr->t0;
/* for the first frame, the previous frame is a copy of the first frame */
if (bFirst)
{
std::memcpy(xa[prev], xa[cur], curr->ncoords*sizeof(xa[prev][0]));
bFirst = FALSE;
}
/* make the molecules whole */
if (bMol)
{
gmx_rmpbc(gpbc, natoms, box, x[cur]);
}
/* calculate the molecules' centers of masses and put them into xa */
if (bMol)
{
calc_mol_com(gnx[0], index[0], &top->mols, &top->atoms, x[cur], xa[cur]);
}
/* first remove the periodic boundary condition crossings */
for (i = 0; i < curr->ngrp; i++)
{
prep_data(bMol, gnx[i], index[i], xa[cur], xa[prev], box);
}
/* calculate the center of mass */
if (gnx_com)
{
prep_data(bMol, gnx_com[0], index_com[0], xa[cur], xa[prev], box);
calc_com(bMol, gnx_com[0], index_com[0], xa[cur], xa[prev], box,
&top->atoms, com);
}
/* loop over all groups in index file */
for (i = 0; (i < curr->ngrp); i++)
{
/* calculate something useful, like mean square displacements */
calc_corr(curr, i, gnx[i], index[i], xa[cur], (gnx_com != NULL), com,
calc1, bTen);
}
cur = prev;
t_prev = t;
curr->nframes++;
}
while (read_next_x(oenv, status, &t, x[cur], box));
fprintf(stderr, "\nUsed %d restart points spaced %g %s over %g %s\n\n",
curr->nrestart,
output_env_conv_time(oenv, dt), output_env_get_time_unit(oenv),
output_env_conv_time(oenv, curr->time[curr->nframes-1]),
output_env_get_time_unit(oenv) );
if (bMol)
{
gmx_rmpbc_done(gpbc);
}
close_trj(status);
return natoms;
}
/*! \brief Do test particle insertion.
\copydoc integrator_t (FILE *fplog, t_commrec *cr, const gmx::MDLogger &mdlog,
int nfile, const t_filenm fnm[],
const gmx_output_env_t *oenv, gmx_bool bVerbose,
int nstglobalcomm,
gmx_vsite_t *vsite, gmx_constr_t constr,
int stepout,
t_inputrec *inputrec,
gmx_mtop_t *top_global, t_fcdata *fcd,
t_state *state_global,
t_mdatoms *mdatoms,
t_nrnb *nrnb, gmx_wallcycle_t wcycle,
gmx_edsam_t ed,
t_forcerec *fr,
int repl_ex_nst, int repl_ex_nex, int repl_ex_seed,
real cpt_period, real max_hours,
int imdport,
unsigned long Flags,
gmx_walltime_accounting_t walltime_accounting)
*/
double do_tpi(FILE *fplog, t_commrec *cr, const gmx::MDLogger gmx_unused &mdlog,
int nfile, const t_filenm fnm[],
const gmx_output_env_t *oenv, gmx_bool bVerbose,
int gmx_unused nstglobalcomm,
gmx_vsite_t gmx_unused *vsite, gmx_constr_t gmx_unused constr,
int gmx_unused stepout,
t_inputrec *inputrec,
gmx_mtop_t *top_global, t_fcdata *fcd,
t_state *state_global,
t_mdatoms *mdatoms,
t_nrnb *nrnb, gmx_wallcycle_t wcycle,
gmx_edsam_t gmx_unused ed,
t_forcerec *fr,
int gmx_unused repl_ex_nst, int gmx_unused repl_ex_nex, int gmx_unused repl_ex_seed,
real gmx_unused cpt_period, real gmx_unused max_hours,
int gmx_unused imdport,
unsigned long gmx_unused Flags,
gmx_walltime_accounting_t walltime_accounting)
{
gmx_localtop_t *top;
gmx_groups_t *groups;
gmx_enerdata_t *enerd;
rvec *f;
real lambda, t, temp, beta, drmax, epot;
double embU, sum_embU, *sum_UgembU, V, V_all, VembU_all;
t_trxstatus *status;
t_trxframe rerun_fr;
gmx_bool bDispCorr, bCharge, bRFExcl, bNotLastFrame, bStateChanged, bNS;
tensor force_vir, shake_vir, vir, pres;
int cg_tp, a_tp0, a_tp1, ngid, gid_tp, nener, e;
rvec *x_mol;
rvec mu_tot, x_init, dx, x_tp;
int nnodes, frame;
gmx_int64_t frame_step_prev, frame_step;
gmx_int64_t nsteps, stepblocksize = 0, step;
gmx_int64_t seed;
int i;
FILE *fp_tpi = NULL;
char *ptr, *dump_pdb, **leg, str[STRLEN], str2[STRLEN];
double dbl, dump_ener;
gmx_bool bCavity;
int nat_cavity = 0, d;
real *mass_cavity = NULL, mass_tot;
int nbin;
double invbinw, *bin, refvolshift, logV, bUlogV;
real prescorr, enercorr, dvdlcorr;
gmx_bool bEnergyOutOfBounds;
const char *tpid_leg[2] = {"direct", "reweighted"};
/* Since there is no upper limit to the insertion energies,
* we need to set an upper limit for the distribution output.
*/
real bU_bin_limit = 50;
real bU_logV_bin_limit = bU_bin_limit + 10;
if (inputrec->cutoff_scheme == ecutsVERLET)
{
gmx_fatal(FARGS, "TPI does not work (yet) with the Verlet cut-off scheme");
}
nnodes = cr->nnodes;
top = gmx_mtop_generate_local_top(top_global, inputrec->efep != efepNO);
groups = &top_global->groups;
bCavity = (inputrec->eI == eiTPIC);
if (bCavity)
{
ptr = getenv("GMX_TPIC_MASSES");
if (ptr == NULL)
{
nat_cavity = 1;
}
else
{
/* Read (multiple) masses from env var GMX_TPIC_MASSES,
* The center of mass of the last atoms is then used for TPIC.
*/
nat_cavity = 0;
while (sscanf(ptr, "%20lf%n", &dbl, &i) > 0)
{
srenew(mass_cavity, nat_cavity+1);
mass_cavity[nat_cavity] = dbl;
fprintf(fplog, "mass[%d] = %f\n",
nat_cavity+1, mass_cavity[nat_cavity]);
nat_cavity++;
ptr += i;
}
if (nat_cavity == 0)
{
gmx_fatal(FARGS, "Found %d masses in GMX_TPIC_MASSES", nat_cavity);
}
}
}
/*
init_em(fplog,TPI,inputrec,&lambda,nrnb,mu_tot,
state_global->box,fr,mdatoms,top,cr,nfile,fnm,NULL,NULL);*/
/* We never need full pbc for TPI */
fr->ePBC = epbcXYZ;
/* Determine the temperature for the Boltzmann weighting */
temp = inputrec->opts.ref_t[0];
if (fplog)
{
for (i = 1; (i < inputrec->opts.ngtc); i++)
{
if (inputrec->opts.ref_t[i] != 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");
}
}
fprintf(fplog,
"\n The temperature for test particle insertion is %.3f K\n\n",
temp);
}
beta = 1.0/(BOLTZ*temp);
/* Number of insertions per frame */
nsteps = inputrec->nsteps;
/* Use the same neighborlist with more insertions points
* in a sphere of radius drmax around the initial point
*/
/* This should be a proper mdp parameter */
drmax = inputrec->rtpi;
/* An environment variable can be set to dump all configurations
* to pdb with an insertion energy <= this value.
*/
dump_pdb = getenv("GMX_TPI_DUMP");
dump_ener = 0;
if (dump_pdb)
{
sscanf(dump_pdb, "%20lf", &dump_ener);
}
atoms2md(top_global, inputrec, 0, NULL, top_global->natoms, mdatoms);
update_mdatoms(mdatoms, inputrec->fepvals->init_lambda);
snew(enerd, 1);
init_enerdata(groups->grps[egcENER].nr, inputrec->fepvals->n_lambda, enerd);
snew(f, top_global->natoms);
/* Print to log file */
walltime_accounting_start(walltime_accounting);
wallcycle_start(wcycle, ewcRUN);
print_start(fplog, cr, walltime_accounting, "Test Particle Insertion");
/* The last charge group is the group to be inserted */
cg_tp = top->cgs.nr - 1;
a_tp0 = top->cgs.index[cg_tp];
a_tp1 = top->cgs.index[cg_tp+1];
if (debug)
{
fprintf(debug, "TPI cg %d, atoms %d-%d\n", cg_tp, a_tp0, a_tp1);
}
GMX_RELEASE_ASSERT(inputrec->rcoulomb <= inputrec->rlist && inputrec->rvdw <= inputrec->rlist, "Twin-range interactions are not supported with TPI");
snew(x_mol, a_tp1-a_tp0);
bDispCorr = (inputrec->eDispCorr != edispcNO);
bCharge = FALSE;
for (i = a_tp0; i < a_tp1; i++)
{
/* Copy the coordinates of the molecule to be insterted */
copy_rvec(state_global->x[i], x_mol[i-a_tp0]);
/* Check if we need to print electrostatic energies */
bCharge |= (mdatoms->chargeA[i] != 0 ||
(mdatoms->chargeB && mdatoms->chargeB[i] != 0));
}
bRFExcl = (bCharge && EEL_RF(fr->eeltype));
calc_cgcm(fplog, cg_tp, cg_tp+1, &(top->cgs), state_global->x, fr->cg_cm);
if (bCavity)
{
if (norm(fr->cg_cm[cg_tp]) > 0.5*inputrec->rlist && fplog)
{
fprintf(fplog, "WARNING: Your TPI molecule is not centered at 0,0,0\n");
fprintf(stderr, "WARNING: Your TPI molecule is not centered at 0,0,0\n");
}
}
else
{
/* Center the molecule to be inserted at zero */
for (i = 0; i < a_tp1-a_tp0; i++)
{
rvec_dec(x_mol[i], fr->cg_cm[cg_tp]);
}
}
if (fplog)
{
fprintf(fplog, "\nWill insert %d atoms %s partial charges\n",
a_tp1-a_tp0, bCharge ? "with" : "without");
fprintf(fplog, "\nWill insert %d times in each frame of %s\n",
(int)nsteps, opt2fn("-rerun", nfile, fnm));
}
if (!bCavity)
{
if (inputrec->nstlist > 1)
{
if (drmax == 0 && a_tp1-a_tp0 == 1)
{
gmx_fatal(FARGS, "Re-using the neighborlist %d times for insertions of a single atom in a sphere of radius %f does not make sense", inputrec->nstlist, drmax);
}
if (fplog)
{
fprintf(fplog, "Will use the same neighborlist for %d insertions in a sphere of radius %f\n", inputrec->nstlist, drmax);
}
}
}
else
{
if (fplog)
{
fprintf(fplog, "Will insert randomly in a sphere of radius %f around the center of the cavity\n", drmax);
}
}
ngid = groups->grps[egcENER].nr;
gid_tp = GET_CGINFO_GID(fr->cginfo[cg_tp]);
nener = 1 + ngid;
if (bDispCorr)
{
nener += 1;
}
if (bCharge)
{
nener += ngid;
if (bRFExcl)
{
nener += 1;
}
if (EEL_FULL(fr->eeltype))
{
nener += 1;
}
}
snew(sum_UgembU, nener);
/* Copy the random seed set by the user */
seed = inputrec->ld_seed;
gmx::ThreeFry2x64<16> rng(seed, gmx::RandomDomain::TestParticleInsertion); // 16 bits internal counter => 2^16 * 2 = 131072 values per stream
gmx::UniformRealDistribution<real> dist;
if (MASTER(cr))
{
fp_tpi = xvgropen(opt2fn("-tpi", nfile, fnm),
"TPI energies", "Time (ps)",
"(kJ mol\\S-1\\N) / (nm\\S3\\N)", oenv);
xvgr_subtitle(fp_tpi, "f. are averages over one frame", oenv);
snew(leg, 4+nener);
e = 0;
sprintf(str, "-kT log(<Ve\\S-\\betaU\\N>/<V>)");
leg[e++] = gmx_strdup(str);
sprintf(str, "f. -kT log<e\\S-\\betaU\\N>");
leg[e++] = gmx_strdup(str);
sprintf(str, "f. <e\\S-\\betaU\\N>");
leg[e++] = gmx_strdup(str);
sprintf(str, "f. V");
leg[e++] = gmx_strdup(str);
sprintf(str, "f. <Ue\\S-\\betaU\\N>");
leg[e++] = gmx_strdup(str);
for (i = 0; i < ngid; i++)
{
sprintf(str, "f. <U\\sVdW %s\\Ne\\S-\\betaU\\N>",
*(groups->grpname[groups->grps[egcENER].nm_ind[i]]));
leg[e++] = gmx_strdup(str);
}
if (bDispCorr)
{
sprintf(str, "f. <U\\sdisp c\\Ne\\S-\\betaU\\N>");
leg[e++] = gmx_strdup(str);
}
if (bCharge)
{
for (i = 0; i < ngid; i++)
{
sprintf(str, "f. <U\\sCoul %s\\Ne\\S-\\betaU\\N>",
*(groups->grpname[groups->grps[egcENER].nm_ind[i]]));
leg[e++] = gmx_strdup(str);
}
if (bRFExcl)
{
sprintf(str, "f. <U\\sRF excl\\Ne\\S-\\betaU\\N>");
leg[e++] = gmx_strdup(str);
}
if (EEL_FULL(fr->eeltype))
{
sprintf(str, "f. <U\\sCoul recip\\Ne\\S-\\betaU\\N>");
leg[e++] = gmx_strdup(str);
}
}
xvgr_legend(fp_tpi, 4+nener, (const char**)leg, oenv);
for (i = 0; i < 4+nener; i++)
{
sfree(leg[i]);
}
sfree(leg);
}
clear_rvec(x_init);
V_all = 0;
VembU_all = 0;
invbinw = 10;
nbin = 10;
snew(bin, nbin);
/* Avoid frame step numbers <= -1 */
frame_step_prev = -1;
bNotLastFrame = read_first_frame(oenv, &status, opt2fn("-rerun", nfile, fnm),
&rerun_fr, TRX_NEED_X);
frame = 0;
if (rerun_fr.natoms - (bCavity ? nat_cavity : 0) !=
mdatoms->nr - (a_tp1 - a_tp0))
{
gmx_fatal(FARGS, "Number of atoms in trajectory (%d)%s "
"is not equal the number in the run input file (%d) "
"minus the number of atoms to insert (%d)\n",
rerun_fr.natoms, bCavity ? " minus one" : "",
mdatoms->nr, a_tp1-a_tp0);
}
refvolshift = log(det(rerun_fr.box));
switch (inputrec->eI)
{
case eiTPI:
stepblocksize = inputrec->nstlist;
break;
case eiTPIC:
stepblocksize = 1;
break;
default:
gmx_fatal(FARGS, "Unknown integrator %s", ei_names[inputrec->eI]);
}
while (bNotLastFrame)
{
frame_step = rerun_fr.step;
if (frame_step <= frame_step_prev)
{
/* We don't have step number in the trajectory file,
* or we have constant or decreasing step numbers.
* Ensure we have increasing step numbers, since we use
* the step numbers as a counter for random numbers.
*/
frame_step = frame_step_prev + 1;
}
frame_step_prev = frame_step;
lambda = rerun_fr.lambda;
t = rerun_fr.time;
sum_embU = 0;
for (e = 0; e < nener; e++)
{
sum_UgembU[e] = 0;
}
/* Copy the coordinates from the input trajectory */
for (i = 0; i < rerun_fr.natoms; i++)
{
copy_rvec(rerun_fr.x[i], state_global->x[i]);
}
copy_mat(rerun_fr.box, state_global->box);
V = det(state_global->box);
logV = log(V);
bStateChanged = TRUE;
bNS = TRUE;
step = cr->nodeid*stepblocksize;
while (step < nsteps)
{
/* Restart random engine using the frame and insertion step
* as counters.
* Note that we need to draw several random values per iteration,
* but by using the internal subcounter functionality of ThreeFry2x64
* we can draw 131072 unique 64-bit values before exhausting
* the stream. This is a huge margin, and if something still goes
* wrong you will get an exception when the stream is exhausted.
*/
rng.restart(frame_step, step);
dist.reset(); // erase any memory in the distribution
if (!bCavity)
{
/* Random insertion in the whole volume */
bNS = (step % inputrec->nstlist == 0);
if (bNS)
{
/* Generate a random position in the box */
for (d = 0; d < DIM; d++)
{
x_init[d] = dist(rng)*state_global->box[d][d];
}
}
if (inputrec->nstlist == 1)
{
copy_rvec(x_init, x_tp);
}
else
{
/* Generate coordinates within |dx|=drmax of x_init */
do
{
for (d = 0; d < DIM; d++)
{
dx[d] = (2*dist(rng) - 1)*drmax;
}
}
while (norm2(dx) > drmax*drmax);
rvec_add(x_init, dx, x_tp);
}
}
else
{
/* Random insertion around a cavity location
* given by the last coordinate of the trajectory.
*/
if (step == 0)
{
if (nat_cavity == 1)
{
/* Copy the location of the cavity */
copy_rvec(rerun_fr.x[rerun_fr.natoms-1], x_init);
}
else
{
/* Determine the center of mass of the last molecule */
clear_rvec(x_init);
mass_tot = 0;
for (i = 0; i < nat_cavity; i++)
{
for (d = 0; d < DIM; d++)
{
x_init[d] +=
mass_cavity[i]*rerun_fr.x[rerun_fr.natoms-nat_cavity+i][d];
}
mass_tot += mass_cavity[i];
}
for (d = 0; d < DIM; d++)
{
x_init[d] /= mass_tot;
}
}
}
/* Generate coordinates within |dx|=drmax of x_init */
do
{
for (d = 0; d < DIM; d++)
{
dx[d] = (2*dist(rng) - 1)*drmax;
}
}
while (norm2(dx) > drmax*drmax);
rvec_add(x_init, dx, x_tp);
}
if (a_tp1 - a_tp0 == 1)
{
/* Insert a single atom, just copy the insertion location */
copy_rvec(x_tp, state_global->x[a_tp0]);
}
else
{
/* Copy the coordinates from the top file */
for (i = a_tp0; i < a_tp1; i++)
{
copy_rvec(x_mol[i-a_tp0], state_global->x[i]);
}
/* Rotate the molecule randomly */
rotate_conf(a_tp1-a_tp0, state_global->x+a_tp0, NULL,
2*M_PI*dist(rng),
2*M_PI*dist(rng),
2*M_PI*dist(rng));
/* Shift to the insertion location */
for (i = a_tp0; i < a_tp1; i++)
{
rvec_inc(state_global->x[i], x_tp);
}
}
/* Clear some matrix variables */
clear_mat(force_vir);
clear_mat(shake_vir);
clear_mat(vir);
clear_mat(pres);
/* Set the charge group center of mass of the test particle */
copy_rvec(x_init, fr->cg_cm[top->cgs.nr-1]);
/* Calc energy (no forces) on new positions.
* Since we only need the intermolecular energy
* and the RF exclusion terms of the inserted molecule occur
* within a single charge group we can pass NULL for the graph.
* This also avoids shifts that would move charge groups
* out of the box. */
/* Make do_force do a single node force calculation */
cr->nnodes = 1;
do_force(fplog, cr, inputrec,
step, nrnb, wcycle, top, &top_global->groups,
state_global->box, state_global->x, &state_global->hist,
f, force_vir, mdatoms, enerd, fcd,
state_global->lambda,
NULL, fr, NULL, mu_tot, t, NULL, NULL, FALSE,
GMX_FORCE_NONBONDED | GMX_FORCE_ENERGY |
(bNS ? GMX_FORCE_DYNAMICBOX | GMX_FORCE_NS : 0) |
(bStateChanged ? GMX_FORCE_STATECHANGED : 0));
cr->nnodes = nnodes;
bStateChanged = FALSE;
bNS = FALSE;
/* Calculate long range corrections to pressure and energy */
calc_dispcorr(inputrec, fr, state_global->box,
lambda, pres, vir, &prescorr, &enercorr, &dvdlcorr);
/* figure out how to rearrange the next 4 lines MRS 8/4/2009 */
enerd->term[F_DISPCORR] = enercorr;
enerd->term[F_EPOT] += enercorr;
enerd->term[F_PRES] += prescorr;
enerd->term[F_DVDL_VDW] += dvdlcorr;
epot = enerd->term[F_EPOT];
bEnergyOutOfBounds = FALSE;
/* If the compiler doesn't optimize this check away
* we catch the NAN energies.
* The epot>GMX_REAL_MAX check catches inf values,
* which should nicely result in embU=0 through the exp below,
* but it does not hurt to check anyhow.
*/
/* Non-bonded Interaction usually diverge at r=0.
* With tabulated interaction functions the first few entries
* should be capped in a consistent fashion between
* repulsion, dispersion and Coulomb to avoid accidental
* negative values in the total energy.
* The table generation code in tables.c does this.
* With user tbales the user should take care of this.
*/
if (epot != epot || epot > GMX_REAL_MAX)
{
bEnergyOutOfBounds = TRUE;
}
if (bEnergyOutOfBounds)
{
if (debug)
{
fprintf(debug, "\n time %.3f, step %d: non-finite energy %f, using exp(-bU)=0\n", t, (int)step, epot);
}
embU = 0;
}
else
{
embU = exp(-beta*epot);
sum_embU += embU;
/* Determine the weighted energy contributions of each energy group */
e = 0;
sum_UgembU[e++] += epot*embU;
if (fr->bBHAM)
{
for (i = 0; i < ngid; i++)
{
sum_UgembU[e++] +=
enerd->grpp.ener[egBHAMSR][GID(i, gid_tp, ngid)]*embU;
}
}
else
{
for (i = 0; i < ngid; i++)
{
sum_UgembU[e++] +=
enerd->grpp.ener[egLJSR][GID(i, gid_tp, ngid)]*embU;
}
}
if (bDispCorr)
{
sum_UgembU[e++] += enerd->term[F_DISPCORR]*embU;
}
if (bCharge)
{
for (i = 0; i < ngid; i++)
{
sum_UgembU[e++] += enerd->grpp.ener[egCOULSR][GID(i, gid_tp, ngid)] * embU;
}
if (bRFExcl)
{
sum_UgembU[e++] += enerd->term[F_RF_EXCL]*embU;
}
if (EEL_FULL(fr->eeltype))
{
sum_UgembU[e++] += enerd->term[F_COUL_RECIP]*embU;
}
}
}
if (embU == 0 || beta*epot > bU_bin_limit)
{
bin[0]++;
}
else
{
i = (int)((bU_logV_bin_limit
- (beta*epot - logV + refvolshift))*invbinw
+ 0.5);
if (i < 0)
{
i = 0;
}
if (i >= nbin)
{
realloc_bins(&bin, &nbin, i+10);
}
bin[i]++;
}
if (debug)
{
fprintf(debug, "TPI %7d %12.5e %12.5f %12.5f %12.5f\n",
(int)step, epot, x_tp[XX], x_tp[YY], x_tp[ZZ]);
}
if (dump_pdb && epot <= dump_ener)
{
sprintf(str, "t%g_step%d.pdb", t, (int)step);
sprintf(str2, "t: %f step %d ener: %f", t, (int)step, epot);
write_sto_conf_mtop(str, str2, top_global, state_global->x, state_global->v,
inputrec->ePBC, state_global->box);
}
step++;
if ((step/stepblocksize) % cr->nnodes != cr->nodeid)
{
/* Skip all steps assigned to the other MPI ranks */
step += (cr->nnodes - 1)*stepblocksize;
}
}
if (PAR(cr))
{
/* When running in parallel sum the energies over the processes */
gmx_sumd(1, &sum_embU, cr);
gmx_sumd(nener, sum_UgembU, cr);
}
frame++;
V_all += V;
VembU_all += V*sum_embU/nsteps;
if (fp_tpi)
{
if (bVerbose || frame%10 == 0 || frame < 10)
{
fprintf(stderr, "mu %10.3e <mu> %10.3e\n",
-log(sum_embU/nsteps)/beta, -log(VembU_all/V_all)/beta);
}
fprintf(fp_tpi, "%10.3f %12.5e %12.5e %12.5e %12.5e",
t,
VembU_all == 0 ? 20/beta : -log(VembU_all/V_all)/beta,
sum_embU == 0 ? 20/beta : -log(sum_embU/nsteps)/beta,
sum_embU/nsteps, V);
for (e = 0; e < nener; e++)
{
fprintf(fp_tpi, " %12.5e", sum_UgembU[e]/nsteps);
}
fprintf(fp_tpi, "\n");
fflush(fp_tpi);
}
bNotLastFrame = read_next_frame(oenv, status, &rerun_fr);
} /* End of the loop */
walltime_accounting_end(walltime_accounting);
close_trj(status);
if (fp_tpi != NULL)
{
xvgrclose(fp_tpi);
}
if (fplog != NULL)
{
fprintf(fplog, "\n");
fprintf(fplog, " <V> = %12.5e nm^3\n", V_all/frame);
fprintf(fplog, " <mu> = %12.5e kJ/mol\n", -log(VembU_all/V_all)/beta);
}
/* Write the Boltzmann factor histogram */
if (PAR(cr))
{
/* When running in parallel sum the bins over the processes */
i = nbin;
global_max(cr, &i);
realloc_bins(&bin, &nbin, i);
gmx_sumd(nbin, bin, cr);
}
if (MASTER(cr))
{
fp_tpi = xvgropen(opt2fn("-tpid", nfile, fnm),
"TPI energy distribution",
"\\betaU - log(V/<V>)", "count", oenv);
sprintf(str, "number \\betaU > %g: %9.3e", bU_bin_limit, bin[0]);
xvgr_subtitle(fp_tpi, str, oenv);
xvgr_legend(fp_tpi, 2, (const char **)tpid_leg, oenv);
for (i = nbin-1; i > 0; i--)
{
bUlogV = -i/invbinw + bU_logV_bin_limit - refvolshift + log(V_all/frame);
fprintf(fp_tpi, "%6.2f %10d %12.5e\n",
bUlogV,
(int)(bin[i]+0.5),
bin[i]*exp(-bUlogV)*V_all/VembU_all);
}
xvgrclose(fp_tpi);
}
sfree(bin);
sfree(sum_UgembU);
walltime_accounting_set_nsteps_done(walltime_accounting, frame*inputrec->nsteps);
return 0;
}
