/* calculates com of all atoms in x[], *index has their index numbers
to get the masses from atom[] */
real calc_com2(rvec x[],int gnx,atom_id *index,t_mdatoms *md,rvec com,
matrix box)
{
int i,ii,m;
real m0,tm;
clear_rvec(com);
tm=0;
for(i=0; (i<gnx); i++) {
ii=index[i];
m0=md->massT[ii];
tm+=m0;
for(m=0; (m<DIM); m++)
com[m]+=m0*x[i][m];
}
svmul(1/tm,com,com);
for(m=DIM-1; m>=0; m--) {
/* next two lines used to be commented out */
if (com[m] < 0 ) rvec_inc(com,box[m]);
if (com[m] > box[m][m]) rvec_dec(com,box[m]);
}
return tm;
}
void orient_princ(t_atoms *atoms, int isize, atom_id *index,
int natoms, rvec x[], rvec *v, rvec d)
{
int i, m;
rvec xcm, prcomp;
matrix trans;
calc_xcm(x, isize, index, atoms->atom, xcm, FALSE);
for (i = 0; i < natoms; i++)
{
rvec_dec(x[i], xcm);
}
principal_comp(isize, index, atoms->atom, x, trans, prcomp);
if (d)
{
copy_rvec(prcomp, d);
}
/* Check whether this trans matrix mirrors the molecule */
if (det(trans) < 0)
{
for (m = 0; (m < DIM); m++)
{
trans[ZZ][m] = -trans[ZZ][m];
}
}
rotate_atoms(natoms, NULL, x, trans);
if (v)
{
rotate_atoms(natoms, NULL, v, trans);
}
for (i = 0; i < natoms; i++)
{
rvec_inc(x[i], xcm);
}
}
void gmx_pme_receive_f(t_commrec *cr,
rvec f[], matrix vir_q, real *energy_q,
matrix vir_lj, real *energy_lj,
real *dvdlambda_q, real *dvdlambda_lj,
float *pme_cycles)
{
int natoms, i;
#ifdef GMX_PME_DELAYED_WAIT
/* Wait for the x request to finish */
gmx_pme_send_coeffs_coords_wait(cr->dd);
#endif
natoms = cr->dd->nat_home;
if (natoms > cr->dd->pme_recv_f_alloc)
{
cr->dd->pme_recv_f_alloc = over_alloc_dd(natoms);
srenew(cr->dd->pme_recv_f_buf, cr->dd->pme_recv_f_alloc);
}
#ifdef GMX_MPI
MPI_Recv(cr->dd->pme_recv_f_buf[0],
natoms*sizeof(rvec), MPI_BYTE,
cr->dd->pme_nodeid, 0, cr->mpi_comm_mysim,
MPI_STATUS_IGNORE);
#endif
for (i = 0; i < natoms; i++)
{
rvec_inc(f[i], cr->dd->pme_recv_f_buf[i]);
}
receive_virial_energy(cr, vir_q, energy_q, vir_lj, energy_lj, dvdlambda_q, dvdlambda_lj, pme_cycles);
}
static void reduce_thread_forces(int n, rvec *f,
tensor vir,
real *Vcorr,
int efpt_ind, real *dvdl,
int nthreads, f_thread_t *f_t)
{
int t, i;
/* This reduction can run over any number of threads */
#pragma omp parallel for num_threads(gmx_omp_nthreads_get(emntBonded)) private(t) schedule(static)
for (i = 0; i < n; i++)
{
for (t = 1; t < nthreads; t++)
{
rvec_inc(f[i], f_t[t].f[i]);
}
}
for (t = 1; t < nthreads; t++)
{
*Vcorr += f_t[t].Vcorr;
*dvdl += f_t[t].dvdl[efpt_ind];
m_add(vir, f_t[t].vir, vir);
}
}
real calc_geom(int isize, atom_id *index, rvec *x, rvec geom_center, rvec min,
rvec max, gmx_bool bDiam)
{
real diam2, d;
char *grpnames;
int ii, i, j;
clear_rvec(geom_center);
diam2 = 0;
if (isize == 0)
{
clear_rvec(min);
clear_rvec(max);
}
else
{
if (index)
{
ii = index[0];
}
else
{
ii = 0;
}
for (j = 0; j < DIM; j++)
{
min[j] = max[j] = x[ii][j];
}
for (i = 0; i < isize; i++)
{
if (index)
{
ii = index[i];
}
else
{
ii = i;
}
rvec_inc(geom_center, x[ii]);
for (j = 0; j < DIM; j++)
{
if (x[ii][j] < min[j])
{
min[j] = x[ii][j];
}
if (x[ii][j] > max[j])
{
max[j] = x[ii][j];
}
}
if (bDiam)
{
if (index)
{
for (j = i + 1; j < isize; j++)
{
d = distance2(x[ii], x[index[j]]);
diam2 = max(d, diam2);
}
}
else
{
for (j = i + 1; j < isize; j++)
{
d = distance2(x[i], x[j]);
diam2 = max(d, diam2);
}
}
}
}
svmul(1.0 / isize, geom_center, geom_center);
}
return sqrt(diam2);
}
static void list_trn(char *fn)
{
static real mass[5] = { 15.9994, 1.008, 1.008, 0.0, 0.0 };
int i,j=0,m,fpread,fpwrite,nframe;
rvec *x,*v,*f,fmol[2],xcm[2],torque[j],dx;
real mmm,len;
matrix box;
t_trnheader trn;
gmx_bool bOK;
printf("Going to open %s\n",fn);
fpread = open_trn(fn,"r");
fpwrite = open_tpx(NULL,"w");
gmx_fio_setdebug(fpwrite,TRUE);
mmm=mass[0]+2*mass[1];
for(i=0; (i<5); i++)
mass[i] /= mmm;
nframe = 0;
while (fread_trnheader(fpread,&trn,&bOK)) {
snew(x,trn.natoms);
snew(v,trn.natoms);
snew(f,trn.natoms);
if (fread_htrn(fpread,&trn,
trn.box_size ? box : NULL,
trn.x_size ? x : NULL,
trn.v_size ? v : NULL,
trn.f_size ? f : NULL)) {
if (trn.x_size && trn.f_size) {
printf("There are %d atoms\n",trn.natoms);
for(j=0; (j<2); j++) {
clear_rvec(xcm[j]);
clear_rvec(fmol[j]);
clear_rvec(torque[j]);
for(i=5*j; (i<5*j+5); i++) {
rvec_inc(fmol[j],f[i]);
for(m=0; (m<DIM); m++)
xcm[j][m] += mass[i%5]*x[i][m];
}
for(i=5*j; (i<5*j+5); i++) {
rvec_dec(x[i],xcm[j]);
cprod(x[i],f[i],dx);
rvec_inc(torque[j],dx);
rvec_inc(x[i],xcm[j]);
}
}
pr_rvecs(stdout,0,"FMOL ",fmol,2);
pr_rvecs(stdout,0,"TORQUE",torque,2);
printf("Distance matrix Water1-Water2\n%5s","");
for(j=0; (j<5); j++)
printf(" %10s",nm[j]);
printf("\n");
for(j=0; (j<5); j++) {
printf("%5s",nm[j]);
for(i=5; (i<10); i++) {
rvec_sub(x[i],x[j],dx);
len = sqrt(iprod(dx,dx));
printf(" %10.7f",len);
}
printf("\n");
}
}
}
sfree(x);
sfree(v);
sfree(f);
nframe++;
}
if (!bOK)
fprintf(stderr,"\nWARNING: Incomplete frame header: nr %d, t=%g\n",
nframe,trn.t);
close_tpx(fpwrite);
close_trn(fpread);
}
int gmx_traj(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] plots coordinates, velocities, forces and/or the box.",
"With [TT]-com[tt] the coordinates, velocities and forces are",
"calculated for the center of mass of each group.",
"When [TT]-mol[tt] is set, the numbers in the index file are",
"interpreted as molecule numbers and the same procedure as with",
"[TT]-com[tt] is used for each molecule.[PAR]",
"Option [TT]-ot[tt] plots the temperature of each group,",
"provided velocities are present in the trajectory file.",
"No corrections are made for constrained degrees of freedom!",
"This implies [TT]-com[tt].[PAR]",
"Options [TT]-ekt[tt] and [TT]-ekr[tt] plot the translational and",
"rotational kinetic energy of each group,",
"provided velocities are present in the trajectory file.",
"This implies [TT]-com[tt].[PAR]",
"Options [TT]-cv[tt] and [TT]-cf[tt] write the average velocities",
"and average forces as temperature factors to a [REF].pdb[ref] file with",
"the average coordinates or the coordinates at [TT]-ctime[tt].",
"The temperature factors are scaled such that the maximum is 10.",
"The scaling can be changed with the option [TT]-scale[tt].",
"To get the velocities or forces of one",
"frame set both [TT]-b[tt] and [TT]-e[tt] to the time of",
"desired frame. When averaging over frames you might need to use",
"the [TT]-nojump[tt] option to obtain the correct average coordinates.",
"If you select either of these option the average force and velocity",
"for each atom are written to an [REF].xvg[ref] file as well",
"(specified with [TT]-av[tt] or [TT]-af[tt]).[PAR]",
"Option [TT]-vd[tt] computes a velocity distribution, i.e. the",
"norm of the vector is plotted. In addition in the same graph",
"the kinetic energy distribution is given."
};
static gmx_bool bMol = FALSE, bCom = FALSE, bPBC = TRUE, bNoJump = FALSE;
static gmx_bool bX = TRUE, bY = TRUE, bZ = TRUE, bNorm = FALSE, bFP = FALSE;
static int ngroups = 1;
static real ctime = -1, scale = 0, binwidth = 1;
t_pargs pa[] = {
{ "-com", FALSE, etBOOL, {&bCom},
"Plot data for the com of each group" },
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Make molecules whole for COM" },
{ "-mol", FALSE, etBOOL, {&bMol},
"Index contains molecule numbers iso atom numbers" },
{ "-nojump", FALSE, etBOOL, {&bNoJump},
"Remove jumps of atoms across the box" },
{ "-x", FALSE, etBOOL, {&bX},
"Plot X-component" },
{ "-y", FALSE, etBOOL, {&bY},
"Plot Y-component" },
{ "-z", FALSE, etBOOL, {&bZ},
"Plot Z-component" },
{ "-ng", FALSE, etINT, {&ngroups},
"Number of groups to consider" },
{ "-len", FALSE, etBOOL, {&bNorm},
"Plot vector length" },
{ "-fp", FALSE, etBOOL, {&bFP},
"Full precision output" },
{ "-bin", FALSE, etREAL, {&binwidth},
"Binwidth for velocity histogram (nm/ps)" },
{ "-ctime", FALSE, etREAL, {&ctime},
"Use frame at this time for x in [TT]-cv[tt] and [TT]-cf[tt] instead of the average x" },
{ "-scale", FALSE, etREAL, {&scale},
"Scale factor for [REF].pdb[ref] output, 0 is autoscale" }
};
FILE *outx = NULL, *outv = NULL, *outf = NULL, *outb = NULL, *outt = NULL;
FILE *outekt = NULL, *outekr = NULL;
t_topology top;
int ePBC;
real *mass, time;
const char *indexfn;
t_trxframe fr, frout;
int flags, nvhisto = 0, *vhisto = NULL;
rvec *xtop, *xp = NULL;
rvec *sumx = NULL, *sumv = NULL, *sumf = NULL;
matrix topbox;
t_trxstatus *status;
t_trxstatus *status_out = NULL;
gmx_rmpbc_t gpbc = NULL;
int i, j;
int nr_xfr, nr_vfr, nr_ffr;
char **grpname;
int *isize0, *isize;
int **index0, **index;
int *atndx;
t_block *mols;
gmx_bool bTop, bOX, bOXT, bOV, bOF, bOB, bOT, bEKT, bEKR, bCV, bCF;
gmx_bool bDim[4], bDum[4], bVD;
char sffmt[STRLEN], sffmt6[STRLEN];
const char *box_leg[6] = { "XX", "YY", "ZZ", "YX", "ZX", "ZY" };
gmx_output_env_t *oenv;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-ox", "coord", ffOPTWR },
{ efTRX, "-oxt", "coord", ffOPTWR },
{ efXVG, "-ov", "veloc", ffOPTWR },
{ efXVG, "-of", "force", ffOPTWR },
{ efXVG, "-ob", "box", ffOPTWR },
{ efXVG, "-ot", "temp", ffOPTWR },
{ efXVG, "-ekt", "ektrans", ffOPTWR },
{ efXVG, "-ekr", "ekrot", ffOPTWR },
{ efXVG, "-vd", "veldist", ffOPTWR },
{ efPDB, "-cv", "veloc", ffOPTWR },
{ efPDB, "-cf", "force", ffOPTWR },
{ efXVG, "-av", "all_veloc", ffOPTWR },
{ efXVG, "-af", "all_force", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv,
PCA_CAN_TIME | PCA_TIME_UNIT | PCA_CAN_VIEW,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
if (bMol)
{
fprintf(stderr, "Interpreting indexfile entries as molecules.\n"
"Using center of mass.\n");
}
bOX = opt2bSet("-ox", NFILE, fnm);
bOXT = opt2bSet("-oxt", NFILE, fnm);
bOV = opt2bSet("-ov", NFILE, fnm);
bOF = opt2bSet("-of", NFILE, fnm);
bOB = opt2bSet("-ob", NFILE, fnm);
bOT = opt2bSet("-ot", NFILE, fnm);
bEKT = opt2bSet("-ekt", NFILE, fnm);
bEKR = opt2bSet("-ekr", NFILE, fnm);
bCV = opt2bSet("-cv", NFILE, fnm) || opt2bSet("-av", NFILE, fnm);
bCF = opt2bSet("-cf", NFILE, fnm) || opt2bSet("-af", NFILE, fnm);
bVD = opt2bSet("-vd", NFILE, fnm) || opt2parg_bSet("-bin", asize(pa), pa);
if (bMol || bOT || bEKT || bEKR)
{
bCom = TRUE;
}
bDim[XX] = bX;
bDim[YY] = bY;
bDim[ZZ] = bZ;
bDim[DIM] = bNorm;
if (bFP)
{
sprintf(sffmt, "\t%s", gmx_real_fullprecision_pfmt);
}
else
{
sprintf(sffmt, "\t%%g");
}
sprintf(sffmt6, "%s%s%s%s%s%s", sffmt, sffmt, sffmt, sffmt, sffmt, sffmt);
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC,
&xtop, NULL, topbox,
bCom && (bOX || bOXT || bOV || bOT || bEKT || bEKR));
sfree(xtop);
if ((bMol || bCV || bCF) && !bTop)
{
gmx_fatal(FARGS, "Need a run input file for option -mol, -cv or -cf");
}
if (bMol)
{
indexfn = ftp2fn(efNDX, NFILE, fnm);
}
else
{
indexfn = ftp2fn_null(efNDX, NFILE, fnm);
}
if (!(bCom && !bMol))
{
ngroups = 1;
}
snew(grpname, ngroups);
snew(isize0, ngroups);
snew(index0, ngroups);
get_index(&(top.atoms), indexfn, ngroups, isize0, index0, grpname);
if (bMol)
{
mols = &(top.mols);
atndx = mols->index;
ngroups = isize0[0];
snew(isize, ngroups);
snew(index, ngroups);
for (i = 0; i < ngroups; i++)
{
if (index0[0][i] < 0 || index0[0][i] >= mols->nr)
{
gmx_fatal(FARGS, "Molecule index (%d) is out of range (%d-%d)",
index0[0][i]+1, 1, mols->nr);
}
isize[i] = atndx[index0[0][i]+1] - atndx[index0[0][i]];
snew(index[i], isize[i]);
for (j = 0; j < isize[i]; j++)
{
index[i][j] = atndx[index0[0][i]] + j;
}
}
}
else
{
isize = isize0;
index = index0;
}
if (bCom)
{
snew(mass, top.atoms.nr);
for (i = 0; i < top.atoms.nr; i++)
{
mass[i] = top.atoms.atom[i].m;
}
}
else
{
mass = NULL;
}
flags = 0;
if (bOX)
{
flags = flags | TRX_READ_X;
outx = xvgropen(opt2fn("-ox", NFILE, fnm),
bCom ? "Center of mass" : "Coordinate",
output_env_get_xvgr_tlabel(oenv), "Coordinate (nm)", oenv);
make_legend(outx, ngroups, isize0[0], index0[0], grpname, bCom, bMol, bDim, oenv);
}
if (bOXT)
{
flags = flags | TRX_READ_X;
status_out = open_trx(opt2fn("-oxt", NFILE, fnm), "w");
}
if (bOV)
{
flags = flags | TRX_READ_V;
outv = xvgropen(opt2fn("-ov", NFILE, fnm),
bCom ? "Center of mass velocity" : "Velocity",
output_env_get_xvgr_tlabel(oenv), "Velocity (nm/ps)", oenv);
make_legend(outv, ngroups, isize0[0], index0[0], grpname, bCom, bMol, bDim, oenv);
}
if (bOF)
{
flags = flags | TRX_READ_F;
outf = xvgropen(opt2fn("-of", NFILE, fnm), "Force",
output_env_get_xvgr_tlabel(oenv), "Force (kJ mol\\S-1\\N nm\\S-1\\N)",
oenv);
make_legend(outf, ngroups, isize0[0], index0[0], grpname, bCom, bMol, bDim, oenv);
}
if (bOB)
{
outb = xvgropen(opt2fn("-ob", NFILE, fnm), "Box vector elements",
output_env_get_xvgr_tlabel(oenv), "(nm)", oenv);
xvgr_legend(outb, 6, box_leg, oenv);
}
if (bOT)
{
bDum[XX] = FALSE;
bDum[YY] = FALSE;
bDum[ZZ] = FALSE;
bDum[DIM] = TRUE;
flags = flags | TRX_READ_V;
outt = xvgropen(opt2fn("-ot", NFILE, fnm), "Temperature",
output_env_get_xvgr_tlabel(oenv), "(K)", oenv);
make_legend(outt, ngroups, isize[0], index[0], grpname, bCom, bMol, bDum, oenv);
}
if (bEKT)
{
bDum[XX] = FALSE;
bDum[YY] = FALSE;
bDum[ZZ] = FALSE;
bDum[DIM] = TRUE;
flags = flags | TRX_READ_V;
outekt = xvgropen(opt2fn("-ekt", NFILE, fnm), "Center of mass translation",
output_env_get_xvgr_tlabel(oenv), "Energy (kJ mol\\S-1\\N)", oenv);
make_legend(outekt, ngroups, isize[0], index[0], grpname, bCom, bMol, bDum, oenv);
}
if (bEKR)
{
bDum[XX] = FALSE;
bDum[YY] = FALSE;
bDum[ZZ] = FALSE;
bDum[DIM] = TRUE;
flags = flags | TRX_READ_X | TRX_READ_V;
outekr = xvgropen(opt2fn("-ekr", NFILE, fnm), "Center of mass rotation",
output_env_get_xvgr_tlabel(oenv), "Energy (kJ mol\\S-1\\N)", oenv);
make_legend(outekr, ngroups, isize[0], index[0], grpname, bCom, bMol, bDum, oenv);
}
if (bVD)
{
flags = flags | TRX_READ_V;
}
if (bCV)
{
flags = flags | TRX_READ_X | TRX_READ_V;
}
if (bCF)
{
flags = flags | TRX_READ_X | TRX_READ_F;
}
if ((flags == 0) && !bOB)
{
fprintf(stderr, "Please select one or more output file options\n");
exit(0);
}
read_first_frame(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &fr, flags);
if ((bOV || bOF) && fn2ftp(ftp2fn(efTRX, NFILE, fnm)) == efXTC)
{
gmx_fatal(FARGS, "Cannot extract velocities or forces since your input XTC file does not contain them.");
}
if (bCV || bCF)
{
snew(sumx, fr.natoms);
}
if (bCV)
{
snew(sumv, fr.natoms);
}
if (bCF)
{
snew(sumf, fr.natoms);
}
nr_xfr = 0;
nr_vfr = 0;
nr_ffr = 0;
if (bCom && bPBC)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, fr.natoms);
}
do
{
time = output_env_conv_time(oenv, fr.time);
if (fr.bX && bNoJump && fr.bBox)
{
if (xp)
{
remove_jump(fr.box, fr.natoms, xp, fr.x);
}
else
{
snew(xp, fr.natoms);
}
for (i = 0; i < fr.natoms; i++)
{
copy_rvec(fr.x[i], xp[i]);
}
}
if (fr.bX && bCom && bPBC)
{
gmx_rmpbc_trxfr(gpbc, &fr);
}
if (bVD && fr.bV)
{
update_histo(isize[0], index[0], fr.v, &nvhisto, &vhisto, binwidth);
}
if (bOX && fr.bX)
{
print_data(outx, time, fr.x, mass, bCom, ngroups, isize, index, bDim, sffmt);
}
if (bOXT && fr.bX)
{
frout = fr;
if (!frout.bAtoms)
{
frout.atoms = &top.atoms;
frout.bAtoms = TRUE;
}
write_trx_x(status_out, &frout, mass, bCom, ngroups, isize, index);
}
if (bOV && fr.bV)
{
print_data(outv, time, fr.v, mass, bCom, ngroups, isize, index, bDim, sffmt);
}
if (bOF && fr.bF)
{
print_data(outf, time, fr.f, NULL, bCom, ngroups, isize, index, bDim, sffmt);
}
if (bOB && fr.bBox)
{
fprintf(outb, "\t%g", fr.time);
fprintf(outb, sffmt6,
fr.box[XX][XX], fr.box[YY][YY], fr.box[ZZ][ZZ],
fr.box[YY][XX], fr.box[ZZ][XX], fr.box[ZZ][YY]);
fprintf(outb, "\n");
}
if (bOT && fr.bV)
{
fprintf(outt, " %g", time);
for (i = 0; i < ngroups; i++)
{
fprintf(outt, sffmt, temp(fr.v, mass, isize[i], index[i]));
}
fprintf(outt, "\n");
}
if (bEKT && fr.bV)
{
fprintf(outekt, " %g", time);
for (i = 0; i < ngroups; i++)
{
fprintf(outekt, sffmt, ektrans(fr.v, mass, isize[i], index[i]));
}
fprintf(outekt, "\n");
}
if (bEKR && fr.bX && fr.bV)
{
fprintf(outekr, " %g", time);
for (i = 0; i < ngroups; i++)
{
fprintf(outekr, sffmt, ekrot(fr.x, fr.v, mass, isize[i], index[i]));
}
fprintf(outekr, "\n");
}
if ((bCV || bCF) && fr.bX &&
(ctime < 0 || (fr.time >= ctime*0.999999 &&
fr.time <= ctime*1.000001)))
{
for (i = 0; i < fr.natoms; i++)
{
rvec_inc(sumx[i], fr.x[i]);
}
nr_xfr++;
}
if (bCV && fr.bV)
{
for (i = 0; i < fr.natoms; i++)
{
rvec_inc(sumv[i], fr.v[i]);
}
nr_vfr++;
}
if (bCF && fr.bF)
{
for (i = 0; i < fr.natoms; i++)
{
rvec_inc(sumf[i], fr.f[i]);
}
nr_ffr++;
}
}
while (read_next_frame(oenv, status, &fr));
if (gpbc != NULL)
{
gmx_rmpbc_done(gpbc);
}
/* clean up a bit */
close_trj(status);
if (bOX)
{
xvgrclose(outx);
}
if (bOXT)
{
close_trx(status_out);
}
if (bOV)
{
xvgrclose(outv);
}
if (bOF)
{
xvgrclose(outf);
}
if (bOB)
{
xvgrclose(outb);
}
if (bOT)
{
xvgrclose(outt);
}
if (bEKT)
{
xvgrclose(outekt);
}
if (bEKR)
{
xvgrclose(outekr);
}
if (bVD)
{
print_histo(opt2fn("-vd", NFILE, fnm), nvhisto, vhisto, binwidth, oenv);
}
if (bCV || bCF)
{
if (nr_xfr > 1)
{
if (ePBC != epbcNONE && !bNoJump)
{
fprintf(stderr, "\nWARNING: More than one frame was used for option -cv or -cf\n"
"If atoms jump across the box you should use the -nojump or -ctime option\n\n");
}
for (i = 0; i < isize[0]; i++)
{
svmul(1.0/nr_xfr, sumx[index[0][i]], sumx[index[0][i]]);
}
}
else if (nr_xfr == 0)
{
fprintf(stderr, "\nWARNING: No coordinate frames found for option -cv or -cf\n\n");
}
}
if (bCV)
{
write_pdb_bfac(opt2fn("-cv", NFILE, fnm),
opt2fn("-av", NFILE, fnm), "average velocity", &(top.atoms),
ePBC, topbox, isize[0], index[0], nr_xfr, sumx,
nr_vfr, sumv, bDim, scale, oenv);
}
if (bCF)
{
write_pdb_bfac(opt2fn("-cf", NFILE, fnm),
opt2fn("-af", NFILE, fnm), "average force", &(top.atoms),
ePBC, topbox, isize[0], index[0], nr_xfr, sumx,
nr_ffr, sumf, bDim, scale, oenv);
}
/* view it */
view_all(oenv, NFILE, fnm);
return 0;
}
int gmx_covar(int argc,char *argv[])
{
const char *desc[] = {
"[TT]g_covar[tt] calculates and diagonalizes the (mass-weighted)",
"covariance matrix.",
"All structures are fitted to the structure in the structure file.",
"When this is not a run input file periodicity will not be taken into",
"account. When the fit and analysis groups are identical and the analysis",
"is non mass-weighted, the fit will also be non mass-weighted.",
"[PAR]",
"The eigenvectors are written to a trajectory file ([TT]-v[tt]).",
"When the same atoms are used for the fit and the covariance analysis,",
"the reference structure for the fit is written first with t=-1.",
"The average (or reference when [TT]-ref[tt] is used) structure is",
"written with t=0, the eigenvectors",
"are written as frames with the eigenvector number as timestamp.",
"[PAR]",
"The eigenvectors can be analyzed with [TT]g_anaeig[tt].",
"[PAR]",
"Option [TT]-ascii[tt] writes the whole covariance matrix to",
"an ASCII file. The order of the elements is: x1x1, x1y1, x1z1, x1x2, ...",
"[PAR]",
"Option [TT]-xpm[tt] writes the whole covariance matrix to an [TT].xpm[tt] file.",
"[PAR]",
"Option [TT]-xpma[tt] writes the atomic covariance matrix to an [TT].xpm[tt] file,",
"i.e. for each atom pair the sum of the xx, yy and zz covariances is",
"written.",
"[PAR]",
"Note that the diagonalization of a matrix requires memory and time",
"that will increase at least as fast as than the square of the number",
"of atoms involved. It is easy to run out of memory, in which",
"case this tool will probably exit with a 'Segmentation fault'. You",
"should consider carefully whether a reduced set of atoms will meet",
"your needs for lower costs."
};
static gmx_bool bFit=TRUE,bRef=FALSE,bM=FALSE,bPBC=TRUE;
static int end=-1;
t_pargs pa[] = {
{ "-fit", FALSE, etBOOL, {&bFit},
"Fit to a reference structure"},
{ "-ref", FALSE, etBOOL, {&bRef},
"Use the deviation from the conformation in the structure file instead of from the average" },
{ "-mwa", FALSE, etBOOL, {&bM},
"Mass-weighted covariance analysis"},
{ "-last", FALSE, etINT, {&end},
"Last eigenvector to write away (-1 is till the last)" },
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Apply corrections for periodic boundary conditions" }
};
FILE *out;
t_trxstatus *status;
t_trxstatus *trjout;
t_topology top;
int ePBC;
t_atoms *atoms;
rvec *x,*xread,*xref,*xav,*xproj;
matrix box,zerobox;
real *sqrtm,*mat,*eigval,sum,trace,inv_nframes;
real t,tstart,tend,**mat2;
real xj,*w_rls=NULL;
real min,max,*axis;
int ntopatoms,step;
int natoms,nat,count,nframes0,nframes,nlevels;
gmx_large_int_t ndim,i,j,k,l;
int WriteXref;
const char *fitfile,*trxfile,*ndxfile;
const char *eigvalfile,*eigvecfile,*averfile,*logfile;
const char *asciifile,*xpmfile,*xpmafile;
char str[STRLEN],*fitname,*ananame,*pcwd;
int d,dj,nfit;
atom_id *index,*ifit;
gmx_bool bDiffMass1,bDiffMass2;
time_t now;
char timebuf[STRLEN];
t_rgb rlo,rmi,rhi;
real *tmp;
output_env_t oenv;
gmx_rmpbc_t gpbc=NULL;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "eigenval", ffWRITE },
{ efTRN, "-v", "eigenvec", ffWRITE },
{ efSTO, "-av", "average.pdb", ffWRITE },
{ efLOG, NULL, "covar", ffWRITE },
{ efDAT, "-ascii","covar", ffOPTWR },
{ efXPM, "-xpm","covar", ffOPTWR },
{ efXPM, "-xpma","covara", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_TIME_UNIT | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL,&oenv);
clear_mat(zerobox);
fitfile = ftp2fn(efTPS,NFILE,fnm);
trxfile = ftp2fn(efTRX,NFILE,fnm);
ndxfile = ftp2fn_null(efNDX,NFILE,fnm);
eigvalfile = ftp2fn(efXVG,NFILE,fnm);
eigvecfile = ftp2fn(efTRN,NFILE,fnm);
averfile = ftp2fn(efSTO,NFILE,fnm);
logfile = ftp2fn(efLOG,NFILE,fnm);
asciifile = opt2fn_null("-ascii",NFILE,fnm);
xpmfile = opt2fn_null("-xpm",NFILE,fnm);
xpmafile = opt2fn_null("-xpma",NFILE,fnm);
read_tps_conf(fitfile,str,&top,&ePBC,&xref,NULL,box,TRUE);
atoms=&top.atoms;
if (bFit) {
printf("\nChoose a group for the least squares fit\n");
get_index(atoms,ndxfile,1,&nfit,&ifit,&fitname);
if (nfit < 3)
gmx_fatal(FARGS,"Need >= 3 points to fit!\n");
} else
nfit=0;
printf("\nChoose a group for the covariance analysis\n");
get_index(atoms,ndxfile,1,&natoms,&index,&ananame);
bDiffMass1=FALSE;
if (bFit) {
snew(w_rls,atoms->nr);
for(i=0; (i<nfit); i++) {
w_rls[ifit[i]]=atoms->atom[ifit[i]].m;
if (i)
bDiffMass1 = bDiffMass1 || (w_rls[ifit[i]]!=w_rls[ifit[i-1]]);
}
}
bDiffMass2=FALSE;
snew(sqrtm,natoms);
for(i=0; (i<natoms); i++)
if (bM) {
sqrtm[i]=sqrt(atoms->atom[index[i]].m);
if (i)
bDiffMass2 = bDiffMass2 || (sqrtm[i]!=sqrtm[i-1]);
}
else
sqrtm[i]=1.0;
if (bFit && bDiffMass1 && !bDiffMass2) {
bDiffMass1 = natoms != nfit;
i=0;
for (i=0; (i<natoms) && !bDiffMass1; i++)
bDiffMass1 = index[i] != ifit[i];
if (!bDiffMass1) {
fprintf(stderr,"\n"
"Note: the fit and analysis group are identical,\n"
" while the fit is mass weighted and the analysis is not.\n"
" Making the fit non mass weighted.\n\n");
for(i=0; (i<nfit); i++)
w_rls[ifit[i]]=1.0;
}
}
/* Prepare reference frame */
if (bPBC) {
gpbc = gmx_rmpbc_init(&top.idef,ePBC,atoms->nr,box);
gmx_rmpbc(gpbc,atoms->nr,box,xref);
}
if (bFit)
reset_x(nfit,ifit,atoms->nr,NULL,xref,w_rls);
snew(x,natoms);
snew(xav,natoms);
ndim=natoms*DIM;
if (sqrt(GMX_LARGE_INT_MAX)<ndim) {
gmx_fatal(FARGS,"Number of degrees of freedoms to large for matrix.\n");
}
snew(mat,ndim*ndim);
fprintf(stderr,"Calculating the average structure ...\n");
nframes0 = 0;
nat=read_first_x(oenv,&status,trxfile,&t,&xread,box);
if (nat != atoms->nr)
fprintf(stderr,"\nWARNING: number of atoms in tpx (%d) and trajectory (%d) do not match\n",natoms,nat);
do {
nframes0++;
/* calculate x: a fitted struture of the selected atoms */
if (bPBC)
gmx_rmpbc(gpbc,nat,box,xread);
if (bFit) {
reset_x(nfit,ifit,nat,NULL,xread,w_rls);
do_fit(nat,w_rls,xref,xread);
}
for (i=0; i<natoms; i++)
rvec_inc(xav[i],xread[index[i]]);
} while (read_next_x(oenv,status,&t,nat,xread,box));
close_trj(status);
inv_nframes = 1.0/nframes0;
for(i=0; i<natoms; i++)
for(d=0; d<DIM; d++) {
xav[i][d] *= inv_nframes;
xread[index[i]][d] = xav[i][d];
}
write_sto_conf_indexed(opt2fn("-av",NFILE,fnm),"Average structure",
atoms,xread,NULL,epbcNONE,zerobox,natoms,index);
sfree(xread);
fprintf(stderr,"Constructing covariance matrix (%dx%d) ...\n",(int)ndim,(int)ndim);
nframes=0;
nat=read_first_x(oenv,&status,trxfile,&t,&xread,box);
tstart = t;
do {
nframes++;
tend = t;
/* calculate x: a (fitted) structure of the selected atoms */
if (bPBC)
gmx_rmpbc(gpbc,nat,box,xread);
if (bFit) {
reset_x(nfit,ifit,nat,NULL,xread,w_rls);
do_fit(nat,w_rls,xref,xread);
}
if (bRef)
for (i=0; i<natoms; i++)
rvec_sub(xread[index[i]],xref[index[i]],x[i]);
else
for (i=0; i<natoms; i++)
rvec_sub(xread[index[i]],xav[i],x[i]);
for (j=0; j<natoms; j++) {
for (dj=0; dj<DIM; dj++) {
k=ndim*(DIM*j+dj);
xj=x[j][dj];
for (i=j; i<natoms; i++) {
l=k+DIM*i;
for(d=0; d<DIM; d++)
mat[l+d] += x[i][d]*xj;
}
}
}
} while (read_next_x(oenv,status,&t,nat,xread,box) &&
(bRef || nframes < nframes0));
close_trj(status);
gmx_rmpbc_done(gpbc);
fprintf(stderr,"Read %d frames\n",nframes);
if (bRef) {
/* copy the reference structure to the ouput array x */
snew(xproj,natoms);
for (i=0; i<natoms; i++)
copy_rvec(xref[index[i]],xproj[i]);
} else {
xproj = xav;
}
/* correct the covariance matrix for the mass */
inv_nframes = 1.0/nframes;
for (j=0; j<natoms; j++)
for (dj=0; dj<DIM; dj++)
for (i=j; i<natoms; i++) {
k = ndim*(DIM*j+dj)+DIM*i;
for (d=0; d<DIM; d++)
mat[k+d] = mat[k+d]*inv_nframes*sqrtm[i]*sqrtm[j];
}
/* symmetrize the matrix */
for (j=0; j<ndim; j++)
for (i=j; i<ndim; i++)
mat[ndim*i+j]=mat[ndim*j+i];
trace=0;
for(i=0; i<ndim; i++)
trace+=mat[i*ndim+i];
fprintf(stderr,"\nTrace of the covariance matrix: %g (%snm^2)\n",
trace,bM ? "u " : "");
if (asciifile) {
out = ffopen(asciifile,"w");
for (j=0; j<ndim; j++) {
for (i=0; i<ndim; i+=3)
fprintf(out,"%g %g %g\n",
mat[ndim*j+i],mat[ndim*j+i+1],mat[ndim*j+i+2]);
}
ffclose(out);
}
if (xpmfile) {
min = 0;
max = 0;
snew(mat2,ndim);
for (j=0; j<ndim; j++) {
mat2[j] = &(mat[ndim*j]);
for (i=0; i<=j; i++) {
if (mat2[j][i] < min)
min = mat2[j][i];
if (mat2[j][j] > max)
max = mat2[j][i];
}
}
snew(axis,ndim);
for(i=0; i<ndim; i++)
axis[i] = i+1;
rlo.r = 0; rlo.g = 0; rlo.b = 1;
rmi.r = 1; rmi.g = 1; rmi.b = 1;
rhi.r = 1; rhi.g = 0; rhi.b = 0;
out = ffopen(xpmfile,"w");
nlevels = 80;
write_xpm3(out,0,"Covariance",bM ? "u nm^2" : "nm^2",
"dim","dim",ndim,ndim,axis,axis,
mat2,min,0.0,max,rlo,rmi,rhi,&nlevels);
ffclose(out);
sfree(axis);
sfree(mat2);
}
if (xpmafile) {
min = 0;
max = 0;
snew(mat2,ndim/DIM);
for (i=0; i<ndim/DIM; i++)
snew(mat2[i],ndim/DIM);
for (j=0; j<ndim/DIM; j++) {
for (i=0; i<=j; i++) {
mat2[j][i] = 0;
for(d=0; d<DIM; d++)
mat2[j][i] += mat[ndim*(DIM*j+d)+DIM*i+d];
if (mat2[j][i] < min)
min = mat2[j][i];
if (mat2[j][j] > max)
max = mat2[j][i];
mat2[i][j] = mat2[j][i];
}
}
snew(axis,ndim/DIM);
for(i=0; i<ndim/DIM; i++)
axis[i] = i+1;
rlo.r = 0; rlo.g = 0; rlo.b = 1;
rmi.r = 1; rmi.g = 1; rmi.b = 1;
rhi.r = 1; rhi.g = 0; rhi.b = 0;
out = ffopen(xpmafile,"w");
nlevels = 80;
write_xpm3(out,0,"Covariance",bM ? "u nm^2" : "nm^2",
"atom","atom",ndim/DIM,ndim/DIM,axis,axis,
mat2,min,0.0,max,rlo,rmi,rhi,&nlevels);
ffclose(out);
sfree(axis);
for (i=0; i<ndim/DIM; i++)
sfree(mat2[i]);
sfree(mat2);
}
/* call diagonalization routine */
fprintf(stderr,"\nDiagonalizing ...\n");
fflush(stderr);
snew(eigval,ndim);
snew(tmp,ndim*ndim);
memcpy(tmp,mat,ndim*ndim*sizeof(real));
eigensolver(tmp,ndim,0,ndim,eigval,mat);
sfree(tmp);
/* now write the output */
sum=0;
for(i=0; i<ndim; i++)
sum+=eigval[i];
fprintf(stderr,"\nSum of the eigenvalues: %g (%snm^2)\n",
sum,bM ? "u " : "");
if (fabs(trace-sum)>0.01*trace)
fprintf(stderr,"\nWARNING: eigenvalue sum deviates from the trace of the covariance matrix\n");
fprintf(stderr,"\nWriting eigenvalues to %s\n",eigvalfile);
sprintf(str,"(%snm\\S2\\N)",bM ? "u " : "");
out=xvgropen(eigvalfile,
"Eigenvalues of the covariance matrix",
"Eigenvector index",str,oenv);
for (i=0; (i<ndim); i++)
fprintf (out,"%10d %g\n",(int)i+1,eigval[ndim-1-i]);
ffclose(out);
if (end==-1) {
if (nframes-1 < ndim)
end=nframes-1;
else
end=ndim;
}
if (bFit) {
/* misuse lambda: 0/1 mass weighted analysis no/yes */
if (nfit==natoms) {
WriteXref = eWXR_YES;
for(i=0; i<nfit; i++)
copy_rvec(xref[ifit[i]],x[i]);
} else
WriteXref = eWXR_NO;
} else {
/* misuse lambda: -1 for no fit */
WriteXref = eWXR_NOFIT;
}
write_eigenvectors(eigvecfile,natoms,mat,TRUE,1,end,
WriteXref,x,bDiffMass1,xproj,bM,eigval);
out = ffopen(logfile,"w");
time(&now);
gmx_ctime_r(&now,timebuf,STRLEN);
fprintf(out,"Covariance analysis log, written %s\n",timebuf);
fprintf(out,"Program: %s\n",argv[0]);
#if ((defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64) && !defined __CYGWIN__ && !defined __CYGWIN32__)
pcwd=_getcwd(str,STRLEN);
#else
pcwd=getcwd(str,STRLEN);
#endif
if(NULL==pcwd)
{
gmx_fatal(FARGS,"Current working directory is undefined");
}
fprintf(out,"Working directory: %s\n\n",str);
fprintf(out,"Read %d frames from %s (time %g to %g %s)\n",nframes,trxfile,
output_env_conv_time(oenv,tstart),output_env_conv_time(oenv,tend),output_env_get_time_unit(oenv));
if (bFit)
fprintf(out,"Read reference structure for fit from %s\n",fitfile);
if (ndxfile)
fprintf(out,"Read index groups from %s\n",ndxfile);
fprintf(out,"\n");
fprintf(out,"Analysis group is '%s' (%d atoms)\n",ananame,natoms);
if (bFit)
fprintf(out,"Fit group is '%s' (%d atoms)\n",fitname,nfit);
else
fprintf(out,"No fit was used\n");
fprintf(out,"Analysis is %smass weighted\n", bDiffMass2 ? "":"non-");
if (bFit)
fprintf(out,"Fit is %smass weighted\n", bDiffMass1 ? "":"non-");
fprintf(out,"Diagonalized the %dx%d covariance matrix\n",(int)ndim,(int)ndim);
fprintf(out,"Trace of the covariance matrix before diagonalizing: %g\n",
trace);
fprintf(out,"Trace of the covariance matrix after diagonalizing: %g\n\n",
sum);
fprintf(out,"Wrote %d eigenvalues to %s\n",(int)ndim,eigvalfile);
if (WriteXref == eWXR_YES)
fprintf(out,"Wrote reference structure to %s\n",eigvecfile);
fprintf(out,"Wrote average structure to %s and %s\n",averfile,eigvecfile);
fprintf(out,"Wrote eigenvectors %d to %d to %s\n",1,end,eigvecfile);
ffclose(out);
fprintf(stderr,"Wrote the log to %s\n",logfile);
thanx(stderr);
return 0;
}
void dd_move_f_specat(gmx_domdec_t *dd, gmx_domdec_specat_comm_t *spac,
rvec *f, rvec *fshift)
{
gmx_specatsend_t *spas;
rvec *vbuf;
int n, n0, n1, d, dim, dir, i;
ivec vis;
int is;
gmx_bool bPBC, bScrew;
n = spac->at_end;
for (d = dd->ndim-1; d >= 0; d--)
{
dim = dd->dim[d];
if (dd->nc[dim] > 2)
{
/* Pulse the grid forward and backward */
spas = spac->spas[d];
n0 = spas[0].nrecv;
n1 = spas[1].nrecv;
n -= n1 + n0;
vbuf = spac->vbuf;
/* Send and receive the coordinates */
dd_sendrecv2_rvec(dd, d,
f+n+n1, n0, vbuf, spas[0].nsend,
f+n, n1, vbuf+spas[0].nsend, spas[1].nsend);
for (dir = 0; dir < 2; dir++)
{
bPBC = ((dir == 0 && dd->ci[dim] == 0) ||
(dir == 1 && dd->ci[dim] == dd->nc[dim]-1));
bScrew = (bPBC && dd->bScrewPBC && dim == XX);
spas = &spac->spas[d][dir];
/* Sum the buffer into the required forces */
if (!bPBC || (!bScrew && fshift == NULL))
{
for (i = 0; i < spas->nsend; i++)
{
rvec_inc(f[spas->a[i]], *vbuf);
vbuf++;
}
}
else
{
clear_ivec(vis);
vis[dim] = (dir == 0 ? 1 : -1);
is = IVEC2IS(vis);
if (!bScrew)
{
/* Sum and add to shift forces */
for (i = 0; i < spas->nsend; i++)
{
rvec_inc(f[spas->a[i]], *vbuf);
rvec_inc(fshift[is], *vbuf);
vbuf++;
}
}
else
{
/* Rotate the forces */
for (i = 0; i < spas->nsend; i++)
{
f[spas->a[i]][XX] += (*vbuf)[XX];
f[spas->a[i]][YY] -= (*vbuf)[YY];
f[spas->a[i]][ZZ] -= (*vbuf)[ZZ];
if (fshift)
{
rvec_inc(fshift[is], *vbuf);
}
vbuf++;
}
}
}
}
}
else
{
/* Two cells, so we only need to communicate one way */
spas = &spac->spas[d][0];
n -= spas->nrecv;
/* Send and receive the coordinates */
dd_sendrecv_rvec(dd, d, dddirForward,
f+n, spas->nrecv, spac->vbuf, spas->nsend);
/* Sum the buffer into the required forces */
if (dd->bScrewPBC && dim == XX &&
(dd->ci[dim] == 0 ||
dd->ci[dim] == dd->nc[dim]-1))
{
for (i = 0; i < spas->nsend; i++)
{
/* Rotate the force */
f[spas->a[i]][XX] += spac->vbuf[i][XX];
f[spas->a[i]][YY] -= spac->vbuf[i][YY];
f[spas->a[i]][ZZ] -= spac->vbuf[i][ZZ];
}
}
else
{
for (i = 0; i < spas->nsend; i++)
{
rvec_inc(f[spas->a[i]], spac->vbuf[i]);
}
}
}
}
}
real
do_listed_vdw_q(int ftype,int nbonds,
const t_iatom iatoms[],const t_iparams iparams[],
const rvec x[],rvec f[],rvec fshift[],
const t_pbc *pbc,const t_graph *g,
real lambda,real *dvdlambda,
const t_mdatoms *md,
const t_forcerec *fr,gmx_grppairener_t *grppener,
int *global_atom_index)
{
static gmx_bool bWarn=FALSE;
real eps,r2,*tab,rtab2=0;
rvec dx,x14[2],f14[2];
int i,ai,aj,itype;
int typeA[2]={0,0},typeB[2]={0,1};
real chargeA[2]={0,0},chargeB[2];
int gid,shift_vir,shift_f;
int j_index[] = { 0, 1 };
int i0=0,i1=1,i2=2;
ivec dt;
int outeriter,inneriter;
int nthreads = 1;
int count;
real krf,crf,tabscale;
int ntype=0;
real *nbfp=NULL;
real *egnb=NULL,*egcoul=NULL;
t_nblist tmplist;
int icoul,ivdw;
gmx_bool bMolPBC,bFreeEnergy;
t_pf_global *pf_global;
#if GMX_THREAD_SHM_FDECOMP
pthread_mutex_t mtx;
#else
void * mtx = NULL;
#endif
#if GMX_THREAD_SHM_FDECOMP
pthread_mutex_initialize(&mtx);
#endif
bMolPBC = fr->bMolPBC;
pf_global = fr->pf_global;
switch (ftype) {
case F_LJ14:
case F_LJC14_Q:
eps = fr->epsfac*fr->fudgeQQ;
ntype = 1;
egnb = grppener->ener[egLJ14];
egcoul = grppener->ener[egCOUL14];
break;
case F_LJC_PAIRS_NB:
eps = fr->epsfac;
ntype = 1;
egnb = grppener->ener[egLJSR];
egcoul = grppener->ener[egCOULSR];
break;
default:
gmx_fatal(FARGS,"Unknown function type %d in do_nonbonded14",
ftype);
}
tab = fr->tab14.tab;
rtab2 = sqr(fr->tab14.r);
tabscale = fr->tab14.scale;
krf = fr->k_rf;
crf = fr->c_rf;
/* Determine the values for icoul/ivdw. */
if (fr->bEwald) {
icoul = 1;
}
else if(fr->bcoultab)
{
icoul = 3;
}
else if(fr->eeltype == eelRF_NEC)
{
icoul = 2;
}
else
{
icoul = 1;
}
if(fr->bvdwtab)
{
ivdw = 3;
}
else if(fr->bBHAM)
{
ivdw = 2;
}
else
{
ivdw = 1;
}
/* We don't do SSE or altivec here, due to large overhead for 4-fold
* unrolling on short lists
*/
bFreeEnergy = FALSE;
for(i=0; (i<nbonds); )
{
itype = iatoms[i++];
ai = iatoms[i++];
aj = iatoms[i++];
gid = GID(md->cENER[ai],md->cENER[aj],md->nenergrp);
switch (ftype) {
case F_LJ14:
bFreeEnergy =
(fr->efep != efepNO &&
((md->nPerturbed && (md->bPerturbed[ai] || md->bPerturbed[aj])) ||
iparams[itype].lj14.c6A != iparams[itype].lj14.c6B ||
iparams[itype].lj14.c12A != iparams[itype].lj14.c12B));
chargeA[0] = md->chargeA[ai];
chargeA[1] = md->chargeA[aj];
nbfp = (real *)&(iparams[itype].lj14.c6A);
break;
case F_LJC14_Q:
eps = fr->epsfac*iparams[itype].ljc14.fqq;
chargeA[0] = iparams[itype].ljc14.qi;
chargeA[1] = iparams[itype].ljc14.qj;
nbfp = (real *)&(iparams[itype].ljc14.c6);
break;
case F_LJC_PAIRS_NB:
chargeA[0] = iparams[itype].ljcnb.qi;
chargeA[1] = iparams[itype].ljcnb.qj;
nbfp = (real *)&(iparams[itype].ljcnb.c6);
break;
}
if (!bMolPBC)
{
/* This is a bonded interaction, atoms are in the same box */
shift_f = CENTRAL;
r2 = distance2(x[ai],x[aj]);
}
else
{
/* Apply full periodic boundary conditions */
shift_f = pbc_dx_aiuc(pbc,x[ai],x[aj],dx);
r2 = norm2(dx);
}
if (r2 >= rtab2)
{
if (!bWarn)
{
fprintf(stderr,"Warning: 1-4 interaction between %d and %d "
"at distance %.3f which is larger than the 1-4 table size %.3f nm\n",
glatnr(global_atom_index,ai),
glatnr(global_atom_index,aj),
sqrt(r2), sqrt(rtab2));
fprintf(stderr,"These are ignored for the rest of the simulation\n");
fprintf(stderr,"This usually means your system is exploding,\n"
"if not, you should increase table-extension in your mdp file\n"
"or with user tables increase the table size\n");
bWarn = TRUE;
}
if (debug)
fprintf(debug,"%8f %8f %8f\n%8f %8f %8f\n1-4 (%d,%d) interaction not within cut-off! r=%g. Ignored\n",
x[ai][XX],x[ai][YY],x[ai][ZZ],
x[aj][XX],x[aj][YY],x[aj][ZZ],
glatnr(global_atom_index,ai),
glatnr(global_atom_index,aj),
sqrt(r2));
}
else
{
copy_rvec(x[ai],x14[0]);
copy_rvec(x[aj],x14[1]);
clear_rvec(f14[0]);
clear_rvec(f14[1]);
#ifdef DEBUG
fprintf(debug,"LJ14: grp-i=%2d, grp-j=%2d, ngrp=%2d, GID=%d\n",
md->cENER[ai],md->cENER[aj],md->nenergrp,gid);
#endif
outeriter = inneriter = count = 0;
if (bFreeEnergy)
{
chargeB[0] = md->chargeB[ai];
chargeB[1] = md->chargeB[aj];
/* We pass &(iparams[itype].lj14.c6A) as LJ parameter matrix
* to the innerloops.
* Here we use that the LJ-14 parameters are stored in iparams
* as c6A,c12A,c6B,c12B, which are referenced correctly
* in the innerloops if we assign type combinations 0-0 and 0-1
* to atom pair ai-aj in topologies A and B respectively.
*/
if(ivdw==2)
{
gmx_fatal(FARGS,"Cannot do free energy Buckingham interactions.");
}
count = 0;
gmx_nb_free_energy_kernel(icoul,
ivdw,
i1,
&i0,
j_index,
&i1,
&shift_f,
fr->shift_vec[0],
fshift[0],
&gid,
x14[0],
f14[0],
chargeA,
chargeB,
eps,
krf,
crf,
fr->ewaldcoeff,
egcoul,
typeA,
typeB,
ntype,
nbfp,
egnb,
tabscale,
tab,
lambda,
dvdlambda,
fr->sc_alpha,
fr->sc_power,
fr->sc_sigma6_def,
fr->sc_sigma6_min,
TRUE,
&outeriter,
&inneriter);
}
else
{
/* Not perturbed - call kernel 330 */
nb_kernel330
( &i1,
&i0,
j_index,
&i1,
&shift_f,
fr->shift_vec[0],
fshift[0],
&gid,
x14[0],
f14[0],
chargeA,
&eps,
&krf,
&crf,
egcoul,
typeA,
&ntype,
nbfp,
egnb,
&tabscale,
tab,
NULL,
NULL,
NULL,
NULL,
&nthreads,
&count,
(void *)&mtx,
&outeriter,
&inneriter,
NULL);
}
/* Add the forces */
rvec_inc(f[ai],f14[0]);
rvec_dec(f[aj],f14[0]);
if (pf_global->bInitialized)
pf_atom_add_bonded(pf_global, ai, aj, PF_INTER_NB14, f14[0]);
if (g)
{
/* Correct the shift forces using the graph */
ivec_sub(SHIFT_IVEC(g,ai),SHIFT_IVEC(g,aj),dt);
shift_vir = IVEC2IS(dt);
rvec_inc(fshift[shift_vir],f14[0]);
rvec_dec(fshift[CENTRAL],f14[0]);
}
/* flops: eNR_KERNEL_OUTER + eNR_KERNEL330 + 12 */
}
}
return 0.0;
}
static void do_sdf(char *fnNDX,char *fnTPS,char *fnTRX, char *fnSDF,
char *fnREF, bool bRef, rvec cutoff, real binwidth,
int mode, rvec triangle, rvec dtri)
{
FILE *fp;
int status;
int ng,natoms,i,j,k,l,X,Y,Z,lc,dest;
ivec nbin;
int ***count;
/* real ***sdf; */
real sdf,min_sdf=1e10,max_sdf=0;
char **grpname;
int *isize;
int isize_cg=0;
int isize_ref=3;
int ref_resind[3];
int nrefmol=0,refc=0;
atom_id **index;
atom_id *index_cg=NULL;
atom_id *index_ref=NULL;
real t,boxmin,hbox,normfac;
real invbinw;
rvec tri_upper,tri_lower;
rvec *x,xcog,dx,*x_i1,xi,*x_refmol;
matrix box;
matrix rot; /* rotation matrix := unit vectors for the molecule frame */
rvec k_mol,i1_mol,i2_mol,dx_mol;
real delta;
atom_id ix,jx;
t_topology top;
int ePBC=-1;
t_pbc pbc;
bool bTop=FALSE,bRefDone=FALSE,bInGroup=FALSE;
char title[STRLEN];
/* Read Topology */
if (fnTPS) {
bTop=read_tps_conf(fnTPS,title,&top,&ePBC,&x,NULL,box,TRUE);
}
if ( !bTop ) {
fprintf(stderr,"\nNeed tpr-file to make a reference structure.\n");
fprintf(stderr,"Option -r will be ignored!\n");
bRef = FALSE;
}
/* Allocate memory for 4 groups, 3 dummy groups and a group for the ref
structure if needed */
ng = 4;
snew(grpname,ng);
/* the dummy groups are used to dynamically store triples of atoms */
/* for molecular coordinate systems */
if ( bRef )
{
snew(isize,ng+4);
snew(index,ng+4);
}
else
{
snew(isize,ng+3);
snew(index,ng+3);
}
/* Read the index groups */
fprintf(stderr,"\nSelect the 3 reference groups and the SDF group:\n");
if (fnTPS)
get_index(&top.atoms,fnNDX,ng,isize,index,grpname);
else
rd_index(fnNDX,ng,isize,index,grpname);
isize[NDX_REF1]=isize[G_REF1];
for (i=NDX_REF1; i<=NDX_REF3; i++)
snew(index[i],isize[NDX_REF1]);
/* Read first frame and check it */
natoms=read_first_x(&status,fnTRX,&t,&x,box);
if ( !natoms )
gmx_fatal(FARGS,"Could not read coordinates from statusfile!\n");
/* check with topology */
if (fnTPS)
if ( natoms > top.atoms.nr )
gmx_fatal(FARGS,"Trajectory (%d atoms) does not match topology (%d atoms)!\n",
natoms,top.atoms.nr);
/* check with index groups */
for (i=0; i<ng; i++)
for (j=0; j<isize[i]; j++)
if ( index[i][j] >= natoms )
gmx_fatal(FARGS,"Atom index (%d) in index group %s (%d atoms) larger "
"than number of atoms in trajectory (%d atoms)!\n",
index[i][j],grpname[i],isize[i],natoms);
/* check reference groups */
if ( mode == 1 )
{
if ( isize[G_REF1] != isize[G_REF2] || isize[G_REF1] != isize[G_REF3] ||
isize[G_REF2] != isize[G_REF3] )
gmx_fatal(FARGS,"For single particle SDF, all reference groups"
"must have the same size.\n");
/* for single particle SDF dynamic triples are not needed */
/* so we build them right here */
/* copy all triples from G_REFx to NDX_REFx */
for (i=0; i<isize[G_REF1]; i++)
{
/* check if all three atoms come from the same molecule */
for (j=G_REF1; j<=G_REF3; j++)
ref_resind[j] = top.atoms.atom[index[j][i]].resind;
if ( ref_resind[G_REF1] != ref_resind[G_REF2] ||
ref_resind[G_REF2] != ref_resind[G_REF3] ||
ref_resind[G_REF3] != ref_resind[G_REF1] )
{
fprintf(stderr,"\nWarning: reference triple (%d) will be skipped.\n",i);
fprintf(stderr, " resnr[1]: %d, resnr[2]: %d, resnr[3]: %d\n",
ref_resind[G_REF1],ref_resind[G_REF2], ref_resind[G_REF3]);
isize[NDX_REF1]--;
for (j=NDX_REF1; j<=NDX_REF3; j++)
srenew(index[j],isize[NDX_REF1]);
continue;
}
else
/* check if all entries are unique*/
if ( index[G_REF1][i] == index[G_REF2][i] ||
index[G_REF2][i] == index[G_REF3][i] ||
index[G_REF3][i] == index[G_REF1][i] )
{
fprintf(stderr,"Warning: reference triple (%d) will be skipped.\n",i);
fprintf(stderr, " index[1]: %d, index[2]: %d, index[3]: %d\n",
index[G_REF1][i],index[G_REF2][i],index[G_REF3][i]);
isize[NDX_REF1]--;
for (j=NDX_REF1; j<=NDX_REF3; j++)
srenew(index[j],isize[NDX_REF1]);
continue;
}
else /* everythings fine, copy that one */
for (j=G_REF1; j<=G_REF3; j++)
index[j+4][i] = index[j][i];
}
}
else if ( mode == 2 )
{
if ( isize[G_REF1] != isize[G_REF2] )
gmx_fatal(FARGS,"For two particle SDF, reference groups 1 and 2"
"must have the same size.\n");
for (i=0; i<isize[G_REF1]; i++)
{
/* check consistency for atoms 1 and 2 */
for (j=G_REF1; j<=G_REF2; j++)
ref_resind[j] = top.atoms.atom[index[j][i]].resind;
if ( ref_resind[G_REF1] != ref_resind[G_REF2] ||
index[G_REF1][i] == index[G_REF2][i] )
{
if ( ref_resind[G_REF1] != ref_resind[G_REF2] )
{
fprintf(stderr,"\nWarning: bond (%d) not from one molecule."
"Will not be used for SDF.\n",i);
fprintf(stderr, " resnr[1]: %d, resnr[2]: %d\n",
ref_resind[G_REF1],ref_resind[G_REF2]);
}
else
{
fprintf(stderr,"\nWarning: atom1 and atom2 are identical."
"Bond (%d) will not be used for SDF.\n",i);
fprintf(stderr, " index[1]: %d, index[2]: %d\n",
index[G_REF1][i],index[G_REF2][i]);
}
for (j=NDX_REF1; j<=NDX_REF2; j++)
{
for (k=i; k<isize[G_REF1]-1; k++)
index[j][k]=index[j][k+1];
isize[j]--;
srenew(index[j],isize[j]);
}
}
}
}
/* Read Atoms for refmol group */
if ( bRef )
{
snew(index[G_REFMOL],1);
for (i=G_REF1; i<=G_REF3; i++)
ref_resind[i] = top.atoms.atom[index[i][0]].resind;
for (i=0; i<natoms; i++)
{
if ( ref_resind[G_REF1] == top.atoms.atom[i].resind ||
ref_resind[G_REF2] == top.atoms.atom[i].resind ||
ref_resind[G_REF3] == top.atoms.atom[i].resind )
nrefmol++;
}
srenew(index[G_REFMOL],nrefmol);
isize[G_REFMOL] = nrefmol;
nrefmol = 0;
for (i=0; i<natoms; i++)
{
if ( ref_resind[G_REF1] == top.atoms.atom[i].resind ||
ref_resind[G_REF2] == top.atoms.atom[i].resind ||
ref_resind[G_REF3] == top.atoms.atom[i].resind )
{
index[G_REFMOL][nrefmol] = i;
nrefmol++;
}
}
}
/* initialize some stuff */
boxmin = min( norm(box[XX]), min( norm(box[YY]), norm(box[ZZ]) ) );
hbox = boxmin / 2.0;
for (i=0; i<DIM; i++)
{
cutoff[i] = cutoff[i] / 2;
nbin[i] = (int)(2 * cutoff[i] / binwidth) + 1;
invbinw = 1.0 / binwidth;
tri_upper[i] = triangle[i] + dtri[i];
tri_upper[i] = sqr(tri_upper[i]);
tri_lower[i] = triangle[i] - dtri[i];
tri_lower[i] = sqr(tri_lower[i]);
}
/* Allocate the array's for sdf */
snew(count,nbin[0]+1);
for(i=0; i<nbin[0]+1; i++)
{
snew(count[i],nbin[1]+1);
for (j=0; j<nbin[1]+1; j++)
snew(count[i][j],nbin[2]+1);
}
/* Allocate space for the coordinates */
snew(x_i1,isize[G_SDF]);
snew(x_refmol,isize[G_REFMOL]);
for (i=0; i<isize[G_REFMOL]; i++)
for (j=XX; j<=ZZ; j++)
x_refmol[i][j] = 0;
normfac = 0;
do {
/* Must init pbc every step because of pressure coupling */
set_pbc(&pbc,ePBC,box);
rm_pbc(&top.idef,ePBC,natoms,box,x,x);
/* Dynamically build the ref tripels */
if ( mode == 2 )
{
isize[NDX_REF1]=0;
for (j=NDX_REF1; j<=NDX_REF3; j++)
srenew(index[j],isize[NDX_REF1]+1);
/* consistancy of G_REF[1,2] has already been check */
/* hence we can look for the third atom right away */
for (i=0; i<isize[G_REF1]; i++)
{
for (j=0; j<isize[G_REF3]; j++)
{
/* Avoid expensive stuff if possible */
if ( top.atoms.atom[index[G_REF1][i]].resind !=
top.atoms.atom[index[G_REF3][j]].resind &&
index[G_REF1][i] != index[G_REF3][j] &&
index[G_REF2][i] != index[G_REF3][j] )
{
pbc_dx(&pbc,x[index[G_REF1][i]],x[index[G_REF3][j]],dx);
delta = norm2(dx);
if ( delta < tri_upper[G_REF1] &&
delta > tri_lower[G_REF1] )
{
pbc_dx(&pbc,x[index[G_REF2][i]],x[index[G_REF3][j]],dx);
delta = norm2(dx);
if ( delta < tri_upper[G_REF2] &&
delta > tri_lower[G_REF2] )
{
/* found triple */
index[NDX_REF1][isize[NDX_REF1]]=index[G_REF1][i];
index[NDX_REF2][isize[NDX_REF1]]=index[G_REF2][i];
index[NDX_REF3][isize[NDX_REF1]]=index[G_REF3][j];
/* resize groups */
isize[NDX_REF1]++;
for (k=NDX_REF1; k<=NDX_REF3; k++)
srenew(index[k],isize[NDX_REF1]+1);
}
}
}
}
}
}
else if ( mode ==3 )
{
isize[NDX_REF1]=0;
for (j=NDX_REF1; j<=NDX_REF3; j++)
srenew(index[j],isize[NDX_REF1]+1);
/* consistancy will be checked while searching */
for (i=0; i<isize[G_REF1]; i++)
{
for (j=0; j<isize[G_REF2]; j++)
{
/* Avoid expensive stuff if possible */
if ( top.atoms.atom[index[G_REF1][i]].resind !=
top.atoms.atom[index[G_REF2][j]].resind &&
index[G_REF1][i] != index[G_REF2][j] )
{
pbc_dx(&pbc,x[index[G_REF1][i]],x[index[G_REF2][j]],dx);
delta = norm2(dx);
if ( delta < tri_upper[G_REF3] &&
delta > tri_lower[G_REF3] )
{
for (k=0; k<isize[G_REF3]; k++)
{
if ( top.atoms.atom[index[G_REF1][i]].resind !=
top.atoms.atom[index[G_REF3][k]].resind &&
top.atoms.atom[index[G_REF2][j]].resind !=
top.atoms.atom[index[G_REF3][k]].resind &&
index[G_REF1][i] != index[G_REF3][k] &&
index[G_REF2][j] != index[G_REF3][k])
{
pbc_dx(&pbc,x[index[G_REF1][i]],x[index[G_REF3][k]],dx);
delta = norm2(dx);
if ( delta < tri_upper[G_REF1] &&
delta > tri_lower[G_REF1] )
{
pbc_dx(&pbc,x[index[G_REF2][j]],x[index[G_REF3][k]],dx);
delta = norm2(dx);
if ( delta < tri_upper[G_REF2] &&
delta > tri_lower[G_REF2] )
{
/* found triple */
index[NDX_REF1][isize[NDX_REF1]]=index[G_REF1][i];
index[NDX_REF2][isize[NDX_REF1]]=index[G_REF2][j];
index[NDX_REF3][isize[NDX_REF1]]=index[G_REF3][k];
/* resize groups */
isize[NDX_REF1]++;
for (l=NDX_REF1; l<=NDX_REF3; l++)
srenew(index[l],isize[NDX_REF1]+1);
}
}
}
}
}
}
}
}
}
for (i=0; i<isize[NDX_REF1]; i++)
{
/* setup the molecular coordinate system (i',j',k') */
/* because the coodinate system of the box forms a unit matrix */
/* (i',j',k') is identical with the rotation matrix */
clear_mat(rot);
/* k' = unitv(r(atom0) - r(atom1)) */
pbc_dx(&pbc,x[index[NDX_REF1][i]],x[index[NDX_REF2][i]],k_mol);
unitv(k_mol,rot[2]);
/* i' = unitv(k' x (r(atom2) - r(atom1))) */
pbc_dx(&pbc,x[index[NDX_REF3][i]],x[index[NDX_REF2][i]],i1_mol);
cprod(i1_mol,rot[2],i2_mol);
unitv(i2_mol,rot[0]);
/* j' = k' x i' */
cprod(rot[2],rot[0],rot[1]);
/* set the point of reference */
if ( mode == 2 )
copy_rvec(x[index[NDX_REF3][i]],xi);
else
copy_rvec(x[index[NDX_REF1][i]],xi);
/* make the reference */
if ( bRef )
{
for (j=0; j<isize[G_REFMOL]; j++)
{
pbc_dx(&pbc,xi,x[index[G_REFMOL][j]],dx);
mvmul(rot,dx,dx_mol);
rvec_inc(x_refmol[j],dx_mol);
for(k=XX; k<=ZZ; k++)
x_refmol[j][k] = x_refmol[j][k] / 2;
}
}
/* Copy the indexed coordinates to a continuous array */
for(j=0; j<isize[G_SDF]; j++)
copy_rvec(x[index[G_SDF][j]],x_i1[j]);
/* count the SDF */
for(j=0; j<isize[G_SDF]; j++)
{
/* Exclude peaks from the reference set */
bInGroup=FALSE;
for (k=NDX_REF1; k<=NDX_REF3; k++)
if ( index[G_SDF][j] == index[k][i] )
bInGroup=TRUE;
if ( !bInGroup )
{
pbc_dx(&pbc,xi,x_i1[j],dx);
/* transfer dx to the molecular coordinate system */
mvmul(rot,dx,dx_mol);
/* check cutoff's and count */
if ( dx_mol[XX] > -cutoff[XX] && dx_mol[XX] < cutoff[XX] )
if ( dx_mol[YY] > -cutoff[YY] && dx_mol[YY] < cutoff[YY] )
if ( dx_mol[ZZ] > -cutoff[ZZ] && dx_mol[ZZ] < cutoff[ZZ] )
{
X = (int)(floor(dx_mol[XX]*invbinw)) + (nbin[XX]-1)/2
+1;
Y = (int)(floor(dx_mol[YY]*invbinw)) + (nbin[YY]-1)/2
+1;
Z = (int)(floor(dx_mol[ZZ]*invbinw)) + (nbin[ZZ]-1)/2
+1;
count[X][Y][Z]++;
normfac++;
}
}
}
}
} while (read_next_x(status,&t,natoms,x,box));
fprintf(stderr,"\n");
close_trj(status);
sfree(x);
/* write the reference strcture*/
if ( bRef )
{
fp=ffopen(fnREF,"w");
fprintf(fp,"%s\n",title);
fprintf(fp," %d\n",isize[G_REFMOL]);
for (i=0; i<isize[G_REFMOL]; i++)
fprintf(fp,"%5d%5s%5s%5d%8.3f%8.3f%8.3f\n",
top.atoms.resinfo[top.atoms.atom[index[G_REFMOL][i]].resind].nr,
*(top.atoms.resinfo[top.atoms.atom[index[G_REFMOL][i]].resind].name),
*(top.atoms.atomname[index[G_REFMOL][i]]),i+1,
-1*x_refmol[i][XX],-1*x_refmol[i][YY],-1*x_refmol[i][ZZ]);
/* Inserted -1* on the line above three times */
fprintf(fp," 10.00000 10.00000 10.00000\n");
ffclose(fp);
fprintf(stderr,"\nWrote reference structure. (%d Atoms)\n",isize[G_REFMOL]);
}
/* Calculate the mean probability density */
fprintf(stderr,"\nNumber of configuations used for SDF: %d\n",(int)normfac);
normfac = nbin[0]*nbin[1]*nbin[2] / normfac;
fprintf(stderr,"\nMean probability density: %f\n",1/normfac);
/* normalize the SDF and write output */
/* see http://www.csc.fi/gopenmol/index.phtml for documentation */
fp=ffopen(fnSDF,"wb");
/* rank */
i_write(fp,3);
/* Type of surface */
i_write(fp,42);
/* Zdim, Ydim, Xdim */
for (i=ZZ; i>=XX; i--)
i_write(fp,nbin[i]);
/* [Z,Y,X][min,max] (box corners in Angstroem)*/
for (i=ZZ; i>=XX; i--)
{
f_write(fp,-cutoff[i]*10);
f_write(fp,cutoff[i]*10);
}
/* Original Code
for (i=1; i<nbin[2]+1; i++)
for (j=1; j<nbin[1]+1; j++)
for (k=1; k<nbin[0]+1; k++)
{
sdf = normfac * count[k][j][i];
if ( sdf < min_sdf ) min_sdf = sdf;
if ( sdf > max_sdf ) max_sdf = sdf;
f_write(fp,sdf);
}*/
/* Changed Code to Mirror SDF to correct coordinates */
for (i=nbin[2]; i>0; i--)
for (j=nbin[1]; j>0; j--)
for (k=nbin[0]; k>0; k--)
{
sdf = normfac * count[k][j][i];
if ( sdf < min_sdf ) min_sdf = sdf;
if ( sdf > max_sdf ) max_sdf = sdf;
f_write(fp,sdf);
}
fprintf(stderr,"\nMin: %f Max: %f\n",min_sdf,max_sdf);
ffclose(fp);
/* Give back the mem */
for(i=0; i<nbin[0]+1; i++)
{
for (j=0; j<nbin[1]+1; j++)
{
sfree(count[i][j]);
}
sfree(count[i]);
}
sfree(count);
}
void unitcell(rvec x[],rvec box,gmx_bool bYaw,real odist,real hdist)
{
#define cx 0.81649658
#define cy 0.47140452
#define cy2 0.94280904
#define cz 0.33333333
rvec xx[24] = {
{ 0, 0, 0 }, /* O1 */
{ 0, 0, 1 }, /* H relative to Oxygen */
{ cx, cy, -cz },
{ cx, cy, -cz }, /* O2 */
{ 0, 0, -1 }, /* H relative to Oxygen */
{ cx,-cy, +cz },
{ cx, cy+cy2, 0 }, /* O3 */
{ -cx, cy, -cz }, /* H relative to Oxygen */
{ 0, -cy2, -cz },
{ 0, 2*cy+cy2, -cz }, /* O4 */
{-cx,-cy, +cz }, /* H relative to Oxygen */
{ 0 , cy2, +cz },
{ 0, 0, 1 }, /* O5 */
{-cx, cy, +cz }, /* H relative to Oxygen */
{ 0 , -cy2, +cz },
{ cx, cy, 1+cz }, /* O6 */
{ -cx, -cy, -cz }, /* H relative to Oxygen */
{ 0, cy2, -cz },
{ cx, cy+cy2, 1 }, /* O7 */
{ 0, 0, -1 }, /* H relative to Oxygen */
{ cx, cy, +cz },
{ 0, 2*cy+cy2,1+cz }, /* O8 */
{ 0, 0, 1 }, /* H relative to Oxygen */
{ cx, -cy, -cz }
};
int i,iin,iout,j,m;
rvec tmp,t2,dip;
clear_rvec(dip);
for(i=0; (i<8); i++) {
iin = 3*i;
if (bYaw)
iout = 5*i;
else
iout = iin;
svmul(odist,xx[iin],x[iout]);
svmul(-0.82,x[iout],t2);
rvec_inc(dip,t2);
for(j=1; (j<=2); j++) {
svmul(hdist,xx[iin+j],tmp);
rvec_add(x[iout],tmp,x[iout+j]);
svmul(0.41,x[iout+j],t2);
rvec_inc(dip,t2);
}
if (bYaw)
for(m=0; (m<DIM); m++)
x[iout+3][m] = x[iout+4][m] =
(1-2*DCONS)*x[iout][m]+DCONS*(x[iout+1][m]+x[iout+2][m]);
}
box[XX] = 2*cx;
box[YY] = 2*(cy2+cy);
box[ZZ] = 2*(1+cz);
for(i=0; (i<DIM); i++)
box[i] *= odist;
printf("Unitcell: %10.5f %10.5f %10.5f\n",box[XX],box[YY],box[ZZ]);
printf("Dipole: %10.5f %10.5f %10.5f (e nm)\n",dip[XX],dip[YY],dip[ZZ]);
}
void virial(FILE *fp,gmx_bool bFull,int nmol,rvec x[],matrix box,real rcut,
gmx_bool bYaw,real q[],gmx_bool bLJ)
{
int i,j,im,jm,natmol,ik,jk,m,ninter;
rvec dx,f,ftot,dvir,vir,pres,xcmi,xcmj,*force;
real dx6,dx2,dx1,fscal,c6,c12,vcoul,v12,v6,vctot,v12tot,v6tot;
t_pbc pbc;
set_pbc(&pbc,box);
fprintf(fp,"%3s - %3s: %6s %6s %6s %6s %8s %8s %8s\n",
"ai","aj","dx","dy","dz","|d|","virx","viry","virz");
clear_rvec(ftot);
clear_rvec(vir);
ninter = 0;
vctot = 0;
v12tot = 0;
v6tot = 0;
natmol = bYaw ? 5 : 3;
snew(force,nmol*natmol);
for(i=0; (i<nmol); i++) {
im = natmol*i;
/* Center of geometry */
clear_rvec(xcmi);
for(ik=0; (ik<natmol); ik++)
rvec_inc(xcmi,x[im+ik]);
for(m=0; (m<DIM); m++)
xcmi[m] /= natmol;
for(j=i+1; (j<nmol); j++) {
jm = natmol*j;
/* Center of geometry */
clear_rvec(xcmj);
for(jk=0; (jk<natmol); jk++)
rvec_inc(xcmj,x[jm+jk]);
for(m=0; (m<DIM); m++)
xcmj[m] /= natmol;
/* First check COM-COM distance */
pbc_dx(&pbc,xcmi,xcmj,dx);
if (norm(dx) < rcut) {
ninter++;
/* Neirest neighbour molecules! */
clear_rvec(dvir);
for(ik=0; (ik<natmol); ik++) {
for(jk=0; (jk<natmol); jk++) {
pbc_dx(&pbc,x[im+ik],x[jm+jk],dx);
dx2 = iprod(dx,dx);
dx1 = sqrt(dx2);
vcoul = q[ik]*q[jk]*ONE_4PI_EPS0/dx1;
vctot += vcoul;
if (bLJ) {
if (bYaw) {
c6 = yaw_lj[ik][2*jk];
c12 = yaw_lj[ik][2*jk+1];
}
else {
c6 = spc_lj[ik][2*jk];
c12 = spc_lj[ik][2*jk+1];
}
dx6 = dx2*dx2*dx2;
v6 = c6/dx6;
v12 = c12/(dx6*dx6);
v6tot -= v6;
v12tot+= v12;
fscal = (vcoul+12*v12-6*v6)/dx2;
}
else
fscal = vcoul/dx2;
for(m=0; (m<DIM); m++) {
f[m] = dx[m]*fscal;
dvir[m] -= 0.5*dx[m]*f[m];
}
rvec_inc(force[ik+im],f);
rvec_dec(force[jk+jm],f);
/*if (bFull)
fprintf(fp,"%3s%4d-%3s%4d: %6.3f %6.3f %6.3f %6.3f"
" %8.3f %8.3f %8.3f\n",
watname[ik],im+ik,watname[jk],jm+jk,
dx[XX],dx[YY],dx[ZZ],norm(dx),
dvir[XX],dvir[YY],dvir[ZZ]);*/
}
}
if (bFull)
fprintf(fp,"%3s%4d-%3s%4d: "
" %8.3f %8.3f %8.3f\n",
"SOL",i,"SOL",j,dvir[XX],dvir[YY],dvir[ZZ]);
rvec_inc(vir,dvir);
}
}
}
fprintf(fp,"There were %d interactions between the %d molecules (%.2f %%)\n",
ninter,nmol,(real)ninter/(0.5*nmol*(nmol-1)));
fprintf(fp,"Vcoul: %10.4e V12: %10.4e V6: %10.4e Vtot: %10.4e (kJ/mol)\n",
vctot/nmol,v12tot/nmol,v6tot/nmol,(vctot+v12tot+v6tot)/nmol);
pr_rvec(fp,0,"vir ",vir,DIM,TRUE);
for(m=0; (m<DIM); m++)
pres[m] = -2*PRESFAC/(det(box))*vir[m];
pr_rvec(fp,0,"pres",pres,DIM,TRUE);
pr_rvecs(fp,0,"force",force,natmol*nmol);
sfree(force);
}
void random_h_coords(int natmol,int nmol,rvec x[],rvec box,
gmx_bool bYaw,real odist,real hdist)
{
#define cx 0.81649658
#define cy 0.47140452
#define cy2 0.94280904
#define cz 0.33333333
rvec xx[24] = {
{ 0, 0, 0 }, /* O1 */
{ 0, 0, 1 }, /* H relative to Oxygen */
{ cx, cy, -cz },
{ cx, cy, -cz }, /* O2 */
{ 0, 0, -1 }, /* H relative to Oxygen */
{ cx,-cy, +cz },
{ cx, cy+cy2, 0 }, /* O3 */
{ -cx, cy, -cz }, /* H relative to Oxygen */
{ 0, -cy2, -cz },
{ 0, 2*cy+cy2, -cz }, /* O4 */
{-cx,-cy, +cz }, /* H relative to Oxygen */
{ 0 , cy2, +cz },
{ 0, 0, 1 }, /* O5 */
{-cx, cy, +cz }, /* H relative to Oxygen */
{ 0 , -cy2, +cz },
{ cx, cy, 1+cz }, /* O6 */
{ -cx, -cy, -cz }, /* H relative to Oxygen */
{ 0, cy2, -cz },
{ cx, cy+cy2, 1 }, /* O7 */
{ 0, 0, -1 }, /* H relative to Oxygen */
{ cx, cy, +cz },
{ 0, 2*cy+cy2,1+cz }, /* O8 */
{ 0, 0, 1 }, /* H relative to Oxygen */
{ cx, -cy, -cz }
};
int i,iin,iout,j,m;
rvec tmp,t2,dip;
clear_rvec(dip);
for(i=0; (i<nmol); i++) {
iin = natmol*i;
iout = iin;
svmul(odist,x[iin],x[iout]);
svmul(-0.82,x[iout],t2);
rvec_inc(dip,t2);
for(j=1; (j<=2); j++) {
svmul(hdist,xx[3*(i % 8)+j],tmp);
rvec_add(x[iout],tmp,x[iout+j]);
svmul(0.41,x[iout+j],t2);
rvec_inc(dip,t2);
}
}
box[XX] = 2*cx;
box[YY] = 2*(cy2+cy);
box[ZZ] = 2*(1+cz);
for(i=0; (i<DIM); i++)
box[i] *= odist;
printf("Unitcell: %10.5f %10.5f %10.5f\n",box[XX],box[YY],box[ZZ]);
printf("Dipole: %10.5f %10.5f %10.5f (e nm)\n",dip[XX],dip[YY],dip[ZZ]);
}
real ewald_LRcorrection(FILE *fplog,
int start, int end,
t_commrec *cr, int thread, t_forcerec *fr,
real *chargeA, real *chargeB,
gmx_bool calc_excl_corr,
t_blocka *excl, rvec x[],
matrix box, rvec mu_tot[],
int ewald_geometry, real epsilon_surface,
rvec *f, tensor vir,
real lambda, real *dvdlambda)
{
int i, i1, i2, j, k, m, iv, jv, q;
atom_id *AA;
double q2sumA, q2sumB, Vexcl, dvdl_excl; /* Necessary for precision */
real one_4pi_eps;
real v, vc, qiA, qiB, dr, dr2, rinv, fscal, enercorr;
real Vself[2], Vdipole[2], rinv2, ewc = fr->ewaldcoeff, ewcdr;
rvec df, dx, mutot[2], dipcorrA, dipcorrB;
tensor dxdf;
real vol = box[XX][XX]*box[YY][YY]*box[ZZ][ZZ];
real L1, dipole_coeff, qqA, qqB, qqL, vr0;
/*#define TABLES*/
#ifdef TABLES
real tabscale = fr->tabscale;
real eps, eps2, VV, FF, F, Y, Geps, Heps2, Fp, fijC, r1t;
real *VFtab = fr->coulvdwtab;
int n0, n1, nnn;
#endif
gmx_bool bFreeEnergy = (chargeB != NULL);
gmx_bool bMolPBC = fr->bMolPBC;
one_4pi_eps = ONE_4PI_EPS0/fr->epsilon_r;
vr0 = ewc*M_2_SQRTPI;
AA = excl->a;
Vexcl = 0;
dvdl_excl = 0;
q2sumA = 0;
q2sumB = 0;
Vdipole[0] = 0;
Vdipole[1] = 0;
L1 = 1.0-lambda;
/* Note that we have to transform back to gromacs units, since
* mu_tot contains the dipole in debye units (for output).
*/
for (i = 0; (i < DIM); i++)
{
mutot[0][i] = mu_tot[0][i]*DEBYE2ENM;
mutot[1][i] = mu_tot[1][i]*DEBYE2ENM;
dipcorrA[i] = 0;
dipcorrB[i] = 0;
}
dipole_coeff = 0;
switch (ewald_geometry)
{
case eewg3D:
if (epsilon_surface != 0)
{
dipole_coeff =
2*M_PI*ONE_4PI_EPS0/((2*epsilon_surface + fr->epsilon_r)*vol);
for (i = 0; (i < DIM); i++)
{
dipcorrA[i] = 2*dipole_coeff*mutot[0][i];
dipcorrB[i] = 2*dipole_coeff*mutot[1][i];
}
}
break;
case eewg3DC:
dipole_coeff = 2*M_PI*one_4pi_eps/vol;
dipcorrA[ZZ] = 2*dipole_coeff*mutot[0][ZZ];
dipcorrB[ZZ] = 2*dipole_coeff*mutot[1][ZZ];
break;
default:
gmx_incons("Unsupported Ewald geometry");
break;
}
if (debug)
{
fprintf(debug, "dipcorr = %8.3f %8.3f %8.3f\n",
dipcorrA[XX], dipcorrA[YY], dipcorrA[ZZ]);
fprintf(debug, "mutot = %8.3f %8.3f %8.3f\n",
mutot[0][XX], mutot[0][YY], mutot[0][ZZ]);
}
clear_mat(dxdf);
if ((calc_excl_corr || dipole_coeff != 0) && !bFreeEnergy)
{
for (i = start; (i < end); i++)
{
/* Initiate local variables (for this i-particle) to 0 */
qiA = chargeA[i]*one_4pi_eps;
if (calc_excl_corr)
{
i1 = excl->index[i];
i2 = excl->index[i+1];
/* Loop over excluded neighbours */
for (j = i1; (j < i2); j++)
{
k = AA[j];
/*
* First we must test whether k <> i, and then, because the
* exclusions are all listed twice i->k and k->i we must select
* just one of the two.
* As a minor optimization we only compute forces when the charges
* are non-zero.
*/
if (k > i)
{
qqA = qiA*chargeA[k];
if (qqA != 0.0)
{
rvec_sub(x[i], x[k], dx);
if (bMolPBC)
{
/* Cheap pbc_dx, assume excluded pairs are at short distance. */
for (m = DIM-1; (m >= 0); m--)
{
if (dx[m] > 0.5*box[m][m])
{
rvec_dec(dx, box[m]);
}
else if (dx[m] < -0.5*box[m][m])
{
rvec_inc(dx, box[m]);
}
}
}
dr2 = norm2(dx);
/* Distance between two excluded particles may be zero in the
* case of shells
*/
if (dr2 != 0)
{
rinv = gmx_invsqrt(dr2);
rinv2 = rinv*rinv;
dr = 1.0/rinv;
#ifdef TABLES
r1t = tabscale*dr;
n0 = r1t;
assert(n0 >= 3);
n1 = 12*n0;
eps = r1t-n0;
eps2 = eps*eps;
nnn = n1;
Y = VFtab[nnn];
F = VFtab[nnn+1];
Geps = eps*VFtab[nnn+2];
Heps2 = eps2*VFtab[nnn+3];
Fp = F+Geps+Heps2;
VV = Y+eps*Fp;
FF = Fp+Geps+2.0*Heps2;
vc = qqA*(rinv-VV);
fijC = qqA*FF;
Vexcl += vc;
fscal = vc*rinv2+fijC*tabscale*rinv;
/* End of tabulated interaction part */
#else
/* This is the code you would want instead if not using
* tables:
*/
ewcdr = ewc*dr;
vc = qqA*gmx_erf(ewcdr)*rinv;
Vexcl += vc;
#ifdef GMX_DOUBLE
/* Relative accuracy at R_ERF_R_INACC of 3e-10 */
#define R_ERF_R_INACC 0.006
#else
/* Relative accuracy at R_ERF_R_INACC of 2e-5 */
#define R_ERF_R_INACC 0.1
#endif
if (ewcdr > R_ERF_R_INACC)
{
fscal = rinv2*(vc - qqA*ewc*M_2_SQRTPI*exp(-ewcdr*ewcdr));
}
else
{
/* Use a fourth order series expansion for small ewcdr */
fscal = ewc*ewc*qqA*vr0*(2.0/3.0 - 0.4*ewcdr*ewcdr);
}
#endif
/* The force vector is obtained by multiplication with the
* distance vector
*/
svmul(fscal, dx, df);
rvec_inc(f[k], df);
rvec_dec(f[i], df);
for (iv = 0; (iv < DIM); iv++)
{
for (jv = 0; (jv < DIM); jv++)
{
dxdf[iv][jv] += dx[iv]*df[jv];
}
}
}
else
{
Vexcl += qqA*vr0;
}
}
}
}
}
/* Dipole correction on force */
if (dipole_coeff != 0)
{
for (j = 0; (j < DIM); j++)
{
f[i][j] -= dipcorrA[j]*chargeA[i];
}
}
}
}
else if (calc_excl_corr || dipole_coeff != 0)
{
for (i = start; (i < end); i++)
{
/* Initiate local variables (for this i-particle) to 0 */
qiA = chargeA[i]*one_4pi_eps;
qiB = chargeB[i]*one_4pi_eps;
if (calc_excl_corr)
{
i1 = excl->index[i];
i2 = excl->index[i+1];
/* Loop over excluded neighbours */
for (j = i1; (j < i2); j++)
{
k = AA[j];
if (k > i)
{
qqA = qiA*chargeA[k];
qqB = qiB*chargeB[k];
if (qqA != 0.0 || qqB != 0.0)
{
qqL = L1*qqA + lambda*qqB;
rvec_sub(x[i], x[k], dx);
if (bMolPBC)
{
/* Cheap pbc_dx, assume excluded pairs are at short distance. */
for (m = DIM-1; (m >= 0); m--)
{
if (dx[m] > 0.5*box[m][m])
{
rvec_dec(dx, box[m]);
}
else if (dx[m] < -0.5*box[m][m])
{
rvec_inc(dx, box[m]);
}
}
}
dr2 = norm2(dx);
if (dr2 != 0)
{
rinv = gmx_invsqrt(dr2);
rinv2 = rinv*rinv;
dr = 1.0/rinv;
v = gmx_erf(ewc*dr)*rinv;
vc = qqL*v;
Vexcl += vc;
fscal = rinv2*(vc-qqL*ewc*M_2_SQRTPI*exp(-ewc*ewc*dr2));
svmul(fscal, dx, df);
rvec_inc(f[k], df);
rvec_dec(f[i], df);
for (iv = 0; (iv < DIM); iv++)
{
for (jv = 0; (jv < DIM); jv++)
{
dxdf[iv][jv] += dx[iv]*df[jv];
}
}
dvdl_excl += (qqB - qqA)*v;
}
else
{
Vexcl += qqL*vr0;
dvdl_excl += (qqB - qqA)*vr0;
}
}
}
}
}
/* Dipole correction on force */
if (dipole_coeff != 0)
{
for (j = 0; (j < DIM); j++)
{
f[i][j] -= L1*dipcorrA[j]*chargeA[i]
+ lambda*dipcorrB[j]*chargeB[i];
}
}
}
}
for (iv = 0; (iv < DIM); iv++)
{
for (jv = 0; (jv < DIM); jv++)
{
vir[iv][jv] += 0.5*dxdf[iv][jv];
}
}
Vself[0] = 0;
Vself[1] = 0;
/* Global corrections only on master process */
if (MASTER(cr) && thread == 0)
{
for (q = 0; q < (bFreeEnergy ? 2 : 1); q++)
{
if (calc_excl_corr)
{
/* Self-energy correction */
Vself[q] = ewc*one_4pi_eps*fr->q2sum[q]*M_1_SQRTPI;
}
/* Apply surface dipole correction:
* correction = dipole_coeff * (dipole)^2
*/
if (dipole_coeff != 0)
{
if (ewald_geometry == eewg3D)
{
Vdipole[q] = dipole_coeff*iprod(mutot[q], mutot[q]);
}
else if (ewald_geometry == eewg3DC)
{
Vdipole[q] = dipole_coeff*mutot[q][ZZ]*mutot[q][ZZ];
}
}
}
}
if (!bFreeEnergy)
{
enercorr = Vdipole[0] - Vself[0] - Vexcl;
}
else
{
enercorr = L1*(Vdipole[0] - Vself[0])
+ lambda*(Vdipole[1] - Vself[1])
- Vexcl;
*dvdlambda += Vdipole[1] - Vself[1]
- (Vdipole[0] - Vself[0]) - dvdl_excl;
}
if (debug)
{
fprintf(debug, "Long Range corrections for Ewald interactions:\n");
fprintf(debug, "start=%d,natoms=%d\n", start, end-start);
fprintf(debug, "q2sum = %g, Vself=%g\n",
L1*q2sumA+lambda*q2sumB, L1*Vself[0]+lambda*Vself[1]);
fprintf(debug, "Long Range correction: Vexcl=%g\n", Vexcl);
if (MASTER(cr) && thread == 0)
{
if (epsilon_surface > 0 || ewald_geometry == eewg3DC)
{
fprintf(debug, "Total dipole correction: Vdipole=%g\n",
L1*Vdipole[0]+lambda*Vdipole[1]);
}
}
}
/* Return the correction to the energy */
return enercorr;
}
static void dielectric(FILE *fmj, FILE *fmd, FILE *outf, FILE *fcur, FILE *mcor,
FILE *fmjdsp, gmx_bool bNoJump, gmx_bool bACF, gmx_bool bINT,
int ePBC, t_topology top, t_trxframe fr, real temp,
real bfit, real efit, real bvit, real evit,
t_trxstatus *status, int isize, int nmols, int nshift,
int *index0, int indexm[], real mass2[],
real qmol[], real eps_rf, const gmx_output_env_t *oenv)
{
int i, j;
int valloc, nalloc, nfr, nvfr;
int vshfr;
real *xshfr = NULL;
int *vfr = NULL;
real refr = 0.0;
real *cacf = NULL;
real *time = NULL;
real *djc = NULL;
real corint = 0.0;
real prefactorav = 0.0;
real prefactor = 0.0;
real volume;
real volume_av = 0.0;
real dk_s, dk_d, dk_f;
real mj = 0.0;
real mj2 = 0.0;
real mjd = 0.0;
real mjdav = 0.0;
real md2 = 0.0;
real mdav2 = 0.0;
real sgk;
rvec mja_tmp;
rvec mjd_tmp;
rvec mdvec;
rvec *mu = NULL;
rvec *xp = NULL;
rvec *v0 = NULL;
rvec *mjdsp = NULL;
real *dsp2 = NULL;
real t0;
real rtmp;
rvec tmp;
rvec *mtrans = NULL;
/*
* Variables for the least-squares fit for Einstein-Helfand and Green-Kubo
*/
int bi, ei, ie, ii;
real rest = 0.0;
real sigma = 0.0;
real malt = 0.0;
real err = 0.0;
real *xfit;
real *yfit;
gmx_rmpbc_t gpbc = NULL;
/*
* indices for EH
*/
ei = 0;
bi = 0;
/*
* indices for GK
*/
ii = 0;
ie = 0;
t0 = 0;
sgk = 0.0;
/* This is the main loop over frames */
nfr = 0;
nvfr = 0;
vshfr = 0;
nalloc = 0;
valloc = 0;
clear_rvec(mja_tmp);
clear_rvec(mjd_tmp);
clear_rvec(mdvec);
clear_rvec(tmp);
gpbc = gmx_rmpbc_init(&top.idef, ePBC, fr.natoms);
do
{
refr = (nfr+1);
if (nfr >= nalloc)
{
nalloc += 100;
srenew(time, nalloc);
srenew(mu, nalloc);
srenew(mjdsp, nalloc);
srenew(dsp2, nalloc);
srenew(mtrans, nalloc);
srenew(xshfr, nalloc);
for (i = nfr; i < nalloc; i++)
{
clear_rvec(mjdsp[i]);
clear_rvec(mu[i]);
clear_rvec(mtrans[i]);
dsp2[i] = 0.0;
xshfr[i] = 0.0;
}
}
GMX_RELEASE_ASSERT(time != NULL, "Memory not allocated correctly - time array is NULL");
if (nfr == 0)
{
t0 = fr.time;
}
time[nfr] = fr.time-t0;
if (time[nfr] <= bfit)
{
bi = nfr;
}
if (time[nfr] <= efit)
{
ei = nfr;
}
if (bNoJump)
{
if (xp)
{
remove_jump(fr.box, fr.natoms, xp, fr.x);
}
else
{
snew(xp, fr.natoms);
}
for (i = 0; i < fr.natoms; i++)
{
copy_rvec(fr.x[i], xp[i]);
}
}
gmx_rmpbc_trxfr(gpbc, &fr);
calc_mj(top, ePBC, fr.box, bNoJump, nmols, indexm, fr.x, mtrans[nfr], mass2, qmol);
for (i = 0; i < isize; i++)
{
j = index0[i];
svmul(top.atoms.atom[j].q, fr.x[j], fr.x[j]);
rvec_inc(mu[nfr], fr.x[j]);
}
/*if(mod(nfr,nshift)==0){*/
if (nfr%nshift == 0)
{
for (j = nfr; j >= 0; j--)
{
rvec_sub(mtrans[nfr], mtrans[j], tmp);
dsp2[nfr-j] += norm2(tmp);
xshfr[nfr-j] += 1.0;
}
}
if (fr.bV)
{
if (nvfr >= valloc)
{
valloc += 100;
srenew(vfr, valloc);
if (bINT)
{
srenew(djc, valloc);
}
srenew(v0, valloc);
if (bACF)
{
srenew(cacf, valloc);
}
}
if (time[nfr] <= bvit)
{
ii = nvfr;
}
if (time[nfr] <= evit)
{
ie = nvfr;
}
vfr[nvfr] = nfr;
clear_rvec(v0[nvfr]);
if (bACF)
{
cacf[nvfr] = 0.0;
}
if (bINT)
{
djc[nvfr] = 0.0;
}
for (i = 0; i < isize; i++)
{
j = index0[i];
svmul(mass2[j], fr.v[j], fr.v[j]);
svmul(qmol[j], fr.v[j], fr.v[j]);
rvec_inc(v0[nvfr], fr.v[j]);
}
fprintf(fcur, "%.3f\t%.6f\t%.6f\t%.6f\n", time[nfr], v0[nfr][XX], v0[nfr][YY], v0[nfr][ZZ]);
if (bACF || bINT)
{
/*if(mod(nvfr,nshift)==0){*/
if (nvfr%nshift == 0)
{
for (j = nvfr; j >= 0; j--)
{
if (bACF)
{
cacf[nvfr-j] += iprod(v0[nvfr], v0[j]);
}
if (bINT)
{
djc[nvfr-j] += iprod(mu[vfr[j]], v0[nvfr]);
}
}
vshfr++;
}
}
nvfr++;
}
volume = det(fr.box);
volume_av += volume;
rvec_inc(mja_tmp, mtrans[nfr]);
mjd += iprod(mu[nfr], mtrans[nfr]);
rvec_inc(mdvec, mu[nfr]);
mj2 += iprod(mtrans[nfr], mtrans[nfr]);
md2 += iprod(mu[nfr], mu[nfr]);
fprintf(fmj, "%.3f\t%8.5f\t%8.5f\t%8.5f\t%8.5f\t%8.5f\n", time[nfr], mtrans[nfr][XX], mtrans[nfr][YY], mtrans[nfr][ZZ], mj2/refr, norm(mja_tmp)/refr);
fprintf(fmd, "%.3f\t%8.5f\t%8.5f\t%8.5f\t%8.5f\t%8.5f\n", \
time[nfr], mu[nfr][XX], mu[nfr][YY], mu[nfr][ZZ], md2/refr, norm(mdvec)/refr);
nfr++;
}
while (read_next_frame(oenv, status, &fr));
gmx_rmpbc_done(gpbc);
volume_av /= refr;
prefactor = 1.0;
prefactor /= 3.0*EPSILON0*volume_av*BOLTZ*temp;
prefactorav = E_CHARGE*E_CHARGE;
prefactorav /= volume_av*BOLTZMANN*temp*NANO*6.0;
fprintf(stderr, "Prefactor fit E-H: 1 / 6.0*V*k_B*T: %g\n", prefactorav);
calc_mjdsp(fmjdsp, prefactorav, dsp2, time, nfr, xshfr);
/*
* Now we can average and calculate the correlation functions
*/
mj2 /= refr;
mjd /= refr;
md2 /= refr;
svmul(1.0/refr, mdvec, mdvec);
svmul(1.0/refr, mja_tmp, mja_tmp);
mdav2 = norm2(mdvec);
mj = norm2(mja_tmp);
mjdav = iprod(mdvec, mja_tmp);
printf("\n\nAverage translational dipole moment M_J [enm] after %d frames (|M|^2): %f %f %f (%f)\n", nfr, mja_tmp[XX], mja_tmp[YY], mja_tmp[ZZ], mj2);
printf("\n\nAverage molecular dipole moment M_D [enm] after %d frames (|M|^2): %f %f %f (%f)\n", nfr, mdvec[XX], mdvec[YY], mdvec[ZZ], md2);
if (v0 != NULL)
{
if (bINT)
{
printf("\nCalculating M_D - current correlation integral ... \n");
corint = calc_cacf(mcor, prefactorav/EPSI0, djc, time, nvfr, vfr, ie, nshift);
}
if (bACF)
{
printf("\nCalculating current autocorrelation ... \n");
sgk = calc_cacf(outf, prefactorav/PICO, cacf, time, nvfr, vfr, ie, nshift);
if (ie > ii)
{
snew(xfit, ie-ii+1);
snew(yfit, ie-ii+1);
for (i = ii; i <= ie; i++)
{
xfit[i-ii] = std::log(time[vfr[i]]);
rtmp = std::abs(cacf[i]);
yfit[i-ii] = std::log(rtmp);
}
lsq_y_ax_b(ie-ii, xfit, yfit, &sigma, &malt, &err, &rest);
malt = std::exp(malt);
sigma += 1.0;
malt *= prefactorav*2.0e12/sigma;
sfree(xfit);
sfree(yfit);
}
}
}
/* Calculation of the dielectric constant */
fprintf(stderr, "\n********************************************\n");
dk_s = calceps(prefactor, md2, mj2, mjd, eps_rf, FALSE);
fprintf(stderr, "\nAbsolute values:\n epsilon=%f\n", dk_s);
fprintf(stderr, " <M_D^2> , <M_J^2>, <(M_J*M_D)^2>: (%f, %f, %f)\n\n", md2, mj2, mjd);
fprintf(stderr, "********************************************\n");
dk_f = calceps(prefactor, md2-mdav2, mj2-mj, mjd-mjdav, eps_rf, FALSE);
fprintf(stderr, "\n\nFluctuations:\n epsilon=%f\n\n", dk_f);
fprintf(stderr, "\n deltaM_D , deltaM_J, deltaM_JD: (%f, %f, %f)\n", md2-mdav2, mj2-mj, mjd-mjdav);
fprintf(stderr, "\n********************************************\n");
if (bINT)
{
dk_d = calceps(prefactor, md2-mdav2, mj2-mj, corint, eps_rf, TRUE);
fprintf(stderr, "\nStatic dielectric constant using integral and fluctuations: %f\n", dk_d);
fprintf(stderr, "\n < M_JM_D > via integral: %.3f\n", -1.0*corint);
}
fprintf(stderr, "\n***************************************************");
fprintf(stderr, "\n\nAverage volume V=%f nm^3 at T=%f K\n", volume_av, temp);
fprintf(stderr, "and corresponding refactor 1.0 / 3.0*V*k_B*T*EPSILON_0: %f \n", prefactor);
if (bACF && (ii < nvfr))
{
fprintf(stderr, "Integral and integrated fit to the current acf yields at t=%f:\n", time[vfr[ii]]);
fprintf(stderr, "sigma=%8.3f (pure integral: %.3f)\n", sgk-malt*std::pow(time[vfr[ii]], sigma), sgk);
}
if (ei > bi)
{
fprintf(stderr, "\nStart fit at %f ps (%f).\n", time[bi], bfit);
fprintf(stderr, "End fit at %f ps (%f).\n\n", time[ei], efit);
snew(xfit, ei-bi+1);
snew(yfit, ei-bi+1);
for (i = bi; i <= ei; i++)
{
xfit[i-bi] = time[i];
yfit[i-bi] = dsp2[i];
}
lsq_y_ax_b(ei-bi, xfit, yfit, &sigma, &malt, &err, &rest);
sigma *= 1e12;
dk_d = calceps(prefactor, md2, 0.5*malt/prefactorav, corint, eps_rf, TRUE);
fprintf(stderr, "Einstein-Helfand fit to the MSD of the translational dipole moment yields:\n\n");
fprintf(stderr, "sigma=%.4f\n", sigma);
fprintf(stderr, "translational fraction of M^2: %.4f\n", 0.5*malt/prefactorav);
fprintf(stderr, "Dielectric constant using EH: %.4f\n", dk_d);
sfree(xfit);
sfree(yfit);
}
else
{
fprintf(stderr, "Too few points for a fit.\n");
}
if (v0 != NULL)
{
sfree(v0);
}
if (bACF)
{
sfree(cacf);
}
if (bINT)
{
sfree(djc);
}
sfree(time);
sfree(mjdsp);
sfree(mu);
}
void dd_pmeredist_f(struct gmx_pme_t *pme, pme_atomcomm_t *atc,
int n, rvec *f,
gmx_bool bAddF)
{
int *commnode, *buf_index;
int nnodes_comm, local_pos, buf_pos, i, scount, rcount, node;
commnode = atc->node_dest;
buf_index = atc->buf_index;
nnodes_comm = min(2*atc->maxshift, atc->nslab-1);
local_pos = atc->count[atc->nodeid];
buf_pos = 0;
for (i = 0; i < nnodes_comm; i++)
{
scount = atc->rcount[i];
rcount = atc->count[commnode[i]];
if (scount > 0 || rcount > 0)
{
/* Communicate the forces */
pme_dd_sendrecv(atc, TRUE, i,
atc->f[local_pos], scount*sizeof(rvec),
pme->bufv[buf_pos], rcount*sizeof(rvec));
local_pos += scount;
}
buf_index[commnode[i]] = buf_pos;
buf_pos += rcount;
}
local_pos = 0;
if (bAddF)
{
for (i = 0; i < n; i++)
{
node = atc->pd[i];
if (node == atc->nodeid)
{
/* Add from the local force array */
rvec_inc(f[i], atc->f[local_pos]);
local_pos++;
}
else
{
/* Add from the receive buffer */
rvec_inc(f[i], pme->bufv[buf_index[node]]);
buf_index[node]++;
}
}
}
else
{
for (i = 0; i < n; i++)
{
node = atc->pd[i];
if (node == atc->nodeid)
{
/* Copy from the local force array */
copy_rvec(atc->f[local_pos], f[i]);
local_pos++;
}
else
{
/* Copy from the receive buffer */
copy_rvec(pme->bufv[buf_index[node]], f[i]);
buf_index[node]++;
}
}
}
}
void calc_order(const char *fn, atom_id *index, atom_id *a, rvec **order,
real ***slOrder, real *slWidth, int nslices, gmx_bool bSliced,
gmx_bool bUnsat, t_topology *top, int ePBC, int ngrps, int axis,
gmx_bool permolecule, gmx_bool radial, gmx_bool distcalc, const char *radfn,
real ***distvals,
const gmx_output_env_t *oenv)
{
/* if permolecule = TRUE, order parameters will be calculed per molecule
* and stored in slOrder with #slices = # molecules */
rvec *x0, /* coordinates with pbc */
*x1, /* coordinates without pbc */
dist; /* vector between two atoms */
matrix box; /* box (3x3) */
t_trxstatus *status;
rvec cossum, /* sum of vector angles for three axes */
Sx, Sy, Sz, /* the three molecular axes */
tmp1, tmp2, /* temp. rvecs for calculating dot products */
frameorder; /* order parameters for one frame */
real *slFrameorder; /* order parameter for one frame, per slice */
real length, /* total distance between two atoms */
t, /* time from trajectory */
z_ave, z1, z2; /* average z, used to det. which slice atom is in */
int natoms, /* nr. atoms in trj */
nr_tails, /* nr tails, to check if index file is correct */
size = 0, /* nr. of atoms in group. same as nr_tails */
i, j, m, k, teller = 0,
slice, /* current slice number */
nr_frames = 0;
int *slCount; /* nr. of atoms in one slice */
real sdbangle = 0; /* sum of these angles */
gmx_bool use_unitvector = FALSE; /* use a specified unit vector instead of axis to specify unit normal*/
rvec direction, com, dref, dvec;
int comsize, distsize;
atom_id *comidx = NULL, *distidx = NULL;
char *grpname = NULL;
t_pbc pbc;
real arcdist, tmpdist;
gmx_rmpbc_t gpbc = NULL;
/* PBC added for center-of-mass vector*/
/* Initiate the pbc structure */
std::memset(&pbc, 0, sizeof(pbc));
if ((natoms = read_first_x(oenv, &status, fn, &t, &x0, box)) == 0)
{
gmx_fatal(FARGS, "Could not read coordinates from statusfile\n");
}
nr_tails = index[1] - index[0];
fprintf(stderr, "Number of elements in first group: %d\n", nr_tails);
/* take first group as standard. Not rocksolid, but might catch error in index*/
if (permolecule)
{
nslices = nr_tails;
bSliced = FALSE; /*force slices off */
fprintf(stderr, "Calculating order parameters for each of %d molecules\n",
nslices);
}
if (radial)
{
use_unitvector = TRUE;
fprintf(stderr, "Select an index group to calculate the radial membrane normal\n");
get_index(&top->atoms, radfn, 1, &comsize, &comidx, &grpname);
}
if (distcalc)
{
if (grpname != NULL)
{
sfree(grpname);
}
fprintf(stderr, "Select an index group to use as distance reference\n");
get_index(&top->atoms, radfn, 1, &distsize, &distidx, &grpname);
bSliced = FALSE; /*force slices off*/
}
if (use_unitvector && bSliced)
{
fprintf(stderr, "Warning: slicing and specified unit vectors are not currently compatible\n");
}
snew(slCount, nslices);
snew(*slOrder, nslices);
for (i = 0; i < nslices; i++)
{
snew((*slOrder)[i], ngrps);
}
if (distcalc)
{
snew(*distvals, nslices);
for (i = 0; i < nslices; i++)
{
snew((*distvals)[i], ngrps);
}
}
snew(*order, ngrps);
snew(slFrameorder, nslices);
snew(x1, natoms);
if (bSliced)
{
*slWidth = box[axis][axis]/nslices;
fprintf(stderr, "Box divided in %d slices. Initial width of slice: %f\n",
nslices, *slWidth);
}
#if 0
nr_tails = index[1] - index[0];
fprintf(stderr, "Number of elements in first group: %d\n", nr_tails);
/* take first group as standard. Not rocksolid, but might catch error
in index*/
#endif
teller = 0;
gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
/*********** Start processing trajectory ***********/
do
{
if (bSliced)
{
*slWidth = box[axis][axis]/nslices;
}
teller++;
set_pbc(&pbc, ePBC, box);
gmx_rmpbc_copy(gpbc, natoms, box, x0, x1);
/* Now loop over all groups. There are ngrps groups, the order parameter can
be calculated for grp 1 to grp ngrps - 1. For each group, loop over all
atoms in group, which is index[i] to (index[i+1] - 1) See block.h. Of
course, in this case index[i+1] -index[i] has to be the same for all
groups, namely the number of tails. i just runs over all atoms in a tail,
so for DPPC ngrps = 16 and i runs from 1 to 14, including 14
*/
if (radial)
{
/*center-of-mass determination*/
com[XX] = 0.0; com[YY] = 0.0; com[ZZ] = 0.0;
for (j = 0; j < comsize; j++)
{
rvec_inc(com, x1[comidx[j]]);
}
svmul(1.0/comsize, com, com);
}
if (distcalc)
{
dref[XX] = 0.0; dref[YY] = 0.0; dref[ZZ] = 0.0;
for (j = 0; j < distsize; j++)
{
rvec_inc(dist, x1[distidx[j]]);
}
svmul(1.0/distsize, dref, dref);
if (radial)
{
pbc_dx(&pbc, dref, com, dvec);
unitv(dvec, dvec);
}
}
for (i = 1; i < ngrps - 1; i++)
{
clear_rvec(frameorder);
size = index[i+1] - index[i];
if (size != nr_tails)
{
gmx_fatal(FARGS, "grp %d does not have same number of"
" elements as grp 1\n", i);
}
for (j = 0; j < size; j++)
{
if (radial)
/*create unit vector*/
{
pbc_dx(&pbc, x1[a[index[i]+j]], com, direction);
unitv(direction, direction);
/*DEBUG*/
/*if (j==0)
fprintf(stderr,"X %f %f %f\tcom %f %f %f\tdirection %f %f %f\n",x1[a[index[i]+j]][0],x1[a[index[i]+j]][1],x1[a[index[i]+j]][2],com[0],com[1],com[2],
direction[0],direction[1],direction[2]);*/
}
if (bUnsat)
{
/* Using convention for unsaturated carbons */
/* first get Sz, the vector from Cn to Cn+1 */
rvec_sub(x1[a[index[i+1]+j]], x1[a[index[i]+j]], dist);
length = norm(dist);
check_length(length, a[index[i]+j], a[index[i+1]+j]);
svmul(1.0/length, dist, Sz);
/* this is actually the cosine of the angle between the double bond
and axis, because Sz is normalized and the two other components of
the axis on the bilayer are zero */
if (use_unitvector)
{
sdbangle += gmx_angle(direction, Sz); /*this can probably be optimized*/
}
else
{
sdbangle += std::acos(Sz[axis]);
}
}
else
{
/* get vector dist(Cn-1,Cn+1) for tail atoms */
rvec_sub(x1[a[index[i+1]+j]], x1[a[index[i-1]+j]], dist);
length = norm(dist); /* determine distance between two atoms */
check_length(length, a[index[i-1]+j], a[index[i+1]+j]);
svmul(1.0/length, dist, Sz);
/* Sz is now the molecular axis Sz, normalized and all that */
}
/* now get Sx. Sx is normal to the plane of Cn-1, Cn and Cn+1 so
we can use the outer product of Cn-1->Cn and Cn+1->Cn, I hope */
rvec_sub(x1[a[index[i+1]+j]], x1[a[index[i]+j]], tmp1);
rvec_sub(x1[a[index[i-1]+j]], x1[a[index[i]+j]], tmp2);
cprod(tmp1, tmp2, Sx);
svmul(1.0/norm(Sx), Sx, Sx);
/* now we can get Sy from the outer product of Sx and Sz */
cprod(Sz, Sx, Sy);
svmul(1.0/norm(Sy), Sy, Sy);
/* the square of cosine of the angle between dist and the axis.
Using the innerproduct, but two of the three elements are zero
Determine the sum of the orderparameter of all atoms in group
*/
if (use_unitvector)
{
cossum[XX] = sqr(iprod(Sx, direction)); /* this is allowed, since Sa is normalized */
cossum[YY] = sqr(iprod(Sy, direction));
cossum[ZZ] = sqr(iprod(Sz, direction));
}
else
{
cossum[XX] = sqr(Sx[axis]); /* this is allowed, since Sa is normalized */
cossum[YY] = sqr(Sy[axis]);
cossum[ZZ] = sqr(Sz[axis]);
}
for (m = 0; m < DIM; m++)
{
frameorder[m] += 0.5 * (3.0 * cossum[m] - 1.0);
}
if (bSliced)
{
/* get average coordinate in box length for slicing,
determine which slice atom is in, increase count for that
slice. slFrameorder and slOrder are reals, not
rvecs. Only the component [axis] of the order tensor is
kept, until I find it necessary to know the others too
*/
z1 = x1[a[index[i-1]+j]][axis];
z2 = x1[a[index[i+1]+j]][axis];
z_ave = 0.5 * (z1 + z2);
if (z_ave < 0)
{
z_ave += box[axis][axis];
}
if (z_ave > box[axis][axis])
{
z_ave -= box[axis][axis];
}
slice = static_cast<int>((0.5 + (z_ave / (*slWidth))) - 1);
slCount[slice]++; /* determine slice, increase count */
slFrameorder[slice] += 0.5 * (3 * cossum[axis] - 1);
}
else if (permolecule)
{
/* store per-molecule order parameter
* To just track single-axis order: (*slOrder)[j][i] += 0.5 * (3 * iprod(cossum,direction) - 1);
* following is for Scd order: */
(*slOrder)[j][i] += -1* (1.0/3.0 * (3 * cossum[XX] - 1) + 1.0/3.0 * 0.5 * (3.0 * cossum[YY] - 1));
}
if (distcalc)
{
if (radial)
{
/* bin order parameter by arc distance from reference group*/
arcdist = gmx_angle(dvec, direction);
(*distvals)[j][i] += arcdist;
}
else if (i == 1)
{
/* Want minimum lateral distance to first group calculated */
tmpdist = trace(box); /* should be max value */
for (k = 0; k < distsize; k++)
{
pbc_dx(&pbc, x1[distidx[k]], x1[a[index[i]+j]], dvec);
/* at the moment, just remove dvec[axis] */
dvec[axis] = 0;
tmpdist = std::min(tmpdist, norm2(dvec));
}
//fprintf(stderr, "Min dist %f; trace %f\n", tmpdist, trace(box));
(*distvals)[j][i] += std::sqrt(tmpdist);
}
}
} /* end loop j, over all atoms in group */
for (m = 0; m < DIM; m++)
{
(*order)[i][m] += (frameorder[m]/size);
}
if (!permolecule)
{ /*Skip following if doing per-molecule*/
for (k = 0; k < nslices; k++)
{
if (slCount[k]) /* if no elements, nothing has to be added */
{
(*slOrder)[k][i] += slFrameorder[k]/slCount[k];
slFrameorder[k] = 0; slCount[k] = 0;
}
}
} /* end loop i, over all groups in indexfile */
}
nr_frames++;
}
while (read_next_x(oenv, status, &t, x0, box));
/*********** done with status file **********/
fprintf(stderr, "\nRead trajectory. Printing parameters to file\n");
gmx_rmpbc_done(gpbc);
/* average over frames */
for (i = 1; i < ngrps - 1; i++)
{
svmul(1.0/nr_frames, (*order)[i], (*order)[i]);
fprintf(stderr, "Atom %d Tensor: x=%g , y=%g, z=%g\n", i, (*order)[i][XX],
(*order)[i][YY], (*order)[i][ZZ]);
if (bSliced || permolecule)
{
for (k = 0; k < nslices; k++)
{
(*slOrder)[k][i] /= nr_frames;
}
}
if (distcalc)
{
for (k = 0; k < nslices; k++)
{
(*distvals)[k][i] /= nr_frames;
}
}
}
if (bUnsat)
{
fprintf(stderr, "Average angle between double bond and normal: %f\n",
180*sdbangle/(nr_frames * size*M_PI));
}
sfree(x0); /* free memory used by coordinate arrays */
sfree(x1);
if (comidx != NULL)
{
sfree(comidx);
}
if (distidx != NULL)
{
sfree(distidx);
}
if (grpname != NULL)
{
sfree(grpname);
}
}
int gmx_gyrate(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes the radius of gyration of a molecule",
"and the radii of gyration about the [IT]x[it]-, [IT]y[it]- and [IT]z[it]-axes,",
"as a function of time. The atoms are explicitly mass weighted.[PAR]",
"The axis components corresponds to the mass-weighted root-mean-square",
"of the radii components orthogonal to each axis, for example:[PAR]",
"Rg(x) = sqrt((sum_i m_i (R_i(y)^2 + R_i(z)^2))/(sum_i m_i)).[PAR]",
"With the [TT]-nmol[tt] option the radius of gyration will be calculated",
"for multiple molecules by splitting the analysis group in equally",
"sized parts.[PAR]",
"With the option [TT]-nz[tt] 2D radii of gyration in the [IT]x-y[it] plane",
"of slices along the [IT]z[it]-axis are calculated."
};
static int nmol = 1, nz = 0;
static gmx_bool bQ = FALSE, bRot = FALSE, bMOI = FALSE;
t_pargs pa[] = {
{ "-nmol", FALSE, etINT, {&nmol},
"The number of molecules to analyze" },
{ "-q", FALSE, etBOOL, {&bQ},
"Use absolute value of the charge of an atom as weighting factor instead of mass" },
{ "-p", FALSE, etBOOL, {&bRot},
"Calculate the radii of gyration about the principal axes." },
{ "-moi", FALSE, etBOOL, {&bMOI},
"Calculate the moments of inertia (defined by the principal axes)." },
{ "-nz", FALSE, etINT, {&nz},
"Calculate the 2D radii of gyration of this number of slices along the z-axis" },
};
FILE *out;
t_trxstatus *status;
t_topology top;
int ePBC;
rvec *x, *x_s;
rvec xcm, gvec, gvec1;
matrix box, trans;
gmx_bool bACF;
real **moi_trans = NULL;
int max_moi = 0, delta_moi = 100;
rvec d, d1; /* eigenvalues of inertia tensor */
real t, t0, tm, gyro;
int natoms;
char *grpname;
int j, m, gnx, nam, mol;
atom_id *index;
gmx_output_env_t *oenv;
gmx_rmpbc_t gpbc = NULL;
const char *leg[] = { "Rg", "Rg\\sX\\N", "Rg\\sY\\N", "Rg\\sZ\\N" };
const char *legI[] = { "Itot", "I1", "I2", "I3" };
#define NLEG asize(leg)
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "gyrate", ffWRITE },
{ efXVG, "-acf", "moi-acf", ffOPTWR },
};
#define NFILE asize(fnm)
int npargs;
t_pargs *ppa;
npargs = asize(pa);
ppa = add_acf_pargs(&npargs, pa);
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_CAN_VIEW,
NFILE, fnm, npargs, ppa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
bACF = opt2bSet("-acf", NFILE, fnm);
if (bACF && nmol != 1)
{
gmx_fatal(FARGS, "Can only do acf with nmol=1");
}
bRot = bRot || bMOI || bACF;
/*
if (nz > 0)
bMOI = TRUE;
*/
if (bRot)
{
printf("Will rotate system along principal axes\n");
snew(moi_trans, DIM);
}
if (bMOI)
{
printf("Will print moments of inertia\n");
bQ = FALSE;
}
if (bQ)
{
printf("Will print radius normalised by charge\n");
}
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, &x, NULL, box, TRUE);
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &gnx, &index, &grpname);
if (nmol > gnx || gnx % nmol != 0)
{
gmx_fatal(FARGS, "The number of atoms in the group (%d) is not a multiple of nmol (%d)", gnx, nmol);
}
nam = gnx/nmol;
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
snew(x_s, natoms);
j = 0;
t0 = t;
if (bQ)
{
out = xvgropen(ftp2fn(efXVG, NFILE, fnm),
"Radius of Charge (total and around axes)", "Time (ps)", "Rg (nm)", oenv);
}
else if (bMOI)
{
out = xvgropen(ftp2fn(efXVG, NFILE, fnm),
"Moments of inertia (total and around axes)", "Time (ps)", "I (a.m.u. nm\\S2\\N)", oenv);
}
else
{
out = xvgropen(ftp2fn(efXVG, NFILE, fnm),
"Radius of gyration (total and around axes)", "Time (ps)", "Rg (nm)", oenv);
}
if (bMOI)
{
xvgr_legend(out, NLEG, legI, oenv);
}
else
{
if (bRot)
{
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(out, "@ subtitle \"Axes are principal component axes\"\n");
}
}
xvgr_legend(out, NLEG, leg, oenv);
}
if (nz == 0)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
}
do
{
if (nz == 0)
{
gmx_rmpbc_copy(gpbc, natoms, box, x, x_s);
}
gyro = 0;
clear_rvec(gvec);
clear_rvec(gvec1);
clear_rvec(d);
clear_rvec(d1);
for (mol = 0; mol < nmol; mol++)
{
tm = sub_xcm(nz == 0 ? x_s : x, nam, index+mol*nam, top.atoms.atom, xcm, bQ);
if (nz == 0)
{
gyro += calc_gyro(x_s, nam, index+mol*nam, top.atoms.atom,
tm, gvec1, d1, bQ, bRot, bMOI, trans);
}
else
{
calc_gyro_z(x, box, nam, index+mol*nam, top.atoms.atom, nz, t, out);
}
rvec_inc(gvec, gvec1);
rvec_inc(d, d1);
}
if (nmol > 0)
{
gyro /= nmol;
svmul(1.0/nmol, gvec, gvec);
svmul(1.0/nmol, d, d);
}
if (nz == 0)
{
if (bRot)
{
if (j >= max_moi)
{
max_moi += delta_moi;
for (m = 0; (m < DIM); m++)
{
srenew(moi_trans[m], max_moi*DIM);
}
}
for (m = 0; (m < DIM); m++)
{
copy_rvec(trans[m], moi_trans[m]+DIM*j);
}
fprintf(out, "%10g %10g %10g %10g %10g\n",
t, gyro, d[XX], d[YY], d[ZZ]);
}
else
{
fprintf(out, "%10g %10g %10g %10g %10g\n",
t, gyro, gvec[XX], gvec[YY], gvec[ZZ]);
}
}
j++;
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (nz == 0)
{
gmx_rmpbc_done(gpbc);
}
xvgrclose(out);
if (bACF)
{
int mode = eacVector;
do_autocorr(opt2fn("-acf", NFILE, fnm), oenv,
"Moment of inertia vector ACF",
j, 3, moi_trans, (t-t0)/j, mode, FALSE);
do_view(oenv, opt2fn("-acf", NFILE, fnm), "-nxy");
}
do_view(oenv, ftp2fn(efXVG, NFILE, fnm), "-nxy");
return 0;
}
void calc_chargegroup_radii(const gmx_mtop_t *mtop,rvec *x,
real *rvdw1,real *rvdw2,
real *rcoul1,real *rcoul2)
{
real r2v1,r2v2,r2c1,r2c2,r2;
int ntype,i,j,mb,m,cg,a_mol,a0,a1,a;
gmx_bool *bLJ;
gmx_molblock_t *molb;
gmx_moltype_t *molt;
t_block *cgs;
t_atom *atom;
rvec cen;
r2v1 = 0;
r2v2 = 0;
r2c1 = 0;
r2c2 = 0;
ntype = mtop->ffparams.atnr;
snew(bLJ,ntype);
for(i=0; i<ntype; i++)
{
bLJ[i] = FALSE;
for(j=0; j<ntype; j++)
{
if (mtop->ffparams.iparams[i*ntype+j].lj.c6 != 0 ||
mtop->ffparams.iparams[i*ntype+j].lj.c12 != 0)
{
bLJ[i] = TRUE;
}
}
}
a_mol = 0;
for(mb=0; mb<mtop->nmolblock; mb++)
{
molb = &mtop->molblock[mb];
molt = &mtop->moltype[molb->type];
cgs = &molt->cgs;
atom = molt->atoms.atom;
for(m=0; m<molb->nmol; m++)
{
for(cg=0; cg<cgs->nr; cg++)
{
a0 = cgs->index[cg];
a1 = cgs->index[cg+1];
if (a1 - a0 > 1)
{
clear_rvec(cen);
for(a=a0; a<a1; a++)
{
rvec_inc(cen,x[a_mol+a]);
}
svmul(1.0/(a1-a0),cen,cen);
for(a=a0; a<a1; a++)
{
r2 = distance2(cen,x[a_mol+a]);
if (r2 > r2v2 && (bLJ[atom[a].type ] ||
bLJ[atom[a].typeB]))
{
if (r2 > r2v1)
{
r2v2 = r2v1;
r2v1 = r2;
}
else
{
r2v2 = r2;
}
}
if (r2 > r2c2 &&
(atom[a].q != 0 || atom[a].qB != 0))
{
if (r2 > r2c1)
{
r2c2 = r2c1;
r2c1 = r2;
}
else
{
r2c2 = r2;
}
}
}
}
}
a_mol += molb->natoms_mol;
}
}
sfree(bLJ);
*rvdw1 = sqrt(r2v1);
*rvdw2 = sqrt(r2v2);
*rcoul1 = sqrt(r2c1);
*rcoul2 = sqrt(r2c2);
}
static void calc_cgcm_av_stddev(t_block *cgs, int n, rvec *x, rvec av, rvec stddev,
t_commrec *cr_sum)
{
int *cgindex;
dvec s1, s2;
double buf[7];
int cg, d, k0, k1, k, nrcg;
real inv_ncg;
rvec cg_cm;
clear_dvec(s1);
clear_dvec(s2);
cgindex = cgs->index;
for (cg = 0; cg < n; cg++)
{
k0 = cgindex[cg];
k1 = cgindex[cg+1];
nrcg = k1 - k0;
if (nrcg == 1)
{
copy_rvec(x[k0], cg_cm);
}
else
{
inv_ncg = 1.0/nrcg;
clear_rvec(cg_cm);
for (k = k0; (k < k1); k++)
{
rvec_inc(cg_cm, x[k]);
}
for (d = 0; (d < DIM); d++)
{
cg_cm[d] *= inv_ncg;
}
}
for (d = 0; d < DIM; d++)
{
s1[d] += cg_cm[d];
s2[d] += cg_cm[d]*cg_cm[d];
}
}
if (cr_sum != NULL)
{
for (d = 0; d < DIM; d++)
{
buf[d] = s1[d];
buf[DIM+d] = s2[d];
}
buf[6] = n;
gmx_sumd(7, buf, cr_sum);
for (d = 0; d < DIM; d++)
{
s1[d] = buf[d];
s2[d] = buf[DIM+d];
}
n = (int)(buf[6] + 0.5);
}
dsvmul(1.0/n, s1, s1);
dsvmul(1.0/n, s2, s2);
for (d = 0; d < DIM; d++)
{
av[d] = s1[d];
stddev[d] = sqrt(s2[d] - s1[d]*s1[d]);
}
}
double do_tpi(FILE *fplog, t_commrec *cr,
int nfile, const t_filenm fnm[],
const output_env_t oenv, gmx_bool bVerbose, gmx_bool gmx_unused bCompact,
int gmx_unused nstglobalcomm,
gmx_vsite_t gmx_unused *vsite, gmx_constr_t gmx_unused constr,
int gmx_unused stepout,
t_inputrec *inputrec,
gmx_mtop_t *top_global, t_fcdata *fcd,
t_state *state,
t_mdatoms *mdatoms,
t_nrnb *nrnb, gmx_wallcycle_t wcycle,
gmx_edsam_t gmx_unused ed,
t_forcerec *fr,
int gmx_unused repl_ex_nst, int gmx_unused repl_ex_nex, int gmx_unused repl_ex_seed,
gmx_membed_t gmx_unused membed,
real gmx_unused cpt_period, real gmx_unused max_hours,
const char gmx_unused *deviceOptions,
int gmx_unused imdport,
unsigned long gmx_unused Flags,
gmx_walltime_accounting_t walltime_accounting)
{
const char *TPI = "Test Particle Insertion";
gmx_localtop_t *top;
gmx_groups_t *groups;
gmx_enerdata_t *enerd;
rvec *f;
real lambda, t, temp, beta, drmax, epot;
double embU, sum_embU, *sum_UgembU, V, V_all, VembU_all;
t_trxstatus *status;
t_trxframe rerun_fr;
gmx_bool bDispCorr, bCharge, bRFExcl, bNotLastFrame, bStateChanged, bNS;
tensor force_vir, shake_vir, vir, pres;
int cg_tp, a_tp0, a_tp1, ngid, gid_tp, nener, e;
rvec *x_mol;
rvec mu_tot, x_init, dx, x_tp;
int nnodes, frame;
gmx_int64_t frame_step_prev, frame_step;
gmx_int64_t nsteps, stepblocksize = 0, step;
gmx_int64_t rnd_count_stride, rnd_count;
gmx_int64_t seed;
double rnd[4];
int i, start, end;
FILE *fp_tpi = NULL;
char *ptr, *dump_pdb, **leg, str[STRLEN], str2[STRLEN];
double dbl, dump_ener;
gmx_bool bCavity;
int nat_cavity = 0, d;
real *mass_cavity = NULL, mass_tot;
int nbin;
double invbinw, *bin, refvolshift, logV, bUlogV;
real dvdl, prescorr, enercorr, dvdlcorr;
gmx_bool bEnergyOutOfBounds;
const char *tpid_leg[2] = {"direct", "reweighted"};
/* Since there is no upper limit to the insertion energies,
* we need to set an upper limit for the distribution output.
*/
real bU_bin_limit = 50;
real bU_logV_bin_limit = bU_bin_limit + 10;
nnodes = cr->nnodes;
top = gmx_mtop_generate_local_top(top_global, inputrec);
groups = &top_global->groups;
bCavity = (inputrec->eI == eiTPIC);
if (bCavity)
{
ptr = getenv("GMX_TPIC_MASSES");
if (ptr == NULL)
{
nat_cavity = 1;
}
else
{
/* Read (multiple) masses from env var GMX_TPIC_MASSES,
* The center of mass of the last atoms is then used for TPIC.
*/
nat_cavity = 0;
while (sscanf(ptr, "%lf%n", &dbl, &i) > 0)
{
srenew(mass_cavity, nat_cavity+1);
mass_cavity[nat_cavity] = dbl;
fprintf(fplog, "mass[%d] = %f\n",
nat_cavity+1, mass_cavity[nat_cavity]);
nat_cavity++;
ptr += i;
}
if (nat_cavity == 0)
{
gmx_fatal(FARGS, "Found %d masses in GMX_TPIC_MASSES", nat_cavity);
}
}
}
/*
init_em(fplog,TPI,inputrec,&lambda,nrnb,mu_tot,
state->box,fr,mdatoms,top,cr,nfile,fnm,NULL,NULL);*/
/* We never need full pbc for TPI */
fr->ePBC = epbcXYZ;
/* Determine the temperature for the Boltzmann weighting */
temp = inputrec->opts.ref_t[0];
if (fplog)
{
for (i = 1; (i < inputrec->opts.ngtc); i++)
{
if (inputrec->opts.ref_t[i] != temp)
{
fprintf(fplog, "\nWARNING: The temperatures of the different temperature coupling groups are not identical\n\n");
fprintf(stderr, "\nWARNING: The temperatures of the different temperature coupling groups are not identical\n\n");
}
}
fprintf(fplog,
"\n The temperature for test particle insertion is %.3f K\n\n",
temp);
}
beta = 1.0/(BOLTZ*temp);
/* Number of insertions per frame */
nsteps = inputrec->nsteps;
/* Use the same neighborlist with more insertions points
* in a sphere of radius drmax around the initial point
*/
/* This should be a proper mdp parameter */
drmax = inputrec->rtpi;
/* An environment variable can be set to dump all configurations
* to pdb with an insertion energy <= this value.
*/
dump_pdb = getenv("GMX_TPI_DUMP");
dump_ener = 0;
if (dump_pdb)
{
sscanf(dump_pdb, "%lf", &dump_ener);
}
atoms2md(top_global, inputrec, 0, NULL, top_global->natoms, mdatoms);
update_mdatoms(mdatoms, inputrec->fepvals->init_lambda);
snew(enerd, 1);
init_enerdata(groups->grps[egcENER].nr, inputrec->fepvals->n_lambda, enerd);
snew(f, top_global->natoms);
/* Print to log file */
walltime_accounting_start(walltime_accounting);
wallcycle_start(wcycle, ewcRUN);
print_start(fplog, cr, walltime_accounting, "Test Particle Insertion");
/* The last charge group is the group to be inserted */
cg_tp = top->cgs.nr - 1;
a_tp0 = top->cgs.index[cg_tp];
a_tp1 = top->cgs.index[cg_tp+1];
if (debug)
{
fprintf(debug, "TPI cg %d, atoms %d-%d\n", cg_tp, a_tp0, a_tp1);
}
if (a_tp1 - a_tp0 > 1 &&
(inputrec->rlist < inputrec->rcoulomb ||
inputrec->rlist < inputrec->rvdw))
{
gmx_fatal(FARGS, "Can not do TPI for multi-atom molecule with a twin-range cut-off");
}
snew(x_mol, a_tp1-a_tp0);
bDispCorr = (inputrec->eDispCorr != edispcNO);
bCharge = FALSE;
for (i = a_tp0; i < a_tp1; i++)
{
/* Copy the coordinates of the molecule to be insterted */
copy_rvec(state->x[i], x_mol[i-a_tp0]);
/* Check if we need to print electrostatic energies */
bCharge |= (mdatoms->chargeA[i] != 0 ||
(mdatoms->chargeB && mdatoms->chargeB[i] != 0));
}
bRFExcl = (bCharge && EEL_RF(fr->eeltype) && fr->eeltype != eelRF_NEC);
calc_cgcm(fplog, cg_tp, cg_tp+1, &(top->cgs), state->x, fr->cg_cm);
if (bCavity)
{
if (norm(fr->cg_cm[cg_tp]) > 0.5*inputrec->rlist && fplog)
{
fprintf(fplog, "WARNING: Your TPI molecule is not centered at 0,0,0\n");
fprintf(stderr, "WARNING: Your TPI molecule is not centered at 0,0,0\n");
}
}
else
{
/* Center the molecule to be inserted at zero */
for (i = 0; i < a_tp1-a_tp0; i++)
{
rvec_dec(x_mol[i], fr->cg_cm[cg_tp]);
}
}
if (fplog)
{
fprintf(fplog, "\nWill insert %d atoms %s partial charges\n",
a_tp1-a_tp0, bCharge ? "with" : "without");
fprintf(fplog, "\nWill insert %d times in each frame of %s\n",
(int)nsteps, opt2fn("-rerun", nfile, fnm));
}
if (!bCavity)
{
if (inputrec->nstlist > 1)
{
if (drmax == 0 && a_tp1-a_tp0 == 1)
{
gmx_fatal(FARGS, "Re-using the neighborlist %d times for insertions of a single atom in a sphere of radius %f does not make sense", inputrec->nstlist, drmax);
}
if (fplog)
{
fprintf(fplog, "Will use the same neighborlist for %d insertions in a sphere of radius %f\n", inputrec->nstlist, drmax);
}
}
}
else
{
if (fplog)
{
fprintf(fplog, "Will insert randomly in a sphere of radius %f around the center of the cavity\n", drmax);
}
}
ngid = groups->grps[egcENER].nr;
gid_tp = GET_CGINFO_GID(fr->cginfo[cg_tp]);
nener = 1 + ngid;
if (bDispCorr)
{
nener += 1;
}
if (bCharge)
{
nener += ngid;
if (bRFExcl)
{
nener += 1;
}
if (EEL_FULL(fr->eeltype))
{
nener += 1;
}
}
snew(sum_UgembU, nener);
/* Copy the random seed set by the user */
seed = inputrec->ld_seed;
/* We use the frame step number as one random counter.
* The second counter use the insertion (step) count. But we
* need multiple random numbers per insertion. This number is
* not fixed, since we generate random locations in a sphere
* by putting locations in a cube and some of these fail.
* A count of 20 is already extremely unlikely, so 10000 is
* a safe margin for random numbers per insertion.
*/
rnd_count_stride = 10000;
if (MASTER(cr))
{
fp_tpi = xvgropen(opt2fn("-tpi", nfile, fnm),
"TPI energies", "Time (ps)",
"(kJ mol\\S-1\\N) / (nm\\S3\\N)", oenv);
xvgr_subtitle(fp_tpi, "f. are averages over one frame", oenv);
snew(leg, 4+nener);
e = 0;
sprintf(str, "-kT log(<Ve\\S-\\betaU\\N>/<V>)");
leg[e++] = strdup(str);
sprintf(str, "f. -kT log<e\\S-\\betaU\\N>");
leg[e++] = strdup(str);
sprintf(str, "f. <e\\S-\\betaU\\N>");
leg[e++] = strdup(str);
sprintf(str, "f. V");
leg[e++] = strdup(str);
sprintf(str, "f. <Ue\\S-\\betaU\\N>");
leg[e++] = strdup(str);
for (i = 0; i < ngid; i++)
{
sprintf(str, "f. <U\\sVdW %s\\Ne\\S-\\betaU\\N>",
*(groups->grpname[groups->grps[egcENER].nm_ind[i]]));
leg[e++] = strdup(str);
}
if (bDispCorr)
{
sprintf(str, "f. <U\\sdisp c\\Ne\\S-\\betaU\\N>");
leg[e++] = strdup(str);
}
if (bCharge)
{
for (i = 0; i < ngid; i++)
{
sprintf(str, "f. <U\\sCoul %s\\Ne\\S-\\betaU\\N>",
*(groups->grpname[groups->grps[egcENER].nm_ind[i]]));
leg[e++] = strdup(str);
}
if (bRFExcl)
{
sprintf(str, "f. <U\\sRF excl\\Ne\\S-\\betaU\\N>");
leg[e++] = strdup(str);
}
if (EEL_FULL(fr->eeltype))
{
sprintf(str, "f. <U\\sCoul recip\\Ne\\S-\\betaU\\N>");
leg[e++] = strdup(str);
}
}
xvgr_legend(fp_tpi, 4+nener, (const char**)leg, oenv);
for (i = 0; i < 4+nener; i++)
{
sfree(leg[i]);
}
sfree(leg);
}
clear_rvec(x_init);
V_all = 0;
VembU_all = 0;
invbinw = 10;
nbin = 10;
snew(bin, nbin);
/* Avoid frame step numbers <= -1 */
frame_step_prev = -1;
bNotLastFrame = read_first_frame(oenv, &status, opt2fn("-rerun", nfile, fnm),
&rerun_fr, TRX_NEED_X);
frame = 0;
if (rerun_fr.natoms - (bCavity ? nat_cavity : 0) !=
mdatoms->nr - (a_tp1 - a_tp0))
{
gmx_fatal(FARGS, "Number of atoms in trajectory (%d)%s "
"is not equal the number in the run input file (%d) "
"minus the number of atoms to insert (%d)\n",
rerun_fr.natoms, bCavity ? " minus one" : "",
mdatoms->nr, a_tp1-a_tp0);
}
refvolshift = log(det(rerun_fr.box));
switch (inputrec->eI)
{
case eiTPI:
stepblocksize = inputrec->nstlist;
break;
case eiTPIC:
stepblocksize = 1;
break;
default:
gmx_fatal(FARGS, "Unknown integrator %s", ei_names[inputrec->eI]);
}
#ifdef GMX_SIMD
/* Make sure we don't detect SIMD overflow generated before this point */
gmx_simd_check_and_reset_overflow();
#endif
while (bNotLastFrame)
{
frame_step = rerun_fr.step;
if (frame_step <= frame_step_prev)
{
/* We don't have step number in the trajectory file,
* or we have constant or decreasing step numbers.
* Ensure we have increasing step numbers, since we use
* the step numbers as a counter for random numbers.
*/
frame_step = frame_step_prev + 1;
}
frame_step_prev = frame_step;
lambda = rerun_fr.lambda;
t = rerun_fr.time;
sum_embU = 0;
for (e = 0; e < nener; e++)
{
sum_UgembU[e] = 0;
}
/* Copy the coordinates from the input trajectory */
for (i = 0; i < rerun_fr.natoms; i++)
{
copy_rvec(rerun_fr.x[i], state->x[i]);
}
copy_mat(rerun_fr.box, state->box);
V = det(state->box);
logV = log(V);
bStateChanged = TRUE;
bNS = TRUE;
step = cr->nodeid*stepblocksize;
while (step < nsteps)
{
/* Initialize the second counter for random numbers using
* the insertion step index. This ensures that we get
* the same random numbers independently of how many
* MPI ranks we use. Also for the same seed, we get
* the same initial random sequence for different nsteps.
*/
rnd_count = step*rnd_count_stride;
if (!bCavity)
{
/* Random insertion in the whole volume */
bNS = (step % inputrec->nstlist == 0);
if (bNS)
{
/* Generate a random position in the box */
gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd);
gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd+2);
for (d = 0; d < DIM; d++)
{
x_init[d] = rnd[d]*state->box[d][d];
}
}
if (inputrec->nstlist == 1)
{
copy_rvec(x_init, x_tp);
}
else
{
/* Generate coordinates within |dx|=drmax of x_init */
do
{
gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd);
gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd+2);
for (d = 0; d < DIM; d++)
{
dx[d] = (2*rnd[d] - 1)*drmax;
}
}
while (norm2(dx) > drmax*drmax);
rvec_add(x_init, dx, x_tp);
}
}
else
{
/* Random insertion around a cavity location
* given by the last coordinate of the trajectory.
*/
if (step == 0)
{
if (nat_cavity == 1)
{
/* Copy the location of the cavity */
copy_rvec(rerun_fr.x[rerun_fr.natoms-1], x_init);
}
else
{
/* Determine the center of mass of the last molecule */
clear_rvec(x_init);
mass_tot = 0;
for (i = 0; i < nat_cavity; i++)
{
for (d = 0; d < DIM; d++)
{
x_init[d] +=
mass_cavity[i]*rerun_fr.x[rerun_fr.natoms-nat_cavity+i][d];
}
mass_tot += mass_cavity[i];
}
for (d = 0; d < DIM; d++)
{
x_init[d] /= mass_tot;
}
}
}
/* Generate coordinates within |dx|=drmax of x_init */
do
{
gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd);
gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd+2);
for (d = 0; d < DIM; d++)
{
dx[d] = (2*rnd[d] - 1)*drmax;
}
}
while (norm2(dx) > drmax*drmax);
rvec_add(x_init, dx, x_tp);
}
if (a_tp1 - a_tp0 == 1)
{
/* Insert a single atom, just copy the insertion location */
copy_rvec(x_tp, state->x[a_tp0]);
}
else
{
/* Copy the coordinates from the top file */
for (i = a_tp0; i < a_tp1; i++)
{
copy_rvec(x_mol[i-a_tp0], state->x[i]);
}
/* Rotate the molecule randomly */
gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd);
gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd+2);
rotate_conf(a_tp1-a_tp0, state->x+a_tp0, NULL,
2*M_PI*rnd[0],
2*M_PI*rnd[1],
2*M_PI*rnd[2]);
/* Shift to the insertion location */
for (i = a_tp0; i < a_tp1; i++)
{
rvec_inc(state->x[i], x_tp);
}
}
/* Clear some matrix variables */
clear_mat(force_vir);
clear_mat(shake_vir);
clear_mat(vir);
clear_mat(pres);
/* Set the charge group center of mass of the test particle */
copy_rvec(x_init, fr->cg_cm[top->cgs.nr-1]);
/* Calc energy (no forces) on new positions.
* Since we only need the intermolecular energy
* and the RF exclusion terms of the inserted molecule occur
* within a single charge group we can pass NULL for the graph.
* This also avoids shifts that would move charge groups
* out of the box.
*
* Some checks above ensure than we can not have
* twin-range interactions together with nstlist > 1,
* therefore we do not need to remember the LR energies.
*/
/* Make do_force do a single node force calculation */
cr->nnodes = 1;
do_force(fplog, cr, inputrec,
step, nrnb, wcycle, top, &top_global->groups,
state->box, state->x, &state->hist,
f, force_vir, mdatoms, enerd, fcd,
state->lambda,
NULL, fr, NULL, mu_tot, t, NULL, NULL, FALSE,
GMX_FORCE_NONBONDED | GMX_FORCE_ENERGY |
(bNS ? GMX_FORCE_DYNAMICBOX | GMX_FORCE_NS | GMX_FORCE_DO_LR : 0) |
(bStateChanged ? GMX_FORCE_STATECHANGED : 0));
cr->nnodes = nnodes;
bStateChanged = FALSE;
bNS = FALSE;
/* Calculate long range corrections to pressure and energy */
calc_dispcorr(fplog, inputrec, fr, step, top_global->natoms, state->box,
lambda, pres, vir, &prescorr, &enercorr, &dvdlcorr);
/* figure out how to rearrange the next 4 lines MRS 8/4/2009 */
enerd->term[F_DISPCORR] = enercorr;
enerd->term[F_EPOT] += enercorr;
enerd->term[F_PRES] += prescorr;
enerd->term[F_DVDL_VDW] += dvdlcorr;
epot = enerd->term[F_EPOT];
bEnergyOutOfBounds = FALSE;
#ifdef GMX_SIMD_X86_SSE2_OR_HIGHER
/* With SSE the energy can overflow, check for this */
if (gmx_mm_check_and_reset_overflow())
{
if (debug)
{
fprintf(debug, "Found an SSE overflow, assuming the energy is out of bounds\n");
}
bEnergyOutOfBounds = TRUE;
}
#endif
/* If the compiler doesn't optimize this check away
* we catch the NAN energies.
* The epot>GMX_REAL_MAX check catches inf values,
* which should nicely result in embU=0 through the exp below,
* but it does not hurt to check anyhow.
*/
/* Non-bonded Interaction usually diverge at r=0.
* With tabulated interaction functions the first few entries
* should be capped in a consistent fashion between
* repulsion, dispersion and Coulomb to avoid accidental
* negative values in the total energy.
* The table generation code in tables.c does this.
* With user tbales the user should take care of this.
*/
if (epot != epot || epot > GMX_REAL_MAX)
{
bEnergyOutOfBounds = TRUE;
}
if (bEnergyOutOfBounds)
{
if (debug)
{
fprintf(debug, "\n time %.3f, step %d: non-finite energy %f, using exp(-bU)=0\n", t, (int)step, epot);
}
embU = 0;
}
else
{
embU = exp(-beta*epot);
sum_embU += embU;
/* Determine the weighted energy contributions of each energy group */
e = 0;
sum_UgembU[e++] += epot*embU;
if (fr->bBHAM)
{
for (i = 0; i < ngid; i++)
{
sum_UgembU[e++] +=
(enerd->grpp.ener[egBHAMSR][GID(i, gid_tp, ngid)] +
enerd->grpp.ener[egBHAMLR][GID(i, gid_tp, ngid)])*embU;
}
}
else
{
for (i = 0; i < ngid; i++)
{
sum_UgembU[e++] +=
(enerd->grpp.ener[egLJSR][GID(i, gid_tp, ngid)] +
enerd->grpp.ener[egLJLR][GID(i, gid_tp, ngid)])*embU;
}
}
if (bDispCorr)
{
sum_UgembU[e++] += enerd->term[F_DISPCORR]*embU;
}
if (bCharge)
{
for (i = 0; i < ngid; i++)
{
sum_UgembU[e++] +=
(enerd->grpp.ener[egCOULSR][GID(i, gid_tp, ngid)] +
enerd->grpp.ener[egCOULLR][GID(i, gid_tp, ngid)])*embU;
}
if (bRFExcl)
{
sum_UgembU[e++] += enerd->term[F_RF_EXCL]*embU;
}
if (EEL_FULL(fr->eeltype))
{
sum_UgembU[e++] += enerd->term[F_COUL_RECIP]*embU;
}
}
}
if (embU == 0 || beta*epot > bU_bin_limit)
{
bin[0]++;
}
else
{
i = (int)((bU_logV_bin_limit
- (beta*epot - logV + refvolshift))*invbinw
+ 0.5);
if (i < 0)
{
i = 0;
}
if (i >= nbin)
{
realloc_bins(&bin, &nbin, i+10);
}
bin[i]++;
}
if (debug)
{
fprintf(debug, "TPI %7d %12.5e %12.5f %12.5f %12.5f\n",
(int)step, epot, x_tp[XX], x_tp[YY], x_tp[ZZ]);
}
if (dump_pdb && epot <= dump_ener)
{
sprintf(str, "t%g_step%d.pdb", t, (int)step);
sprintf(str2, "t: %f step %d ener: %f", t, (int)step, epot);
write_sto_conf_mtop(str, str2, top_global, state->x, state->v,
inputrec->ePBC, state->box);
}
step++;
if ((step/stepblocksize) % cr->nnodes != cr->nodeid)
{
/* Skip all steps assigned to the other MPI ranks */
step += (cr->nnodes - 1)*stepblocksize;
}
}
if (PAR(cr))
{
/* When running in parallel sum the energies over the processes */
gmx_sumd(1, &sum_embU, cr);
gmx_sumd(nener, sum_UgembU, cr);
}
frame++;
V_all += V;
VembU_all += V*sum_embU/nsteps;
if (fp_tpi)
{
if (bVerbose || frame%10 == 0 || frame < 10)
{
fprintf(stderr, "mu %10.3e <mu> %10.3e\n",
-log(sum_embU/nsteps)/beta, -log(VembU_all/V_all)/beta);
}
fprintf(fp_tpi, "%10.3f %12.5e %12.5e %12.5e %12.5e",
t,
VembU_all == 0 ? 20/beta : -log(VembU_all/V_all)/beta,
sum_embU == 0 ? 20/beta : -log(sum_embU/nsteps)/beta,
sum_embU/nsteps, V);
for (e = 0; e < nener; e++)
{
fprintf(fp_tpi, " %12.5e", sum_UgembU[e]/nsteps);
}
fprintf(fp_tpi, "\n");
fflush(fp_tpi);
}
bNotLastFrame = read_next_frame(oenv, status, &rerun_fr);
} /* End of the loop */
walltime_accounting_end(walltime_accounting);
close_trj(status);
if (fp_tpi != NULL)
{
gmx_fio_fclose(fp_tpi);
}
if (fplog != NULL)
{
fprintf(fplog, "\n");
fprintf(fplog, " <V> = %12.5e nm^3\n", V_all/frame);
fprintf(fplog, " <mu> = %12.5e kJ/mol\n", -log(VembU_all/V_all)/beta);
}
/* Write the Boltzmann factor histogram */
if (PAR(cr))
{
/* When running in parallel sum the bins over the processes */
i = nbin;
global_max(cr, &i);
realloc_bins(&bin, &nbin, i);
gmx_sumd(nbin, bin, cr);
}
if (MASTER(cr))
{
fp_tpi = xvgropen(opt2fn("-tpid", nfile, fnm),
"TPI energy distribution",
"\\betaU - log(V/<V>)", "count", oenv);
sprintf(str, "number \\betaU > %g: %9.3e", bU_bin_limit, bin[0]);
xvgr_subtitle(fp_tpi, str, oenv);
xvgr_legend(fp_tpi, 2, (const char **)tpid_leg, oenv);
for (i = nbin-1; i > 0; i--)
{
bUlogV = -i/invbinw + bU_logV_bin_limit - refvolshift + log(V_all/frame);
fprintf(fp_tpi, "%6.2f %10d %12.5e\n",
bUlogV,
(int)(bin[i]+0.5),
bin[i]*exp(-bUlogV)*V_all/VembU_all);
}
gmx_fio_fclose(fp_tpi);
}
sfree(bin);
sfree(sum_UgembU);
walltime_accounting_set_nsteps_done(walltime_accounting, frame*inputrec->nsteps);
return 0;
}
int gmx_vanhove(int argc,char *argv[])
{
const char *desc[] = {
"g_vanhove computes the Van Hove correlation function.",
"The Van Hove G(r,t) is the probability that a particle that is at r0",
"at time zero can be found at position r0+r at time t.",
"g_vanhove determines G not for a vector r, but for the length of r.",
"Thus it gives the probability that a particle moves a distance of r",
"in time t.",
"Jumps across the periodic boundaries are removed.",
"Corrections are made for scaling due to isotropic",
"or anisotropic pressure coupling.",
"[PAR]",
"With option [TT]-om[tt] the whole matrix can be written as a function",
"of t and r or as a function of sqrt(t) and r (option [TT]-sqrt[tt]).",
"[PAR]",
"With option [TT]-or[tt] the Van Hove function is plotted for one",
"or more values of t. Option [TT]-nr[tt] sets the number of times,",
"option [TT]-fr[tt] the number spacing between the times.",
"The binwidth is set with option [TT]-rbin[tt]. The number of bins",
"is determined automatically.",
"[PAR]",
"With option [TT]-ot[tt] the integral up to a certain distance",
"(option [TT]-rt[tt]) is plotted as a function of time.",
"[PAR]",
"For all frames that are read the coordinates of the selected particles",
"are stored in memory. Therefore the program may use a lot of memory.",
"For options [TT]-om[tt] and [TT]-ot[tt] the program may be slow.",
"This is because the calculation scales as the number of frames times",
"[TT]-fm[tt] or [TT]-ft[tt].",
"Note that with the [TT]-dt[tt] option the memory usage and calculation",
"time can be reduced."
};
static int fmmax=0,ftmax=0,nlev=81,nr=1,fshift=0;
static real sbin=0,rmax=2,rbin=0.01,mmax=0,rint=0;
t_pargs pa[] = {
{ "-sqrt", FALSE, etREAL,{&sbin},
"Use sqrt(t) on the matrix axis which binspacing # in sqrt(ps)" },
{ "-fm", FALSE, etINT, {&fmmax},
"Number of frames in the matrix, 0 is plot all" },
{ "-rmax", FALSE, etREAL, {&rmax},
"Maximum r in the matrix (nm)" },
{ "-rbin", FALSE, etREAL, {&rbin},
"Binwidth in the matrix and for -or (nm)" },
{ "-mmax", FALSE, etREAL, {&mmax},
"Maximum density in the matrix, 0 is calculate (1/nm)" },
{ "-nlevels" ,FALSE, etINT, {&nlev},
"Number of levels in the matrix" },
{ "-nr", FALSE, etINT, {&nr},
"Number of curves for the -or output" },
{ "-fr", FALSE, etINT, {&fshift},
"Frame spacing for the -or output" },
{ "-rt", FALSE, etREAL, {&rint},
"Integration limit for the -ot output (nm)" },
{ "-ft", FALSE, etINT, {&ftmax},
"Number of frames in the -ot output, 0 is plot all" }
};
#define NPA asize(pa)
t_filenm fnm[] = {
{ efTRX, NULL, NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXPM, "-om", "vanhove", ffOPTWR },
{ efXVG, "-or", "vanhove_r", ffOPTWR },
{ efXVG, "-ot", "vanhove_t", ffOPTWR }
};
#define NFILE asize(fnm)
output_env_t oenv;
const char *matfile,*otfile,*orfile;
char title[256];
t_topology top;
int ePBC;
matrix boxtop,box,*sbox,avbox,corr;
rvec *xtop,*x,**sx;
int isize,nalloc,nallocn,natom;
t_trxstatus *status;
atom_id *index;
char *grpname;
int nfr,f,ff,i,m,mat_nx=0,nbin=0,bin,mbin,fbin;
real *time,t,invbin=0,rmax2=0,rint2=0,d2;
real invsbin=0,matmax,normfac,dt,*tickx,*ticky;
char buf[STRLEN],**legend;
real **mat=NULL;
int *pt=NULL,**pr=NULL,*mcount=NULL,*tcount=NULL,*rcount=NULL;
FILE *fp;
t_rgb rlo={1,1,1}, rhi={0,0,0};
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_VIEW | PCA_CAN_TIME | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL,&oenv);
matfile = opt2fn_null("-om",NFILE,fnm);
if (opt2parg_bSet("-fr",NPA,pa))
orfile = opt2fn("-or",NFILE,fnm);
else
orfile = opt2fn_null("-or",NFILE,fnm);
if (opt2parg_bSet("-rt",NPA,pa))
otfile = opt2fn("-ot",NFILE,fnm);
else
otfile = opt2fn_null("-ot",NFILE,fnm);
if (!matfile && !otfile && !orfile) {
fprintf(stderr,
"For output set one (or more) of the output file options\n");
exit(0);
}
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xtop,NULL,boxtop,
FALSE);
get_index(&top.atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&isize,&index,&grpname);
nalloc = 0;
time = NULL;
sbox = NULL;
sx = NULL;
clear_mat(avbox);
natom=read_first_x(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
nfr = 0;
do {
if (nfr >= nalloc) {
nalloc += 100;
srenew(time,nalloc);
srenew(sbox,nalloc);
srenew(sx,nalloc);
}
time[nfr] = t;
copy_mat(box,sbox[nfr]);
/* This assumes that the off-diagonal box elements
* are not affected by jumps across the periodic boundaries.
*/
m_add(avbox,box,avbox);
snew(sx[nfr],isize);
for(i=0; i<isize; i++)
copy_rvec(x[index[i]],sx[nfr][i]);
nfr++;
} while (read_next_x(oenv,status,&t,natom,x,box));
/* clean up */
sfree(x);
close_trj(status);
fprintf(stderr,"Read %d frames\n",nfr);
dt = (time[nfr-1] - time[0])/(nfr - 1);
/* Some ugly rounding to get nice nice times in the output */
dt = (int)(10000.0*dt + 0.5)/10000.0;
invbin = 1.0/rbin;
if (matfile) {
if (fmmax <= 0 || fmmax >= nfr)
fmmax = nfr - 1;
snew(mcount,fmmax);
nbin = (int)(rmax*invbin + 0.5);
if (sbin == 0) {
mat_nx = fmmax + 1;
} else {
invsbin = 1.0/sbin;
mat_nx = sqrt(fmmax*dt)*invsbin + 1;
}
snew(mat,mat_nx);
for(f=0; f<mat_nx; f++)
snew(mat[f],nbin);
rmax2 = sqr(nbin*rbin);
/* Initialize time zero */
mat[0][0] = nfr*isize;
mcount[0] += nfr;
} else {
fmmax = 0;
}
if (orfile) {
snew(pr,nr);
nalloc = 0;
snew(rcount,nr);
}
if (otfile) {
if (ftmax <= 0)
ftmax = nfr - 1;
snew(tcount,ftmax);
snew(pt,nfr);
rint2 = rint*rint;
/* Initialize time zero */
pt[0] = nfr*isize;
tcount[0] += nfr;
} else {
ftmax = 0;
}
msmul(avbox,1.0/nfr,avbox);
for(f=0; f<nfr; f++) {
if (f % 100 == 0)
fprintf(stderr,"\rProcessing frame %d",f);
/* Scale all the configuration to the average box */
m_inv_ur0(sbox[f],corr);
mmul_ur0(avbox,corr,corr);
for(i=0; i<isize; i++) {
mvmul_ur0(corr,sx[f][i],sx[f][i]);
if (f > 0) {
/* Correct for periodic jumps */
for(m=DIM-1; m>=0; m--) {
while(sx[f][i][m] - sx[f-1][i][m] > 0.5*avbox[m][m])
rvec_dec(sx[f][i],avbox[m]);
while(sx[f][i][m] - sx[f-1][i][m] <= -0.5*avbox[m][m])
rvec_inc(sx[f][i],avbox[m]);
}
}
}
for(ff=0; ff<f; ff++) {
fbin = f - ff;
if (fbin <= fmmax || fbin <= ftmax) {
if (sbin == 0)
mbin = fbin;
else
mbin = (int)(sqrt(fbin*dt)*invsbin + 0.5);
for(i=0; i<isize; i++) {
d2 = distance2(sx[f][i],sx[ff][i]);
if (mbin < mat_nx && d2 < rmax2) {
bin = (int)(sqrt(d2)*invbin + 0.5);
if (bin < nbin) {
mat[mbin][bin] += 1;
}
}
if (fbin <= ftmax && d2 <= rint2)
pt[fbin]++;
}
if (matfile)
mcount[mbin]++;
if (otfile)
tcount[fbin]++;
}
}
if (orfile) {
for(fbin=0; fbin<nr; fbin++) {
ff = f - (fbin + 1)*fshift;
if (ff >= 0) {
for(i=0; i<isize; i++) {
d2 = distance2(sx[f][i],sx[ff][i]);
bin = (int)(sqrt(d2)*invbin);
if (bin >= nalloc) {
nallocn = 10*(bin/10) + 11;
for(m=0; m<nr; m++) {
srenew(pr[m],nallocn);
for(i=nalloc; i<nallocn; i++)
pr[m][i] = 0;
}
nalloc = nallocn;
}
pr[fbin][bin]++;
}
rcount[fbin]++;
}
}
}
}
fprintf(stderr,"\n");
if (matfile) {
matmax = 0;
for(f=0; f<mat_nx; f++) {
normfac = 1.0/(mcount[f]*isize*rbin);
for(i=0; i<nbin; i++) {
mat[f][i] *= normfac;
if (mat[f][i] > matmax && (f!=0 || i!=0))
matmax = mat[f][i];
}
}
fprintf(stdout,"Value at (0,0): %.3f, maximum of the rest %.3f\n",
mat[0][0],matmax);
if (mmax > 0)
matmax = mmax;
snew(tickx,mat_nx);
for(f=0; f<mat_nx; f++) {
if (sbin == 0)
tickx[f] = f*dt;
else
tickx[f] = f*sbin;
}
snew(ticky,nbin+1);
for(i=0; i<=nbin; i++)
ticky[i] = i*rbin;
fp = ffopen(matfile,"w");
write_xpm(fp,MAT_SPATIAL_Y,"Van Hove function","G (1/nm)",
sbin==0 ? "time (ps)" : "sqrt(time) (ps^1/2)","r (nm)",
mat_nx,nbin,tickx,ticky,mat,0,matmax,rlo,rhi,&nlev);
ffclose(fp);
}
if (orfile) {
fp = xvgropen(orfile,"Van Hove function","r (nm)","G (nm\\S-1\\N)",oenv);
fprintf(fp,"@ subtitle \"for particles in group %s\"\n",grpname);
snew(legend,nr);
for(fbin=0; fbin<nr; fbin++) {
sprintf(buf,"%g ps",(fbin + 1)*fshift*dt);
legend[fbin] = strdup(buf);
}
xvgr_legend(fp,nr,(const char**)legend,oenv);
for(i=0; i<nalloc; i++) {
fprintf(fp,"%g",i*rbin);
for(fbin=0; fbin<nr; fbin++)
fprintf(fp," %g",
(real)pr[fbin][i]/(rcount[fbin]*isize*rbin*(i==0 ? 0.5 : 1)));
fprintf(fp,"\n");
}
ffclose(fp);
}
if (otfile) {
sprintf(buf,"Probability of moving less than %g nm",rint);
fp = xvgropen(otfile,buf,"t (ps)","",oenv);
fprintf(fp,"@ subtitle \"for particles in group %s\"\n",grpname);
for(f=0; f<=ftmax; f++)
fprintf(fp,"%g %g\n",f*dt,(real)pt[f]/(tcount[f]*isize));
ffclose(fp);
}
do_view(oenv, matfile,NULL);
do_view(oenv, orfile,NULL);
do_view(oenv, otfile,NULL);
thanx(stderr);
return 0;
}
/* Estimate the reciprocal space part error of the SPME Ewald sum. */
static real estimate_reciprocal(
t_inputinfo *info,
rvec x[], /* array of particles */
real q[], /* array of charges */
int nr, /* number of charges = size of the charge array */
FILE *fp_out,
gmx_bool bVerbose,
unsigned int seed, /* The seed for the random number generator */
int *nsamples, /* Return the number of samples used if Monte Carlo
* algorithm is used for self energy error estimate */
t_commrec *cr)
{
real e_rec=0; /* reciprocal error estimate */
real e_rec1=0; /* Error estimate term 1*/
real e_rec2=0; /* Error estimate term 2*/
real e_rec3=0; /* Error estimate term 3 */
real e_rec3x=0; /* part of Error estimate term 3 in x */
real e_rec3y=0; /* part of Error estimate term 3 in y */
real e_rec3z=0; /* part of Error estimate term 3 in z */
int i,ci;
int nx,ny,nz; /* grid coordinates */
real q2_all=0; /* sum of squared charges */
rvec gridpx; /* reciprocal grid point in x direction*/
rvec gridpxy; /* reciprocal grid point in x and y direction*/
rvec gridp; /* complete reciprocal grid point in 3 directions*/
rvec tmpvec; /* template to create points from basis vectors */
rvec tmpvec2; /* template to create points from basis vectors */
real coeff=0; /* variable to compute coefficients of the error estimate */
real coeff2=0; /* variable to compute coefficients of the error estimate */
real tmp=0; /* variables to compute different factors from vectors */
real tmp1=0;
real tmp2=0;
gmx_bool bFraction;
/* Random number generator */
gmx_rng_t rng=NULL;
int *numbers=NULL;
/* Index variables for parallel work distribution */
int startglobal,stopglobal;
int startlocal, stoplocal;
int x_per_core;
int xtot;
#ifdef TAKETIME
double t0=0.0;
double t1=0.0;
#endif
rng=gmx_rng_init(seed);
clear_rvec(gridpx);
clear_rvec(gridpxy);
clear_rvec(gridp);
clear_rvec(tmpvec);
clear_rvec(tmpvec2);
for(i=0;i<nr;i++)
{
q2_all += q[i]*q[i];
}
/* Calculate indices for work distribution */
startglobal=-info->nkx[0]/2;
stopglobal = info->nkx[0]/2;
xtot = stopglobal*2+1;
if (PAR(cr))
{
x_per_core = ceil((real)xtot / (real)cr->nnodes);
startlocal = startglobal + x_per_core*cr->nodeid;
stoplocal = startlocal + x_per_core -1;
if (stoplocal > stopglobal)
stoplocal = stopglobal;
}
else
{
startlocal = startglobal;
stoplocal = stopglobal;
x_per_core = xtot;
}
/*
#ifdef GMX_LIB_MPI
MPI_Barrier(MPI_COMM_WORLD);
#endif
*/
#ifdef GMX_LIB_MPI
#ifdef TAKETIME
if (MASTER(cr))
t0 = MPI_Wtime();
#endif
#endif
if (MASTER(cr)){
fprintf(stderr, "Calculating reciprocal error part 1 ...");
}
for(nx=startlocal; nx<=stoplocal; nx++)
{
svmul(nx,info->recipbox[XX],gridpx);
for(ny=-info->nky[0]/2; ny<info->nky[0]/2+1; ny++)
{
svmul(ny,info->recipbox[YY],tmpvec);
rvec_add(gridpx,tmpvec,gridpxy);
for(nz=-info->nkz[0]/2; nz<info->nkz[0]/2+1; nz++)
{
if ( 0 == nx && 0 == ny && 0 == nz )
continue;
svmul(nz,info->recipbox[ZZ],tmpvec);
rvec_add(gridpxy,tmpvec,gridp);
tmp=norm2(gridp);
coeff=exp(-1.0 * M_PI * M_PI * tmp / info->ewald_beta[0] / info->ewald_beta[0] ) ;
coeff/= 2.0 * M_PI * info->volume * tmp;
coeff2=tmp ;
tmp=eps_poly2(nx,info->nkx[0],info->pme_order[0]);
tmp+=eps_poly2(ny,info->nkx[0],info->pme_order[0]);
tmp+=eps_poly2(nz,info->nkx[0],info->pme_order[0]);
tmp1=eps_poly1(nx,info->nkx[0],info->pme_order[0]);
tmp2=eps_poly1(ny,info->nky[0],info->pme_order[0]);
tmp+=2.0 * tmp1 * tmp2;
tmp1=eps_poly1(nz,info->nkz[0],info->pme_order[0]);
tmp2=eps_poly1(ny,info->nky[0],info->pme_order[0]);
tmp+=2.0 * tmp1 * tmp2;
tmp1=eps_poly1(nz,info->nkz[0],info->pme_order[0]);
tmp2=eps_poly1(nx,info->nkx[0],info->pme_order[0]);
tmp+=2.0 * tmp1 * tmp2;
tmp1=eps_poly1(nx,info->nkx[0],info->pme_order[0]);
tmp1+=eps_poly1(ny,info->nky[0],info->pme_order[0]);
tmp1+=eps_poly1(nz,info->nkz[0],info->pme_order[0]);
tmp+= tmp1 * tmp1;
e_rec1+= 32.0 * M_PI * M_PI * coeff * coeff * coeff2 * tmp * q2_all * q2_all / nr ;
tmp1=eps_poly3(nx,info->nkx[0],info->pme_order[0]);
tmp1*=info->nkx[0];
tmp2=iprod(gridp,info->recipbox[XX]);
tmp=tmp1*tmp2;
tmp1=eps_poly3(ny,info->nky[0],info->pme_order[0]);
tmp1*=info->nky[0];
tmp2=iprod(gridp,info->recipbox[YY]);
tmp+=tmp1*tmp2;
tmp1=eps_poly3(nz,info->nkz[0],info->pme_order[0]);
tmp1*=info->nkz[0];
tmp2=iprod(gridp,info->recipbox[ZZ]);
tmp+=tmp1*tmp2;
tmp*=4.0 * M_PI;
tmp1=eps_poly4(nx,info->nkx[0],info->pme_order[0]);
tmp1*=norm2(info->recipbox[XX]);
tmp1*=info->nkx[0] * info->nkx[0];
tmp+=tmp1;
tmp1=eps_poly4(ny,info->nky[0],info->pme_order[0]);
tmp1*=norm2(info->recipbox[YY]);
tmp1*=info->nky[0] * info->nky[0];
tmp+=tmp1;
tmp1=eps_poly4(nz,info->nkz[0],info->pme_order[0]);
tmp1*=norm2(info->recipbox[ZZ]);
tmp1*=info->nkz[0] * info->nkz[0];
tmp+=tmp1;
e_rec2+= 4.0 * coeff * coeff * tmp * q2_all * q2_all / nr ;
}
}
if (MASTER(cr))
fprintf(stderr, "\rCalculating reciprocal error part 1 ... %3.0f%%", 100.0*(nx-startlocal+1)/(x_per_core));
}
if (MASTER(cr))
fprintf(stderr, "\n");
/* Use just a fraction of all charges to estimate the self energy error term? */
bFraction = (info->fracself > 0.0) && (info->fracself < 1.0);
if (bFraction)
{
/* Here xtot is the number of samples taken for the Monte Carlo calculation
* of the average of term IV of equation 35 in Wang2010. Round up to a
* number of samples that is divisible by the number of nodes */
x_per_core = ceil(info->fracself * nr / (real)cr->nnodes);
xtot = x_per_core * cr->nnodes;
}
else
{
/* In this case we use all nr particle positions */
xtot = nr;
x_per_core = ceil( (real)xtot / (real)cr->nnodes );
}
startlocal = x_per_core * cr->nodeid;
stoplocal = min(startlocal + x_per_core, xtot); /* min needed if xtot == nr */
if (bFraction)
{
/* Make shure we get identical results in serial and parallel. Therefore,
* take the sample indices from a single, global random number array that
* is constructed on the master node and that only depends on the seed */
snew(numbers, xtot);
if (MASTER(cr))
{
for (i=0; i<xtot; i++)
{
numbers[i] = floor(gmx_rng_uniform_real(rng) * nr );
}
}
/* Broadcast the random number array to the other nodes */
if (PAR(cr))
{
nblock_bc(cr,xtot,numbers);
}
if (bVerbose && MASTER(cr))
{
fprintf(stdout, "Using %d sample%s to approximate the self interaction error term",
xtot, xtot==1?"":"s");
if (PAR(cr))
fprintf(stdout, " (%d sample%s per node)", x_per_core, x_per_core==1?"":"s");
fprintf(stdout, ".\n");
}
}
/* Return the number of positions used for the Monte Carlo algorithm */
*nsamples = xtot;
for(i=startlocal;i<stoplocal;i++)
{
e_rec3x=0;
e_rec3y=0;
e_rec3z=0;
if (bFraction)
{
/* Randomly pick a charge */
ci = numbers[i];
}
else
{
/* Use all charges */
ci = i;
}
/* for(nx=startlocal; nx<=stoplocal; nx++)*/
for(nx=-info->nkx[0]/2; nx<info->nkx[0]/2+1; nx++)
{
svmul(nx,info->recipbox[XX],gridpx);
for(ny=-info->nky[0]/2; ny<info->nky[0]/2+1; ny++)
{
svmul(ny,info->recipbox[YY],tmpvec);
rvec_add(gridpx,tmpvec,gridpxy);
for(nz=-info->nkz[0]/2; nz<info->nkz[0]/2+1; nz++)
{
if ( 0 == nx && 0 == ny && 0 == nz)
continue;
svmul(nz,info->recipbox[ZZ],tmpvec);
rvec_add(gridpxy,tmpvec,gridp);
tmp=norm2(gridp);
coeff=exp(-1.0 * M_PI * M_PI * tmp / info->ewald_beta[0] / info->ewald_beta[0] );
coeff/= tmp ;
e_rec3x+=coeff*eps_self(nx,info->nkx[0],info->recipbox[XX],info->pme_order[0],x[ci]);
e_rec3y+=coeff*eps_self(ny,info->nky[0],info->recipbox[YY],info->pme_order[0],x[ci]);
e_rec3z+=coeff*eps_self(nz,info->nkz[0],info->recipbox[ZZ],info->pme_order[0],x[ci]);
}
}
}
clear_rvec(tmpvec2);
svmul(e_rec3x,info->recipbox[XX],tmpvec);
rvec_inc(tmpvec2,tmpvec);
svmul(e_rec3y,info->recipbox[YY],tmpvec);
rvec_inc(tmpvec2,tmpvec);
svmul(e_rec3z,info->recipbox[ZZ],tmpvec);
rvec_inc(tmpvec2,tmpvec);
e_rec3 += q[ci]*q[ci]*q[ci]*q[ci]*norm2(tmpvec2) / ( xtot * M_PI * info->volume * M_PI * info->volume);
if (MASTER(cr)){
fprintf(stderr, "\rCalculating reciprocal error part 2 ... %3.0f%%",
100.0*(i+1)/stoplocal);
}
}
if (MASTER(cr))
fprintf(stderr, "\n");
#ifdef GMX_LIB_MPI
#ifdef TAKETIME
if (MASTER(cr))
{
t1= MPI_Wtime() - t0;
fprintf(fp_out, "Recip. err. est. took : %lf s\n", t1);
}
#endif
#endif
#ifdef DEBUG
if (PAR(cr))
{
fprintf(stderr, "Node %3d: nx=[%3d...%3d] e_rec3=%e\n",
cr->nodeid, startlocal, stoplocal, e_rec3);
}
#endif
if (PAR(cr))
{
gmx_sum(1,&e_rec1,cr);
gmx_sum(1,&e_rec2,cr);
gmx_sum(1,&e_rec3,cr);
}
/* e_rec1*=8.0 * q2_all / info->volume / info->volume / nr ;
e_rec2*= q2_all / M_PI / M_PI / info->volume / info->volume / nr ;
e_rec3/= M_PI * M_PI * info->volume * info->volume * nr ;
*/
e_rec=sqrt(e_rec1+e_rec2+e_rec3);
return ONE_4PI_EPS0 * e_rec;
}
int gmx_editconf(int argc, char *argv[])
{
const char
*desc[] =
{
"editconf converts generic structure format to [TT].gro[tt], [TT].g96[tt]",
"or [TT].pdb[tt].",
"[PAR]",
"The box can be modified with options [TT]-box[tt], [TT]-d[tt] and",
"[TT]-angles[tt]. Both [TT]-box[tt] and [TT]-d[tt]",
"will center the system in the box, unless [TT]-noc[tt] is used.",
"[PAR]",
"Option [TT]-bt[tt] determines the box type: [TT]triclinic[tt] is a",
"triclinic box, [TT]cubic[tt] is a rectangular box with all sides equal",
"[TT]dodecahedron[tt] represents a rhombic dodecahedron and",
"[TT]octahedron[tt] is a truncated octahedron.",
"The last two are special cases of a triclinic box.",
"The length of the three box vectors of the truncated octahedron is the",
"shortest distance between two opposite hexagons.",
"The volume of a dodecahedron is 0.71 and that of a truncated octahedron",
"is 0.77 of that of a cubic box with the same periodic image distance.",
"[PAR]",
"Option [TT]-box[tt] requires only",
"one value for a cubic box, dodecahedron and a truncated octahedron.",
"[PAR]",
"With [TT]-d[tt] and a [TT]triclinic[tt] box the size of the system in the x, y",
"and z directions is used. With [TT]-d[tt] and [TT]cubic[tt],",
"[TT]dodecahedron[tt] or [TT]octahedron[tt] boxes, the dimensions are set",
"to the diameter of the system (largest distance between atoms) plus twice",
"the specified distance.",
"[PAR]",
"Option [TT]-angles[tt] is only meaningful with option [TT]-box[tt] and",
"a triclinic box and can not be used with option [TT]-d[tt].",
"[PAR]",
"When [TT]-n[tt] or [TT]-ndef[tt] is set, a group",
"can be selected for calculating the size and the geometric center,",
"otherwise the whole system is used.",
"[PAR]",
"[TT]-rotate[tt] rotates the coordinates and velocities.",
"[PAR]",
"[TT]-princ[tt] aligns the principal axes of the system along the",
"coordinate axes, this may allow you to decrease the box volume,",
"but beware that molecules can rotate significantly in a nanosecond.",
"[PAR]",
"Scaling is applied before any of the other operations are",
"performed. Boxes and coordinates can be scaled to give a certain density (option",
"[TT]-density[tt]). Note that this may be inaccurate in case a gro",
"file is given as input. A special feature of the scaling option, when the",
"factor -1 is given in one dimension, one obtains a mirror image,",
"mirrored in one of the plains, when one uses -1 in three dimensions",
"a point-mirror image is obtained.[PAR]",
"Groups are selected after all operations have been applied.[PAR]",
"Periodicity can be removed in a crude manner.",
"It is important that the box sizes at the bottom of your input file",
"are correct when the periodicity is to be removed.",
"[PAR]",
"When writing [TT].pdb[tt] files, B-factors can be",
"added with the [TT]-bf[tt] option. B-factors are read",
"from a file with with following format: first line states number of",
"entries in the file, next lines state an index",
"followed by a B-factor. The B-factors will be attached per residue",
"unless an index is larger than the number of residues or unless the",
"[TT]-atom[tt] option is set. Obviously, any type of numeric data can",
"be added instead of B-factors. [TT]-legend[tt] will produce",
"a row of CA atoms with B-factors ranging from the minimum to the",
"maximum value found, effectively making a legend for viewing.",
"[PAR]",
"With the option -mead a special pdb (pqr) file for the MEAD electrostatics",
"program (Poisson-Boltzmann solver) can be made. A further prerequisite",
"is that the input file is a run input file.",
"The B-factor field is then filled with the Van der Waals radius",
"of the atoms while the occupancy field will hold the charge.",
"[PAR]",
"The option -grasp is similar, but it puts the charges in the B-factor",
"and the radius in the occupancy.",
"[PAR]",
"Option [TT]-align[tt] allows alignment",
"of the principal axis of a specified group against the given vector, ",
"with an optional center of rotation specified by [TT]-aligncenter[tt].",
"[PAR]",
"Finally with option [TT]-label[tt] editconf can add a chain identifier",
"to a pdb file, which can be useful for analysis with e.g. rasmol.",
"[PAR]",
"To convert a truncated octrahedron file produced by a package which uses",
"a cubic box with the corners cut off (such as Gromos) use:[BR]",
"[TT]editconf -f <in> -rotate 0 45 35.264 -bt o -box <veclen> -o <out>[tt][BR]",
"where [TT]veclen[tt] is the size of the cubic box times sqrt(3)/2." };
const char *bugs[] =
{
"For complex molecules, the periodicity removal routine may break down, ",
"in that case you can use trjconv." };
static real dist = 0.0, rbox = 0.0, to_diam = 0.0;
static gmx_bool bNDEF = FALSE, bRMPBC = FALSE, bCenter = FALSE, bReadVDW =
FALSE, bCONECT = FALSE;
static gmx_bool peratom = FALSE, bLegend = FALSE, bOrient = FALSE, bMead =
FALSE, bGrasp = FALSE, bSig56 = FALSE;
static rvec scale =
{ 1, 1, 1 }, newbox =
{ 0, 0, 0 }, newang =
{ 90, 90, 90 };
static real rho = 1000.0, rvdw = 0.12;
static rvec center =
{ 0, 0, 0 }, translation =
{ 0, 0, 0 }, rotangles =
{ 0, 0, 0 }, aligncenter =
{ 0, 0, 0 }, targetvec =
{ 0, 0, 0 };
static const char *btype[] =
{ NULL, "triclinic", "cubic", "dodecahedron", "octahedron", NULL },
*label = "A";
static rvec visbox =
{ 0, 0, 0 };
t_pargs
pa[] =
{
{ "-ndef", FALSE, etBOOL,
{ &bNDEF }, "Choose output from default index groups" },
{ "-visbox", FALSE, etRVEC,
{ visbox },
"HIDDENVisualize a grid of boxes, -1 visualizes the 14 box images" },
{ "-bt", FALSE, etENUM,
{ btype }, "Box type for -box and -d" },
{ "-box", FALSE, etRVEC,
{ newbox }, "Box vector lengths (a,b,c)" },
{ "-angles", FALSE, etRVEC,
{ newang }, "Angles between the box vectors (bc,ac,ab)" },
{ "-d", FALSE, etREAL,
{ &dist }, "Distance between the solute and the box" },
{ "-c", FALSE, etBOOL,
{ &bCenter },
"Center molecule in box (implied by -box and -d)" },
{ "-center", FALSE, etRVEC,
{ center }, "Coordinates of geometrical center" },
{ "-aligncenter", FALSE, etRVEC,
{ aligncenter }, "Center of rotation for alignment" },
{ "-align", FALSE, etRVEC,
{ targetvec },
"Align to target vector" },
{ "-translate", FALSE, etRVEC,
{ translation }, "Translation" },
{ "-rotate", FALSE, etRVEC,
{ rotangles },
"Rotation around the X, Y and Z axes in degrees" },
{ "-princ", FALSE, etBOOL,
{ &bOrient },
"Orient molecule(s) along their principal axes" },
{ "-scale", FALSE, etRVEC,
{ scale }, "Scaling factor" },
{ "-density", FALSE, etREAL,
{ &rho },
"Density (g/l) of the output box achieved by scaling" },
{ "-pbc", FALSE, etBOOL,
{ &bRMPBC },
"Remove the periodicity (make molecule whole again)" },
{ "-grasp", FALSE, etBOOL,
{ &bGrasp },
"Store the charge of the atom in the B-factor field and the radius of the atom in the occupancy field" },
{
"-rvdw", FALSE, etREAL,
{ &rvdw },
"Default Van der Waals radius (in nm) if one can not be found in the database or if no parameters are present in the topology file" },
{ "-sig56", FALSE, etREAL,
{ &bSig56 },
"Use rmin/2 (minimum in the Van der Waals potential) rather than sigma/2 " },
{
"-vdwread", FALSE, etBOOL,
{ &bReadVDW },
"Read the Van der Waals radii from the file vdwradii.dat rather than computing the radii based on the force field" },
{ "-atom", FALSE, etBOOL,
{ &peratom }, "Force B-factor attachment per atom" },
{ "-legend", FALSE, etBOOL,
{ &bLegend }, "Make B-factor legend" },
{ "-label", FALSE, etSTR,
{ &label }, "Add chain label for all residues" },
{
"-conect", FALSE, etBOOL,
{ &bCONECT },
"Add CONECT records to a pdb file when written. Can only be done when a topology is present" } };
#define NPA asize(pa)
FILE *out;
const char *infile, *outfile;
char title[STRLEN];
int outftp, inftp, natom, i, j, n_bfac, itype, ntype;
double *bfac = NULL, c6, c12;
int *bfac_nr = NULL;
t_topology *top = NULL;
t_atoms atoms;
char *grpname, *sgrpname, *agrpname;
int isize, ssize, tsize, asize;
atom_id *index, *sindex, *tindex, *aindex;
rvec *x, *v, gc, min, max, size;
int ePBC;
matrix box,rotmatrix,trans;
rvec princd,tmpvec;
gmx_bool bIndex, bSetSize, bSetAng, bCubic, bDist, bSetCenter, bAlign;
gmx_bool bHaveV, bScale, bRho, bTranslate, bRotate, bCalcGeom, bCalcDiam;
real xs, ys, zs, xcent, ycent, zcent, diam = 0, mass = 0, d, vdw;
gmx_atomprop_t aps;
gmx_conect conect;
output_env_t oenv;
t_filenm fnm[] =
{
{ efSTX, "-f", NULL, ffREAD },
{ efNDX, "-n", NULL, ffOPTRD },
{ efSTO, NULL, NULL, ffOPTWR },
{ efPQR, "-mead", "mead", ffOPTWR },
{ efDAT, "-bf", "bfact", ffOPTRD } };
#define NFILE asize(fnm)
CopyRight(stderr, argv[0]);
parse_common_args(&argc, argv, PCA_CAN_VIEW, NFILE, fnm, NPA, pa,
asize(desc), desc, asize(bugs), bugs, &oenv);
bIndex = opt2bSet("-n", NFILE, fnm) || bNDEF;
bMead = opt2bSet("-mead", NFILE, fnm);
bSetSize = opt2parg_bSet("-box", NPA, pa);
bSetAng = opt2parg_bSet("-angles", NPA, pa);
bSetCenter = opt2parg_bSet("-center", NPA, pa);
bDist = opt2parg_bSet("-d", NPA, pa);
bAlign = opt2parg_bSet("-align", NPA, pa);
/* Only automatically turn on centering without -noc */
if ((bDist || bSetSize || bSetCenter) && !opt2parg_bSet("-c", NPA, pa))
{
bCenter = TRUE;
}
bScale = opt2parg_bSet("-scale", NPA, pa);
bRho = opt2parg_bSet("-density", NPA, pa);
bTranslate = opt2parg_bSet("-translate", NPA, pa);
bRotate = opt2parg_bSet("-rotate", NPA, pa);
if (bScale && bRho)
fprintf(stderr, "WARNING: setting -density overrides -scale\n");
bScale = bScale || bRho;
bCalcGeom = bCenter || bRotate || bOrient || bScale;
bCalcDiam = btype[0][0] == 'c' || btype[0][0] == 'd' || btype[0][0] == 'o';
infile = ftp2fn(efSTX, NFILE, fnm);
if (bMead)
outfile = ftp2fn(efPQR, NFILE, fnm);
else
outfile = ftp2fn(efSTO, NFILE, fnm);
outftp = fn2ftp(outfile);
inftp = fn2ftp(infile);
aps = gmx_atomprop_init();
if (bMead && bGrasp)
{
printf("Incompatible options -mead and -grasp. Turning off -grasp\n");
bGrasp = FALSE;
}
if (bGrasp && (outftp != efPDB))
gmx_fatal(FARGS, "Output file should be a .pdb file"
" when using the -grasp option\n");
if ((bMead || bGrasp) && !((fn2ftp(infile) == efTPR) ||
(fn2ftp(infile) == efTPA) ||
(fn2ftp(infile) == efTPB)))
gmx_fatal(FARGS,"Input file should be a .tp[abr] file"
" when using the -mead option\n");
get_stx_coordnum(infile,&natom);
init_t_atoms(&atoms,natom,TRUE);
snew(x,natom);
snew(v,natom);
read_stx_conf(infile,title,&atoms,x,v,&ePBC,box);
if (fn2ftp(infile) == efPDB)
{
get_pdb_atomnumber(&atoms,aps);
}
printf("Read %d atoms\n",atoms.nr);
/* Get the element numbers if available in a pdb file */
if (fn2ftp(infile) == efPDB)
get_pdb_atomnumber(&atoms,aps);
if (ePBC != epbcNONE)
{
real vol = det(box);
printf("Volume: %g nm^3, corresponds to roughly %d electrons\n",
vol,100*((int)(vol*4.5)));
}
if (bMead || bGrasp || bCONECT)
top = read_top(infile,NULL);
if (bMead || bGrasp)
{
if (atoms.nr != top->atoms.nr)
gmx_fatal(FARGS,"Atom numbers don't match (%d vs. %d)",atoms.nr,top->atoms.nr);
snew(atoms.pdbinfo,top->atoms.nr);
ntype = top->idef.atnr;
for(i=0; (i<atoms.nr); i++) {
/* Determine the Van der Waals radius from the force field */
if (bReadVDW) {
if (!gmx_atomprop_query(aps,epropVDW,
*top->atoms.resinfo[top->atoms.atom[i].resind].name,
*top->atoms.atomname[i],&vdw))
vdw = rvdw;
}
else {
itype = top->atoms.atom[i].type;
c12 = top->idef.iparams[itype*ntype+itype].lj.c12;
c6 = top->idef.iparams[itype*ntype+itype].lj.c6;
if ((c6 != 0) && (c12 != 0)) {
real sig6;
if (bSig56)
sig6 = 2*c12/c6;
else
sig6 = c12/c6;
vdw = 0.5*pow(sig6,1.0/6.0);
}
else
vdw = rvdw;
}
/* Factor of 10 for nm -> Angstroms */
vdw *= 10;
if (bMead) {
atoms.pdbinfo[i].occup = top->atoms.atom[i].q;
atoms.pdbinfo[i].bfac = vdw;
}
else {
atoms.pdbinfo[i].occup = vdw;
atoms.pdbinfo[i].bfac = top->atoms.atom[i].q;
}
}
}
bHaveV=FALSE;
for (i=0; (i<natom) && !bHaveV; i++)
for (j=0; (j<DIM) && !bHaveV; j++)
bHaveV=bHaveV || (v[i][j]!=0);
printf("%selocities found\n",bHaveV?"V":"No v");
if (visbox[0] > 0) {
if (bIndex)
gmx_fatal(FARGS,"Sorry, can not visualize box with index groups");
if (outftp != efPDB)
gmx_fatal(FARGS,"Sorry, can only visualize box with a pdb file");
} else if (visbox[0] == -1)
visualize_images("images.pdb",ePBC,box);
/* remove pbc */
if (bRMPBC)
rm_gropbc(&atoms,x,box);
if (bCalcGeom) {
if (bIndex) {
fprintf(stderr,"\nSelect a group for determining the system size:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&ssize,&sindex,&sgrpname);
} else {
ssize = atoms.nr;
sindex = NULL;
}
diam=calc_geom(ssize,sindex,x,gc,min,max,bCalcDiam);
rvec_sub(max, min, size);
printf(" system size :%7.3f%7.3f%7.3f (nm)\n",
size[XX], size[YY], size[ZZ]);
if (bCalcDiam)
printf(" diameter :%7.3f (nm)\n",diam);
printf(" center :%7.3f%7.3f%7.3f (nm)\n", gc[XX], gc[YY], gc[ZZ]);
printf(" box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf(" box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[YY],box[ZZ])),
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[ZZ])),
norm2(box[YY])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[YY])));
printf(" box volume :%7.2f (nm^3)\n",det(box));
}
if (bRho || bOrient || bAlign)
mass = calc_mass(&atoms,!fn2bTPX(infile),aps);
if (bOrient) {
atom_id *index;
char *grpnames;
/* Get a group for principal component analysis */
fprintf(stderr,"\nSelect group for the determining the orientation\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&isize,&index,&grpnames);
/* Orient the principal axes along the coordinate axes */
orient_princ(&atoms,isize,index,natom,x,bHaveV ? v : NULL, NULL);
sfree(index);
sfree(grpnames);
}
if ( bScale ) {
/* scale coordinates and box */
if (bRho) {
/* Compute scaling constant */
real vol,dens;
vol = det(box);
dens = (mass*AMU)/(vol*NANO*NANO*NANO);
fprintf(stderr,"Volume of input %g (nm^3)\n",vol);
fprintf(stderr,"Mass of input %g (a.m.u.)\n",mass);
fprintf(stderr,"Density of input %g (g/l)\n",dens);
if (vol==0 || mass==0)
gmx_fatal(FARGS,"Cannot scale density with "
"zero mass (%g) or volume (%g)\n",mass,vol);
scale[XX] = scale[YY] = scale[ZZ] = pow(dens/rho,1.0/3.0);
fprintf(stderr,"Scaling all box vectors by %g\n",scale[XX]);
}
scale_conf(atoms.nr,x,box,scale);
}
if (bAlign) {
if (bIndex) {
fprintf(stderr,"\nSelect a group that you want to align:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&asize,&aindex,&agrpname);
} else {
asize = atoms.nr;
snew(aindex,asize);
for (i=0;i<asize;i++)
aindex[i]=i;
}
printf("Aligning %d atoms (out of %d) to %g %g %g, center of rotation %g %g %g\n",asize,natom,
targetvec[XX],targetvec[YY],targetvec[ZZ],
aligncenter[XX],aligncenter[YY],aligncenter[ZZ]);
/*subtract out pivot point*/
for(i=0; i<asize; i++)
rvec_dec(x[aindex[i]],aligncenter);
/*now determine transform and rotate*/
/*will this work?*/
principal_comp(asize,aindex,atoms.atom,x, trans,princd);
unitv(targetvec,targetvec);
printf("Using %g %g %g as principal axis\n", trans[0][2],trans[1][2],trans[2][2]);
tmpvec[XX]=trans[0][2]; tmpvec[YY]=trans[1][2]; tmpvec[ZZ]=trans[2][2];
calc_rotmatrix(tmpvec, targetvec, rotmatrix);
/* rotmatrix finished */
for (i=0;i<asize;++i)
{
mvmul(rotmatrix,x[aindex[i]],tmpvec);
copy_rvec(tmpvec,x[aindex[i]]);
}
/*add pivot point back*/
for(i=0; i<asize; i++)
rvec_inc(x[aindex[i]],aligncenter);
if (!bIndex)
sfree(aindex);
}
if (bTranslate) {
if (bIndex) {
fprintf(stderr,"\nSelect a group that you want to translate:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&ssize,&sindex,&sgrpname);
} else {
ssize = atoms.nr;
sindex = NULL;
}
printf("Translating %d atoms (out of %d) by %g %g %g nm\n",ssize,natom,
translation[XX],translation[YY],translation[ZZ]);
if (sindex) {
for(i=0; i<ssize; i++)
rvec_inc(x[sindex[i]],translation);
}
else {
for(i=0; i<natom; i++)
rvec_inc(x[i],translation);
}
}
if (bRotate) {
/* Rotate */
printf("Rotating %g, %g, %g degrees around the X, Y and Z axis respectively\n",rotangles[XX],rotangles[YY],rotangles[ZZ]);
for(i=0; i<DIM; i++)
rotangles[i] *= DEG2RAD;
rotate_conf(natom,x,v,rotangles[XX],rotangles[YY],rotangles[ZZ]);
}
if (bCalcGeom) {
/* recalc geometrical center and max and min coordinates and size */
calc_geom(ssize,sindex,x,gc,min,max,FALSE);
rvec_sub(max, min, size);
if (bScale || bOrient || bRotate)
printf("new system size : %6.3f %6.3f %6.3f\n",
size[XX],size[YY],size[ZZ]);
}
if (bSetSize || bDist || (btype[0][0]=='t' && bSetAng)) {
ePBC = epbcXYZ;
if (!(bSetSize || bDist))
for (i=0; i<DIM; i++)
newbox[i] = norm(box[i]);
clear_mat(box);
/* calculate new boxsize */
switch(btype[0][0]){
case 't':
if (bDist)
for(i=0; i<DIM; i++)
newbox[i] = size[i]+2*dist;
if (!bSetAng) {
box[XX][XX] = newbox[XX];
box[YY][YY] = newbox[YY];
box[ZZ][ZZ] = newbox[ZZ];
} else {
matrix_convert(box,newbox,newang);
}
break;
case 'c':
case 'd':
case 'o':
if (bSetSize)
d = newbox[0];
else
d = diam+2*dist;
if (btype[0][0] == 'c')
for(i=0; i<DIM; i++)
box[i][i] = d;
else if (btype[0][0] == 'd') {
box[XX][XX] = d;
box[YY][YY] = d;
box[ZZ][XX] = d/2;
box[ZZ][YY] = d/2;
box[ZZ][ZZ] = d*sqrt(2)/2;
} else {
box[XX][XX] = d;
box[YY][XX] = d/3;
box[YY][YY] = d*sqrt(2)*2/3;
box[ZZ][XX] = -d/3;
box[ZZ][YY] = d*sqrt(2)/3;
box[ZZ][ZZ] = d*sqrt(6)/3;
}
break;
}
}
/* calculate new coords for geometrical center */
if (!bSetCenter)
calc_box_center(ecenterDEF,box,center);
/* center molecule on 'center' */
if (bCenter)
center_conf(natom,x,center,gc);
/* print some */
if (bCalcGeom) {
calc_geom(ssize,sindex,x, gc, min, max, FALSE);
printf("new center :%7.3f%7.3f%7.3f (nm)\n",gc[XX],gc[YY],gc[ZZ]);
}
if (bOrient || bScale || bDist || bSetSize) {
printf("new box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf("new box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[YY],box[ZZ])),
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[ZZ])),
norm2(box[YY])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[YY])));
printf("new box volume :%7.2f (nm^3)\n",det(box));
}
if (check_box(epbcXYZ,box))
printf("\nWARNING: %s\n",check_box(epbcXYZ,box));
if (bDist && btype[0][0]=='t')
{
if(TRICLINIC(box))
{
printf("\nWARNING: Your box is triclinic with non-orthogonal axes. In this case, the\n"
"distance from the solute to a box surface along the corresponding normal\n"
"vector might be somewhat smaller than your specified value %f.\n"
"You can check the actual value with g_mindist -pi\n",dist);
}
else
{
printf("\nWARNING: No boxtype specified - distance condition applied in each dimension.\n"
"If the molecule rotates the actual distance will be smaller. You might want\n"
"to use a cubic box instead, or why not try a dodecahedron today?\n");
}
}
if (bCONECT && (outftp == efPDB) && (inftp == efTPR))
conect = gmx_conect_generate(top);
else
conect = NULL;
if (bIndex) {
fprintf(stderr,"\nSelect a group for output:\n");
get_index(&atoms,opt2fn_null("-n",NFILE,fnm),
1,&isize,&index,&grpname);
if (opt2parg_bSet("-label",NPA,pa)) {
for(i=0; (i<atoms.nr); i++)
atoms.resinfo[atoms.atom[i].resind].chainid=label[0];
}
if (opt2bSet("-bf",NFILE,fnm) || bLegend)
{
gmx_fatal(FARGS,"Sorry, cannot do bfactors with an index group.");
}
if (outftp == efPDB)
{
out=ffopen(outfile,"w");
write_pdbfile_indexed(out,title,&atoms,x,ePBC,box,' ',1,isize,index,conect,TRUE);
ffclose(out);
}
else
{
write_sto_conf_indexed(outfile,title,&atoms,x,bHaveV?v:NULL,ePBC,box,isize,index);
}
}
else {
if ((outftp == efPDB) || (outftp == efPQR)) {
out=ffopen(outfile,"w");
if (bMead) {
set_pdb_wide_format(TRUE);
fprintf(out,"REMARK "
"The B-factors in this file hold atomic radii\n");
fprintf(out,"REMARK "
"The occupancy in this file hold atomic charges\n");
}
else if (bGrasp) {
fprintf(out,"GRASP PDB FILE\nFORMAT NUMBER=1\n");
fprintf(out,"REMARK "
"The B-factors in this file hold atomic charges\n");
fprintf(out,"REMARK "
"The occupancy in this file hold atomic radii\n");
}
else if (opt2bSet("-bf",NFILE,fnm)) {
read_bfac(opt2fn("-bf",NFILE,fnm),&n_bfac,&bfac,&bfac_nr);
set_pdb_conf_bfac(atoms.nr,atoms.nres,&atoms,
n_bfac,bfac,bfac_nr,peratom);
}
if (opt2parg_bSet("-label",NPA,pa)) {
for(i=0; (i<atoms.nr); i++)
atoms.resinfo[atoms.atom[i].resind].chainid=label[0];
}
write_pdbfile(out,title,&atoms,x,ePBC,box,' ',-1,conect,TRUE);
if (bLegend)
pdb_legend(out,atoms.nr,atoms.nres,&atoms,x);
if (visbox[0] > 0)
visualize_box(out,bLegend ? atoms.nr+12 : atoms.nr,
bLegend? atoms.nres=12 : atoms.nres,box,visbox);
ffclose(out);
}
else
write_sto_conf(outfile,title,&atoms,x,bHaveV?v:NULL,ePBC,box);
}
gmx_atomprop_destroy(aps);
do_view(oenv,outfile,NULL);
thanx(stderr);
return 0;
}
real RF_excl_correction(FILE *log,
const t_forcerec *fr,t_graph *g,
const t_mdatoms *mdatoms,const t_blocka *excl,
rvec x[],rvec f[],rvec *fshift,const t_pbc *pbc,
real lambda,real *dvdlambda)
{
/* Calculate the reaction-field energy correction for this node:
* epsfac q_i q_j (k_rf r_ij^2 - c_rf)
* and force correction for all excluded pairs, including self pairs.
*/
int top,i,j,j1,j2,k,ki;
double q2sumA,q2sumB,ener;
const real *chargeA,*chargeB;
real ek,ec,L1,qiA,qiB,qqA,qqB,qqL,v;
rvec dx,df;
atom_id *AA;
ivec dt;
int start = mdatoms->start;
int end = mdatoms->homenr+start;
int niat;
gmx_bool bMolPBC = fr->bMolPBC;
if (fr->n_tpi)
/* For test particle insertion we only correct for the test molecule */
start = mdatoms->nr - fr->n_tpi;
ek = fr->epsfac*fr->k_rf;
ec = fr->epsfac*fr->c_rf;
chargeA = mdatoms->chargeA;
chargeB = mdatoms->chargeB;
AA = excl->a;
ki = CENTRAL;
if (fr->bDomDec)
niat = excl->nr;
else
niat = end;
q2sumA = 0;
q2sumB = 0;
ener = 0;
if (mdatoms->nChargePerturbed == 0) {
for(i=start; i<niat; i++) {
qiA = chargeA[i];
if (i < end)
q2sumA += qiA*qiA;
/* Do the exclusions */
j1 = excl->index[i];
j2 = excl->index[i+1];
for(j=j1; j<j2; j++) {
k = AA[j];
if (k > i) {
qqA = qiA*chargeA[k];
if (qqA != 0) {
if (g) {
rvec_sub(x[i],x[k],dx);
ivec_sub(SHIFT_IVEC(g,i),SHIFT_IVEC(g,k),dt);
ki=IVEC2IS(dt);
} else if (bMolPBC) {
ki = pbc_dx_aiuc(pbc,x[i],x[k],dx);
} else
rvec_sub(x[i],x[k],dx);
ener += qqA*(ek*norm2(dx) - ec);
svmul(-2*qqA*ek,dx,df);
rvec_inc(f[i],df);
rvec_dec(f[k],df);
rvec_inc(fshift[ki],df);
rvec_dec(fshift[CENTRAL],df);
}
}
}
}
ener += -0.5*ec*q2sumA;
} else {
L1 = 1.0 - lambda;
for(i=start; i<niat; i++) {
qiA = chargeA[i];
qiB = chargeB[i];
if (i < end) {
q2sumA += qiA*qiA;
q2sumB += qiB*qiB;
}
/* Do the exclusions */
j1 = excl->index[i];
j2 = excl->index[i+1];
for(j=j1; j<j2; j++) {
k = AA[j];
if (k > i) {
qqA = qiA*chargeA[k];
qqB = qiB*chargeB[k];
if (qqA != 0 || qqB != 0) {
qqL = L1*qqA + lambda*qqB;
if (g) {
rvec_sub(x[i],x[k],dx);
ivec_sub(SHIFT_IVEC(g,i),SHIFT_IVEC(g,k),dt);
ki=IVEC2IS(dt);
} else if (bMolPBC) {
ki = pbc_dx_aiuc(pbc,x[i],x[k],dx);
} else
rvec_sub(x[i],x[k],dx);
v = ek*norm2(dx) - ec;
ener += qqL*v;
svmul(-2*qqL*ek,dx,df);
rvec_inc(f[i],df);
rvec_dec(f[k],df);
rvec_inc(fshift[ki],df);
rvec_dec(fshift[CENTRAL],df);
*dvdlambda += (qqB - qqA)*v;
}
}
}
}
ener += -0.5*ec*(L1*q2sumA + lambda*q2sumB);
*dvdlambda += -0.5*ec*(q2sumB - q2sumA);
}
if (debug)
fprintf(debug,"RF exclusion energy: %g\n",ener);
return ener;
}
int main(int argc,char *argv[])
{
const char *desc[] = {
"[TT]do_multiprot[tt] ",
"reads a trajectory file and aligns it to a reference structure ",
"each time frame",
"calling the multiprot program. This allows you to use a reference",
"structure whose sequence is different than that of the protein in the ",
"trajectory, since the alignment is based on the geometry, not sequence.",
"The output of [TT]do_multiprot[tt] includes the rmsd and the number of residues",
"on which it was calculated.",
"[PAR]",
"An aligned trajectory file is generated with the [TT]-ox[tt] option.[PAR]",
"With the [TT]-cr[tt] option, the number of hits in the alignment is given",
"per residue. This number can be between 0 and the number of frames, and",
"indicates the structural conservation of this residue.[PAR]",
"If you do not have the [TT]multiprot[tt] program, get it. [TT]do_multiprot[tt] assumes",
"that the [TT]multiprot[tt] executable is [TT]/usr/local/bin/multiprot[tt]. If this is ",
"not the case, then you should set an environment variable [BB]MULTIPROT[bb]",
"pointing to the [TT]multiprot[tt] executable, e.g.: [PAR]",
"[TT]setenv MULTIPROT /usr/MultiProtInstall/multiprot.Linux[tt][PAR]",
"Note that at the current implementation only binary alignment (your",
"molecule to a reference) is supported. In addition, note that the ",
"by default [TT]multiprot[tt] aligns the two proteins on their C-alpha carbons.",
"and that this depends on the [TT]multiprot[tt] parameters which are not dealt ",
"with here. Thus, the C-alpha carbons is expected to give the same "
"results as choosing the whole protein and will be slightly faster.[PAR]",
"For information about [TT]multiprot[tt], see:",
"http://bioinfo3d.cs.tau.ac.il/MultiProt/.[PAR]"
};
static bool bVerbose;
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"HIDDENGenerate miles of useless information" }
};
const char *bugs[] = {
"The program is very slow, since multiprot is run externally"
};
t_trxstatus *status;
t_trxstatus *trxout=NULL;
FILE *tapein,*fo,*frc,*tmpf,*out=NULL,*fres=NULL;
const char *fnRef;
const char *fn="2_sol.res";
t_topology top;
int ePBC;
t_atoms *atoms,ratoms,useatoms;
t_trxframe fr;
t_pdbinfo p;
int nres,nres2,nr0;
real t;
int i,j,natoms,nratoms,nframe=0,model_nr=-1;
int cur_res,prev_res;
int nout;
t_countres *countres=NULL;
matrix box,rbox;
int gnx;
char *grpnm,*ss_str;
atom_id *index;
rvec *xp,*x,*xr;
char pdbfile[32],refpdb[256],title[256],rtitle[256],filemode[5];
char out_title[256];
char multiprot[256],*mptr;
int ftp;
int outftp=-1;
real rmsd;
bool bTrjout,bCountres;
const char *TrjoutFile=NULL;
output_env_t oenv;
static rvec translation={0,0,0},rotangles={0,0,0};
gmx_rmpbc_t gpbc=NULL;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efSTX, "-r", NULL , ffREAD },
{ efXVG, "-o", "rmss", ffWRITE },
{ efXVG, "-rc", "rescount", ffWRITE},
{ efXVG, "-cr", "countres", ffOPTWR},
{ efTRX, "-ox", "aligned", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_TIME_UNIT,
NFILE,fnm, asize(pa),pa, asize(desc),desc,
asize(bugs),bugs,&oenv
);
fnRef=opt2fn("-r",NFILE,fnm);
bTrjout = opt2bSet("-ox",NFILE,fnm);
bCountres= opt2bSet("-cr",NFILE,fnm);
if (bTrjout) {
TrjoutFile = opt2fn_null("-ox",NFILE,fnm);
}
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xp,NULL,box,FALSE);
gpbc = gmx_rmpbc_init(&top.idef,ePBC,top.atoms.nr,box);
atoms=&(top.atoms);
ftp=fn2ftp(fnRef);
get_stx_coordnum(fnRef,&nratoms);
init_t_atoms(&ratoms,nratoms,TRUE);
snew(xr,nratoms);
read_stx_conf(fnRef,rtitle,&ratoms,xr,NULL,&ePBC,rbox);
if (bVerbose) {
fprintf(stderr,"Read %d atoms\n",atoms->nr);
fprintf(stderr,"Read %d reference atoms\n",ratoms.nr);
}
if (bCountres) {
snew(countres,ratoms.nres);
j=0;
cur_res=0;
for (i=0;i<ratoms.nr;i++) {
prev_res=cur_res;
cur_res=ratoms.atom[i].resind;
if (cur_res != prev_res) {
countres[j].resnr=cur_res;
countres[j].count=0;
j++;
}
}
}
get_index(atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&gnx,&index,&grpnm);
nres=0;
nr0=-1;
for(i=0; (i<gnx); i++) {
if (atoms->atom[index[i]].resind != nr0) {
nr0=atoms->atom[index[i]].resind;
nres++;
}
}
fprintf(stderr,"There are %d residues in your selected group\n",nres);
strcpy(pdbfile,"ddXXXXXX");
gmx_tmpnam(pdbfile);
if ((tmpf = fopen(pdbfile,"w")) == NULL) {
sprintf(pdbfile,"%ctmp%cfilterXXXXXX",DIR_SEPARATOR,DIR_SEPARATOR);
gmx_tmpnam(pdbfile);
if ((tmpf = fopen(pdbfile,"w")) == NULL) {
gmx_fatal(FARGS,"Can not open tmp file %s",pdbfile);
}
}
else {
gmx_ffclose(tmpf);
}
if (ftp != efPDB) {
strcpy(refpdb,"ddXXXXXX");
gmx_tmpnam(refpdb);
strcat(refpdb,".pdb");
write_sto_conf(refpdb,rtitle,&ratoms,xr,NULL,ePBC,rbox);
}
else {
strcpy(refpdb,fnRef);
}
if ((mptr=getenv("MULTIPROT")) == NULL) {
mptr="/usr/local/bin/multiprot";
}
if (!gmx_fexist(mptr)) {
gmx_fatal(FARGS,"MULTIPROT executable (%s) does not exist (use setenv MULTIPROT)",
mptr);
}
sprintf (multiprot,"%s %s %s > /dev/null %s",
mptr, refpdb, pdbfile, "2> /dev/null");
if (bVerbose)
fprintf(stderr,"multiprot cmd='%s'\n",multiprot);
if (!read_first_frame(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&fr,TRX_READ_X))
gmx_fatal(FARGS,"Could not read a frame from %s",ftp2fn(efTRX,NFILE,fnm));
natoms = fr.natoms;
if (bTrjout) {
nout=natoms;
/* open file now */
outftp=fn2ftp(TrjoutFile);
if (bVerbose)
fprintf(stderr,"Will write %s: %s\n",ftp2ext(ftp),ftp2desc(outftp));
strcpy(filemode,"w");
switch (outftp) {
case efXTC:
case efG87:
case efTRR:
case efTRJ:
out=NULL;
trxout = open_trx(TrjoutFile,filemode);
break;
case efGRO:
case efG96:
case efPDB:
/* Make atoms struct for output in GRO or PDB files */
/* get memory for stuff to go in pdb file */
init_t_atoms(&useatoms,nout,FALSE);
sfree(useatoms.resinfo);
useatoms.resinfo=atoms->resinfo;
for(i=0;(i<nout);i++) {
useatoms.atomname[i]=atoms->atomname[i];
useatoms.atom[i]=atoms->atom[i];
useatoms.nres=max(useatoms.nres,useatoms.atom[i].resind+1);
}
useatoms.nr=nout;
out=gmx_ffopen(TrjoutFile,filemode);
break;
}
}
if (natoms > atoms->nr) {
gmx_fatal(FARGS,"\nTrajectory does not match topology!");
}
if (gnx > natoms) {
gmx_fatal(FARGS,"\nTrajectory does not match selected group!");
}
fo = xvgropen(opt2fn("-o",NFILE,fnm),"RMSD","Time (ps)","RMSD (nm)",oenv);
frc = xvgropen(opt2fn("-rc",NFILE,fnm),"Number of Residues in the alignment","Time (ps)","Residues",oenv);
do {
t = output_env_conv_time(oenv,fr.time);
gmx_rmpbc(gpbc,natoms,fr.box,fr.x);
tapein=gmx_ffopen(pdbfile,"w");
write_pdbfile_indexed(tapein,NULL,atoms,fr.x,ePBC,fr.box,' ',-1,gnx,index,NULL,TRUE);
gmx_ffclose(tapein);
system(multiprot);
remove(pdbfile);
process_multiprot_output(fn, &rmsd, &nres2,rotangles,translation,bCountres,countres);
fprintf(fo,"%12.7f",t);
fprintf(fo," %12.7f\n",rmsd);
fprintf(frc,"%12.7f",t);
fprintf(frc,"%12d\n",nres2);
if (bTrjout) {
rotate_conf(natoms,fr.x,NULL,rotangles[XX],rotangles[YY],rotangles[ZZ]);
for(i=0; i<natoms; i++) {
rvec_inc(fr.x[i],translation);
}
switch(outftp) {
case efTRJ:
case efTRR:
case efG87:
case efXTC:
write_trxframe(trxout,&fr,NULL);
break;
case efGRO:
case efG96:
case efPDB:
sprintf(out_title,"Generated by do_multiprot : %s t= %g %s",
title,output_env_conv_time(oenv,fr.time),output_env_get_time_unit(oenv));
switch(outftp) {
case efGRO:
write_hconf_p(out,out_title,&useatoms,prec2ndec(fr.prec),
fr.x,NULL,fr.box);
break;
case efPDB:
fprintf(out,"REMARK GENERATED BY DO_MULTIPROT\n");
sprintf(out_title,"%s t= %g %s",title,output_env_conv_time(oenv,fr.time),output_env_get_time_unit(oenv));
/* if reading from pdb, we want to keep the original
model numbering else we write the output frame
number plus one, because model 0 is not allowed in pdb */
if (ftp==efPDB && fr.step > model_nr) {
model_nr = fr.step;
}
else {
model_nr++;
}
write_pdbfile(out,out_title,&useatoms,fr.x,ePBC,fr.box,' ',model_nr,NULL,TRUE);
break;
case efG96:
fr.title = out_title;
fr.bTitle = (nframe == 0);
fr.bAtoms = FALSE;
fr.bStep = TRUE;
fr.bTime = TRUE;
write_g96_conf(out,&fr,-1,NULL);
}
break;
}
}
nframe++;
} while(read_next_frame(oenv,status,&fr));
if (bCountres) {
fres= xvgropen(opt2fn("-cr",NFILE,fnm),"Number of frames in which the residues are aligned to","Residue","Number",oenv);
for (i=0;i<ratoms.nres;i++) {
fprintf(fres,"%10d %12d\n",countres[i].resnr,countres[i].count);
}
gmx_ffclose(fres);
}
gmx_ffclose(fo);
gmx_ffclose(frc);
fprintf(stderr,"\n");
close_trj(status);
if (trxout != NULL) {
close_trx(trxout);
}
else if (out != NULL) {
gmx_ffclose(out);
}
view_all(oenv,NFILE, fnm);
sfree(xr);
if (bCountres) {
sfree(countres);
}
free_t_atoms(&ratoms,TRUE);
if (bTrjout) {
if (outftp==efPDB || outftp==efGRO || outftp==efG96) {
free_t_atoms(&useatoms,TRUE);
}
}
gmx_thanx(stderr);
return 0;
}
/* There's nothing special to do here if just masses are perturbed,
* but if either charge or type is perturbed then the implementation
* requires that B states are defined for both charge and type, and
* does not optimize for the cases where only one changes.
*
* The parameter vectors for B states are left undefined in atoms2md()
* when either FEP is inactive, or when there are no mass/charge/type
* perturbations. The parameter vectors for LJ-PME are likewise
* undefined when LJ-PME is not active. This works because
* bHaveChargeOrTypePerturbed handles the control flow. */
void ewald_LRcorrection(int numAtomsLocal,
t_commrec *cr,
int numThreads, int thread,
t_forcerec *fr,
real *chargeA, real *chargeB,
real *C6A, real *C6B,
real *sigmaA, real *sigmaB,
real *sigma3A, real *sigma3B,
gmx_bool bHaveChargeOrTypePerturbed,
gmx_bool calc_excl_corr,
t_blocka *excl, rvec x[],
matrix box, rvec mu_tot[],
int ewald_geometry, real epsilon_surface,
rvec *f, tensor vir_q, tensor vir_lj,
real *Vcorr_q, real *Vcorr_lj,
real lambda_q, real lambda_lj,
real *dvdlambda_q, real *dvdlambda_lj)
{
int numAtomsToBeCorrected;
if (calc_excl_corr)
{
/* We need to correct all exclusion pairs (cutoff-scheme = group) */
numAtomsToBeCorrected = excl->nr;
GMX_RELEASE_ASSERT(numAtomsToBeCorrected >= numAtomsLocal, "We might need to do self-corrections");
}
else
{
/* We need to correct only self interactions */
numAtomsToBeCorrected = numAtomsLocal;
}
int start = (numAtomsToBeCorrected* thread )/numThreads;
int end = (numAtomsToBeCorrected*(thread + 1))/numThreads;
int i, i1, i2, j, k, m, iv, jv, q;
int *AA;
double Vexcl_q, dvdl_excl_q, dvdl_excl_lj; /* Necessary for precision */
double Vexcl_lj;
real one_4pi_eps;
real v, vc, qiA, qiB, dr2, rinv;
real Vself_q[2], Vself_lj[2], Vdipole[2], rinv2, ewc_q = fr->ewaldcoeff_q, ewcdr;
real ewc_lj = fr->ewaldcoeff_lj, ewc_lj2 = ewc_lj * ewc_lj;
real c6Ai = 0, c6Bi = 0, c6A = 0, c6B = 0, ewcdr2, ewcdr4, c6L = 0, rinv6;
rvec df, dx, mutot[2], dipcorrA, dipcorrB;
tensor dxdf_q = {{0}}, dxdf_lj = {{0}};
real vol = box[XX][XX]*box[YY][YY]*box[ZZ][ZZ];
real L1_q, L1_lj, dipole_coeff, qqA, qqB, qqL, vr0_q, vr0_lj = 0;
gmx_bool bMolPBC = fr->bMolPBC;
gmx_bool bDoingLBRule = (fr->ljpme_combination_rule == eljpmeLB);
gmx_bool bNeedLongRangeCorrection;
/* This routine can be made faster by using tables instead of analytical interactions
* However, that requires a thorough verification that they are correct in all cases.
*/
one_4pi_eps = ONE_4PI_EPS0/fr->epsilon_r;
vr0_q = ewc_q*M_2_SQRTPI;
if (EVDW_PME(fr->vdwtype))
{
vr0_lj = -gmx::power6(ewc_lj)/6.0;
}
AA = excl->a;
Vexcl_q = 0;
Vexcl_lj = 0;
dvdl_excl_q = 0;
dvdl_excl_lj = 0;
Vdipole[0] = 0;
Vdipole[1] = 0;
L1_q = 1.0-lambda_q;
L1_lj = 1.0-lambda_lj;
/* Note that we have to transform back to gromacs units, since
* mu_tot contains the dipole in debye units (for output).
*/
for (i = 0; (i < DIM); i++)
{
mutot[0][i] = mu_tot[0][i]*DEBYE2ENM;
mutot[1][i] = mu_tot[1][i]*DEBYE2ENM;
dipcorrA[i] = 0;
dipcorrB[i] = 0;
}
dipole_coeff = 0;
switch (ewald_geometry)
{
case eewg3D:
if (epsilon_surface != 0)
{
dipole_coeff =
2*M_PI*ONE_4PI_EPS0/((2*epsilon_surface + fr->epsilon_r)*vol);
for (i = 0; (i < DIM); i++)
{
dipcorrA[i] = 2*dipole_coeff*mutot[0][i];
dipcorrB[i] = 2*dipole_coeff*mutot[1][i];
}
}
break;
case eewg3DC:
dipole_coeff = 2*M_PI*one_4pi_eps/vol;
dipcorrA[ZZ] = 2*dipole_coeff*mutot[0][ZZ];
dipcorrB[ZZ] = 2*dipole_coeff*mutot[1][ZZ];
break;
default:
gmx_incons("Unsupported Ewald geometry");
break;
}
if (debug)
{
fprintf(debug, "dipcorr = %8.3f %8.3f %8.3f\n",
dipcorrA[XX], dipcorrA[YY], dipcorrA[ZZ]);
fprintf(debug, "mutot = %8.3f %8.3f %8.3f\n",
mutot[0][XX], mutot[0][YY], mutot[0][ZZ]);
}
bNeedLongRangeCorrection = (calc_excl_corr || dipole_coeff != 0);
if (bNeedLongRangeCorrection && !bHaveChargeOrTypePerturbed)
{
for (i = start; (i < end); i++)
{
/* Initiate local variables (for this i-particle) to 0 */
qiA = chargeA[i]*one_4pi_eps;
if (EVDW_PME(fr->vdwtype))
{
c6Ai = C6A[i];
if (bDoingLBRule)
{
c6Ai *= sigma3A[i];
}
}
if (calc_excl_corr)
{
i1 = excl->index[i];
i2 = excl->index[i+1];
/* Loop over excluded neighbours */
for (j = i1; (j < i2); j++)
{
k = AA[j];
/*
* First we must test whether k <> i, and then,
* because the exclusions are all listed twice i->k
* and k->i we must select just one of the two. As
* a minor optimization we only compute forces when
* the charges are non-zero.
*/
if (k > i)
{
qqA = qiA*chargeA[k];
if (EVDW_PME(fr->vdwtype))
{
c6A = c6Ai * C6A[k];
if (bDoingLBRule)
{
c6A *= gmx::power6(0.5*(sigmaA[i]+sigmaA[k]))*sigma3A[k];
}
}
if (qqA != 0.0 || c6A != 0.0)
{
rvec_sub(x[i], x[k], dx);
if (bMolPBC)
{
/* Cheap pbc_dx, assume excluded pairs are at short distance. */
for (m = DIM-1; (m >= 0); m--)
{
if (dx[m] > 0.5*box[m][m])
{
rvec_dec(dx, box[m]);
}
else if (dx[m] < -0.5*box[m][m])
{
rvec_inc(dx, box[m]);
}
}
}
dr2 = norm2(dx);
/* Distance between two excluded particles
* may be zero in the case of shells
*/
if (dr2 != 0)
{
rinv = gmx::invsqrt(dr2);
rinv2 = rinv*rinv;
if (qqA != 0.0)
{
real dr, fscal;
dr = 1.0/rinv;
ewcdr = ewc_q*dr;
vc = qqA*std::erf(ewcdr)*rinv;
Vexcl_q += vc;
#if GMX_DOUBLE
/* Relative accuracy at R_ERF_R_INACC of 3e-10 */
#define R_ERF_R_INACC 0.006
#else
/* Relative accuracy at R_ERF_R_INACC of 2e-5 */
#define R_ERF_R_INACC 0.1
#endif
/* fscal is the scalar force pre-multiplied by rinv,
* to normalise the relative position vector dx */
if (ewcdr > R_ERF_R_INACC)
{
fscal = rinv2*(vc - qqA*ewc_q*M_2_SQRTPI*exp(-ewcdr*ewcdr));
}
else
{
/* Use a fourth order series expansion for small ewcdr */
fscal = ewc_q*ewc_q*qqA*vr0_q*(2.0/3.0 - 0.4*ewcdr*ewcdr);
}
/* The force vector is obtained by multiplication with
* the relative position vector
*/
svmul(fscal, dx, df);
rvec_inc(f[k], df);
rvec_dec(f[i], df);
for (iv = 0; (iv < DIM); iv++)
{
for (jv = 0; (jv < DIM); jv++)
{
dxdf_q[iv][jv] += dx[iv]*df[jv];
}
}
}
if (c6A != 0.0)
{
real fscal;
rinv6 = rinv2*rinv2*rinv2;
ewcdr2 = ewc_lj2*dr2;
ewcdr4 = ewcdr2*ewcdr2;
/* We get the excluded long-range contribution from -C6*(1-g(r))
* g(r) is also defined in the manual under LJ-PME
*/
vc = -c6A*rinv6*(1.0 - exp(-ewcdr2)*(1 + ewcdr2 + 0.5*ewcdr4));
Vexcl_lj += vc;
/* The force is the derivative of the potential vc.
* fscal is the scalar force pre-multiplied by rinv,
* to normalise the relative position vector dx */
fscal = 6.0*vc*rinv2 + c6A*rinv6*exp(-ewcdr2)*ewc_lj2*ewcdr4;
/* The force vector is obtained by multiplication with
* the relative position vector
*/
svmul(fscal, dx, df);
rvec_inc(f[k], df);
rvec_dec(f[i], df);
for (iv = 0; (iv < DIM); iv++)
{
for (jv = 0; (jv < DIM); jv++)
{
dxdf_lj[iv][jv] += dx[iv]*df[jv];
}
}
}
}
else
{
Vexcl_q += qqA*vr0_q;
Vexcl_lj += c6A*vr0_lj;
}
}
}
}
}
/* Dipole correction on force */
if (dipole_coeff != 0 && i < numAtomsLocal)
{
for (j = 0; (j < DIM); j++)
{
f[i][j] -= dipcorrA[j]*chargeA[i];
}
}
}
}
else if (bNeedLongRangeCorrection)
{
for (i = start; (i < end); i++)
{
/* Initiate local variables (for this i-particle) to 0 */
qiA = chargeA[i]*one_4pi_eps;
qiB = chargeB[i]*one_4pi_eps;
if (EVDW_PME(fr->vdwtype))
{
c6Ai = C6A[i];
c6Bi = C6B[i];
if (bDoingLBRule)
{
c6Ai *= sigma3A[i];
c6Bi *= sigma3B[i];
}
}
if (calc_excl_corr)
{
i1 = excl->index[i];
i2 = excl->index[i+1];
/* Loop over excluded neighbours */
for (j = i1; (j < i2); j++)
{
k = AA[j];
if (k > i)
{
qqA = qiA*chargeA[k];
qqB = qiB*chargeB[k];
if (EVDW_PME(fr->vdwtype))
{
c6A = c6Ai*C6A[k];
c6B = c6Bi*C6B[k];
if (bDoingLBRule)
{
c6A *= gmx::power6(0.5*(sigmaA[i]+sigmaA[k]))*sigma3A[k];
c6B *= gmx::power6(0.5*(sigmaB[i]+sigmaB[k]))*sigma3B[k];
}
}
if (qqA != 0.0 || qqB != 0.0 || c6A != 0.0 || c6B != 0.0)
{
real fscal;
qqL = L1_q*qqA + lambda_q*qqB;
if (EVDW_PME(fr->vdwtype))
{
c6L = L1_lj*c6A + lambda_lj*c6B;
}
rvec_sub(x[i], x[k], dx);
if (bMolPBC)
{
/* Cheap pbc_dx, assume excluded pairs are at short distance. */
for (m = DIM-1; (m >= 0); m--)
{
if (dx[m] > 0.5*box[m][m])
{
rvec_dec(dx, box[m]);
}
else if (dx[m] < -0.5*box[m][m])
{
rvec_inc(dx, box[m]);
}
}
}
dr2 = norm2(dx);
if (dr2 != 0)
{
rinv = gmx::invsqrt(dr2);
rinv2 = rinv*rinv;
if (qqA != 0.0 || qqB != 0.0)
{
real dr;
dr = 1.0/rinv;
v = std::erf(ewc_q*dr)*rinv;
vc = qqL*v;
Vexcl_q += vc;
/* fscal is the scalar force pre-multiplied by rinv,
* to normalise the relative position vector dx */
fscal = rinv2*(vc-qqL*ewc_q*M_2_SQRTPI*exp(-ewc_q*ewc_q*dr2));
dvdl_excl_q += (qqB - qqA)*v;
/* The force vector is obtained by multiplication with
* the relative position vector
*/
svmul(fscal, dx, df);
rvec_inc(f[k], df);
rvec_dec(f[i], df);
for (iv = 0; (iv < DIM); iv++)
{
for (jv = 0; (jv < DIM); jv++)
{
dxdf_q[iv][jv] += dx[iv]*df[jv];
}
}
}
if ((c6A != 0.0 || c6B != 0.0) && EVDW_PME(fr->vdwtype))
{
rinv6 = rinv2*rinv2*rinv2;
ewcdr2 = ewc_lj2*dr2;
ewcdr4 = ewcdr2*ewcdr2;
v = -rinv6*(1.0 - exp(-ewcdr2)*(1 + ewcdr2 + 0.5*ewcdr4));
vc = c6L*v;
Vexcl_lj += vc;
/* fscal is the scalar force pre-multiplied by rinv,
* to normalise the relative position vector dx */
fscal = 6.0*vc*rinv2 + c6L*rinv6*exp(-ewcdr2)*ewc_lj2*ewcdr4;
dvdl_excl_lj += (c6B - c6A)*v;
/* The force vector is obtained by multiplication with
* the relative position vector
*/
svmul(fscal, dx, df);
rvec_inc(f[k], df);
rvec_dec(f[i], df);
for (iv = 0; (iv < DIM); iv++)
{
for (jv = 0; (jv < DIM); jv++)
{
dxdf_lj[iv][jv] += dx[iv]*df[jv];
}
}
}
}
else
{
Vexcl_q += qqL*vr0_q;
dvdl_excl_q += (qqB - qqA)*vr0_q;
Vexcl_lj += c6L*vr0_lj;
dvdl_excl_lj += (c6B - c6A)*vr0_lj;
}
}
}
}
}
/* Dipole correction on force */
if (dipole_coeff != 0 && i < numAtomsLocal)
{
for (j = 0; (j < DIM); j++)
{
f[i][j] -= L1_q*dipcorrA[j]*chargeA[i]
+ lambda_q*dipcorrB[j]*chargeB[i];
}
}
}
}
for (iv = 0; (iv < DIM); iv++)
{
for (jv = 0; (jv < DIM); jv++)
{
vir_q[iv][jv] += 0.5*dxdf_q[iv][jv];
vir_lj[iv][jv] += 0.5*dxdf_lj[iv][jv];
}
}
Vself_q[0] = 0;
Vself_q[1] = 0;
Vself_lj[0] = 0;
Vself_lj[1] = 0;
/* Global corrections only on master process */
if (MASTER(cr) && thread == 0)
{
for (q = 0; q < (bHaveChargeOrTypePerturbed ? 2 : 1); q++)
{
if (calc_excl_corr)
{
/* Self-energy correction */
Vself_q[q] = ewc_q*one_4pi_eps*fr->q2sum[q]*M_1_SQRTPI;
if (EVDW_PME(fr->vdwtype))
{
Vself_lj[q] = fr->c6sum[q]*0.5*vr0_lj;
}
}
/* Apply surface dipole correction:
* correction = dipole_coeff * (dipole)^2
*/
if (dipole_coeff != 0)
{
if (ewald_geometry == eewg3D)
{
Vdipole[q] = dipole_coeff*iprod(mutot[q], mutot[q]);
}
else if (ewald_geometry == eewg3DC)
{
Vdipole[q] = dipole_coeff*mutot[q][ZZ]*mutot[q][ZZ];
}
}
}
}
if (!bHaveChargeOrTypePerturbed)
{
*Vcorr_q = Vdipole[0] - Vself_q[0] - Vexcl_q;
if (EVDW_PME(fr->vdwtype))
{
*Vcorr_lj = -Vself_lj[0] - Vexcl_lj;
}
}
else
{
*Vcorr_q = L1_q*(Vdipole[0] - Vself_q[0])
+ lambda_q*(Vdipole[1] - Vself_q[1])
- Vexcl_q;
*dvdlambda_q += Vdipole[1] - Vself_q[1]
- (Vdipole[0] - Vself_q[0]) - dvdl_excl_q;
if (EVDW_PME(fr->vdwtype))
{
*Vcorr_lj = -(L1_lj*Vself_lj[0] + lambda_lj*Vself_lj[1]) - Vexcl_lj;
*dvdlambda_lj += -Vself_lj[1] + Vself_lj[0] - dvdl_excl_lj;
}
}
if (debug)
{
fprintf(debug, "Long Range corrections for Ewald interactions:\n");
fprintf(debug, "q2sum = %g, Vself_q=%g c6sum = %g, Vself_lj=%g\n",
L1_q*fr->q2sum[0]+lambda_q*fr->q2sum[1], L1_q*Vself_q[0]+lambda_q*Vself_q[1], L1_lj*fr->c6sum[0]+lambda_lj*fr->c6sum[1], L1_lj*Vself_lj[0]+lambda_lj*Vself_lj[1]);
fprintf(debug, "Electrostatic Long Range correction: Vexcl=%g\n", Vexcl_q);
fprintf(debug, "Lennard-Jones Long Range correction: Vexcl=%g\n", Vexcl_lj);
if (MASTER(cr) && thread == 0)
{
if (epsilon_surface > 0 || ewald_geometry == eewg3DC)
{
fprintf(debug, "Total dipole correction: Vdipole=%g\n",
L1_q*Vdipole[0]+lambda_q*Vdipole[1]);
}
}
}
}
int gmx_rmsf(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes the root mean square fluctuation (RMSF, i.e. standard ",
"deviation) of atomic positions in the trajectory (supplied with [TT]-f[tt])",
"after (optionally) fitting to a reference frame (supplied with [TT]-s[tt]).[PAR]",
"With option [TT]-oq[tt] the RMSF values are converted to B-factor",
"values, which are written to a [REF].pdb[ref] file with the coordinates, of the",
"structure file, or of a [REF].pdb[ref] file when [TT]-q[tt] is specified.",
"Option [TT]-ox[tt] writes the B-factors to a file with the average",
"coordinates.[PAR]",
"With the option [TT]-od[tt] the root mean square deviation with",
"respect to the reference structure is calculated.[PAR]",
"With the option [TT]-aniso[tt], [THISMODULE] will compute anisotropic",
"temperature factors and then it will also output average coordinates",
"and a [REF].pdb[ref] file with ANISOU records (corresonding to the [TT]-oq[tt]",
"or [TT]-ox[tt] option). Please note that the U values",
"are orientation-dependent, so before comparison with experimental data",
"you should verify that you fit to the experimental coordinates.[PAR]",
"When a [REF].pdb[ref] input file is passed to the program and the [TT]-aniso[tt]",
"flag is set",
"a correlation plot of the Uij will be created, if any anisotropic",
"temperature factors are present in the [REF].pdb[ref] file.[PAR]",
"With option [TT]-dir[tt] the average MSF (3x3) matrix is diagonalized.",
"This shows the directions in which the atoms fluctuate the most and",
"the least."
};
static gmx_bool bRes = FALSE, bAniso = FALSE, bFit = TRUE;
t_pargs pargs[] = {
{ "-res", FALSE, etBOOL, {&bRes},
"Calculate averages for each residue" },
{ "-aniso", FALSE, etBOOL, {&bAniso},
"Compute anisotropic termperature factors" },
{ "-fit", FALSE, etBOOL, {&bFit},
"Do a least squares superposition before computing RMSF. Without this you must make sure that the reference structure and the trajectory match." }
};
int natom;
int i, m, teller = 0;
real t, *w_rls;
t_topology top;
int ePBC;
t_atoms *pdbatoms, *refatoms;
matrix box, pdbbox;
rvec *x, *pdbx, *xref;
t_trxstatus *status;
const char *label;
FILE *fp; /* the graphics file */
const char *devfn, *dirfn;
int resind;
gmx_bool bReadPDB;
int *index;
int isize;
char *grpnames;
real bfac, pdb_bfac, *Uaver;
double **U, *xav;
int aid;
rvec *rmsd_x = nullptr;
double *rmsf, invcount, totmass;
int d;
real count = 0;
rvec xcm;
gmx_rmpbc_t gpbc = nullptr;
gmx_output_env_t *oenv;
const char *leg[2] = { "MD", "X-Ray" };
t_filenm fnm[] = {
{ efTRX, "-f", nullptr, ffREAD },
{ efTPS, nullptr, nullptr, ffREAD },
{ efNDX, nullptr, nullptr, ffOPTRD },
{ efPDB, "-q", nullptr, ffOPTRD },
{ efPDB, "-oq", "bfac", ffOPTWR },
{ efPDB, "-ox", "xaver", ffOPTWR },
{ efXVG, "-o", "rmsf", ffWRITE },
{ efXVG, "-od", "rmsdev", ffOPTWR },
{ efXVG, "-oc", "correl", ffOPTWR },
{ efLOG, "-dir", "rmsf", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_CAN_VIEW,
NFILE, fnm, asize(pargs), pargs, asize(desc), desc, 0, nullptr,
&oenv))
{
return 0;
}
bReadPDB = ftp2bSet(efPDB, NFILE, fnm);
devfn = opt2fn_null("-od", NFILE, fnm);
dirfn = opt2fn_null("-dir", NFILE, fnm);
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, &xref, nullptr, box, TRUE);
const char *title = *top.name;
snew(w_rls, top.atoms.nr);
fprintf(stderr, "Select group(s) for root mean square calculation\n");
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &isize, &index, &grpnames);
/* Set the weight */
for (i = 0; i < isize; i++)
{
w_rls[index[i]] = top.atoms.atom[index[i]].m;
}
/* Malloc the rmsf arrays */
snew(xav, isize*DIM);
snew(U, isize);
for (i = 0; i < isize; i++)
{
snew(U[i], DIM*DIM);
}
snew(rmsf, isize);
if (devfn)
{
snew(rmsd_x, isize);
}
if (bReadPDB)
{
t_topology *top_pdb;
snew(top_pdb, 1);
/* Read coordinates twice */
read_tps_conf(opt2fn("-q", NFILE, fnm), top_pdb, nullptr, nullptr, nullptr, pdbbox, FALSE);
snew(pdbatoms, 1);
*pdbatoms = top_pdb->atoms;
read_tps_conf(opt2fn("-q", NFILE, fnm), top_pdb, nullptr, &pdbx, nullptr, pdbbox, FALSE);
/* TODO Should this assert that top_pdb->atoms.nr == top.atoms.nr?
* See discussion at https://gerrit.gromacs.org/#/c/6430/1 */
title = *top_pdb->name;
snew(refatoms, 1);
*refatoms = top_pdb->atoms;
sfree(top_pdb);
}
else
{
pdbatoms = &top.atoms;
refatoms = &top.atoms;
pdbx = xref;
snew(pdbatoms->pdbinfo, pdbatoms->nr);
pdbatoms->havePdbInfo = TRUE;
copy_mat(box, pdbbox);
}
if (bFit)
{
sub_xcm(xref, isize, index, top.atoms.atom, xcm, FALSE);
}
natom = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
if (bFit)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, natom);
}
/* Now read the trj again to compute fluctuations */
teller = 0;
do
{
if (bFit)
{
/* Remove periodic boundary */
gmx_rmpbc(gpbc, natom, box, x);
/* Set center of mass to zero */
sub_xcm(x, isize, index, top.atoms.atom, xcm, FALSE);
/* Fit to reference structure */
do_fit(natom, w_rls, xref, x);
}
/* Calculate Anisotropic U Tensor */
for (i = 0; i < isize; i++)
{
aid = index[i];
for (d = 0; d < DIM; d++)
{
xav[i*DIM + d] += x[aid][d];
for (m = 0; m < DIM; m++)
{
U[i][d*DIM + m] += x[aid][d]*x[aid][m];
}
}
}
if (devfn)
{
/* Calculate RMS Deviation */
for (i = 0; (i < isize); i++)
{
aid = index[i];
for (d = 0; (d < DIM); d++)
{
rmsd_x[i][d] += gmx::square(x[aid][d]-xref[aid][d]);
}
}
}
count += 1.0;
teller++;
}
while (read_next_x(oenv, status, &t, x, box));
close_trx(status);
if (bFit)
{
gmx_rmpbc_done(gpbc);
}
invcount = 1.0/count;
snew(Uaver, DIM*DIM);
totmass = 0;
for (i = 0; i < isize; i++)
{
for (d = 0; d < DIM; d++)
{
xav[i*DIM + d] *= invcount;
}
for (d = 0; d < DIM; d++)
{
for (m = 0; m < DIM; m++)
{
U[i][d*DIM + m] = U[i][d*DIM + m]*invcount
- xav[i*DIM + d]*xav[i*DIM + m];
Uaver[3*d+m] += top.atoms.atom[index[i]].m*U[i][d*DIM + m];
}
}
totmass += top.atoms.atom[index[i]].m;
}
for (d = 0; d < DIM*DIM; d++)
{
Uaver[d] /= totmass;
}
if (bRes)
{
for (d = 0; d < DIM*DIM; d++)
{
average_residues(nullptr, U, d, isize, index, w_rls, &top.atoms);
}
}
if (bAniso)
{
for (i = 0; i < isize; i++)
{
aid = index[i];
pdbatoms->pdbinfo[aid].bAnisotropic = TRUE;
pdbatoms->pdbinfo[aid].uij[U11] = static_cast<int>(1e6*U[i][XX*DIM + XX]);
pdbatoms->pdbinfo[aid].uij[U22] = static_cast<int>(1e6*U[i][YY*DIM + YY]);
pdbatoms->pdbinfo[aid].uij[U33] = static_cast<int>(1e6*U[i][ZZ*DIM + ZZ]);
pdbatoms->pdbinfo[aid].uij[U12] = static_cast<int>(1e6*U[i][XX*DIM + YY]);
pdbatoms->pdbinfo[aid].uij[U13] = static_cast<int>(1e6*U[i][XX*DIM + ZZ]);
pdbatoms->pdbinfo[aid].uij[U23] = static_cast<int>(1e6*U[i][YY*DIM + ZZ]);
}
}
if (bRes)
{
label = "Residue";
}
else
{
label = "Atom";
}
for (i = 0; i < isize; i++)
{
rmsf[i] = U[i][XX*DIM + XX] + U[i][YY*DIM + YY] + U[i][ZZ*DIM + ZZ];
}
if (dirfn)
{
fprintf(stdout, "\n");
print_dir(stdout, Uaver);
fp = gmx_ffopen(dirfn, "w");
print_dir(fp, Uaver);
gmx_ffclose(fp);
}
for (i = 0; i < isize; i++)
{
sfree(U[i]);
}
sfree(U);
/* Write RMSF output */
if (bReadPDB)
{
bfac = 8.0*M_PI*M_PI/3.0*100;
fp = xvgropen(ftp2fn(efXVG, NFILE, fnm), "B-Factors",
label, "(A\\b\\S\\So\\N\\S2\\N)", oenv);
xvgr_legend(fp, 2, leg, oenv);
for (i = 0; (i < isize); i++)
{
if (!bRes || i+1 == isize ||
top.atoms.atom[index[i]].resind != top.atoms.atom[index[i+1]].resind)
{
resind = top.atoms.atom[index[i]].resind;
pdb_bfac = find_pdb_bfac(pdbatoms, &top.atoms.resinfo[resind],
*(top.atoms.atomname[index[i]]));
fprintf(fp, "%5d %10.5f %10.5f\n",
bRes ? top.atoms.resinfo[top.atoms.atom[index[i]].resind].nr : index[i]+1, rmsf[i]*bfac,
pdb_bfac);
}
}
xvgrclose(fp);
}
else
{
fp = xvgropen(ftp2fn(efXVG, NFILE, fnm), "RMS fluctuation", label, "(nm)", oenv);
for (i = 0; i < isize; i++)
{
if (!bRes || i+1 == isize ||
top.atoms.atom[index[i]].resind != top.atoms.atom[index[i+1]].resind)
{
fprintf(fp, "%5d %8.4f\n",
bRes ? top.atoms.resinfo[top.atoms.atom[index[i]].resind].nr : index[i]+1, std::sqrt(rmsf[i]));
}
}
xvgrclose(fp);
}
for (i = 0; i < isize; i++)
{
pdbatoms->pdbinfo[index[i]].bfac = 800*M_PI*M_PI/3.0*rmsf[i];
}
if (devfn)
{
for (i = 0; i < isize; i++)
{
rmsf[i] = (rmsd_x[i][XX]+rmsd_x[i][YY]+rmsd_x[i][ZZ])/count;
}
if (bRes)
{
average_residues(rmsf, nullptr, 0, isize, index, w_rls, &top.atoms);
}
/* Write RMSD output */
fp = xvgropen(devfn, "RMS Deviation", label, "(nm)", oenv);
for (i = 0; i < isize; i++)
{
if (!bRes || i+1 == isize ||
top.atoms.atom[index[i]].resind != top.atoms.atom[index[i+1]].resind)
{
fprintf(fp, "%5d %8.4f\n",
bRes ? top.atoms.resinfo[top.atoms.atom[index[i]].resind].nr : index[i]+1, std::sqrt(rmsf[i]));
}
}
xvgrclose(fp);
}
if (opt2bSet("-oq", NFILE, fnm))
{
/* Write a .pdb file with B-factors and optionally anisou records */
for (i = 0; i < isize; i++)
{
rvec_inc(pdbx[index[i]], xcm);
}
write_sto_conf_indexed(opt2fn("-oq", NFILE, fnm), title, pdbatoms, pdbx,
nullptr, ePBC, pdbbox, isize, index);
}
if (opt2bSet("-ox", NFILE, fnm))
{
rvec *bFactorX;
snew(bFactorX, top.atoms.nr);
for (i = 0; i < isize; i++)
{
for (d = 0; d < DIM; d++)
{
bFactorX[index[i]][d] = xcm[d] + xav[i*DIM + d];
}
}
/* Write a .pdb file with B-factors and optionally anisou records */
write_sto_conf_indexed(opt2fn("-ox", NFILE, fnm), title, pdbatoms, bFactorX, nullptr,
ePBC, pdbbox, isize, index);
sfree(bFactorX);
}
if (bAniso)
{
correlate_aniso(opt2fn("-oc", NFILE, fnm), refatoms, pdbatoms, oenv);
do_view(oenv, opt2fn("-oc", NFILE, fnm), "-nxy");
}
do_view(oenv, opt2fn("-o", NFILE, fnm), "-nxy");
if (devfn)
{
do_view(oenv, opt2fn("-od", NFILE, fnm), "-nxy");
}
return 0;
}
static void rot_conf(t_atoms *atoms, rvec x[], rvec v[], real trans, real angle,
rvec head, rvec tail, matrix box, int isize, atom_id index[],
rvec xout[], rvec vout[])
{
rvec arrow, center, xcm;
real theta, phi, arrow_len;
mat4 Rx, Ry, Rz, Rinvy, Rinvz, Mtot, Tcm, Tinvcm, Tx;
mat4 temp1, temp2, temp3, temp4, temp21, temp43;
vec4 xv;
int i, j, ai;
rvec_sub(tail, head, arrow);
arrow_len = norm(arrow);
if (debug)
{
fprintf(debug, "Arrow vector: %10.4f %10.4f %10.4f\n",
arrow[XX], arrow[YY], arrow[ZZ]);
fprintf(debug, "Effective translation %g nm\n", trans);
}
if (arrow_len == 0.0)
{
gmx_fatal(FARGS, "Arrow vector not given");
}
/* Copy all aoms to output */
for (i = 0; (i < atoms->nr); i++)
{
copy_rvec(x[i], xout[i]);
copy_rvec(v[i], vout[i]);
}
/* Compute center of mass and move atoms there */
clear_rvec(xcm);
for (i = 0; (i < isize); i++)
{
rvec_inc(xcm, x[index[i]]);
}
for (i = 0; (i < DIM); i++)
{
xcm[i] /= isize;
}
if (debug)
{
fprintf(debug, "Center of mass: %10.4f %10.4f %10.4f\n",
xcm[XX], xcm[YY], xcm[ZZ]);
}
for (i = 0; (i < isize); i++)
{
rvec_sub(x[index[i]], xcm, xout[index[i]]);
}
/* Compute theta and phi that describe the arrow */
theta = acos(arrow[ZZ]/arrow_len);
phi = atan2(arrow[YY]/arrow_len, arrow[XX]/arrow_len);
if (debug)
{
fprintf(debug, "Phi = %.1f, Theta = %.1f\n", RAD2DEG*phi, RAD2DEG*theta);
}
/* Now the total rotation matrix: */
/* Rotate a couple of times */
rotate(ZZ, -phi, Rz);
rotate(YY, M_PI/2-theta, Ry);
rotate(XX, angle*DEG2RAD, Rx);
Rx[WW][XX] = trans;
rotate(YY, theta-M_PI/2, Rinvy);
rotate(ZZ, phi, Rinvz);
mult_matrix(temp1, Ry, Rz);
mult_matrix(temp2, Rinvy, Rx);
mult_matrix(temp3, temp2, temp1);
mult_matrix(Mtot, Rinvz, temp3);
print_m4(debug, "Rz", Rz);
print_m4(debug, "Ry", Ry);
print_m4(debug, "Rx", Rx);
print_m4(debug, "Rinvy", Rinvy);
print_m4(debug, "Rinvz", Rinvz);
print_m4(debug, "Mtot", Mtot);
for (i = 0; (i < isize); i++)
{
ai = index[i];
m4_op(Mtot, xout[ai], xv);
rvec_add(xv, xcm, xout[ai]);
m4_op(Mtot, v[ai], xv);
copy_rvec(xv, vout[ai]);
}
}
