static void constr_dum3FAD(rvec xi,rvec xj,rvec xk,rvec x,real a,real b)
{
rvec xij,xjk,xp;
real a1,b1,c1,invdij;
rvec_sub(xj,xi,xij);
rvec_sub(xk,xj,xjk);
/* 6 flops */
invdij = invsqrt(iprod(xij,xij));
c1 = invdij * invdij * iprod(xij,xjk);
xp[XX] = xjk[XX] - c1*xij[XX];
xp[YY] = xjk[YY] - c1*xij[YY];
xp[ZZ] = xjk[ZZ] - c1*xij[ZZ];
a1 = a*invdij;
b1 = b*invsqrt(iprod(xp,xp));
/* 45 */
x[XX] = xi[XX] + a1*xij[XX] + b1*xp[XX];
x[YY] = xi[YY] + a1*xij[YY] + b1*xp[YY];
x[ZZ] = xi[ZZ] + a1*xij[ZZ] + b1*xp[ZZ];
/* 12 Flops */
/* TOTAL: 63 flops */
}
void compute_factors_restangles(int type, const t_iparams forceparams[],
rvec delta_ante, rvec delta_post,
real *prefactor, real *ratio_ante, real *ratio_post, real *v)
{
real theta_equil, k_bending;
real cosine_theta_equil;
real c_ante, c_cros, c_post;
real norm;
real delta_cosine, cosine_theta;
real sine_theta_sq;
real term_theta_theta_equil;
k_bending = forceparams[type].harmonic.krA;
theta_equil = forceparams[type].harmonic.rA*DEG2RAD;
theta_equil = M_PI - theta_equil;
cosine_theta_equil = cos(theta_equil);
c_ante = iprod(delta_ante, delta_ante);
c_cros = iprod(delta_ante, delta_post);
c_post = iprod(delta_post, delta_post);
norm = gmx_invsqrt(c_ante * c_post);
cosine_theta = c_cros * norm;
sine_theta_sq = 1 - cosine_theta * cosine_theta;
*ratio_ante = c_cros / c_ante;
*ratio_post = c_cros / c_post;
delta_cosine = cosine_theta - cosine_theta_equil;
term_theta_theta_equil = 1 - cosine_theta * cosine_theta_equil;
*prefactor = -(k_bending) * delta_cosine * norm * term_theta_theta_equil / (sine_theta_sq * sine_theta_sq);
*v = k_bending * 0.5 * delta_cosine * delta_cosine / sine_theta_sq;
}
void calc_force(int natom,rvec f[],rvec fff[])
{
int i,j,m;
int jindex[] = { 0, 5, 10};
rvec dx,df;
real msf1,msf2;
for(j=0; (j<2); j++) {
clear_rvec(fff[j]);
for(i=jindex[j]; (i<jindex[j+1]); i++) {
for(m=0; (m<DIM); m++) {
fff[j][m] += f[i][m];
}
}
}
msf1 = iprod(fff[0],fff[0]);
msf2 = iprod(fff[1],fff[1]);
if (debug) {
pr_rvecs(debug,0,"force",f,natom);
fprintf(debug,"FMOL: %10.3f %10.3f %10.3f %10.3f %10.3f %10.3f\n",
fff[0][XX],fff[0][YY],fff[0][ZZ],fff[1][XX],fff[1][YY],fff[1][ZZ]);
fprintf(debug,"RMSF: %10.3e %10.3e\n",msf1,msf2);
}
}
void calc_f_dev(int natoms,real charge[],rvec x[],rvec f[],
t_idef *idef,real *xiH,real *xiS)
{
enum { wwwO, wwwH1, wwwH2, wwwS, wwwNR };
int lj_index[wwwNR] = { 0, 4, 4, 8 };
real rmsf,dFH,dFS,dFO,dr_14;
real q[wwwNR],c6[wwwNR],c12[wwwNR],c12ratio;
rvec fff[2],dx;
int i,j,aj;
for(i=0; (i<wwwNR); i++) {
q[i] = charge[i];
c12[i] = idef->iparams[lj_index[i]].lj.c12;
c6[i] = idef->iparams[lj_index[i]].lj.c6;
}
calc_force(natoms,f,fff);
rmsf = norm(fff[0]);
dFS = 0;
dFH = 0;
dFO = 0;
for(i=0; (i<4); i++) {
for(j=4; (j<8); j++) {
if (c12[i] != 0) {
rvec_sub(x[i],x[j],dx);
aj = j % 4;
dr_14 = pow(iprod(dx,dx),-7);
c12ratio = -12*sqrt(c12[aj]/c12[i])*dr_14*iprod(fff[0],dx);
switch (i) {
case wwwH1:
case wwwH2:
dFH += c12ratio;
break;
case wwwS:
dFS += c12ratio;
break;
case wwwO:
dFS += c12ratio;
break;
}
}
}
}
if (debug) {
fprintf(debug,"FFF: dFS=%10.3e, dFH=%10.3e, dFO=%10.3e, rmsf=%10.3e\n",
dFS,dFH,dFO,rmsf);
}
if (dFH == 0)
*xiH = 1;
else
*xiH=rmsf/(10*c12[wwwH1]*dFH);
if (dFS == 0)
*xiS = 1;
else
*xiS=rmsf/(10*c12[wwwS]*dFS);
}
static void spread_dum3FAD(rvec xi,rvec xj,rvec xk,
rvec fi,rvec fj,rvec fk,rvec f,real a,real b)
{
rvec xij,xjk,xperp,Fpij,Fppp,f1,f2,f3;
real a1,b1,c1,c2,invdij,invdij2,invdp,fproj;
int d;
rvec_sub(xj,xi,xij);
rvec_sub(xk,xj,xjk);
/* 6 flops */
invdij = invsqrt(iprod(xij,xij));
invdij2 = invdij * invdij;
c1 = iprod(xij,xjk) * invdij2;
xperp[XX] = xjk[XX] - c1*xij[XX];
xperp[YY] = xjk[YY] - c1*xij[YY];
xperp[ZZ] = xjk[ZZ] - c1*xij[ZZ];
/* xperp in plane ijk, perp. to ij */
invdp = invsqrt(iprod(xperp,xperp));
a1 = a*invdij;
b1 = b*invdp;
/* 45 flops */
/* a1, b1 and c1 are already calculated in constr_dum3FAD
storing them somewhere will save 45 flops! */
fproj=iprod(xij ,f)*invdij2;
svmul(fproj, xij, Fpij); /* proj. f on xij */
svmul(iprod(xperp,f)*invdp*invdp,xperp,Fppp); /* proj. f on xperp */
svmul(b1*fproj, xperp,f3);
/* 23 flops */
rvec_sub(f,Fpij,f1); /* f1 = f - Fpij */
rvec_sub(f1,Fppp,f2); /* f2 = f - Fpij - Fppp */
for (d=0; (d<DIM); d++) {
f1[d]*=a1;
f2[d]*=b1;
}
/* 12 flops */
c2=1+c1;
fi[XX] += f[XX] - f1[XX] + c1*f2[XX] + f3[XX];
fi[YY] += f[YY] - f1[YY] + c1*f2[YY] + f3[YY];
fi[ZZ] += f[ZZ] - f1[ZZ] + c1*f2[ZZ] + f3[ZZ];
fj[XX] += f1[XX] - c2*f2[XX] - f3[XX];
fj[YY] += f1[YY] - c2*f2[YY] - f3[YY];
fj[ZZ] += f1[ZZ] - c2*f2[ZZ] - f3[ZZ];
fk[XX] += f2[XX];
fk[YY] += f2[YY];
fk[ZZ] += f2[ZZ];
/* 30 Flops */
/* TOTAL: 113 flops */
}
static void spread_dum4FD(rvec xi,rvec xj,rvec xk,rvec xl,
rvec fi,rvec fj,rvec fk,rvec fl,rvec f,
real a,real b,real c)
{
real fx,fy,fz,d,invl,fproj,a1;
rvec xij,xjk,xjl,xix,temp;
rvec_sub(xj,xi,xij);
rvec_sub(xk,xj,xjk);
rvec_sub(xl,xj,xjl);
/* 9 flops */
/* xix goes from i to point x on the plane jkl */
xix[XX]=xij[XX]+a*xjk[XX]+b*xjl[XX];
xix[YY]=xij[YY]+a*xjk[YY]+b*xjl[YY];
xix[ZZ]=xij[ZZ]+a*xjk[ZZ]+b*xjl[ZZ];
/* 12 flops */
invl=invsqrt(iprod(xix,xix));
d=c*invl;
/* 4 + ?10? flops */
fproj=iprod(xix,f)*invl*invl; /* = (xix . f)/(xix . xix) */
fx=f[XX];
fy=f[YY];
fz=f[ZZ];
temp[XX]=d*(fx-fproj*xix[XX]);
temp[YY]=d*(fy-fproj*xix[YY]);
temp[ZZ]=d*(fz-fproj*xix[ZZ]);
/* 16 */
/* c is already calculated in constr_dum3FD
storing c somewhere will save 35 flops! */
a1=1-a-b;
fi[XX]+=fx-temp[XX];
fi[YY]+=fy-temp[YY];
fi[ZZ]+=fz-temp[ZZ];
fj[XX]+=a1*temp[XX];
fj[YY]+=a1*temp[YY];
fj[ZZ]+=a1*temp[ZZ];
fk[XX]+= a*temp[XX];
fk[YY]+= a*temp[YY];
fk[ZZ]+= a*temp[ZZ];
fl[XX]+= b*temp[XX];
fl[YY]+= b*temp[YY];
fl[ZZ]+= b*temp[ZZ];
/* 26 Flops */
/* TOTAL: 77 flops */
}
/* calculate the DXF polyline "bulge" value corresponding to the angle
between two vectors. In case of "infinity" return 0.0. */
static double bulge(dpoint_t v, dpoint_t w) {
double v2, w2, vw, vxw, nvw;
v2 = iprod(v, v);
w2 = iprod(w, w);
vw = iprod(v, w);
vxw = xprod(v, w);
nvw = sqrt(v2 * w2);
if (vxw == 0.0) {
return 0.0;
}
return (nvw - vw) / vxw;
}
static void spread_dum3FD(rvec xi,rvec xj,rvec xk,
rvec fi,rvec fj,rvec fk,rvec f,real a,real b)
{
real fx,fy,fz,c,invl,fproj,a1;
rvec xij,xjk,xix,temp;
rvec_sub(xj,xi,xij);
rvec_sub(xk,xj,xjk);
/* 6 flops */
/* xix goes from i to point x on the line jk */
xix[XX]=xij[XX]+a*xjk[XX];
xix[YY]=xij[YY]+a*xjk[YY];
xix[ZZ]=xij[ZZ]+a*xjk[ZZ];
/* 6 flops */
invl=invsqrt(iprod(xix,xix));
c=b*invl;
/* 4 + ?10? flops */
fproj=iprod(xix,f)*invl*invl; /* = (xix . f)/(xix . xix) */
fx=f[XX];
fy=f[YY];
fz=f[ZZ];
temp[XX]=c*(fx-fproj*xix[XX]);
temp[YY]=c*(fy-fproj*xix[YY]);
temp[ZZ]=c*(fz-fproj*xix[ZZ]);
/* 16 */
/* c is already calculated in constr_dum3FD
storing c somewhere will save 26 flops! */
a1=1-a;
fi[XX]+=fx-temp[XX];
fi[YY]+=fy-temp[YY];
fi[ZZ]+=fz-temp[ZZ];
fj[XX]+=a1*temp[XX];
fj[YY]+=a1*temp[YY];
fj[ZZ]+=a1*temp[ZZ];
fk[XX]+= a*temp[XX];
fk[YY]+= a*temp[YY];
fk[ZZ]+= a*temp[ZZ];
/* 19 Flops */
/* TOTAL: 61 flops */
}
static void constr_dum4FD(rvec xi,rvec xj,rvec xk,rvec xl,rvec x,
real a,real b,real c)
{
rvec xij,xjk,xjl,temp;
real d;
rvec_sub(xj,xi,xij);
rvec_sub(xk,xj,xjk);
rvec_sub(xl,xj,xjl);
/* 9 flops */
/* temp goes from i to a point on the plane jkl */
temp[XX] = xij[XX] + a*xjk[XX] + b*xjl[XX];
temp[YY] = xij[YY] + a*xjk[YY] + b*xjl[YY];
temp[ZZ] = xij[ZZ] + a*xjk[ZZ] + b*xjl[ZZ];
/* 12 flops */
d=c*invsqrt(iprod(temp,temp));
/* 6 + 10 flops */
x[XX] = xi[XX] + d*temp[XX];
x[YY] = xi[YY] + d*temp[YY];
x[ZZ] = xi[ZZ] + d*temp[ZZ];
/* 6 Flops */
/* TOTAL: 43 flops */
}
static void constr_dum3FD(rvec xi,rvec xj,rvec xk,rvec x,real a,real b)
{
rvec xij,xjk,temp;
real c;
rvec_sub(xj,xi,xij);
rvec_sub(xk,xj,xjk);
/* 6 flops */
/* temp goes from i to a point on the line jk */
temp[XX] = xij[XX] + a*xjk[XX];
temp[YY] = xij[YY] + a*xjk[YY];
temp[ZZ] = xij[ZZ] + a*xjk[ZZ];
/* 6 flops */
c=b*invsqrt(iprod(temp,temp));
/* 6 + 10 flops */
x[XX] = xi[XX] + c*temp[XX];
x[YY] = xi[YY] + c*temp[YY];
x[ZZ] = xi[ZZ] + c*temp[ZZ];
/* 6 Flops */
/* TOTAL: 34 flops */
}
static real rmsd_dist(t_pdbfile *pa,t_pdbfile *pb,bool bRMSD)
{
int i;
real rmsd,dist;
rvec acm,bcm,dx;
if (bRMSD) {
rmsd = 0;
for(i=0; (i<pa->atoms.nr); i++) {
rvec_sub(pa->x[i],pb->x[i],dx);
rmsd += iprod(dx,dx);
}
rmsd = sqrt(rmsd/pa->atoms.nr);
}
else {
dist = 0;
clear_rvec(acm);
clear_rvec(bcm);
for(i=0; (i<pa->atoms.nr); i++) {
rvec_inc(acm,pa->x[i]);
rvec_inc(bcm,pb->x[i]);
}
rvec_sub(acm,bcm,dx);
for(i=0; (i<DIM); i++)
dx[i] /= pa->atoms.nr;
rmsd = norm(dx);
}
return rmsd;
}
static void overlap(const char *outfile,int natoms,
rvec **eigvec1,
int nvec2,int *eignr2,rvec **eigvec2,
int noutvec,int *outvec,
const output_env_t oenv)
{
FILE *out;
int i,v,vec,x;
real overlap,inp;
fprintf(stderr,"Calculating overlap between eigenvectors of set 2 with eigenvectors\n");
for(i=0; i<noutvec; i++)
fprintf(stderr,"%d ",outvec[i]+1);
fprintf(stderr,"\n");
out=xvgropen(outfile,"Subspace overlap",
"Eigenvectors of trajectory 2","Overlap",oenv);
fprintf(out,"@ subtitle \"using %d eigenvectors of trajectory 1\"\n",
noutvec);
overlap=0;
for(x=0; x<nvec2; x++) {
for(v=0; v<noutvec; v++) {
vec=outvec[v];
inp=0;
for(i=0; i<natoms; i++)
inp+=iprod(eigvec1[vec][i],eigvec2[x][i]);
overlap+=sqr(inp);
}
fprintf(out,"%5d %5.3f\n",eignr2[x]+1,overlap/noutvec);
}
ffclose(out);
}
void lincs_warning(rvec *x,rvec *xprime,
int ncons,int *bla1,int *bla2,real *bllen,real wangle)
{
int b,i,j;
rvec v0,v1;
real wfac,d0,d1,cosine;
char buf[STRLEN];
wfac=cos(DEG2RAD*wangle);
sprintf(buf,"bonds that rotated more than %g degrees:\n"
" atom 1 atom 2 angle previous, current, constraint length\n",
wangle);
fprintf(stderr,buf);
if(stdlog)
fprintf(stdlog,buf);
for(b=0;b<ncons;b++) {
i=bla1[b];
j=bla2[b];
rvec_sub(x[i],x[j],v0);
rvec_sub(xprime[i],xprime[j],v1);
d0=norm(v0);
d1=norm(v1);
cosine=iprod(v0,v1)/(d0*d1);
if (cosine<wfac) {
sprintf(buf," %6d %6d %5.1f %8.4f %8.4f %8.4f\n",
i+1,j+1,RAD2DEG*acos(cosine),d0,d1,bllen[b]);
fprintf(stderr,buf);
if(stdlog)
fprintf(stdlog,buf);
}
}
}
void do_conect(const char *fn,int n,rvec x[])
{
FILE *fp;
int i,j;
t_conect *c;
rvec dx;
real d2;
fprintf(stderr,"Building CONECT records\n");
snew(c,n);
for(i=0; (i<n); i++)
c[i].aa = c[i].ab = NO_ATID;
for(i=0; (i<n); i++) {
for(j=i+1; (j<n); j++) {
rvec_sub(x[i],x[j],dx);
d2 = iprod(dx,dx);
add_rec(c,i,j,d2);
add_rec(c,j,i,d2);
}
}
fp = ffopen(fn,"a");
for(i=0; (i<n); i++) {
if ((c[i].aa == NO_ATID) || (c[i].ab == NO_ATID))
fprintf(stderr,"Warning dot %d has no conections\n",i+1);
fprintf(fp,"CONECT%5d%5d%5d\n",i+1,c[i].aa+1,c[i].ab+1);
}
ffclose(fp);
sfree(c);
}
void mk_bonds(int nnm, t_nm2type nmt[],
t_atoms *atoms, rvec x[], t_params *bond, int nbond[],
gmx_bool bPBC, matrix box)
{
t_param b;
int i, j;
t_pbc pbc;
rvec dx;
real dx2;
for (i = 0; (i < MAXATOMLIST); i++)
{
b.a[i] = -1;
}
for (i = 0; (i < MAXFORCEPARAM); i++)
{
b.c[i] = 0.0;
}
if (bPBC)
{
set_pbc(&pbc, -1, box);
}
for (i = 0; (i < atoms->nr); i++)
{
if ((i % 10) == 0)
{
fprintf(stderr, "\ratom %d", i);
}
for (j = i+1; (j < atoms->nr); j++)
{
if (bPBC)
{
pbc_dx(&pbc, x[i], x[j], dx);
}
else
{
rvec_sub(x[i], x[j], dx);
}
dx2 = iprod(dx, dx);
if (is_bond(nnm, nmt, *atoms->atomname[i], *atoms->atomname[j],
sqrt(dx2)))
{
b.AI = i;
b.AJ = j;
b.C0 = sqrt(dx2);
add_param_to_list (bond, &b);
nbond[i]++;
nbond[j]++;
if (debug)
{
fprintf(debug, "Bonding atoms %s-%d and %s-%d\n",
*atoms->atomname[i], i+1, *atoms->atomname[j], j+1);
}
}
}
}
fprintf(stderr, "\ratom %d\n", i);
}
static t_bbb *mk_bonds(int natoms,rvec x[],real odist,
gmx_bool bPBC,matrix box)
{
real od2 = odist*odist+1e-5;
t_pbc pbc;
t_bbb *bbb;
int i,j;
rvec dx;
if (bPBC)
set_pbc(&pbc,box);
snew(bbb,natoms);
for(i=0; (i<natoms); i++) {
for(j=i+1; (j<natoms); j++) {
if (bPBC)
pbc_dx(&pbc,x[i],x[j],dx);
else
rvec_sub(x[i],x[j],dx);
if (iprod(dx,dx) <= od2) {
bbb[i].aa[bbb[i].n++] = j;
bbb[j].aa[bbb[j].n++] = i;
}
}
}
if (debug)
#define PRB(nn) (bbb[(i)].n >= (nn)) ? bbb[i].aa[nn-1] : -1
for(i=0; (i<natoms); i++)
fprintf(debug,"bonds from %3d: %d %d %d %d\n",
i,PRB(1),PRB(2),PRB(3),PRB(4));
#undef PRB
return bbb;
}
static void insert_ion(int nsa, const int *nwater,
gmx_bool bSet[], int repl[], int index[],
rvec x[], t_pbc *pbc,
int sign, int q, const char *ionname,
t_atoms *atoms,
real rmin,
gmx::DefaultRandomEngine * rng)
{
int i, ei, nw;
real rmin2;
rvec dx;
int64_t maxrand;
gmx::UniformIntDistribution<int> dist(0, *nwater-1);
nw = *nwater;
maxrand = nw;
maxrand *= 1000;
do
{
ei = dist(*rng);
maxrand--;
}
while (bSet[ei] && (maxrand > 0));
if (bSet[ei])
{
gmx_fatal(FARGS, "No more replaceable solvent!");
}
fprintf(stderr, "Replacing solvent molecule %d (atom %d) with %s\n",
ei, index[nsa*ei], ionname);
/* Replace solvent molecule charges with ion charge */
bSet[ei] = TRUE;
repl[ei] = sign;
atoms->atom[index[nsa*ei]].q = q;
for (i = 1; i < nsa; i++)
{
atoms->atom[index[nsa*ei+i]].q = 0;
}
/* Mark all solvent molecules within rmin as unavailable for substitution */
if (rmin > 0)
{
rmin2 = rmin*rmin;
for (i = 0; (i < nw); i++)
{
if (!bSet[i])
{
pbc_dx(pbc, x[index[nsa*ei]], x[index[nsa*i]], dx);
if (iprod(dx, dx) < rmin2)
{
bSet[i] = TRUE;
}
}
}
}
}
static gmx_bool hbond(rvec x[], int i, int j, real distance)
{
real tol = distance*distance;
rvec tmp;
rvec_sub(x[i], x[j], tmp);
return (iprod(tmp, tmp) < tol);
}
// C(t) = (1/2)⟨3[e(τ)e(τ + t)]^2 − 1⟩
// from
// Chatfield, D. C.; Szabo, A.; Brooks, B. R.,
// Molecular Dynamics of Staphylococcal Nuclease: Comparison of Simulation with 15N and 13C NMR Relaxation Data.
// Journal of the American Chemical Society 1998, 120 (21), 5301-5311.
// and
// Gu, Y.; Li, D.-W.; Brüschweiler, R.,
// NMR Order Parameter Determination from Long Molecular Dynamics Trajectories for Objective Comparison with Experiment.
// Journal of Chemical Theory and Computation 2014, 10 (6), 2599-2607.
void gc_calc_ac(const rvec vecs[], int nvecs, int nt, real auto_corr[]) {
// tdelay is the number of indexes of separation between consecutive vectors in the current time delay
for(int tdelay = 1; tdelay <= nt; ++tdelay) { // iterate through time delays of autocorrelation domain
real sum = 0, dot;
for(int i = 0; i < nvecs - tdelay; ++i) { // iterate through the vectors for each time delay
dot = iprod(vecs[i], vecs[i + tdelay]);
sum += 3.0 * dot * dot - 1.0;
}
auto_corr[tdelay - 1] = 0.5 * (sum / (nvecs - tdelay));
}
}
static void check_cons(FILE *log, int nc, rvec x[], rvec prime[], rvec v[],
t_iparams ip[], t_iatom *iatom,
real invmass[], int econq)
{
t_iatom *ia;
int ai, aj;
int i;
real d, dp;
rvec dx, dv;
fprintf(log,
" i mi j mj before after should be\n");
ia = iatom;
for (i = 0; (i < nc); i++, ia += 3)
{
ai = ia[1];
aj = ia[2];
rvec_sub(x[ai], x[aj], dx);
d = norm(dx);
switch (econq)
{
case econqCoord:
rvec_sub(prime[ai], prime[aj], dx);
dp = norm(dx);
fprintf(log, "%5d %5.2f %5d %5.2f %10.5f %10.5f %10.5f\n",
ai+1, 1.0/invmass[ai],
aj+1, 1.0/invmass[aj], d, dp, ip[ia[0]].constr.dA);
break;
case econqVeloc:
rvec_sub(v[ai], v[aj], dv);
d = iprod(dx, dv);
rvec_sub(prime[ai], prime[aj], dv);
dp = iprod(dx, dv);
fprintf(log, "%5d %5.2f %5d %5.2f %10.5f %10.5f %10.5f\n",
ai+1, 1.0/invmass[ai],
aj+1, 1.0/invmass[aj], d, dp, 0.);
break;
}
}
}
/* Output vertices (with bulges) corresponding to a smooth pair of
circular arcs from A to B, tangent to AC at A and to CB at
B. Segments are meant to be concatenated, so don't output the final
vertex. */
static void pseudo_quad(FILE *fout, char *layer, dpoint_t A, dpoint_t C, dpoint_t B) {
dpoint_t v, w;
double v2, w2, vw, vxw, nvw;
double a, b, c, y;
dpoint_t G;
double bulge1, bulge2;
v = sub(A, C);
w = sub(B, C);
v2 = iprod(v, v);
w2 = iprod(w, w);
vw = iprod(v, w);
vxw = xprod(v, w);
nvw = sqrt(v2 * w2);
a = v2 + 2*vw + w2;
b = v2 + 2*nvw + w2;
c = 4*nvw;
if (vxw == 0 || a == 0) {
goto degenerate;
}
/* assert: a,b,c >= 0, b*b - a*c >= 0, and 0 <= b - sqrt(b*b - a*c) <= a */
y = (b - sqrt(b*b - a*c)) / a;
G = interval(y, C, interval(0.5, A, B));
bulge1 = bulge(sub(A,G), v);
bulge2 = bulge(w, sub(B,G));
ship_vertex(fout, layer, A, -bulge1);
ship_vertex(fout, layer, G, -bulge2);
return;
degenerate:
ship_vertex(fout, layer, A, 0);
return;
}
void calc_ke_part_visc(matrix box,rvec x[],rvec v[],
t_grpopts *opts,t_mdatoms *md,
gmx_ekindata_t *ekind,
t_nrnb *nrnb,real lambda)
{
int start=md->start,homenr=md->homenr;
int g,d,n,gt=0;
rvec v_corrt;
real hm;
t_grp_tcstat *tcstat=ekind->tcstat;
t_cos_acc *cosacc=&(ekind->cosacc);
real dekindl;
real fac,cosz;
double mvcos;
for(g=0; g<opts->ngtc; g++) {
copy_mat(ekind->tcstat[g].ekinh,ekind->tcstat[g].ekinh_old);
clear_mat(ekind->tcstat[g].ekinh);
}
ekind->dekindl_old = ekind->dekindl;
fac = 2*M_PI/box[ZZ][ZZ];
mvcos = 0;
dekindl = 0;
for(n=start; n<start+homenr; n++) {
if (md->cTC)
gt = md->cTC[n];
hm = 0.5*md->massT[n];
/* Note that the times of x and v differ by half a step */
cosz = cos(fac*x[n][ZZ]);
/* Calculate the amplitude of the new velocity profile */
mvcos += 2*cosz*md->massT[n]*v[n][XX];
copy_rvec(v[n],v_corrt);
/* Subtract the profile for the kinetic energy */
v_corrt[XX] -= cosz*cosacc->vcos;
for(d=0; (d<DIM); d++) {
tcstat[gt].ekinh[XX][d]+=hm*v_corrt[XX]*v_corrt[d];
tcstat[gt].ekinh[YY][d]+=hm*v_corrt[YY]*v_corrt[d];
tcstat[gt].ekinh[ZZ][d]+=hm*v_corrt[ZZ]*v_corrt[d];
}
if(md->nPerturbed && md->bPerturbed[n])
dekindl -= 0.5*(md->massB[n] - md->massA[n])*iprod(v_corrt,v_corrt);
}
ekind->dekindl = dekindl;
cosacc->mvcos = mvcos;
inc_nrnb(nrnb,eNR_EKIN,homenr);
}
static inline real eps_self(
real m, /* grid coordinate in certain direction */
real K, /* grid size in corresponding direction */
rvec rboxv, /* reciprocal box vector */
real n, /* spline interpolation order of the SPME */
rvec x) /* coordinate of charge */
{
int i;
real tmp = 0; /* temporary variables for computations */
real tmp1 = 0; /* temporary variables for computations */
real tmp2 = 0; /* temporary variables for computations */
real rcoord = 0; /* coordinate in certain reciprocal space direction */
real nom = 0; /* nominator */
real denom = 0; /* denominator */
if (m == 0.0)
{
return 0.0;
}
rcoord = iprod(rboxv, x);
for (i = -SUMORDER; i < 0; i++)
{
tmp = -sin(2.0 * M_PI * i * K * rcoord);
tmp1 = 2.0 * M_PI * m / K + 2.0 * M_PI * i;
tmp2 = pow(tmp1, -n);
nom += tmp * tmp2 * i;
denom += tmp2;
}
for (i = SUMORDER; i > 0; i--)
{
tmp = -sin(2.0 * M_PI * i * K * rcoord);
tmp1 = 2.0 * M_PI * m / K + 2.0 * M_PI * i;
tmp2 = pow(tmp1, -n);
nom += tmp * tmp2 * i;
denom += tmp2;
}
tmp = 2.0 * M_PI * m / K;
tmp1 = pow(tmp, -n);
denom += tmp1;
return 2.0 * M_PI * nom / denom * K;
}
static void dump_shells(FILE *fp,rvec x[],rvec f[],real ftol,int ns,t_shell s[])
{
int i,shell;
real ft2,ff2;
ft2 = sqr(ftol);
for(i=0; (i<ns); i++) {
shell = s[i].shell;
ff2 = iprod(f[shell],f[shell]);
if (ff2 > ft2)
fprintf(fp,"SHELL %5d, force %10.5f %10.5f %10.5f, |f| %10.5f\n",
shell,f[shell][XX],f[shell][YY],f[shell][ZZ],sqrt(ff2));
check_pbc(fp,x,shell);
}
}
/* compute the interval i to be the smallest interval including all <v
| dir> for points in the pathlist. If the pathlist is empty, return
the singleton interval [0,0]. */
void path_limits(potrace_path_t *path, dpoint_t dir, interval_t *i) {
potrace_path_t *p;
/* empty image? */
if (path == NULL) {
interval(i, 0, 0);
return;
}
/* initialize interval to a point on the first curve */
singleton(i, iprod(path->curve.c[0][2], dir));
/* iterate */
list_forall(p, path) {
curve_limits(&p->curve, dir, i);
}
/* extend the interval i to include the inner product <v | dir> for
all points v on the segment. Assume precondition a in i. */
static inline void segment_limits(int tag, dpoint_t a, dpoint_t c[3], dpoint_t dir, interval_t *i) {
switch (tag) {
case POTRACE_CORNER:
extend(i, iprod(c[1], dir));
extend(i, iprod(c[2], dir));
break;
case POTRACE_CURVETO:
bezier_limits(iprod(a, dir), iprod(c[0], dir), iprod(c[1], dir), iprod(c[2], dir), i);
break;
}
}
void calc_ke_part(rvec v[],t_grpopts *opts,t_mdatoms *md,
gmx_ekindata_t *ekind,
t_nrnb *nrnb,real lambda)
{
int start=md->start,homenr=md->homenr;
int g,d,n,ga=0,gt=0;
rvec v_corrt;
real hm;
t_grp_tcstat *tcstat=ekind->tcstat;
t_grp_acc *grpstat=ekind->grpstat;
real dekindl;
/* group velocities are calculated in update_ekindata and
* accumulated in acumulate_groups.
* Now the partial global and groups ekin.
*/
for(g=0; (g<opts->ngtc); g++) {
copy_mat(ekind->tcstat[g].ekinh,ekind->tcstat[g].ekinh_old);
clear_mat(ekind->tcstat[g].ekinh);
}
ekind->dekindl_old = ekind->dekindl;
dekindl = 0;
for(n=start; (n<start+homenr); n++) {
if (md->cACC)
ga = md->cACC[n];
if (md->cTC)
gt = md->cTC[n];
hm = 0.5*md->massT[n];
for(d=0; (d<DIM); d++) {
v_corrt[d] = v[n][d] - grpstat[ga].u[d];
}
for(d=0; (d<DIM); d++) {
tcstat[gt].ekinh[XX][d]+=hm*v_corrt[XX]*v_corrt[d];
tcstat[gt].ekinh[YY][d]+=hm*v_corrt[YY]*v_corrt[d];
tcstat[gt].ekinh[ZZ][d]+=hm*v_corrt[ZZ]*v_corrt[d];
}
if (md->nMassPerturbed && md->bPerturbed[n])
dekindl -= 0.5*(md->massB[n] - md->massA[n])*iprod(v_corrt,v_corrt);
}
ekind->dekindl = dekindl;
inc_nrnb(nrnb,eNR_EKIN,homenr);
}
static real msf(int n,rvec f1[],rvec f2[])
{
int i,j;
rvec ff2;
real msf1=0;
for(i=0; (i<n); ) {
clear_rvec(ff2);
for(j=0; ((j<ff.molsize) && (i<n)); j++,i++) {
rvec_inc(ff2,f1[i]);
if (f2)
rvec_inc(ff2,f2[i]);
}
msf1 += iprod(ff2,ff2);
}
return msf1/n;
}
double project_field(const rvec &vector, const double *field) {
double projection = 0;
double vlen = pow(iprod(vector,vector),.5);
for (int i=0; i<3; i++)
{
projection += field[i] * vector[i] / vlen;
}
if (! std::isnan(projection)) {
return projection;
}
else
{
std::cerr << "\nERROR: NAN is a result for a projection, there's a bug somewhere!\n";
//std::cout << vector[0] << " " << vector[1] << " " << vector[2] << std::endl;
//std::exit(1);
return 0;
}
}
void analyse_structure(t_ana_struct *anal,real t,rvec center,
rvec x[],int nparticle,real charge[])
{
int i,j,m,nel,n=0;
rvec dx,com;
real dx2,dx1;
j = anal->index;
if (j >= anal->nanal)
gmx_fatal(FARGS,"Too many points in analyse_structure");
anal->t[j] = t;
anal->maxdist[j] = 0;
clear_rvec(com);
nel = 0;
for(i=0; (i<nparticle); i++) {
if (charge[i] < 0) {
rvec_inc(com,x[i]);
nel++;
}
}
if (nel > 0)
for(m=0; (m<3); m++)
com[m] /= nel;
for(i=0; (i<nparticle); i++) {
if (charge[i] < 0) {
rvec_sub(x[i],com,dx);
for(m=0; (m<DIM); m++) {
anal->d2_com[j][m] += sqr(dx[m]);
anal->d2_origin[j][m] += sqr(x[i][m]);
}
dx2 = iprod(x[i],x[i]);
dx1 = sqrt(dx2);
if (dx1 > anal->maxdist[j])
anal->maxdist[j] = dx1;
n++;
}
}
do_add_struct(anal,nparticle,x);
anal->nion[j] = n;
anal->index++;
}
