void
posres_wrapper(t_nrnb *nrnb,
const t_idef *idef,
const struct t_pbc *pbc,
const rvec x[],
gmx_enerdata_t *enerd,
real *lambda,
t_forcerec *fr)
{
real v, dvdl;
dvdl = 0;
v = posres(idef->il[F_POSRES].nr, idef->il[F_POSRES].iatoms,
idef->iparams_posres,
x, fr->f_novirsum, fr->vir_diag_posres,
fr->ePBC == epbcNONE ? NULL : pbc,
lambda[efptRESTRAINT], &dvdl,
fr->rc_scaling, fr->ePBC, fr->posres_com, fr->posres_comB);
enerd->term[F_POSRES] += v;
/* If just the force constant changes, the FEP term is linear,
* but if k changes, it is not.
*/
enerd->dvdl_nonlin[efptRESTRAINT] += dvdl;
inc_nrnb(nrnb, eNR_POSRES, idef->il[F_POSRES].nr/2);
}
void
posres_wrapper_lambda(struct gmx_wallcycle *wcycle,
const t_lambda *fepvals,
const t_idef *idef,
const struct t_pbc *pbc,
const rvec x[],
gmx_enerdata_t *enerd,
real *lambda,
t_forcerec *fr)
{
real v;
int i;
if (0 == idef->il[F_POSRES].nr)
{
return;
}
wallcycle_sub_start_nocount(wcycle, ewcsRESTRAINTS);
for (i = 0; i < enerd->n_lambda; i++)
{
real dvdl_dum = 0, lambda_dum;
lambda_dum = (i == 0 ? lambda[efptRESTRAINT] : fepvals->all_lambda[efptRESTRAINT][i-1]);
v = posres(idef->il[F_POSRES].nr, idef->il[F_POSRES].iatoms,
idef->iparams_posres,
x, NULL, NULL,
fr->ePBC == epbcNONE ? NULL : pbc, lambda_dum, &dvdl_dum,
fr->rc_scaling, fr->ePBC, fr->posres_com, fr->posres_comB);
enerd->enerpart_lambda[i] += v;
}
wallcycle_sub_stop(wcycle, ewcsRESTRAINTS);
}
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);
}
