real *dvdlambda, /* FEP force */
real invdt, /* 1/delta_t */
rvec *v, /* Also constrain v if v!=NULL */
- gmx_bool bCalcVir, /* Calculate r x m delta_r */
- tensor rmdr, /* sum r x m delta_r */
+ gmx_bool bCalcVir, /* Calculate r x m delta_r */
+ tensor vir_r_m_dr, /* sum r x m delta_r */
gmx_bool bDumpOnError, /* Dump debugging stuff on error*/
int econq, /* which type of constrainint is occurring */
t_vetavars *vetavar); /* veta for pressure control */
real invdt, /* 1/delta_t */
real *v, /* Also constrain v if v!=NULL */
int calcvir_atom_end, /* Calculate r x m delta_r up to this atom */
- tensor rmdr, /* sum r x m delta_r */
+ tensor vir_r_m_dr, /* sum r x m delta_r */
int *xerror,
t_vetavars *vetavar /* variables for pressure control */
);
const t_pbc *pbc, /* PBC data pointer, can be NULL */
rvec x[],
rvec *der,rvec *derp,
- int CalcVirAtomEnd,tensor rmdder, t_vetavars *vetavar);
+ int CalcVirAtomEnd,tensor vir_r_m_dder,
+ t_vetavars *vetavar);
/* Analytical algorithm to subtract the components of derivatives
* of coordinates working on settle type constraint.
*/
matrix box,t_pbc *pbc,
real lambda,real *dvdlambda,
real invdt,rvec *v,
- gmx_bool bCalcVir,tensor rmdr,
+ gmx_bool bCalcVir,tensor vir_r_m_dr,
int econ,
t_nrnb *nrnb,
int maxwarn,int *warncount);
int nind_r; /* number of indices */
int *ind_r; /* constraint index for updating atom data */
int ind_nalloc; /* allocation size of ind and ind_r */
- tensor rmdr; /* temporary variable for virial calculation */
+ tensor vir_r_m_dr;/* temporary variable for virial calculation */
} lincs_thread_t;
typedef struct gmx_lincsdata {
gmx_bool bCalcLambda,
real wangle,int *warn,
real invdt,rvec *v,
- gmx_bool bCalcVir,tensor rmdr)
+ gmx_bool bCalcVir,tensor vir_r_m_dr)
{
int b0,b1,b,i,j,k,n,iter;
real tmp0,tmp1,tmp2,im1,im2,mvb,rlen,len,len2,dlen2,wfac;
tmp1 = tmp0*r[b][i];
for(j=0; j<DIM; j++)
{
- rmdr[i][j] -= tmp1*r[b][j];
+ vir_r_m_dr[i][j] -= tmp1*r[b][j];
}
}
} /* 22 ncons flops */
matrix box,t_pbc *pbc,
real lambda,real *dvdlambda,
real invdt,rvec *v,
- gmx_bool bCalcVir,tensor rmdr,
+ gmx_bool bCalcVir,tensor vir_r_m_dr,
int econq,
t_nrnb *nrnb,
int maxwarn,int *warncount)
{
int th=gmx_omp_get_thread_num();
- clear_mat(lincsd->th[th].rmdr);
+ clear_mat(lincsd->th[th].vir_r_m_dr);
do_lincs(x,xprime,box,pbc,lincsd,th,
md->invmass,cr,
bCalcVir || (ir->efep != efepNO),
ir->LincsWarnAngle,&warn,
invdt,v,bCalcVir,
- th==0 ? rmdr : lincsd->th[th].rmdr);
+ th==0 ? vir_r_m_dr : lincsd->th[th].vir_r_m_dr);
}
if (ir->efep != efepNO)
do_lincsp(x,xprime,min_proj,pbc,lincsd,th,
md->invmass,econq,ir->efep != efepNO ? dvdlambda : NULL,
- bCalcVir,th==0 ? rmdr : lincsd->th[th].rmdr);
+ bCalcVir,th==0 ? vir_r_m_dr : lincsd->th[th].vir_r_m_dr);
}
}
{
for(i=1; i<lincsd->nth; i++)
{
- m_add(rmdr,lincsd->th[i].rmdr,rmdr);
+ m_add(vir_r_m_dr,lincsd->th[i].vir_r_m_dr,vir_r_m_dr);
}
}
int warncount_settle;
gmx_edsam_t ed; /* The essential dynamics data */
- tensor *rmdr_th; /* Thread local working data */
+ tensor *vir_r_m_dr_th;/* Thread local working data */
int *settle_error; /* Thread local working data */
gmx_mtop_t *warn_mtop; /* Only used for printing warnings */
int start,homenr,nrend;
int i,j,d;
int ncons,settle_error;
- tensor rmdr;
+ tensor vir_r_m_dr;
rvec *vstor;
real invdt,vir_fac,t;
t_ilist *settle;
if (vir != NULL)
{
- clear_mat(rmdr);
+ clear_mat(vir_r_m_dr);
}
where();
nth = 1;
}
- if (nth > 1 && constr->rmdr_th == NULL)
+ if (nth > 1 && constr->vir_r_m_dr_th == NULL)
{
- snew(constr->rmdr_th,nth);
+ snew(constr->vir_r_m_dr_th,nth);
snew(constr->settle_error,nth);
}
bOK = constrain_lincs(fplog,bLog,bEner,ir,step,constr->lincsd,md,cr,
x,xprime,min_proj,
box,pbc_null,lambda,dvdlambda,
- invdt,v,vir!=NULL,rmdr,
+ invdt,v,vir!=NULL,vir_r_m_dr,
econq,nrnb,
constr->maxwarn,&constr->warncount_lincs);
if (!bOK && constr->maxwarn >= 0)
homenr,md->invmass,constr->nblocks,constr->sblock,
idef,ir,x,xprime,nrnb,
constr->lagr,lambda,dvdlambda,
- invdt,v,vir!=NULL,rmdr,constr->maxwarn>=0,econq,&vetavar);
+ invdt,v,vir!=NULL,vir_r_m_dr,
+ constr->maxwarn>=0,econq,&vetavar);
break;
case (econqVeloc):
bOK = bshakef(fplog,constr->shaked,
homenr,md->invmass,constr->nblocks,constr->sblock,
idef,ir,x,min_proj,nrnb,
constr->lagr,lambda,dvdlambda,
- invdt,NULL,vir!=NULL,rmdr,constr->maxwarn>=0,econq,&vetavar);
+ invdt,NULL,vir!=NULL,vir_r_m_dr,
+ constr->maxwarn>=0,econq,&vetavar);
break;
default:
gmx_fatal(FARGS,"Internal error, SHAKE called for constraining something else than coordinates");
if (th > 0)
{
- clear_mat(constr->rmdr_th[th]);
+ clear_mat(constr->vir_r_m_dr_th[th]);
}
start_th = (nsettle* th )/nth;
pbc_null,
x[0],xprime[0],
invdt,v?v[0]:NULL,calcvir_atom_end,
- th == 0 ? rmdr : constr->rmdr_th[th],
+ th == 0 ? vir_r_m_dr : constr->vir_r_m_dr_th[th],
th == 0 ? &settle_error : &constr->settle_error[th],
&vetavar);
}
if (th > 0)
{
- clear_mat(constr->rmdr_th[th]);
+ clear_mat(constr->vir_r_m_dr_th[th]);
}
start_th = (nsettle* th )/nth;
pbc_null,
x,
xprime,min_proj,calcvir_atom_end,
- th == 0 ? rmdr : constr->rmdr_th[th],
+ th == 0 ? vir_r_m_dr : constr->vir_r_m_dr_th[th],
&vetavar);
}
}
/* Combine virial and error info of the other threads */
for(i=1; i<nth; i++)
{
- m_add(rmdr,constr->rmdr_th[i],rmdr);
+ m_add(vir_r_m_dr,constr->vir_r_m_dr_th[i],vir_r_m_dr);
settle_error = constr->settle_error[i];
}
{
for(j=0; j<DIM; j++)
{
- (*vir)[i][j] = vir_fac*rmdr[i][j];
+ (*vir)[i][j] = vir_fac*vir_r_m_dr[i][j];
}
}
}
const t_pbc *pbc,
rvec x[],
rvec *der,rvec *derp,
- int calcvir_atom_end,tensor rmdder,t_vetavars *vetavar)
+ int calcvir_atom_end,tensor vir_r_m_dder,
+ t_vetavars *vetavar)
{
/* Settle for projection out constraint components
* of derivatives of the coordinates.
{
for(m2=0; m2<DIM; m2++)
{
- rmdder[m][m2] +=
+ vir_r_m_dder[m][m2] +=
dOH*roh2[m]*roh2[m2]*fcv[0] +
dOH*roh3[m]*roh3[m2]*fcv[1] +
dHH*rhh [m]*rhh [m2]*fcv[2];
if (calcvir_atom_end > 0)
{
- /* Correct rmdder, which will be used to calcualate the virial;
+ /* Correct r_m_dder, which will be used to calcualate the virial;
* we need to use the unscaled multipliers in the virial.
*/
- msmul(rmdder,1.0/vetavar->vscale,rmdder);
+ msmul(vir_r_m_dder,1.0/vetavar->vscale,vir_r_m_dder);
}
}
const t_pbc *pbc,
real b4[], real after[],
real invdt,real *v,int CalcVirAtomEnd,
- tensor rmdr,int *error,t_vetavars *vetavar)
+ tensor vir_r_m_dr,
+ int *error,
+ t_vetavars *vetavar)
{
/* ***************************************************************** */
/* ** */
mdcx = mHs*dcx;
mdcy = mHs*dcy;
mdcz = mHs*dcz;
- rmdr[XX][XX] -= b4[ow1 ]*mdax + (b4[ow1 ]+xb0)*mdbx + (b4[ow1 ]+xc0)*mdcx;
- rmdr[XX][YY] -= b4[ow1 ]*mday + (b4[ow1 ]+xb0)*mdby + (b4[ow1 ]+xc0)*mdcy;
- rmdr[XX][ZZ] -= b4[ow1 ]*mdaz + (b4[ow1 ]+xb0)*mdbz + (b4[ow1 ]+xc0)*mdcz;
- rmdr[YY][XX] -= b4[ow1+1]*mdax + (b4[ow1+1]+yb0)*mdbx + (b4[ow1+1]+yc0)*mdcx;
- rmdr[YY][YY] -= b4[ow1+1]*mday + (b4[ow1+1]+yb0)*mdby + (b4[ow1+1]+yc0)*mdcy;
- rmdr[YY][ZZ] -= b4[ow1+1]*mdaz + (b4[ow1+1]+yb0)*mdbz + (b4[ow1+1]+yc0)*mdcz;
- rmdr[ZZ][XX] -= b4[ow1+2]*mdax + (b4[ow1+2]+zb0)*mdbx + (b4[ow1+2]+zc0)*mdcx;
- rmdr[ZZ][YY] -= b4[ow1+2]*mday + (b4[ow1+2]+zb0)*mdby + (b4[ow1+2]+zc0)*mdcy;
- rmdr[ZZ][ZZ] -= b4[ow1+2]*mdaz + (b4[ow1+2]+zb0)*mdbz + (b4[ow1+2]+zc0)*mdcz;
+ vir_r_m_dr[XX][XX] -= b4[ow1 ]*mdax + (b4[ow1 ]+xb0)*mdbx + (b4[ow1 ]+xc0)*mdcx;
+ vir_r_m_dr[XX][YY] -= b4[ow1 ]*mday + (b4[ow1 ]+xb0)*mdby + (b4[ow1 ]+xc0)*mdcy;
+ vir_r_m_dr[XX][ZZ] -= b4[ow1 ]*mdaz + (b4[ow1 ]+xb0)*mdbz + (b4[ow1 ]+xc0)*mdcz;
+ vir_r_m_dr[YY][XX] -= b4[ow1+1]*mdax + (b4[ow1+1]+yb0)*mdbx + (b4[ow1+1]+yc0)*mdcx;
+ vir_r_m_dr[YY][YY] -= b4[ow1+1]*mday + (b4[ow1+1]+yb0)*mdby + (b4[ow1+1]+yc0)*mdcy;
+ vir_r_m_dr[YY][ZZ] -= b4[ow1+1]*mdaz + (b4[ow1+1]+yb0)*mdbz + (b4[ow1+1]+yc0)*mdcz;
+ vir_r_m_dr[ZZ][XX] -= b4[ow1+2]*mdax + (b4[ow1+2]+zb0)*mdbx + (b4[ow1+2]+zc0)*mdcx;
+ vir_r_m_dr[ZZ][YY] -= b4[ow1+2]*mday + (b4[ow1+2]+zb0)*mdby + (b4[ow1+2]+zc0)*mdcy;
+ vir_r_m_dr[ZZ][ZZ] -= b4[ow1+2]*mdaz + (b4[ow1+2]+zb0)*mdbz + (b4[ow1+2]+zc0)*mdcz;
/* 3*24 - 9 flops */
}
} else {
real tol,rvec x[],rvec prime[],real omega,
gmx_bool bFEP,real lambda,real lagr[],
real invdt,rvec *v,
- gmx_bool bCalcVir,tensor rmdr,int econq,
+ gmx_bool bCalcVir,tensor vir_r_m_dr,int econq,
t_vetavars *vetavar)
{
rvec *rij;
tmp = mm*rij[ll][i];
for(j=0; j<DIM; j++)
{
- rmdr[i][j] -= tmp*rij[ll][j];
+ vir_r_m_dr[i][j] -= tmp*rij[ll][j];
}
}
/* 21 flops */
}
gmx_bool bshakef(FILE *log,gmx_shakedata_t shaked,
- int natoms,real invmass[],int nblocks,int sblock[],
- t_idef *idef,t_inputrec *ir,rvec x_s[],rvec prime[],
- t_nrnb *nrnb,real *lagr,real lambda,real *dvdlambda,
- real invdt,rvec *v,gmx_bool bCalcVir,tensor rmdr,gmx_bool bDumpOnError,int econq,t_vetavars *vetavar)
+ int natoms,real invmass[],int nblocks,int sblock[],
+ t_idef *idef,t_inputrec *ir,rvec x_s[],rvec prime[],
+ t_nrnb *nrnb,real *lagr,real lambda,real *dvdlambda,
+ real invdt,rvec *v,gmx_bool bCalcVir,tensor vir_r_m_dr,
+ gmx_bool bDumpOnError,int econq,t_vetavars *vetavar)
{
t_iatom *iatoms;
real *lam,dt_2,dvdl;
blen /= 3;
n0 = vec_shakef(log,shaked,natoms,invmass,blen,idef->iparams,
iatoms,ir->shake_tol,x_s,prime,shaked->omega,
- ir->efep!=efepNO,lambda,lam,invdt,v,bCalcVir,rmdr,econq,vetavar);
+ ir->efep!=efepNO,lambda,lam,invdt,v,bCalcVir,vir_r_m_dr,
+ econq,vetavar);
#ifdef DEBUGSHAKE
check_cons(log,blen,x_s,prime,v,idef->iparams,iatoms,invmass,econq);