void parrinellorahman_pcoupl(FILE *fplog,gmx_step_t step,
t_inputrec *ir,real dt,tensor pres,
tensor box,tensor box_rel,tensor boxv,
tensor M,matrix mu,bool bFirstStep)
{
/* This doesn't do any coordinate updating. It just
* integrates the box vector equations from the calculated
* acceleration due to pressure difference. We also compute
* the tensor M which is used in update to couple the particle
* coordinates to the box vectors.
*
* In Nose and Klein (Mol.Phys 50 (1983) no 5., p 1055) this is
* given as
* -1 . . -1
* M_nk = (h') * (h' * h + h' h) * h
*
* with the dots denoting time derivatives and h is the transformation from
* the scaled frame to the real frame, i.e. the TRANSPOSE of the box.
* This also goes for the pressure and M tensors - they are transposed relative
* to ours. Our equation thus becomes:
*
* -1 . . -1
* M_gmx = M_nk' = b * (b * b' + b * b') * b'
*
* where b is the gromacs box matrix.
* Our box accelerations are given by
* .. ..
* b = vol/W inv(box') * (P-ref_P) (=h')
*/
int d,n;
tensor winv;
real vol=box[XX][XX]*box[YY][YY]*box[ZZ][ZZ];
real atot,arel,change,maxchange,xy_pressure;
tensor invbox,pdiff,t1,t2;
real maxl;
m_inv_ur0(box,invbox);
if (!bFirstStep) {
/* Note that PRESFAC does not occur here.
* The pressure and compressibility always occur as a product,
* therefore the pressure unit drops out.
*/
maxl=max(box[XX][XX],box[YY][YY]);
maxl=max(maxl,box[ZZ][ZZ]);
for(d=0;d<DIM;d++)
for(n=0;n<DIM;n++)
winv[d][n]=
(4*M_PI*M_PI*ir->compress[d][n])/(3*ir->tau_p*ir->tau_p*maxl);
m_sub(pres,ir->ref_p,pdiff);
if(ir->epct==epctSURFACETENSION) {
/* Unlike Berendsen coupling it might not be trivial to include a z
* pressure correction here? On the other hand we don't scale the
* box momentarily, but change accelerations, so it might not be crucial.
*/
xy_pressure=0.5*(pres[XX][XX]+pres[YY][YY]);
for(d=0;d<ZZ;d++)
pdiff[d][d]=(xy_pressure-(pres[ZZ][ZZ]-ir->ref_p[d][d]/box[d][d]));
}
tmmul(invbox,pdiff,t1);
/* Move the off-diagonal elements of the 'force' to one side to ensure
* that we obey the box constraints.
*/
for(d=0;d<DIM;d++) {
for(n=0;n<d;n++) {
t1[d][n] += t1[n][d];
t1[n][d] = 0;
}
}
switch (ir->epct) {
case epctANISOTROPIC:
for(d=0;d<DIM;d++)
for(n=0;n<=d;n++)
t1[d][n] *= winv[d][n]*vol;
break;
case epctISOTROPIC:
/* calculate total volume acceleration */
atot=box[XX][XX]*box[YY][YY]*t1[ZZ][ZZ]+
box[XX][XX]*t1[YY][YY]*box[ZZ][ZZ]+
t1[XX][XX]*box[YY][YY]*box[ZZ][ZZ];
arel=atot/(3*vol);
/* set all RELATIVE box accelerations equal, and maintain total V
* change speed */
for(d=0;d<DIM;d++)
for(n=0;n<=d;n++)
t1[d][n] = winv[0][0]*vol*arel*box[d][n];
break;
case epctSEMIISOTROPIC:
case epctSURFACETENSION:
/* Note the correction to pdiff above for surftens. coupling */
/* calculate total XY volume acceleration */
atot=box[XX][XX]*t1[YY][YY]+t1[XX][XX]*box[YY][YY];
arel=atot/(2*box[XX][XX]*box[YY][YY]);
/* set RELATIVE XY box accelerations equal, and maintain total V
* change speed. Dont change the third box vector accelerations */
for(d=0;d<ZZ;d++)
for(n=0;n<=d;n++)
t1[d][n] = winv[d][n]*vol*arel*box[d][n];
for(n=0;n<DIM;n++)
t1[ZZ][n] *= winv[d][n]*vol;
break;
default:
gmx_fatal(FARGS,"Parrinello-Rahman pressure coupling type %s "
"not supported yet\n",EPCOUPLTYPETYPE(ir->epct));
break;
}
maxchange=0;
for(d=0;d<DIM;d++)
for(n=0;n<=d;n++) {
boxv[d][n] += dt*t1[d][n];
/* We do NOT update the box vectors themselves here, since
* we need them for shifting later. It is instead done last
* in the update() routine.
*/
/* Calculate the change relative to diagonal elements -
* since it's perfectly ok for the off-diagonal ones to
* be zero it doesn't make sense to check the change relative
* to its current size.
*/
change=fabs(dt*boxv[d][n]/box[d][d]);
if(change>maxchange)
maxchange=change;
}
if (maxchange > 0.01 && fplog) {
char buf[22];
fprintf(fplog,"\nStep %s Warning: Pressure scaling more than 1%%.\n",
gmx_step_str(step,buf));
}
}
preserve_box_shape(ir,box_rel,boxv);
mtmul(boxv,box,t1); /* t1=boxv * b' */
mmul(invbox,t1,t2);
mtmul(t2,invbox,M);
/* Determine the scaling matrix mu for the coordinates */
for(d=0;d<DIM;d++)
for(n=0;n<=d;n++)
t1[d][n] = box[d][n] + dt*boxv[d][n];
preserve_box_shape(ir,box_rel,t1);
/* t1 is the box at t+dt, determine mu as the relative change */
mmul_ur0(invbox,t1,mu);
}
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,edt1,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;
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 node, use less processors");
}
bTAV = (od->edt != 0);
edt = od->edt;
edt1 = od->edt1;
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 = 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] + edt1*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 = 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 */
}
real calc_orires_dev(t_commrec *mcr,
int nfa,t_iatom forceatoms[],t_iparams ip[],
t_mdatoms *md,rvec x[],t_fcdata *fcd)
{
int fa,d,i,j,type,ex,nref;
real edt,edt1,invn,pfac,r2,invr,corrfac,weight,wsv2,sw,dev;
tensor *S,R,TMP;
rvec5 *Dinsl,*Dins,*Dtav,*rhs;
real *mref,***T;
rvec *xref,*xtmp,com,r_unrot,r;
t_oriresdata *od;
bool bTAV;
static real two_thr=2.0/3.0;
od = &(fcd->orires);
bTAV = (fabs(od->edt)>GMX_REAL_MIN);
edt = od->edt;
edt1 = od->edt1;
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;
od->exp_min_t_tau *= edt;
if (mcr)
invn = 1.0/mcr->nnodes;
else
invn = 1.0;
j=0;
for(i=0; i<md->nr; i++)
if (md->cORF[i] == 0) {
copy_rvec(x[i],xtmp[j]);
for(d=0; d<DIM; d++)
com[d] += mref[j]*xref[j][d];
j++;
}
svmul(od->invmref,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(nref,mref,xref,xtmp,R);
copy_mat(R,od->R);
d = 0;
for(fa=0; fa<nfa; fa+=3) {
type = forceatoms[fa];
rvec_sub(x[forceatoms[fa+1]],x[forceatoms[fa+2]],r_unrot);
mvmul(R,r_unrot,r);
r2 = norm2(r);
invr = 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.pow; 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 (mcr)
for(i=0; i<5; i++)
Dins[d][i] = Dinsl[d][i]*invn;
d++;
}
if (mcr)
gmx_sum(5*od->nr,Dins[0],mcr);
/* Correction factor to correct for the lack of history for short times */
corrfac = 1.0/(1.0-od->exp_min_t_tau);
/* 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)
for(i=0; i<5; i++)
Dtav[d][i] = edt*Dtav[d][i] + edt1*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 (mcr)
/* 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 = 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 */
}