/* Assemble the positions of the group such that every node has all of them.
* The atom indices are retrieved from anrs_loc[0..nr_loc]
* Note that coll_ind[i] = i is needed in the serial case */
extern void communicate_group_positions(
t_commrec *cr,
rvec *xcoll, /* OUT: Collective array of positions */
ivec *shifts, /* IN+OUT: Collective array of shifts for xcoll */
ivec *extra_shifts, /* BUF: Extra shifts since last time step */
const gmx_bool bNS, /* IN: NS step, the shifts have changed */
rvec *x_loc, /* IN: Local positions on this node */
const int nr, /* IN: Total number of atoms in the group */
const int nr_loc, /* IN: Local number of atoms in the group */
int *anrs_loc, /* IN: Local atom numbers */
int *coll_ind, /* IN: Collective index */
rvec *xcoll_old, /* IN+OUT: Positions from the last time step, used to make group whole */
matrix box)
{
int i;
/* Zero out the groups' global position array */
clear_rvecs(nr, xcoll);
/* Put the local positions that this node has into the right place of
* the collective array. Note that in the serial case, coll_ind[i] = i */
for (i=0; i<nr_loc; i++)
copy_rvec(x_loc[anrs_loc[i]], xcoll[coll_ind[i]]);
if (PAR(cr))
{
/* Add the arrays from all nodes together */
gmx_sum(nr*3, xcoll[0], cr);
}
/* To make the group whole, start with a whole group and each
* step move the assembled positions at closest distance to the positions
* from the last step. First shift the positions with the saved shift
* vectors (these are 0 when this routine is called for the first time!) */
shift_positions_group(box, xcoll, shifts, nr);
/* Now check if some shifts changed since the last step.
* This only needs to be done when the shifts are expected to have changed,
* i.e. after neighboursearching */
if (bNS)
{
get_shifts_group(3, box, xcoll, nr, xcoll_old, extra_shifts);
/* Shift with the additional shifts such that we get a whole group now */
shift_positions_group(box, xcoll, extra_shifts, nr);
/* Add the shift vectors together for the next time step */
for (i=0; i<nr; i++)
{
shifts[i][XX] += extra_shifts[i][XX];
shifts[i][YY] += extra_shifts[i][YY];
shifts[i][ZZ] += extra_shifts[i][ZZ];
}
/* Store current correctly-shifted positions for comparison in the next NS time step */
for (i=0; i<nr; i++)
copy_rvec(xcoll[i],xcoll_old[i]);
}
}
int gmx_helixorient(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] calculates the coordinates and direction of the average",
"axis inside an alpha helix, and the direction/vectors of both the",
"C[GRK]alpha[grk] and (optionally) a sidechain atom relative to the axis.[PAR]",
"As input, you need to specify an index group with C[GRK]alpha[grk] atoms",
"corresponding to an [GRK]alpha[grk]-helix of continuous residues. Sidechain",
"directions require a second index group of the same size, containing",
"the heavy atom in each residue that should represent the sidechain.[PAR]",
"[BB]Note[bb] that this program does not do any fitting of structures.[PAR]",
"We need four C[GRK]alpha[grk] coordinates to define the local direction of the helix",
"axis.[PAR]",
"The tilt/rotation is calculated from Euler rotations, where we define",
"the helix axis as the local [IT]x[it]-axis, the residues/C[GRK]alpha[grk] vector as [IT]y[it], and the",
"[IT]z[it]-axis from their cross product. We use the Euler Y-Z-X rotation, meaning",
"we first tilt the helix axis (1) around and (2) orthogonal to the residues",
"vector, and finally apply the (3) rotation around it. For debugging or other",
"purposes, we also write out the actual Euler rotation angles as [TT]theta[1-3].xvg[tt]"
};
t_topology *top = NULL;
real t;
rvec *x = NULL;
matrix box;
t_trxstatus *status;
int natoms;
real theta1, theta2, theta3;
int i, j, teller = 0;
int iCA, iSC;
int *ind_CA;
int *ind_SC;
char *gn_CA;
char *gn_SC;
rvec v1, v2;
rvec *x_CA, *x_SC;
rvec *r12;
rvec *r23;
rvec *r34;
rvec *diff13;
rvec *diff24;
rvec *helixaxis;
rvec *residuehelixaxis;
rvec *residueorigin;
rvec *residuevector;
rvec *sidechainvector;
rvec *residuehelixaxis_t0;
rvec *residuevector_t0;
rvec *axis3_t0;
rvec *residuehelixaxis_tlast;
rvec *residuevector_tlast;
rvec *axis3_tlast;
rvec refaxes[3], newaxes[3];
rvec unitaxes[3];
rvec rot_refaxes[3], rot_newaxes[3];
real tilt, rotation;
rvec *axis3;
real *twist, *residuetwist;
real *radius, *residueradius;
real *rise, *residuerise;
real *residuebending;
real tmp;
real weight[3];
t_pbc pbc;
matrix A;
FILE *fpaxis, *fpcenter, *fptilt, *fprotation;
FILE *fpradius, *fprise, *fptwist;
FILE *fptheta1, *fptheta2, *fptheta3;
FILE *fpbending;
int ePBC;
gmx_output_env_t *oenv;
gmx_rmpbc_t gpbc = NULL;
static gmx_bool bSC = FALSE;
static gmx_bool bIncremental = FALSE;
static t_pargs pa[] = {
{ "-sidechain", FALSE, etBOOL, {&bSC},
"Calculate sidechain directions relative to helix axis too." },
{ "-incremental", FALSE, etBOOL, {&bIncremental},
"Calculate incremental rather than total rotation/tilt." },
};
#define NPA asize(pa)
t_filenm fnm[] = {
{ efTPR, NULL, NULL, ffREAD },
{ efTRX, "-f", NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efDAT, "-oaxis", "helixaxis", ffWRITE },
{ efDAT, "-ocenter", "center", ffWRITE },
{ efXVG, "-orise", "rise", ffWRITE },
{ efXVG, "-oradius", "radius", ffWRITE },
{ efXVG, "-otwist", "twist", ffWRITE },
{ efXVG, "-obending", "bending", ffWRITE },
{ efXVG, "-otilt", "tilt", ffWRITE },
{ efXVG, "-orot", "rotation", ffWRITE }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME,
NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
top = read_top(ftp2fn(efTPR, NFILE, fnm), &ePBC);
for (i = 0; i < 3; i++)
{
weight[i] = 1.0;
}
/* read index files */
printf("Select a group of Calpha atoms corresponding to a single continuous helix:\n");
get_index(&(top->atoms), ftp2fn_null(efNDX, NFILE, fnm), 1, &iCA, &ind_CA, &gn_CA);
snew(x_CA, iCA);
snew(x_SC, iCA); /* sic! */
snew(r12, iCA-3);
snew(r23, iCA-3);
snew(r34, iCA-3);
snew(diff13, iCA-3);
snew(diff24, iCA-3);
snew(helixaxis, iCA-3);
snew(twist, iCA);
snew(residuetwist, iCA);
snew(radius, iCA);
snew(residueradius, iCA);
snew(rise, iCA);
snew(residuerise, iCA);
snew(residueorigin, iCA);
snew(residuehelixaxis, iCA);
snew(residuevector, iCA);
snew(sidechainvector, iCA);
snew(residuebending, iCA);
snew(residuehelixaxis_t0, iCA);
snew(residuevector_t0, iCA);
snew(axis3_t0, iCA);
snew(residuehelixaxis_tlast, iCA);
snew(residuevector_tlast, iCA);
snew(axis3_tlast, iCA);
snew(axis3, iCA);
if (bSC)
{
printf("Select a group of atoms defining the sidechain direction (1/residue):\n");
get_index(&(top->atoms), ftp2fn_null(efNDX, NFILE, fnm), 1, &iSC, &ind_SC, &gn_SC);
if (iSC != iCA)
{
gmx_fatal(FARGS, "Number of sidechain atoms (%d) != number of CA atoms (%d)", iSC, iCA);
}
}
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
fpaxis = gmx_ffopen(opt2fn("-oaxis", NFILE, fnm), "w");
fpcenter = gmx_ffopen(opt2fn("-ocenter", NFILE, fnm), "w");
fprise = gmx_ffopen(opt2fn("-orise", NFILE, fnm), "w");
fpradius = gmx_ffopen(opt2fn("-oradius", NFILE, fnm), "w");
fptwist = gmx_ffopen(opt2fn("-otwist", NFILE, fnm), "w");
fpbending = gmx_ffopen(opt2fn("-obending", NFILE, fnm), "w");
fptheta1 = gmx_ffopen("theta1.xvg", "w");
fptheta2 = gmx_ffopen("theta2.xvg", "w");
fptheta3 = gmx_ffopen("theta3.xvg", "w");
if (bIncremental)
{
fptilt = xvgropen(opt2fn("-otilt", NFILE, fnm),
"Incremental local helix tilt", "Time(ps)", "Tilt (degrees)",
oenv);
fprotation = xvgropen(opt2fn("-orot", NFILE, fnm),
"Incremental local helix rotation", "Time(ps)",
"Rotation (degrees)", oenv);
}
else
{
fptilt = xvgropen(opt2fn("-otilt", NFILE, fnm),
"Cumulative local helix tilt", "Time(ps)", "Tilt (degrees)", oenv);
fprotation = xvgropen(opt2fn("-orot", NFILE, fnm),
"Cumulative local helix rotation", "Time(ps)",
"Rotation (degrees)", oenv);
}
clear_rvecs(3, unitaxes);
unitaxes[0][0] = 1;
unitaxes[1][1] = 1;
unitaxes[2][2] = 1;
gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
do
{
/* initialisation for correct distance calculations */
set_pbc(&pbc, ePBC, box);
/* make molecules whole again */
gmx_rmpbc(gpbc, natoms, box, x);
/* copy coords to our smaller arrays */
for (i = 0; i < iCA; i++)
{
copy_rvec(x[ind_CA[i]], x_CA[i]);
if (bSC)
{
copy_rvec(x[ind_SC[i]], x_SC[i]);
}
}
for (i = 0; i < iCA-3; i++)
{
rvec_sub(x_CA[i+1], x_CA[i], r12[i]);
rvec_sub(x_CA[i+2], x_CA[i+1], r23[i]);
rvec_sub(x_CA[i+3], x_CA[i+2], r34[i]);
rvec_sub(r12[i], r23[i], diff13[i]);
rvec_sub(r23[i], r34[i], diff24[i]);
/* calculate helix axis */
cprod(diff13[i], diff24[i], helixaxis[i]);
svmul(1.0/norm(helixaxis[i]), helixaxis[i], helixaxis[i]);
tmp = cos_angle(diff13[i], diff24[i]);
twist[i] = 180.0/M_PI * std::acos( tmp );
radius[i] = std::sqrt( norm(diff13[i])*norm(diff24[i]) ) / (2.0* (1.0-tmp) );
rise[i] = std::abs(iprod(r23[i], helixaxis[i]));
svmul(radius[i]/norm(diff13[i]), diff13[i], v1);
svmul(radius[i]/norm(diff24[i]), diff24[i], v2);
rvec_sub(x_CA[i+1], v1, residueorigin[i+1]);
rvec_sub(x_CA[i+2], v2, residueorigin[i+2]);
}
residueradius[0] = residuetwist[0] = residuerise[0] = 0;
residueradius[1] = radius[0];
residuetwist[1] = twist[0];
residuerise[1] = rise[0];
residuebending[0] = residuebending[1] = 0;
for (i = 2; i < iCA-2; i++)
{
residueradius[i] = 0.5*(radius[i-2]+radius[i-1]);
residuetwist[i] = 0.5*(twist[i-2]+twist[i-1]);
residuerise[i] = 0.5*(rise[i-2]+rise[i-1]);
residuebending[i] = 180.0/M_PI*std::acos( cos_angle(helixaxis[i-2], helixaxis[i-1]) );
}
residueradius[iCA-2] = radius[iCA-4];
residuetwist[iCA-2] = twist[iCA-4];
residuerise[iCA-2] = rise[iCA-4];
residueradius[iCA-1] = residuetwist[iCA-1] = residuerise[iCA-1] = 0;
residuebending[iCA-2] = residuebending[iCA-1] = 0;
clear_rvec(residueorigin[0]);
clear_rvec(residueorigin[iCA-1]);
/* average helix axes to define them on the residues.
* Just extrapolate second first/list atom.
*/
copy_rvec(helixaxis[0], residuehelixaxis[0]);
copy_rvec(helixaxis[0], residuehelixaxis[1]);
for (i = 2; i < iCA-2; i++)
{
rvec_add(helixaxis[i-2], helixaxis[i-1], residuehelixaxis[i]);
svmul(0.5, residuehelixaxis[i], residuehelixaxis[i]);
}
copy_rvec(helixaxis[iCA-4], residuehelixaxis[iCA-2]);
copy_rvec(helixaxis[iCA-4], residuehelixaxis[iCA-1]);
/* Normalize the axis */
for (i = 0; i < iCA; i++)
{
svmul(1.0/norm(residuehelixaxis[i]), residuehelixaxis[i], residuehelixaxis[i]);
}
/* calculate vector from origin to residue CA */
fprintf(fpaxis, "%15.12g ", t);
fprintf(fpcenter, "%15.12g ", t);
fprintf(fprise, "%15.12g ", t);
fprintf(fpradius, "%15.12g ", t);
fprintf(fptwist, "%15.12g ", t);
fprintf(fpbending, "%15.12g ", t);
for (i = 0; i < iCA; i++)
{
if (i == 0 || i == iCA-1)
{
fprintf(fpaxis, "%15.12g %15.12g %15.12g ", 0.0, 0.0, 0.0);
fprintf(fpcenter, "%15.12g %15.12g %15.12g ", 0.0, 0.0, 0.0);
fprintf(fprise, "%15.12g ", 0.0);
fprintf(fpradius, "%15.12g ", 0.0);
fprintf(fptwist, "%15.12g ", 0.0);
fprintf(fpbending, "%15.12g ", 0.0);
}
else
{
rvec_sub( bSC ? x_SC[i] : x_CA[i], residueorigin[i], residuevector[i]);
svmul(1.0/norm(residuevector[i]), residuevector[i], residuevector[i]);
cprod(residuehelixaxis[i], residuevector[i], axis3[i]);
fprintf(fpaxis, "%15.12g %15.12g %15.12g ", residuehelixaxis[i][0], residuehelixaxis[i][1], residuehelixaxis[i][2]);
fprintf(fpcenter, "%15.12g %15.12g %15.12g ", residueorigin[i][0], residueorigin[i][1], residueorigin[i][2]);
fprintf(fprise, "%15.12g ", residuerise[i]);
fprintf(fpradius, "%15.12g ", residueradius[i]);
fprintf(fptwist, "%15.12g ", residuetwist[i]);
fprintf(fpbending, "%15.12g ", residuebending[i]);
}
}
fprintf(fprise, "\n");
fprintf(fpradius, "\n");
fprintf(fpaxis, "\n");
fprintf(fpcenter, "\n");
fprintf(fptwist, "\n");
fprintf(fpbending, "\n");
if (teller == 0)
{
for (i = 0; i < iCA; i++)
{
copy_rvec(residuehelixaxis[i], residuehelixaxis_t0[i]);
copy_rvec(residuevector[i], residuevector_t0[i]);
copy_rvec(axis3[i], axis3_t0[i]);
}
}
else
{
fprintf(fptilt, "%15.12g ", t);
fprintf(fprotation, "%15.12g ", t);
fprintf(fptheta1, "%15.12g ", t);
fprintf(fptheta2, "%15.12g ", t);
fprintf(fptheta3, "%15.12g ", t);
for (i = 0; i < iCA; i++)
{
if (i == 0 || i == iCA-1)
{
tilt = rotation = 0;
}
else
{
if (!bIncremental)
{
/* Total rotation & tilt */
copy_rvec(residuehelixaxis_t0[i], refaxes[0]);
copy_rvec(residuevector_t0[i], refaxes[1]);
copy_rvec(axis3_t0[i], refaxes[2]);
}
else
{
/* Rotation/tilt since last step */
copy_rvec(residuehelixaxis_tlast[i], refaxes[0]);
copy_rvec(residuevector_tlast[i], refaxes[1]);
copy_rvec(axis3_tlast[i], refaxes[2]);
}
copy_rvec(residuehelixaxis[i], newaxes[0]);
copy_rvec(residuevector[i], newaxes[1]);
copy_rvec(axis3[i], newaxes[2]);
/* rotate reference frame onto unit axes */
calc_fit_R(3, 3, weight, unitaxes, refaxes, A);
for (j = 0; j < 3; j++)
{
mvmul(A, refaxes[j], rot_refaxes[j]);
mvmul(A, newaxes[j], rot_newaxes[j]);
}
/* Determine local rotation matrix A */
calc_fit_R(3, 3, weight, rot_newaxes, rot_refaxes, A);
/* Calculate euler angles, from rotation order y-z-x, where
* x is helixaxis, y residuevector, and z axis3.
*
* A contains rotation column vectors.
*/
theta1 = 180.0/M_PI*std::atan2(A[0][2], A[0][0]);
theta2 = 180.0/M_PI*std::asin(-A[0][1]);
theta3 = 180.0/M_PI*std::atan2(A[2][1], A[1][1]);
tilt = std::sqrt(theta1*theta1+theta2*theta2);
rotation = theta3;
fprintf(fptheta1, "%15.12g ", theta1);
fprintf(fptheta2, "%15.12g ", theta2);
fprintf(fptheta3, "%15.12g ", theta3);
}
fprintf(fptilt, "%15.12g ", tilt);
fprintf(fprotation, "%15.12g ", rotation);
}
fprintf(fptilt, "\n");
fprintf(fprotation, "\n");
fprintf(fptheta1, "\n");
fprintf(fptheta2, "\n");
fprintf(fptheta3, "\n");
}
for (i = 0; i < iCA; i++)
{
copy_rvec(residuehelixaxis[i], residuehelixaxis_tlast[i]);
copy_rvec(residuevector[i], residuevector_tlast[i]);
copy_rvec(axis3[i], axis3_tlast[i]);
}
teller++;
}
while (read_next_x(oenv, status, &t, x, box));
gmx_rmpbc_done(gpbc);
gmx_ffclose(fpaxis);
gmx_ffclose(fpcenter);
xvgrclose(fptilt);
xvgrclose(fprotation);
gmx_ffclose(fprise);
gmx_ffclose(fpradius);
gmx_ffclose(fptwist);
gmx_ffclose(fpbending);
gmx_ffclose(fptheta1);
gmx_ffclose(fptheta2);
gmx_ffclose(fptheta3);
close_trj(status);
return 0;
}
void do_force(FILE *log,t_commrec *cr,t_commrec *mcr,
t_parm *parm,t_nsborder *nsb,tensor vir_part,tensor pme_vir,
int step,t_nrnb *nrnb,t_topology *top,t_groups *grps,
rvec x[],rvec v[],rvec f[],rvec buf[],
t_mdatoms *mdatoms,real ener[],t_fcdata *fcd,bool bVerbose,
real lambda,t_graph *graph,
bool bNS,bool bNBFonly,t_forcerec *fr, rvec mu_tot,
bool bGatherOnly)
{
static rvec box_size;
static real dvdl_lr = 0;
int cg0,cg1,i,j;
int start,homenr;
static real mu_and_q[DIM+1];
real qsum;
start = START(nsb);
homenr = HOMENR(nsb);
cg0 = CG0(nsb);
cg1 = CG1(nsb);
update_forcerec(log,fr,parm->box);
/* Calculate total (local) dipole moment in a temporary common array.
* This makes it possible to sum them over nodes faster.
*/
calc_mu_and_q(nsb,x,mdatoms->chargeT,mu_and_q,mu_and_q+DIM);
if (fr->ePBC != epbcNONE) {
/* Compute shift vectors every step, because of pressure coupling! */
if (parm->ir.epc != epcNO)
calc_shifts(parm->box,box_size,fr->shift_vec);
if (bNS) {
put_charge_groups_in_box(log,cg0,cg1,parm->box,box_size,
&(top->blocks[ebCGS]),x,fr->cg_cm);
inc_nrnb(nrnb,eNR_RESETX,homenr);
} else if (parm->ir.eI==eiSteep || parm->ir.eI==eiCG)
unshift_self(graph,parm->box,x);
}
else if (bNS)
calc_cgcm(log,cg0,cg1,&(top->blocks[ebCGS]),x,fr->cg_cm);
if (bNS) {
inc_nrnb(nrnb,eNR_CGCM,cg1-cg0);
if (PAR(cr))
move_cgcm(log,cr,fr->cg_cm,nsb->workload);
if (debug)
pr_rvecs(debug,0,"cgcm",fr->cg_cm,nsb->cgtotal);
}
/* Communicate coordinates and sum dipole and net charge if necessary */
if (PAR(cr)) {
move_x(log,cr->left,cr->right,x,nsb,nrnb);
gmx_sum(DIM+1,mu_and_q,cr);
}
for(i=0;i<DIM;i++)
mu_tot[i]=mu_and_q[i];
qsum=mu_and_q[DIM];
/* Reset energies */
reset_energies(&(parm->ir.opts),grps,fr,bNS,ener);
if (bNS) {
if (fr->ePBC != epbcNONE)
/* Calculate intramolecular shift vectors to make molecules whole */
mk_mshift(log,graph,parm->box,x);
/* Reset long range forces if necessary */
if (fr->bTwinRange) {
clear_rvecs(nsb->natoms,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_lr = 0;
ns(log,fr,x,f,parm->box,grps,&(parm->ir.opts),top,mdatoms,
cr,nrnb,nsb,step,lambda,&dvdl_lr);
}
/* Reset PME/Ewald forces if necessary */
if (EEL_LR(fr->eeltype))
clear_rvecs(homenr,fr->f_pme+start);
/* Copy long range forces into normal buffers */
if (fr->bTwinRange) {
for(i=0; i<nsb->natoms; 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 {
clear_rvecs(nsb->natoms,f);
clear_rvecs(SHIFTS,fr->fshift);
}
/* Compute the forces */
force(log,step,fr,&(parm->ir),&(top->idef),nsb,cr,mcr,nrnb,grps,mdatoms,
top->atoms.grps[egcENER].nr,&(parm->ir.opts),
x,f,ener,fcd,bVerbose,parm->box,lambda,graph,&(top->atoms.excl),
bNBFonly,pme_vir,mu_tot,qsum,bGatherOnly);
/* Take long range contribution to free energy into account */
ener[F_DVDL] += dvdl_lr;
#ifdef DEBUG
if (bNS)
print_nrnb(log,nrnb);
#endif
/* The short-range virial from surrounding boxes */
clear_mat(vir_part);
calc_vir(log,SHIFTS,fr->shift_vec,fr->fshift,vir_part);
inc_nrnb(nrnb,eNR_VIRIAL,SHIFTS);
if (debug)
pr_rvecs(debug,0,"vir_shifts",vir_part,DIM);
/* Compute forces due to electric field */
calc_f_el(start,homenr,mdatoms->chargeT,f,parm->ir.ex);
/* When using PME/Ewald we compute the long range virial (pme_vir) 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))
move_f(log,cr->left,cr->right,f,buf,nsb,nrnb);
}
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);
}
/* Assemble the positions of the group such that every node has all of them.
* The atom indices are retrieved from anrs_loc[0..nr_loc]
* Note that coll_ind[i] = i is needed in the serial case */
extern void communicate_group_positions(
const t_commrec *cr, /* Pointer to MPI communication data */
rvec *xcoll, /* Collective array of positions */
ivec *shifts, /* Collective array of shifts for xcoll (can be NULL) */
ivec *extra_shifts, /* (optional) Extra shifts since last time step */
const gmx_bool bNS, /* (optional) NS step, the shifts have changed */
const rvec *x_loc, /* Local positions on this node */
const int nr, /* Total number of atoms in the group */
const int nr_loc, /* Local number of atoms in the group */
const int *anrs_loc, /* Local atom numbers */
const int *coll_ind, /* Collective index */
rvec *xcoll_old, /* (optional) Positions from the last time step,
used to make group whole */
const matrix box) /* (optional) The box */
{
int i;
/* Zero out the groups' global position array */
clear_rvecs(nr, xcoll);
/* Put the local positions that this node has into the right place of
* the collective array. Note that in the serial case, coll_ind[i] = i */
for (i = 0; i < nr_loc; i++)
{
copy_rvec(x_loc[anrs_loc[i]], xcoll[coll_ind[i]]);
}
if (PAR(cr))
{
/* Add the arrays from all nodes together */
gmx_sum(nr*3, xcoll[0], cr);
}
/* Now we have all the positions of the group in the xcoll array present on all
* nodes.
*
* The rest of the code is for making the group whole again in case atoms changed
* their PBC representation / crossed a box boundary. We only do that if the
* shifts array is allocated. */
if (nullptr != shifts)
{
/* To make the group whole, start with a whole group and each
* step move the assembled positions at closest distance to the positions
* from the last step. First shift the positions with the saved shift
* vectors (these are 0 when this routine is called for the first time!) */
shift_positions_group(box, xcoll, shifts, nr);
/* Now check if some shifts changed since the last step.
* This only needs to be done when the shifts are expected to have changed,
* i.e. after neighbor searching */
if (bNS)
{
get_shifts_group(3, box, xcoll, nr, xcoll_old, extra_shifts);
/* Shift with the additional shifts such that we get a whole group now */
shift_positions_group(box, xcoll, extra_shifts, nr);
/* Add the shift vectors together for the next time step */
for (i = 0; i < nr; i++)
{
shifts[i][XX] += extra_shifts[i][XX];
shifts[i][YY] += extra_shifts[i][YY];
shifts[i][ZZ] += extra_shifts[i][ZZ];
}
/* Store current correctly-shifted positions for comparison in the next NS time step */
for (i = 0; i < nr; i++)
{
copy_rvec(xcoll[i], xcoll_old[i]);
}
}
}
}
