void comp_trx(const output_env_t oenv,const char *fn1, const char *fn2,
gmx_bool bRMSD,real ftol,real abstol)
{
int i;
const char *fn[2];
t_trxframe fr[2];
t_trxstatus *status[2];
gmx_bool b[2];
fn[0]=fn1;
fn[1]=fn2;
fprintf(stderr,"Comparing trajectory files %s and %s\n",fn1,fn2);
for (i=0; i<2; i++)
b[i] = read_first_frame(oenv,&status[i],fn[i],&fr[i],TRX_READ_X|TRX_READ_V|TRX_READ_F);
if (b[0] && b[1]) {
do {
comp_frame(stdout, &(fr[0]), &(fr[1]), bRMSD, ftol, abstol);
for (i=0; i<2; i++)
b[i] = read_next_frame(oenv,status[i],&fr[i]);
} while (b[0] && b[1]);
for (i=0; i<2; i++) {
if (b[i] && !b[1-i])
fprintf(stdout,"\nEnd of file on %s but not on %s\n",fn[i],fn[1-i]);
close_trj(status[i]);
}
}
if (!b[0] && !b[1])
fprintf(stdout,"\nBoth files read correctly\n");
}
static int
view_fli(char *name, Vscreen *screen, int loop)
{
struct fli_head fh;
FILE *fd;
long clock;
int i;
long f1off;
if ((fd = read_fli_head(name, &fh)) == 0)
return(0);
clock = get80hz();
mouse_on = 0;
if (loop)
{
if (!read_next_frame(name,fd,screen,1))
goto OUT;
f1off = jtell(fd);
clock += fh.speed;
if (!wait_til(clock))
goto OUT;
if (clock > get80hz())
clock = get80hz();
}
do
{
for (i=0; i<fh.frame_count; i++)
{
if (!read_next_frame(name,fd,screen,1))
goto OUT;
clock += fh.speed;
if (!wait_til(clock))
goto OUT;
if (clock > get80hz())
clock = get80hz();
}
if (loop)
jseek(fd, f1off, 0);
}
while (loop);
OUT:
jclose(fd);
mouse_on = 1;
}
static void cont_status(char *slog,char *ener,
bool bNeedVel,bool bGenVel, real fr_time,
t_inputrec *ir,t_state *state,
gmx_mtop_t *sys)
/* If fr_time == -1 read the last frame available which is complete */
{
t_trxframe fr;
int fp;
fprintf(stderr,
"Reading Coordinates%s and Box size from old trajectory\n",
(!bNeedVel || bGenVel) ? "" : ", Velocities");
if (fr_time == -1)
fprintf(stderr,"Will read whole trajectory\n");
else
fprintf(stderr,"Will read till time %g\n",fr_time);
if (!bNeedVel || bGenVel) {
if (bGenVel)
fprintf(stderr,"Velocities generated: "
"ignoring velocities in input trajectory\n");
read_first_frame(&fp,slog,&fr,TRX_NEED_X);
} else
read_first_frame(&fp,slog,&fr,TRX_NEED_X | TRX_NEED_V);
state->natoms = fr.natoms;
if (sys->natoms != state->natoms)
gmx_fatal(FARGS,"Number of atoms in Topology "
"is not the same as in Trajectory");
/* Find the appropriate frame */
while ((fr_time == -1 || fr.time < fr_time) && read_next_frame(fp,&fr));
close_trj(fp);
if (fr.not_ok & FRAME_NOT_OK)
gmx_fatal(FARGS,"Can not start from an incomplete frame");
state->x = fr.x;
if (bNeedVel && !bGenVel)
state->v = fr.v;
copy_mat(fr.box,state->box);
/* Set the relative box lengths for preserving the box shape.
* Note that this call can lead to differences in the last bit
* with respect to using tpbconv to create a tpx file.
*/
set_box_rel(ir,state);
fprintf(stderr,"Using frame at t = %g ps\n",fr.time);
fprintf(stderr,"Starting time for run is %g ps\n",ir->init_t);
if ((ir->epc != epcNO || ir->etc ==etcNOSEHOOVER) && ener) {
get_enx_state(ener,fr.time,&sys->groups,ir,state);
preserve_box_shape(ir,state->box_rel,state->boxv);
}
}
gmx_bool read_next_x(const gmx_output_env_t *oenv, t_trxstatus *status, real *t,
rvec x[], matrix box)
{
gmx_bool bRet;
status->xframe->x = x;
/*xframe[status].x = x;*/
bRet = read_next_frame(oenv, status, status->xframe);
*t = status->xframe->time;
copy_mat(status->xframe->box, box);
return bRet;
}
bool
TrajectoryAnalysisRunnerCommon::readNextFrame()
{
bool bContinue = false;
if (hasTrajectory())
{
bContinue = read_next_frame(impl_->oenv_, impl_->status_, impl_->fr);
}
if (!bContinue)
{
impl_->finishTrajectory();
}
return bContinue;
}
static void scan_trj_files(char **fnms,int nfiles,
real *readtime,real *timestep,atom_id imax)
{
/* Check start time of all files */
int i,status,natoms=0;
real t;
t_trxframe fr;
bool ok;
for(i=0;i<nfiles;i++) {
ok=read_first_frame(&status,fnms[i],&fr,FLAGS);
if(!ok)
gmx_fatal(FARGS,"\nCouldn't read frame from file.");
if(fr.bTime)
readtime[i]=fr.time;
else {
readtime[i]=0;
fprintf(stderr,"\nWARNING: Couldn't find a time in the frame.\n");
}
if(i==0) {
natoms=fr.natoms;
}
else {
if (imax==NO_ATID) {
if(natoms!=fr.natoms)
gmx_fatal(FARGS,"\nDifferent numbers of atoms (%d/%d) in files",
natoms,fr.natoms);
} else {
if(fr.natoms <= imax)
gmx_fatal(FARGS,"\nNot enough atoms (%d) for index group (%d)",
fr.natoms,imax);
}
}
ok=read_next_frame(status,&fr);
if(ok && fr.bTime) {
timestep[i] = fr.time - readtime[i];
} else {
timestep[i] = 0;
}
close_trj(status);
}
fprintf(stderr,"\n");
sfree(fr.x);
}
gmx_bool read_next_v(const output_env_t oenv,t_trxstatus *status,real *t,
int natoms,rvec v[], matrix box)
{
t_trxframe fr;
gmx_bool bRet;
clear_trxframe(&fr,TRUE);
fr.flags = TRX_NEED_V;
fr.natoms = natoms;
fr.time = *t;
fr.v = v;
bRet = read_next_frame(oenv,status,&fr);
*t = fr.time;
clear_v(&fr);
copy_mat(fr.box,box);
return bRet;
}
bool
TrajectoryFrameReader::readNextFrame()
{
if (haveProbedForNextFrame_)
{
if (nextFrameExists_)
{
GMX_THROW(APIError("This frame has already been probed for, it should be used before probing again."));
}
else
{
GMX_THROW(APIError("This frame has already been probed for, it doesn't exist, so there should not be subsequent attempts to probe for it."));
}
}
haveProbedForNextFrame_ = true;
// If there's a next frame, read it into trxframe_, and report the result.
if (!haveReadFirstFrame_)
{
t_trxstatus *trajectoryFile;
int flags = TRX_READ_X | TRX_READ_V | TRX_READ_F;
nextFrameExists_ = read_first_frame(oenvGuard_.get(),
&trajectoryFile,
filename_.c_str(),
trxframeGuard_.get(),
flags);
if (!trajectoryFile)
{
GMX_THROW(FileIOError("Could not open trajectory file " + filename_ + " for reading"));
}
trajectoryFileGuard_.reset(trajectoryFile);
haveReadFirstFrame_ = true;
}
else
{
nextFrameExists_ = read_next_frame(oenvGuard_.get(),
trajectoryFileGuard_.get(),
trxframeGuard_.get());
}
return nextFrameExists_;
}
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_dyecoupl(int argc, char *argv[])
{
const char *desc[] =
{
"[THISMODULE] extracts dye dynamics from trajectory files.",
"Currently, R and kappa^2 between dyes is extracted for (F)RET",
"simulations with assumed dipolar coupling as in the Foerster equation.",
"It further allows the calculation of R(t) and kappa^2(t), R and",
"kappa^2 histograms and averages, as well as the instantaneous FRET",
"efficiency E(t) for a specified Foerster radius R_0 (switch [TT]-R0[tt]).",
"The input dyes have to be whole (see res and mol pbc options",
"in [TT]trjconv[tt]).",
"The dye transition dipole moment has to be defined by at least",
"a single atom pair, however multiple atom pairs can be provided ",
"in the index file. The distance R is calculated on the basis of",
"the COMs of the given atom pairs.",
"The [TT]-pbcdist[tt] option calculates distances to the nearest periodic",
"image instead to the distance in the box. This works however only,"
"for periodic boundaries in all 3 dimensions.",
"The [TT]-norm[tt] option (area-) normalizes the histograms."
};
static gmx_bool bPBCdist = FALSE, bNormHist = FALSE;
int histbins = 50;
gmx_output_env_t *oenv;
real R0 = -1;
t_pargs pa[] =
{
{ "-pbcdist", FALSE, etBOOL, { &bPBCdist }, "Distance R based on PBC" },
{ "-norm", FALSE, etBOOL, { &bNormHist }, "Normalize histograms" },
{ "-bins", FALSE, etINT, {&histbins}, "# of histogram bins" },
{ "-R0", FALSE, etREAL, {&R0}, "Foerster radius including kappa^2=2/3 in nm" }
};
#define NPA asize(pa)
t_filenm fnm[] =
{
{ efTRX, "-f", NULL, ffREAD },
{ efNDX, NULL, NULL, ffREAD },
{ efXVG, "-ot", "rkappa", ffOPTWR },
{ efXVG, "-oe", "insteff", ffOPTWR },
{ efDAT, "-o", "rkappa", ffOPTWR },
{ efXVG, "-rhist", "rhist", ffOPTWR },
{ efXVG, "-khist", "khist", ffOPTWR }
};
#define NFILE asize(fnm)
const char *in_trajfile, *out_xvgrkfile = NULL, *out_xvginstefffile = NULL, *out_xvgrhistfile = NULL, *out_xvgkhistfile = NULL, *out_datfile = NULL;
gmx_bool bHaveFirstFrame, bHaveNextFrame, indexOK = TRUE;
int ndon, nacc;
atom_id *donindex, *accindex;
char *grpnm;
t_trxstatus *status;
t_trxframe fr;
int flags;
int allocblock = 1000;
real histexpand = 1e-6;
rvec donvec, accvec, donpos, accpos, dist, distnorm;
int natoms;
/*we rely on PBC autodetection (...currently)*/
int ePBC = -1;
real *rvalues = NULL, *kappa2values = NULL, *rhist = NULL, *khist = NULL;
t_pbc *pbc = NULL;
int i, bin;
FILE *rkfp = NULL, *rhfp = NULL, *khfp = NULL, *datfp = NULL, *iefp = NULL;
gmx_bool bRKout, bRhistout, bKhistout, bDatout, bInstEffout, grident;
const char *rkleg[2] = { "R", "\\f{Symbol}k\\f{}\\S2\\N" };
const char *rhleg[1] = { "p(R)" };
const char *khleg[1] = { "p(\\f{Symbol}k\\f{}\\S2\\N)" };
const char *ieleg[1] = { "E\\sRET\\N(t)" };
real R, kappa2, insteff, Rs = 0., kappa2s = 0., insteffs = 0., rmax, rmin, kmin = 0., kmax = 4.,
rrange, krange, rincr, kincr, Rfrac;
int rkcount = 0, rblocksallocated = 0, kblocksallocated = 0;
if (!parse_common_args(&argc, argv, PCA_CAN_BEGIN | PCA_CAN_END | PCA_CAN_VIEW | PCA_TIME_UNIT,
NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
/* Check command line options for filenames and set bool flags when switch used*/
in_trajfile = opt2fn("-f", NFILE, fnm);
out_xvgrkfile = opt2fn("-ot", NFILE, fnm);
out_xvgrhistfile = opt2fn("-rhist", NFILE, fnm);
out_xvgkhistfile = opt2fn("-khist", NFILE, fnm);
out_xvginstefffile = opt2fn("-oe", NFILE, fnm);
out_datfile = opt2fn("-o", NFILE, fnm);
bRKout = opt2bSet("-ot", NFILE, fnm);
bRhistout = opt2bSet("-rhist", NFILE, fnm);
bKhistout = opt2bSet("-khist", NFILE, fnm);
bDatout = opt2bSet("-o", NFILE, fnm);
bInstEffout = opt2bSet("-oe", NFILE, fnm);
/* PBC warning. */
if (bPBCdist)
{
printf("Calculating distances to periodic image.\n");
printf("Be careful! This produces only valid results for PBC in all three dimensions\n");
}
if (bInstEffout && R0 <= 0.)
{
gmx_fatal(FARGS, "You have to specify R0 and R0 has to be larger than 0 nm.\n\n");
}
printf("Select group with donor atom pairs defining the transition moment\n");
get_index(NULL, ftp2fn_null(efNDX, NFILE, fnm), 1, &ndon, &donindex, &grpnm);
printf("Select group with acceptor atom pairs defining the transition moment\n");
get_index(NULL, ftp2fn_null(efNDX, NFILE, fnm), 1, &nacc, &accindex, &grpnm);
/*check if groups are identical*/
grident = TRUE;
if (ndon == nacc)
{
for (i = 0; i < nacc; i++)
{
if (accindex[i] != donindex[i])
{
grident = FALSE;
break;
}
}
}
if (grident)
{
gmx_fatal(FARGS, "Donor and acceptor group are identical. This makes no sense.");
}
printf("Reading first frame\n");
/* open trx file for reading */
flags = 0;
flags = flags | TRX_READ_X;
bHaveFirstFrame = read_first_frame(oenv, &status, in_trajfile, &fr, flags);
if (bHaveFirstFrame)
{
printf("First frame is OK\n");
natoms = fr.natoms;
if ((ndon % 2 != 0) || (nacc % 2 != 0))
{
indexOK = FALSE;
}
else
{
for (i = 0; i < ndon; i++)
{
if (donindex[i] >= natoms)
{
indexOK = FALSE;
}
}
for (i = 0; i < nacc; i++)
{
if (accindex[i] >= natoms)
{
indexOK = FALSE;
}
}
}
if (indexOK)
{
if (bDatout)
{
datfp = gmx_ffopen(out_datfile, "w");
}
if (bRKout)
{
rkfp = xvgropen(out_xvgrkfile,
"Distance and \\f{Symbol}k\\f{}\\S2\\N trajectory",
"Time (ps)", "Distance (nm) / \\f{Symbol}k\\f{}\\S2\\N",
oenv);
xvgr_legend(rkfp, 2, rkleg, oenv);
}
if (bInstEffout)
{
iefp = xvgropen(out_xvginstefffile,
"Instantaneous RET Efficiency",
"Time (ps)", "RET Efficiency",
oenv);
xvgr_legend(iefp, 1, ieleg, oenv);
}
if (bRhistout)
{
snew(rvalues, allocblock);
rblocksallocated += 1;
snew(rhist, histbins);
}
if (bKhistout)
{
snew(kappa2values, allocblock);
kblocksallocated += 1;
snew(khist, histbins);
}
do
{
clear_rvec(donvec);
clear_rvec(accvec);
clear_rvec(donpos);
clear_rvec(accpos);
for (i = 0; i < ndon / 2; i++)
{
rvec_sub(donvec, fr.x[donindex[2 * i]], donvec);
rvec_add(donvec, fr.x[donindex[2 * i + 1]], donvec);
rvec_add(donpos, fr.x[donindex[2 * i]], donpos);
rvec_add(donpos, fr.x[donindex[2 * i + 1]], donpos);
}
for (i = 0; i < nacc / 2; i++)
{
rvec_sub(accvec, fr.x[accindex[2 * i]], accvec);
rvec_add(accvec, fr.x[accindex[2 * i + 1]], accvec);
rvec_add(accpos, fr.x[accindex[2 * i]], accpos);
rvec_add(accpos, fr.x[accindex[2 * i + 1]], accpos);
}
unitv(donvec, donvec);
unitv(accvec, accvec);
svmul(1.0 / ndon, donpos, donpos);
svmul(1.0 / nacc, accpos, accpos);
if (bPBCdist)
{
set_pbc(pbc, ePBC, fr.box);
pbc_dx(pbc, donpos, accpos, dist);
}
else
{
rvec_sub(donpos, accpos, dist);
}
unitv(dist, distnorm);
R = norm(dist);
kappa2 = iprod(donvec, accvec)- 3.* (iprod(donvec, distnorm) * iprod(distnorm, accvec));
kappa2 *= kappa2;
if (R0 > 0)
{
Rfrac = R/R0;
insteff = 1/(1+(Rfrac*Rfrac*Rfrac*Rfrac*Rfrac*Rfrac)*2/3/kappa2);
insteffs += insteff;
if (bInstEffout)
{
fprintf(iefp, "%12.7f %12.7f\n", fr.time, insteff);
}
}
Rs += R;
kappa2s += kappa2;
rkcount++;
if (bRKout)
{
fprintf(rkfp, "%12.7f %12.7f %12.7f\n", fr.time, R, kappa2);
}
if (bDatout)
{
fprintf(datfp, "%12.7f %12.7f %12.7f\n", fr.time, R, kappa2);
}
if (bRhistout)
{
rvalues[rkcount-1] = R;
if (rkcount % allocblock == 0)
{
srenew(rvalues, allocblock*(rblocksallocated+1));
rblocksallocated += 1;
}
}
if (bKhistout)
{
kappa2values[rkcount-1] = kappa2;
if (rkcount % allocblock == 0)
{
srenew(kappa2values, allocblock*(kblocksallocated+1));
kblocksallocated += 1;
}
}
bHaveNextFrame = read_next_frame(oenv, status, &fr);
}
while (bHaveNextFrame);
if (bRKout)
{
xvgrclose(rkfp);
}
if (bDatout)
{
gmx_ffclose(datfp);
}
if (bInstEffout)
{
xvgrclose(iefp);
}
if (bRhistout)
{
printf("Writing R-Histogram\n");
rmin = rvalues[0];
rmax = rvalues[0];
for (i = 1; i < rkcount; i++)
{
if (rvalues[i] < rmin)
{
rmin = rvalues[i];
}
else if (rvalues[i] > rmax)
{
rmax = rvalues[i];
}
}
rmin -= histexpand;
rmax += histexpand;
rrange = rmax - rmin;
rincr = rrange / histbins;
for (i = 1; i < rkcount; i++)
{
bin = static_cast<int>((rvalues[i] - rmin) / rincr);
rhist[bin] += 1;
}
if (bNormHist)
{
for (i = 0; i < histbins; i++)
{
rhist[i] /= rkcount * rrange/histbins;
}
rhfp = xvgropen(out_xvgrhistfile, "Distance Distribution",
"R (nm)", "Normalized Probability", oenv);
}
else
{
rhfp = xvgropen(out_xvgrhistfile, "Distance Distribution",
"R (nm)", "Probability", oenv);
}
xvgr_legend(rhfp, 1, rhleg, oenv);
for (i = 0; i < histbins; i++)
{
fprintf(rhfp, "%12.7f %12.7f\n", (i + 0.5) * rincr + rmin,
rhist[i]);
}
xvgrclose(rhfp);
}
if (bKhistout)
{
printf("Writing kappa^2-Histogram\n");
krange = kmax - kmin;
kincr = krange / histbins;
for (i = 1; i < rkcount; i++)
{
bin = static_cast<int>((kappa2values[i] - kmin) / kincr);
khist[bin] += 1;
}
if (bNormHist)
{
for (i = 0; i < histbins; i++)
{
khist[i] /= rkcount * krange/histbins;
}
khfp = xvgropen(out_xvgkhistfile,
"\\f{Symbol}k\\f{}\\S2\\N Distribution",
"\\f{Symbol}k\\f{}\\S2\\N",
"Normalized Probability", oenv);
}
else
{
khfp = xvgropen(out_xvgkhistfile,
"\\f{Symbol}k\\f{}\\S2\\N Distribution",
"\\f{Symbol}k\\f{}\\S2\\N", "Probability", oenv);
}
xvgr_legend(khfp, 1, khleg, oenv);
for (i = 0; i < histbins; i++)
{
fprintf(khfp, "%12.7f %12.7f\n", (i + 0.5) * kincr + kmin,
khist[i]);
}
xvgrclose(khfp);
}
printf("\nAverages:\n");
printf("R_avg = %8.4f nm\nKappa^2 = %8.4f\n", Rs / rkcount,
kappa2s / rkcount);
if (R0 > 0)
{
printf("E_RETavg = %8.4f\n", insteffs / rkcount);
}
please_cite(stdout, "Hoefling2011");
}
else
{
gmx_fatal(FARGS, "Index file invalid, check your index file for correct pairs.\n");
}
}
else
{
gmx_fatal(FARGS, "Could not read first frame of the trajectory.\n");
}
return 0;
}
int gmx_tcaf(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes tranverse current autocorrelations.",
"These are used to estimate the shear viscosity, [GRK]eta[grk].",
"For details see: Palmer, Phys. Rev. E 49 (1994) pp 359-366.[PAR]",
"Transverse currents are calculated using the",
"k-vectors (1,0,0) and (2,0,0) each also in the [IT]y[it]- and [IT]z[it]-direction,",
"(1,1,0) and (1,-1,0) each also in the 2 other planes (these vectors",
"are not independent) and (1,1,1) and the 3 other box diagonals (also",
"not independent). For each k-vector the sine and cosine are used, in",
"combination with the velocity in 2 perpendicular directions. This gives",
"a total of 16*2*2=64 transverse currents. One autocorrelation is",
"calculated fitted for each k-vector, which gives 16 TCAFs. Each of",
"these TCAFs is fitted to [MATH]f(t) = [EXP]-v[exp]([COSH]Wv[cosh] + 1/W [SINH]Wv[sinh])[math],",
"[MATH]v = -t/(2 [GRK]tau[grk])[math], [MATH]W = [SQRT]1 - 4 [GRK]tau[grk] [GRK]eta[grk]/[GRK]rho[grk] k^2[sqrt][math], which gives 16 values of [GRK]tau[grk]",
"and [GRK]eta[grk]. The fit weights decay exponentially with time constant [MATH]w[math] (given with [TT]-wt[tt]) as [MATH][EXP]-t/w[exp][math], and the TCAF and",
"fit are calculated up to time [MATH]5*w[math].",
"The [GRK]eta[grk] values should be fitted to [MATH]1 - a [GRK]eta[grk](k) k^2[math], from which",
"one can estimate the shear viscosity at k=0.[PAR]",
"When the box is cubic, one can use the option [TT]-oc[tt], which",
"averages the TCAFs over all k-vectors with the same length.",
"This results in more accurate TCAFs.",
"Both the cubic TCAFs and fits are written to [TT]-oc[tt]",
"The cubic [GRK]eta[grk] estimates are also written to [TT]-ov[tt].[PAR]",
"With option [TT]-mol[tt], the transverse current is determined of",
"molecules instead of atoms. In this case, the index group should",
"consist of molecule numbers instead of atom numbers.[PAR]",
"The k-dependent viscosities in the [TT]-ov[tt] file should be",
"fitted to [MATH][GRK]eta[grk](k) = [GRK]eta[grk][SUB]0[sub] (1 - a k^2)[math] to obtain the viscosity at",
"infinite wavelength.[PAR]",
"[BB]Note:[bb] make sure you write coordinates and velocities often enough.",
"The initial, non-exponential, part of the autocorrelation function",
"is very important for obtaining a good fit."
};
static gmx_bool bMol = FALSE, bK34 = FALSE;
static real wt = 5;
t_pargs pa[] = {
{ "-mol", FALSE, etBOOL, {&bMol},
"Calculate TCAF of molecules" },
{ "-k34", FALSE, etBOOL, {&bK34},
"Also use k=(3,0,0) and k=(4,0,0)" },
{ "-wt", FALSE, etREAL, {&wt},
"Exponential decay time for the TCAF fit weights" }
};
t_topology top;
int ePBC;
t_trxframe fr;
matrix box;
gmx_bool bTop;
int gnx;
int *index, *atndx = NULL, at;
char *grpname;
char title[256];
real t0, t1, dt, m, mtot, sysmass, rho, sx, cx;
t_trxstatus *status;
int nframes, n_alloc, i, j, k, d;
rvec mv_mol, cm_mol, kfac[NK];
int nkc, nk, ntc;
real **tc;
gmx_output_env_t *oenv;
#define NHISTO 360
t_filenm fnm[] = {
{ efTRN, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-ot", "transcur", ffOPTWR },
{ efXVG, "-oa", "tcaf_all", ffWRITE },
{ efXVG, "-o", "tcaf", ffWRITE },
{ efXVG, "-of", "tcaf_fit", ffWRITE },
{ efXVG, "-oc", "tcaf_cub", ffOPTWR },
{ efXVG, "-ov", "visc_k", ffWRITE }
};
#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_VIEW | PCA_CAN_TIME,
NFILE, fnm, npargs, ppa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, NULL, NULL, box,
TRUE);
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &gnx, &index, &grpname);
if (bMol)
{
if (!bTop)
{
gmx_fatal(FARGS, "Need a topology to determine the molecules");
}
atndx = top.mols.index;
}
if (bK34)
{
nkc = NKC;
}
else
{
nkc = NKC0;
}
nk = kset_c[nkc];
ntc = nk*NPK;
sprintf(title, "Velocity Autocorrelation Function for %s", grpname);
sysmass = 0;
for (i = 0; i < nk; i++)
{
if (iprod(v0[i], v1[i]) != 0)
{
gmx_fatal(FARGS, "DEATH HORROR: vectors not orthogonal");
}
if (iprod(v0[i], v2[i]) != 0)
{
gmx_fatal(FARGS, "DEATH HORROR: vectors not orthogonal");
}
if (iprod(v1[i], v2[i]) != 0)
{
gmx_fatal(FARGS, "DEATH HORROR: vectors not orthogonal");
}
unitv(v1[i], v1[i]);
unitv(v2[i], v2[i]);
}
snew(tc, ntc);
for (i = 0; i < top.atoms.nr; i++)
{
sysmass += top.atoms.atom[i].m;
}
read_first_frame(oenv, &status, ftp2fn(efTRN, NFILE, fnm), &fr,
TRX_NEED_X | TRX_NEED_V);
t0 = fr.time;
n_alloc = 0;
nframes = 0;
rho = 0;
do
{
if (nframes >= n_alloc)
{
n_alloc += 100;
for (i = 0; i < ntc; i++)
{
srenew(tc[i], n_alloc);
}
}
rho += 1/det(fr.box);
for (k = 0; k < nk; k++)
{
for (d = 0; d < DIM; d++)
{
kfac[k][d] = 2*M_PI*v0[k][d]/fr.box[d][d];
}
}
for (i = 0; i < ntc; i++)
{
tc[i][nframes] = 0;
}
for (i = 0; i < gnx; i++)
{
if (bMol)
{
clear_rvec(mv_mol);
clear_rvec(cm_mol);
mtot = 0;
for (j = 0; j < atndx[index[i]+1] - atndx[index[i]]; j++)
{
at = atndx[index[i]] + j;
m = top.atoms.atom[at].m;
mv_mol[XX] += m*fr.v[at][XX];
mv_mol[YY] += m*fr.v[at][YY];
mv_mol[ZZ] += m*fr.v[at][ZZ];
cm_mol[XX] += m*fr.x[at][XX];
cm_mol[YY] += m*fr.x[at][YY];
cm_mol[ZZ] += m*fr.x[at][ZZ];
mtot += m;
}
svmul(1.0/mtot, cm_mol, cm_mol);
}
else
{
svmul(top.atoms.atom[index[i]].m, fr.v[index[i]], mv_mol);
}
if (!bMol)
{
copy_rvec(fr.x[index[i]], cm_mol);
}
j = 0;
for (k = 0; k < nk; k++)
{
sx = std::sin(iprod(kfac[k], cm_mol));
cx = std::cos(iprod(kfac[k], cm_mol));
tc[j][nframes] += sx*iprod(v1[k], mv_mol);
j++;
tc[j][nframes] += cx*iprod(v1[k], mv_mol);
j++;
tc[j][nframes] += sx*iprod(v2[k], mv_mol);
j++;
tc[j][nframes] += cx*iprod(v2[k], mv_mol);
j++;
}
}
t1 = fr.time;
nframes++;
}
while (read_next_frame(oenv, status, &fr));
close_trj(status);
dt = (t1-t0)/(nframes-1);
rho *= sysmass/nframes*AMU/(NANO*NANO*NANO);
fprintf(stdout, "Density = %g (kg/m^3)\n", rho);
process_tcaf(nframes, dt, nkc, tc, kfac, rho, wt,
opt2fn_null("-ot", NFILE, fnm),
opt2fn("-oa", NFILE, fnm), opt2fn("-o", NFILE, fnm),
opt2fn("-of", NFILE, fnm), opt2fn_null("-oc", NFILE, fnm),
opt2fn("-ov", NFILE, fnm), oenv);
return 0;
}
int main(int argc,char *argv[])
{
static char *desc[] = {
"[TT]g_anavel[tt] computes temperature profiles in a sample. The sample",
"can be analysed radial, i.e. the temperature as a function of",
"distance from the center, cylindrical, i.e. as a function of distance",
"from the vector (0,0,1) through the center of the box, or otherwise",
"(will be specified later)"
};
t_filenm fnm[] = {
{ efTRN, "-f", NULL, ffREAD },
{ efTPX, "-s", NULL, ffREAD },
{ efXPM, "-o", "xcm", ffWRITE }
};
#define NFILE asize(fnm)
static int mode = 0, nlevels = 10;
static real tmax = 300, xmax = -1;
t_pargs pa[] = {
{ "-mode", FALSE, etINT, {&mode}, "mode" },
{ "-nlevels", FALSE, etINT, {&nlevels}, "number of levels" },
{ "-tmax", FALSE, etREAL, {&tmax}, "max temperature in output" },
{ "-xmax", FALSE, etREAL, {&xmax}, "max distance from center" }
};
FILE *fp;
int *npts,nmax;
int status;
int i,j,idum,step,nframe=0,index;
real temp,rdum,hboxx,hboxy,scale,xnorm=0;
real **profile=NULL;
real *t_x=NULL,*t_y,hi=0;
t_topology *top;
int d,m,n;
matrix box;
atom_id *sysindex;
gmx_bool bHaveV,bReadV;
t_rgb rgblo = { 0, 0, 1 },rgbhi = { 1, 0, 0 };
int flags = TRX_READ_X | TRX_READ_V;
t_trxframe fr;
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_BE_NICE ,NFILE,fnm,
asize(pa),pa,asize(desc),desc,0,NULL);
top = read_top(ftp2fn(efTPX,NFILE,fnm));
read_first_frame(&status,ftp2fn(efTRX,NFILE,fnm),&fr,flags);
if (xmax > 0) {
scale = 5;
nmax = xmax*scale;
}
else {
scale = 5;
nmax = (0.5*sqrt(sqr(box[XX][XX])+sqr(box[YY][YY])))*scale;
}
snew(npts,nmax+1);
snew(t_y,nmax+1);
for(i=0; (i<=nmax); i++) {
npts[i] = 0;
t_y[i] = i/scale;
}
do {
srenew(profile,++nframe);
snew(profile[nframe-1],nmax+1);
srenew(t_x,nframe);
t_x[nframe-1] = fr.time*1000;
hboxx = box[XX][XX]/2;
hboxy = box[YY][YY]/2;
for(i=0; (i<fr.natoms); i++) {
/* determine position dependent on mode */
switch (mode) {
case 0:
xnorm = sqrt(sqr(fr.x[i][XX]-hboxx) + sqr(fr.x[i][YY]-hboxy));
break;
default:
gmx_fatal(FARGS,"Unknown mode %d",mode);
}
index = xnorm*scale;
if (index <= nmax) {
temp = top->atoms.atom[i].m*iprod(fr.v[i],fr.v[i])/(2*BOLTZ);
if (temp > hi)
hi = temp;
npts[index]++;
profile[nframe-1][index] += temp;
}
}
for(i=0; (i<=nmax); i++) {
if (npts[i] != 0)
profile[nframe-1][i] /= npts[i];
npts[i] = 0;
}
} while (read_next_frame(status,&fr));
close_trx(status);
fp = ftp2FILE(efXPM,NFILE,fnm,"w");
write_xpm(fp,0,"Temp. profile","T (a.u.)",
"t (fs)","R (nm)",
nframe,nmax+1,t_x,t_y,profile,0,tmax,
rgblo,rgbhi,&nlevels);
gmx_thanx(stderr);
return 0;
}
int gmx_dos(int argc, char *argv[])
{
const char *desc[] = {
"[TT]g_dos[tt] computes the Density of States from a simulations.",
"In order for this to be meaningful the velocities must be saved",
"in the trajecotry with sufficiently high frequency such as to cover",
"all vibrations. For flexible systems that would be around a few fs",
"between saving. Properties based on the DoS are printed on the",
"standard output."
};
const char *bugs[] = {
"This program needs a lot of memory: total usage equals the number of atoms times 3 times number of frames times 4 (or 8 when run in double precision)."
};
FILE *fp, *fplog;
t_topology top;
int ePBC = -1;
t_trxframe fr;
matrix box;
int gnx;
char title[256];
real t0, t1, m;
t_trxstatus *status;
int nV, nframes, n_alloc, i, j, k, l, fftcode, Nmol, Natom;
double rho, dt, V2sum, Vsum, V, tmass, dostot, dos2, dosabs;
real **c1, **dos, mi, beta, bfac, *nu, *tt, stddev, c1j;
output_env_t oenv;
gmx_fft_t fft;
double cP, S, A, E, DiffCoeff, Delta, f, y, z, sigHS, Shs, Sig, DoS0, recip_fac;
double wCdiff, wSdiff, wAdiff, wEdiff;
static gmx_bool bVerbose = TRUE, bAbsolute = FALSE, bNormalize = FALSE;
static gmx_bool bRecip = FALSE, bDump = FALSE;
static real Temp = 298.15, toler = 1e-6;
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"Be loud and noisy." },
{ "-recip", FALSE, etBOOL, {&bRecip},
"Use cm^-1 on X-axis instead of 1/ps for DoS plots." },
{ "-abs", FALSE, etBOOL, {&bAbsolute},
"Use the absolute value of the Fourier transform of the VACF as the Density of States. Default is to use the real component only" },
{ "-normdos", FALSE, etBOOL, {&bNormalize},
"Normalize the DoS such that it adds up to 3N. This is a hack that should not be necessary." },
{ "-T", FALSE, etREAL, {&Temp},
"Temperature in the simulation" },
{ "-toler", FALSE, etREAL, {&toler},
"[HIDDEN]Tolerance when computing the fluidicity using bisection algorithm" },
{ "-dump", FALSE, etBOOL, {&bDump},
"[HIDDEN]Dump the y/fy plot corresponding to Fig. 2 inLin2003a and the and the weighting functions corresponding to Fig. 1 in Berens1983a." }
};
t_filenm fnm[] = {
{ efTRN, "-f", NULL, ffREAD },
{ efTPX, "-s", NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-vacf", "vacf", ffWRITE },
{ efXVG, "-mvacf", "mvacf", ffWRITE },
{ efXVG, "-dos", "dos", ffWRITE },
{ efLOG, "-g", "dos", ffWRITE },
};
#define NFILE asize(fnm)
int npargs;
t_pargs *ppa;
const char *DoSlegend[] = {
"DoS(v)", "DoS(v)[Solid]", "DoS(v)[Diff]"
};
npargs = asize(pa);
ppa = add_acf_pargs(&npargs, pa);
parse_common_args(&argc, argv, PCA_CAN_VIEW | PCA_CAN_TIME | PCA_BE_NICE,
NFILE, fnm, npargs, ppa, asize(desc), desc,
asize(bugs), bugs, &oenv);
beta = 1/(Temp*BOLTZ);
if (bDump)
{
printf("Dumping reference figures. Thanks for your patience.\n");
dump_fy(oenv, toler);
dump_w(oenv, beta);
exit(0);
}
fplog = gmx_fio_fopen(ftp2fn(efLOG, NFILE, fnm), "w");
fprintf(fplog, "Doing density of states analysis based on trajectory.\n");
please_cite(fplog, "Pascal2011a");
please_cite(fplog, "Caleman2011b");
read_tps_conf(ftp2fn(efTPX, NFILE, fnm), title, &top, &ePBC, NULL, NULL, box,
TRUE);
V = det(box);
tmass = 0;
for (i = 0; (i < top.atoms.nr); i++)
{
tmass += top.atoms.atom[i].m;
}
Natom = top.atoms.nr;
Nmol = top.mols.nr;
gnx = Natom*DIM;
/* Correlation stuff */
snew(c1, gnx);
for (i = 0; (i < gnx); i++)
{
c1[i] = NULL;
}
read_first_frame(oenv, &status, ftp2fn(efTRN, NFILE, fnm), &fr, TRX_NEED_V);
t0 = fr.time;
n_alloc = 0;
nframes = 0;
Vsum = V2sum = 0;
nV = 0;
do
{
if (fr.bBox)
{
V = det(fr.box);
V2sum += V*V;
Vsum += V;
nV++;
}
if (nframes >= n_alloc)
{
n_alloc += 100;
for (i = 0; i < gnx; i++)
{
srenew(c1[i], n_alloc);
}
}
for (i = 0; i < gnx; i += DIM)
{
c1[i+XX][nframes] = fr.v[i/DIM][XX];
c1[i+YY][nframes] = fr.v[i/DIM][YY];
c1[i+ZZ][nframes] = fr.v[i/DIM][ZZ];
}
t1 = fr.time;
nframes++;
}
while (read_next_frame(oenv, status, &fr));
close_trj(status);
dt = (t1-t0)/(nframes-1);
if (nV > 0)
{
V = Vsum/nV;
}
if (bVerbose)
{
printf("Going to do %d fourier transforms of length %d. Hang on.\n",
gnx, nframes);
}
low_do_autocorr(NULL, oenv, NULL, nframes, gnx, nframes, c1, dt, eacNormal, 0, FALSE,
FALSE, FALSE, -1, -1, 0, 0);
snew(dos, DOS_NR);
for (j = 0; (j < DOS_NR); j++)
{
snew(dos[j], nframes+4);
}
if (bVerbose)
{
printf("Going to merge the ACFs into the mass-weighted and plain ACF\n");
}
for (i = 0; (i < gnx); i += DIM)
{
mi = top.atoms.atom[i/DIM].m;
for (j = 0; (j < nframes/2); j++)
{
c1j = (c1[i+XX][j] + c1[i+YY][j] + c1[i+ZZ][j]);
dos[VACF][j] += c1j/Natom;
dos[MVACF][j] += mi*c1j;
}
}
fp = xvgropen(opt2fn("-vacf", NFILE, fnm), "Velocity ACF",
"Time (ps)", "C(t)", oenv);
snew(tt, nframes/2);
for (j = 0; (j < nframes/2); j++)
{
tt[j] = j*dt;
fprintf(fp, "%10g %10g\n", tt[j], dos[VACF][j]);
}
xvgrclose(fp);
fp = xvgropen(opt2fn("-mvacf", NFILE, fnm), "Mass-weighted velocity ACF",
"Time (ps)", "C(t)", oenv);
for (j = 0; (j < nframes/2); j++)
{
fprintf(fp, "%10g %10g\n", tt[j], dos[MVACF][j]);
}
xvgrclose(fp);
if ((fftcode = gmx_fft_init_1d_real(&fft, nframes/2,
GMX_FFT_FLAG_NONE)) != 0)
{
gmx_fatal(FARGS, "gmx_fft_init_1d_real returned %d", fftcode);
}
if ((fftcode = gmx_fft_1d_real(fft, GMX_FFT_REAL_TO_COMPLEX,
(void *)dos[MVACF], (void *)dos[DOS])) != 0)
{
gmx_fatal(FARGS, "gmx_fft_1d_real returned %d", fftcode);
}
/* First compute the DoS */
/* Magic factor of 8 included now. */
bfac = 8*dt*beta/2;
dos2 = 0;
snew(nu, nframes/4);
for (j = 0; (j < nframes/4); j++)
{
nu[j] = 2*j/(t1-t0);
dos2 += sqr(dos[DOS][2*j]) + sqr(dos[DOS][2*j+1]);
if (bAbsolute)
{
dos[DOS][j] = bfac*sqrt(sqr(dos[DOS][2*j]) + sqr(dos[DOS][2*j+1]));
}
else
{
dos[DOS][j] = bfac*dos[DOS][2*j];
}
}
/* Normalize it */
dostot = evaluate_integral(nframes/4, nu, dos[DOS], NULL, nframes/4, &stddev);
if (bNormalize)
{
for (j = 0; (j < nframes/4); j++)
{
dos[DOS][j] *= 3*Natom/dostot;
}
}
/* Now analyze it */
DoS0 = dos[DOS][0];
/* Note this eqn. is incorrect in Pascal2011a! */
Delta = ((2*DoS0/(9*Natom))*sqrt(M_PI*BOLTZ*Temp*Natom/tmass)*
pow((Natom/V), 1.0/3.0)*pow(6/M_PI, 2.0/3.0));
f = calc_fluidicity(Delta, toler);
y = calc_y(f, Delta, toler);
z = calc_compress(y);
Sig = BOLTZ*(5.0/2.0+log(2*M_PI*BOLTZ*Temp/(sqr(PLANCK))*V/(f*Natom)));
Shs = Sig+calc_Shs(f, y);
rho = (tmass*AMU)/(V*NANO*NANO*NANO);
sigHS = pow(6*y*V/(M_PI*Natom), 1.0/3.0);
fprintf(fplog, "System = \"%s\"\n", title);
fprintf(fplog, "Nmol = %d\n", Nmol);
fprintf(fplog, "Natom = %d\n", Natom);
fprintf(fplog, "dt = %g ps\n", dt);
fprintf(fplog, "tmass = %g amu\n", tmass);
fprintf(fplog, "V = %g nm^3\n", V);
fprintf(fplog, "rho = %g g/l\n", rho);
fprintf(fplog, "T = %g K\n", Temp);
fprintf(fplog, "beta = %g mol/kJ\n", beta);
fprintf(fplog, "\nDoS parameters\n");
fprintf(fplog, "Delta = %g\n", Delta);
fprintf(fplog, "fluidicity = %g\n", f);
fprintf(fplog, "hard sphere packing fraction = %g\n", y);
fprintf(fplog, "hard sphere compressibility = %g\n", z);
fprintf(fplog, "ideal gas entropy = %g\n", Sig);
fprintf(fplog, "hard sphere entropy = %g\n", Shs);
fprintf(fplog, "sigma_HS = %g nm\n", sigHS);
fprintf(fplog, "DoS0 = %g\n", DoS0);
fprintf(fplog, "Dos2 = %g\n", dos2);
fprintf(fplog, "DoSTot = %g\n", dostot);
/* Now compute solid (2) and diffusive (3) components */
fp = xvgropen(opt2fn("-dos", NFILE, fnm), "Density of states",
bRecip ? "E (cm\\S-1\\N)" : "\\f{12}n\\f{4} (1/ps)",
"\\f{4}S(\\f{12}n\\f{4})", oenv);
xvgr_legend(fp, asize(DoSlegend), DoSlegend, oenv);
recip_fac = bRecip ? (1e7/SPEED_OF_LIGHT) : 1.0;
for (j = 0; (j < nframes/4); j++)
{
dos[DOS_DIFF][j] = DoS0/(1+sqr(DoS0*M_PI*nu[j]/(6*f*Natom)));
dos[DOS_SOLID][j] = dos[DOS][j]-dos[DOS_DIFF][j];
fprintf(fp, "%10g %10g %10g %10g\n",
recip_fac*nu[j],
dos[DOS][j]/recip_fac,
dos[DOS_SOLID][j]/recip_fac,
dos[DOS_DIFF][j]/recip_fac);
}
xvgrclose(fp);
/* Finally analyze the results! */
wCdiff = 0.5;
wSdiff = Shs/(3*BOLTZ); /* Is this correct? */
wEdiff = 0.5;
wAdiff = wEdiff-wSdiff;
for (j = 0; (j < nframes/4); j++)
{
dos[DOS_CP][j] = (dos[DOS_DIFF][j]*wCdiff +
dos[DOS_SOLID][j]*wCsolid(nu[j], beta));
dos[DOS_S][j] = (dos[DOS_DIFF][j]*wSdiff +
dos[DOS_SOLID][j]*wSsolid(nu[j], beta));
dos[DOS_A][j] = (dos[DOS_DIFF][j]*wAdiff +
dos[DOS_SOLID][j]*wAsolid(nu[j], beta));
dos[DOS_E][j] = (dos[DOS_DIFF][j]*wEdiff +
dos[DOS_SOLID][j]*wEsolid(nu[j], beta));
}
DiffCoeff = evaluate_integral(nframes/2, tt, dos[VACF], NULL, nframes/2, &stddev);
DiffCoeff = 1000*DiffCoeff/3.0;
fprintf(fplog, "Diffusion coefficient from VACF %g 10^-5 cm^2/s\n",
DiffCoeff);
fprintf(fplog, "Diffusion coefficient from DoS %g 10^-5 cm^2/s\n",
1000*DoS0/(12*tmass*beta));
cP = BOLTZ * evaluate_integral(nframes/4, nu, dos[DOS_CP], NULL,
nframes/4, &stddev);
fprintf(fplog, "Heat capacity %g J/mol K\n", 1000*cP/Nmol);
/*
S = BOLTZ * evaluate_integral(nframes/4,nu,dos[DOS_S],NULL,
nframes/4,&stddev);
fprintf(fplog,"Entropy %g J/mol K\n",1000*S/Nmol);
A = BOLTZ * evaluate_integral(nframes/4,nu,dos[DOS_A],NULL,
nframes/4,&stddev);
fprintf(fplog,"Helmholtz energy %g kJ/mol\n",A/Nmol);
E = BOLTZ * evaluate_integral(nframes/4,nu,dos[DOS_E],NULL,
nframes/4,&stddev);
fprintf(fplog,"Internal energy %g kJ/mol\n",E/Nmol);
*/
fprintf(fplog, "\nArrivederci!\n");
gmx_fio_fclose(fplog);
do_view(oenv, ftp2fn(efXVG, NFILE, fnm), "-nxy");
thanx(stderr);
return 0;
}
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);
}
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;
}
int gmx_velacc(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes the velocity autocorrelation function.",
"When the [TT]-m[tt] option is used, the momentum autocorrelation",
"function is calculated.[PAR]",
"With option [TT]-mol[tt] the velocity autocorrelation function of",
"molecules is calculated. In this case the index group should consist",
"of molecule numbers instead of atom numbers.[PAR]",
"Be sure that your trajectory contains frames with velocity information",
"(i.e. [TT]nstvout[tt] was set in your original [REF].mdp[ref] file),",
"and that the time interval between data collection points is",
"much shorter than the time scale of the autocorrelation."
};
static gmx_bool bMass = FALSE, bMol = FALSE, bRecip = TRUE;
t_pargs pa[] = {
{ "-m", FALSE, etBOOL, {&bMass},
"Calculate the momentum autocorrelation function" },
{ "-recip", FALSE, etBOOL, {&bRecip},
"Use cm^-1 on X-axis instead of 1/ps for spectra." },
{ "-mol", FALSE, etBOOL, {&bMol},
"Calculate the velocity acf of molecules" }
};
t_topology top;
int ePBC = -1;
t_trxframe fr;
matrix box;
gmx_bool bTPS = FALSE, bTop = FALSE;
int gnx;
int *index;
char *grpname;
/* t0, t1 are the beginning and end time respectively.
* dt is the time step, mass is temp variable for atomic mass.
*/
real t0, t1, dt, mass;
t_trxstatus *status;
int counter, n_alloc, i, j, counter_dim, k, l;
rvec mv_mol;
/* Array for the correlation function */
real **c1;
real *normm = NULL;
gmx_output_env_t *oenv;
#define NHISTO 360
t_filenm fnm[] = {
{ efTRN, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-o", "vac", ffWRITE },
{ efXVG, "-os", "spectrum", 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_VIEW | PCA_CAN_TIME,
NFILE, fnm, npargs, ppa, asize(desc), desc, 0, NULL, &oenv))
{
sfree(ppa);
return 0;
}
if (bMol || bMass)
{
bTPS = ftp2bSet(efTPS, NFILE, fnm) || !ftp2bSet(efNDX, NFILE, fnm);
}
if (bTPS)
{
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, NULL, NULL, box,
TRUE);
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &gnx, &index, &grpname);
}
else
{
rd_index(ftp2fn(efNDX, NFILE, fnm), 1, &gnx, &index, &grpname);
}
if (bMol)
{
if (!bTop)
{
gmx_fatal(FARGS, "Need a topology to determine the molecules");
}
snew(normm, top.atoms.nr);
precalc(top, normm);
index_atom2mol(&gnx, index, &top.mols);
}
/* Correlation stuff */
snew(c1, gnx);
for (i = 0; (i < gnx); i++)
{
c1[i] = NULL;
}
read_first_frame(oenv, &status, ftp2fn(efTRN, NFILE, fnm), &fr, TRX_NEED_V);
t0 = fr.time;
n_alloc = 0;
counter = 0;
do
{
if (counter >= n_alloc)
{
n_alloc += 100;
for (i = 0; i < gnx; i++)
{
srenew(c1[i], DIM*n_alloc);
}
}
counter_dim = DIM*counter;
if (bMol)
{
for (i = 0; i < gnx; i++)
{
clear_rvec(mv_mol);
k = top.mols.index[index[i]];
l = top.mols.index[index[i]+1];
for (j = k; j < l; j++)
{
if (bMass)
{
mass = top.atoms.atom[j].m;
}
else
{
mass = normm[j];
}
mv_mol[XX] += mass*fr.v[j][XX];
mv_mol[YY] += mass*fr.v[j][YY];
mv_mol[ZZ] += mass*fr.v[j][ZZ];
}
c1[i][counter_dim+XX] = mv_mol[XX];
c1[i][counter_dim+YY] = mv_mol[YY];
c1[i][counter_dim+ZZ] = mv_mol[ZZ];
}
}
else
{
for (i = 0; i < gnx; i++)
{
if (bMass)
{
mass = top.atoms.atom[index[i]].m;
}
else
{
mass = 1;
}
c1[i][counter_dim+XX] = mass*fr.v[index[i]][XX];
c1[i][counter_dim+YY] = mass*fr.v[index[i]][YY];
c1[i][counter_dim+ZZ] = mass*fr.v[index[i]][ZZ];
}
}
t1 = fr.time;
counter++;
}
while (read_next_frame(oenv, status, &fr));
close_trj(status);
if (counter >= 4)
{
/* Compute time step between frames */
dt = (t1-t0)/(counter-1);
do_autocorr(opt2fn("-o", NFILE, fnm), oenv,
bMass ?
"Momentum Autocorrelation Function" :
"Velocity Autocorrelation Function",
counter, gnx, c1, dt, eacVector, TRUE);
do_view(oenv, opt2fn("-o", NFILE, fnm), "-nxy");
if (opt2bSet("-os", NFILE, fnm))
{
calc_spectrum(counter/2, (real *) (c1[0]), (t1-t0)/2, opt2fn("-os", NFILE, fnm),
oenv, bRecip);
do_view(oenv, opt2fn("-os", NFILE, fnm), "-nxy");
}
}
else
{
fprintf(stderr, "Not enough frames in trajectory - no output generated.\n");
}
return 0;
}
int gmx_trjcat(int argc,char *argv[])
{
static char *desc[] = {
"trjcat concatenates several input trajectory files in sorted order. ",
"In case of double time frames the one in the later file is used. ",
"By specifying [TT]-settime[tt] you will be asked for the start time ",
"of each file. The input files are taken from the command line, ",
"such that a command like [TT]trjcat -o fixed.trr *.trr[tt] should do ",
"the trick. Using [TT]-cat[tt] you can simply paste several files ",
"together without removal of frames with identical time stamps.[PAR]",
"One important option is inferred when the output file is amongst the",
"input files. In that case that particular file will be appended to",
"which implies you do not need to store double the amount of data.",
"Obviously the file to append to has to be the one with lowest starting",
"time since one can only append at the end of a file.[PAR]",
"If the [TT]-demux[tt] option is given, the N trajectories that are",
"read, are written in another order as specified in the xvg file."
"The xvg file should contain something like:[PAR]",
"0 0 1 2 3 4 5[BR]",
"2 1 0 2 3 5 4[BR]",
"Where the first number is the time, and subsequent numbers point to",
"trajectory indices.",
"The frames corresponding to the numbers present at the first line",
"are collected into the output trajectory. If the number of frames in",
"the trajectory does not match that in the xvg file then the program",
"tries to be smart. Beware."
};
static bool bVels=TRUE;
static int prec=3;
static bool bCat=FALSE;
static bool bSort=TRUE;
static bool bKeepLast=FALSE;
static bool bSetTime=FALSE;
static bool bDeMux;
static real begin=-1;
static real end=-1;
static real dt=0;
t_pargs pa[] = {
{ "-b", FALSE, etTIME, {&begin},
"First time to use (%t)"},
{ "-e", FALSE, etTIME, {&end},
"Last time to use (%t)"},
{ "-dt", FALSE, etTIME, {&dt},
"Only write frame when t MOD dt = first time (%t)" },
{ "-prec", FALSE, etINT, {&prec},
"Precision for .xtc and .gro writing in number of decimal places" },
{ "-vel", FALSE, etBOOL, {&bVels},
"Read and write velocities if possible" },
{ "-settime", FALSE, etBOOL, {&bSetTime},
"Change starting time interactively" },
{ "-sort", FALSE, etBOOL, {&bSort},
"Sort trajectory files (not frames)" },
{ "-keeplast",FALSE, etBOOL, {&bKeepLast},
"keep overlapping frames at end of trajectory" },
{ "-cat", FALSE, etBOOL, {&bCat},
"do not discard double time frames" }
};
#define npargs asize(pa)
int status,ftpin,i,frame,frame_out,step=0,trjout=0;
rvec *x,*v;
real xtcpr,t_corr;
t_trxframe fr,frout;
char **fnms,**fnms_out,*in_file,*out_file;
int n_append;
int trxout=-1;
bool bNewFile,bIndex,bWrite;
int earliersteps,nfile_in,nfile_out,*cont_type,last_ok_step;
real *readtime,*timest,*settime;
real first_time=0,lasttime=NOTSET,last_ok_t=-1,timestep;
int isize,j;
atom_id *index=NULL,imax;
char *grpname;
real **val=NULL,*t=NULL,dt_remd;
int n,nset;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffRDMULT },
{ efTRO, "-o", NULL, ffWRMULT },
{ efNDX, "-n", "index", ffOPTRD },
{ efXVG, "-demux", "remd", ffOPTRD }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_BE_NICE|PCA_TIME_UNIT,
NFILE,fnm,asize(pa),pa,asize(desc),desc,
0,NULL);
bIndex = ftp2bSet(efNDX,NFILE,fnm);
bDeMux = ftp2bSet(efXVG,NFILE,fnm);
bSort = bSort && !bDeMux;
imax=NO_ATID;
if (bIndex) {
printf("Select group for output\n");
rd_index(ftp2fn(efNDX,NFILE,fnm),1,&isize,&index,&grpname);
/* scan index */
imax=index[0];
for(i=1; i<isize; i++)
imax = max(imax, index[i]);
}
if (bDeMux) {
nset = 0;
dt_remd = 0;
val=read_xvg_time(opt2fn("-demux",NFILE,fnm),TRUE,
opt2parg_bSet("-b",npargs,pa),begin,
opt2parg_bSet("-e",npargs,pa),end,
1,&nset,&n,&dt_remd,&t);
printf("Read %d sets of %d points, dt = %g\n\n",nset,n,dt_remd);
if (debug) {
fprintf(debug,"Dump of replica_index.xvg\n");
for(i=0; (i<n); i++) {
fprintf(debug,"%10g",t[i]);
for(j=0; (j<nset); j++) {
fprintf(debug," %3d",gmx_nint(val[j][i]));
}
fprintf(debug,"\n");
}
}
}
/* prec is in nr of decimal places, xtcprec is a multiplication factor: */
xtcpr=1;
for (i=0; i<prec; i++)
xtcpr*=10;
nfile_in = opt2fns(&fnms,"-f",NFILE,fnm);
if (!nfile_in)
gmx_fatal(FARGS,"No input files!");
if (bDeMux && (nfile_in != nset))
gmx_fatal(FARGS,"You have specified %d files and %d entries in the demux table",nfile_in,nset);
nfile_out = opt2fns(&fnms_out,"-o",NFILE,fnm);
if (!nfile_out)
gmx_fatal(FARGS,"No output files!");
if ((nfile_out > 1) && !bDeMux)
gmx_fatal(FARGS,"Don't know what to do with more than 1 output file if not demultiplexing");
else if (bDeMux && (nfile_out != nset) && (nfile_out != 1))
gmx_fatal(FARGS,"Number of output files should be 1 or %d (#input files), not %d",nset,nfile_out);
if (bDeMux) {
if (nfile_out != nset) {
char *buf = strdup(fnms_out[0]);
snew(fnms_out,nset);
for(i=0; (i<nset); i++) {
snew(fnms_out[i],strlen(buf)+32);
sprintf(fnms_out[i],"%d_%s",i,buf);
}
}
do_demux(nfile_in,fnms,fnms_out,n,val,t,dt_remd,isize,index,dt);
}
else {
snew(readtime,nfile_in+1);
snew(timest,nfile_in+1);
scan_trj_files(fnms,nfile_in,readtime,timest,imax);
snew(settime,nfile_in+1);
snew(cont_type,nfile_in+1);
edit_files(fnms,nfile_in,readtime,timest,settime,cont_type,bSetTime,bSort);
/* Check whether the output file is amongst the input files
* This has to be done after sorting etc.
*/
out_file = fnms_out[0];
n_append = -1;
for(i=0; ((i<nfile_in) && (n_append==-1)); i++) {
if (strcmp(fnms[i],out_file) == 0) {
n_append = i;
}
}
if (n_append == 0)
fprintf(stderr,"Will append to %s rather than creating a new file\n",
out_file);
else if (n_append != -1)
gmx_fatal(FARGS,"Can only append to the first file which is %s (not %s)",
fnms[0],out_file);
earliersteps=0;
/* Not checking input format, could be dangerous :-) */
/* Not checking output format, equally dangerous :-) */
frame=-1;
frame_out=-1;
/* the default is not to change the time at all,
* but this is overridden by the edit_files routine
*/
t_corr=0;
if (n_append == -1) {
trxout = open_trx(out_file,"w");
memset(&frout,0,sizeof(frout));
}
else {
/* Read file to find what is the last frame in it */
if (!read_first_frame(&status,out_file,&fr,FLAGS))
gmx_fatal(FARGS,"Reading first frame from %s",out_file);
while (read_next_frame(status,&fr))
;
close_trj(status);
lasttime = fr.time;
bKeepLast = TRUE;
trxout = open_trx(out_file,"a");
frout = fr;
}
/* Lets stitch up some files */
timestep = timest[0];
for(i=n_append+1; (i<nfile_in); i++) {
/* Open next file */
/* set the next time from the last frame in previous file */
if (i > 0) {
if (frame_out >= 0) {
if(cont_type[i]==TIME_CONTINUE) {
begin =frout.time;
begin += 0.5*timestep;
settime[i]=frout.time;
cont_type[i]=TIME_EXPLICIT;
}
else if(cont_type[i]==TIME_LAST) {
begin=frout.time;
begin += 0.5*timestep;
}
/* Or, if the time in the next part should be changed by the
* same amount, start at half a timestep from the last time
* so we dont repeat frames.
*/
/* I don't understand the comment above, but for all the cases
* I tried the code seems to work properly. B. Hess 2008-4-2.
*/
}
/* Or, if time is set explicitly, we check for overlap/gap */
if(cont_type[i]==TIME_EXPLICIT)
if( ( i < nfile_in ) &&
( frout.time < settime[i]-1.5*timestep ) )
fprintf(stderr, "WARNING: Frames around t=%f %s have a different "
"spacing than the rest,\n"
"might be a gap or overlap that couldn't be corrected "
"automatically.\n",convert_time(frout.time),time_unit());
}
/* if we don't have a timestep in the current file, use the old one */
if ( timest[i] != 0 )
timestep = timest[i];
read_first_frame(&status,fnms[i],&fr,FLAGS);
if(!fr.bTime) {
fr.time=0;
fprintf(stderr,"\nWARNING: Couldn't find a time in the frame.\n");
}
if(cont_type[i]==TIME_EXPLICIT)
t_corr=settime[i]-fr.time;
/* t_corr is the amount we want to change the time.
* If the user has chosen not to change the time for
* this part of the trajectory t_corr remains at
* the value it had in the last part, changing this
* by the same amount.
* If no value was given for the first trajectory part
* we let the time start at zero, see the edit_files routine.
*/
bNewFile=TRUE;
printf("\n");
if (lasttime != NOTSET)
printf("lasttime %g\n", lasttime);
do {
/* copy the input frame to the output frame */
frout=fr;
/* set the new time by adding the correct calculated above */
frout.time += t_corr;
/* quit if we have reached the end of what should be written */
if((end > 0) && (frout.time > end+GMX_REAL_EPS)) {
i=nfile_in;
break;
}
/* determine if we should write this frame (dt is handled elsewhere) */
if (bCat) /* write all frames of all files */
bWrite = TRUE;
else if ( bKeepLast ) /* write till last frame of this traj
and skip first frame(s) of next traj */
bWrite = ( frout.time > lasttime+0.5*timestep );
else /* write till first frame of next traj */
bWrite = ( frout.time < settime[i+1]-0.5*timestep );
if( bWrite && (frout.time >= begin) ) {
frame++;
if (frame_out == -1)
first_time = frout.time;
lasttime = frout.time;
if (dt==0 || bRmod(frout.time,first_time,dt)) {
frame_out++;
last_ok_t=frout.time;
if(bNewFile) {
fprintf(stderr,"\nContinue writing frames from %s t=%g %s, "
"frame=%d \n",
fnms[i],convert_time(frout.time),time_unit(),frame);
bNewFile=FALSE;
}
if (bIndex)
write_trxframe_indexed(trxout,&frout,isize,index);
else
write_trxframe(trxout,&frout);
if ( ((frame % 10) == 0) || (frame < 10) )
fprintf(stderr," -> frame %6d time %8.3f %s \r",
frame_out,convert_time(frout.time),time_unit());
}
}
} while( read_next_frame(status,&fr));
close_trj(status);
earliersteps+=step;
}
if (trxout >= 0)
close_trx(trxout);
fprintf(stderr,"\nLast frame written was %d, time %f %s\n",
frame,convert_time(last_ok_t),time_unit());
}
thanx(stderr);
return 0;
}
extern int do_scattering_intensity (const char* fnTPS, const char* fnNDX,
const char* fnXVG, const char *fnTRX,
const char* fnDAT,
real start_q, real end_q,
real energy, int ng, const output_env_t oenv)
{
int i, *isize, flags = TRX_READ_X, **index_atp;
t_trxstatus *status;
char **grpname, title[STRLEN];
atom_id **index;
t_topology top;
int ePBC;
t_trxframe fr;
reduced_atom_t **red;
structure_factor *sf;
rvec *xtop;
real **sf_table;
int nsftable;
matrix box;
double r_tmp;
gmx_structurefactors_t *gmx_sf;
real *a, *b, c;
int success;
snew(a, 4);
snew(b, 4);
gmx_sf = gmx_structurefactors_init(fnDAT);
success = gmx_structurefactors_get_sf(gmx_sf, 0, a, b, &c);
snew (sf, 1);
sf->energy = energy;
/* Read the topology informations */
read_tps_conf (fnTPS, title, &top, &ePBC, &xtop, NULL, box, TRUE);
sfree (xtop);
/* groups stuff... */
snew (isize, ng);
snew (index, ng);
snew (grpname, ng);
fprintf (stderr, "\nSelect %d group%s\n", ng,
ng == 1 ? "" : "s");
if (fnTPS)
{
get_index (&top.atoms, fnNDX, ng, isize, index, grpname);
}
else
{
rd_index (fnNDX, ng, isize, index, grpname);
}
/* The first time we read data is a little special */
read_first_frame (oenv, &status, fnTRX, &fr, flags);
sf->total_n_atoms = fr.natoms;
snew (red, ng);
snew (index_atp, ng);
r_tmp = max (box[XX][XX], box[YY][YY]);
r_tmp = (double) max (box[ZZ][ZZ], r_tmp);
sf->ref_k = (2.0 * M_PI) / (r_tmp);
/* ref_k will be the reference momentum unit */
sf->n_angles = (int) (end_q / sf->ref_k + 0.5);
snew (sf->F, ng);
for (i = 0; i < ng; i++)
{
snew (sf->F[i], sf->n_angles);
}
for (i = 0; i < ng; i++)
{
snew (red[i], isize[i]);
rearrange_atoms (red[i], &fr, index[i], isize[i], &top, TRUE, gmx_sf);
index_atp[i] = create_indexed_atom_type (red[i], isize[i]);
}
sf_table = compute_scattering_factor_table (gmx_sf, (structure_factor_t *)sf);
/* This is the main loop over frames */
do
{
sf->nSteps++;
for (i = 0; i < ng; i++)
{
rearrange_atoms (red[i], &fr, index[i], isize[i], &top, FALSE, gmx_sf);
compute_structure_factor ((structure_factor_t *)sf, box, red[i], isize[i],
start_q, end_q, i, sf_table);
}
}
while (read_next_frame (oenv, status, &fr));
save_data ((structure_factor_t *)sf, fnXVG, ng, start_q, end_q, oenv);
sfree(a);
sfree(b);
gmx_structurefactors_done(gmx_sf);
return 0;
}
int gmx_bundle(int argc,char *argv[])
{
const char *desc[] = {
"g_bundle analyzes bundles of axes. The axes can be for instance",
"helix axes. The program reads two index groups and divides both",
"of them in [TT]-na[tt] parts. The centers of mass of these parts",
"define the tops and bottoms of the axes.",
"Several quantities are written to file:",
"the axis length, the distance and the z-shift of the axis mid-points",
"with respect to the average center of all axes, the total tilt,",
"the radial tilt and the lateral tilt with respect to the average axis.",
"[PAR]",
"With options [TT]-ok[tt], [TT]-okr[tt] and [TT]-okl[tt] the total,",
"radial and lateral kinks of the axes are plotted. An extra index",
"group of kink atoms is required, which is also divided into [TT]-na[tt]",
"parts. The kink angle is defined as the angle between the kink-top and",
"the bottom-kink vectors.",
"[PAR]",
"With option [TT]-oa[tt] the top, mid (or kink when [TT]-ok[tt] is set)",
"and bottom points of each axis",
"are written to a pdb file each frame. The residue numbers correspond",
"to the axis numbers. When viewing this file with [TT]rasmol[tt], use the",
"command line option [TT]-nmrpdb[tt], and type [TT]set axis true[tt] to",
"display the reference axis."
};
static int n=0;
static gmx_bool bZ=FALSE;
t_pargs pa[] = {
{ "-na", FALSE, etINT, {&n},
"Number of axes" },
{ "-z", FALSE, etBOOL, {&bZ},
"Use the Z-axis as reference iso the average axis" }
};
FILE *out,*flen,*fdist,*fz,*ftilt,*ftiltr,*ftiltl;
FILE *fkink=NULL,*fkinkr=NULL,*fkinkl=NULL;
t_trxstatus *status;
t_trxstatus *fpdb;
t_topology top;
int ePBC;
rvec *xtop;
matrix box;
t_trxframe fr;
t_atoms outatoms;
real t,comp;
int natoms;
char *grpname[MAX_ENDS],title[256];
/* FIXME: The constness should not be cast away */
char *anm=(char *)"CA",*rnm=(char *)"GLY";
int i,j,gnx[MAX_ENDS];
atom_id *index[MAX_ENDS];
t_bundle bun;
gmx_bool bKink;
rvec va,vb,vc,vr,vl;
output_env_t oenv;
gmx_rmpbc_t gpbc=NULL;
#define NLEG asize(leg)
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-ol", "bun_len", ffWRITE },
{ efXVG, "-od", "bun_dist", ffWRITE },
{ efXVG, "-oz", "bun_z", ffWRITE },
{ efXVG, "-ot", "bun_tilt", ffWRITE },
{ efXVG, "-otr", "bun_tiltr", ffWRITE },
{ efXVG, "-otl", "bun_tiltl", ffWRITE },
{ efXVG, "-ok", "bun_kink", ffOPTWR },
{ efXVG, "-okr", "bun_kinkr", ffOPTWR },
{ efXVG, "-okl", "bun_kinkl", ffOPTWR },
{ efPDB, "-oa", "axes", 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);
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xtop,NULL,box,TRUE);
bKink = opt2bSet("-ok",NFILE,fnm) || opt2bSet("-okr",NFILE,fnm)
|| opt2bSet("-okl",NFILE,fnm);
if (bKink)
bun.nend = 3;
else
bun.nend = 2;
fprintf(stderr,"Select a group of top and a group of bottom ");
if (bKink)
fprintf(stderr,"and a group of kink ");
fprintf(stderr,"atoms\n");
get_index(&top.atoms,ftp2fn_null(efNDX,NFILE,fnm),bun.nend,
gnx,index,grpname);
if (n<=0 || gnx[0] % n || gnx[1] % n || (bKink && gnx[2] % n))
gmx_fatal(FARGS,
"The size of one of your index groups is not a multiple of n");
bun.n = n;
snew(bun.end[0],n);
snew(bun.end[1],n);
if (bKink)
snew(bun.end[2],n);
snew(bun.mid,n);
snew(bun.dir,n);
snew(bun.len,n);
flen = xvgropen(opt2fn("-ol",NFILE,fnm),"Axis lengths",
output_env_get_xvgr_tlabel(oenv),"(nm)",oenv);
fdist = xvgropen(opt2fn("-od",NFILE,fnm),"Distance of axis centers",
output_env_get_xvgr_tlabel(oenv),"(nm)",oenv);
fz = xvgropen(opt2fn("-oz",NFILE,fnm),"Z-shift of axis centers",
output_env_get_xvgr_tlabel(oenv),"(nm)",oenv);
ftilt = xvgropen(opt2fn("-ot",NFILE,fnm),"Axis tilts",
output_env_get_xvgr_tlabel(oenv),"(degrees)",oenv);
ftiltr = xvgropen(opt2fn("-otr",NFILE,fnm),"Radial axis tilts",
output_env_get_xvgr_tlabel(oenv),"(degrees)",oenv);
ftiltl = xvgropen(opt2fn("-otl",NFILE,fnm),"Lateral axis tilts",
output_env_get_xvgr_tlabel(oenv),"(degrees)",oenv);
if (bKink) {
fkink = xvgropen(opt2fn("-ok",NFILE,fnm),"Kink angles",
output_env_get_xvgr_tlabel(oenv),"(degrees)",oenv);
fkinkr = xvgropen(opt2fn("-okr",NFILE,fnm),"Radial kink angles",
output_env_get_xvgr_tlabel(oenv),"(degrees)",oenv);
if (output_env_get_print_xvgr_codes(oenv))
fprintf(fkinkr,"@ subtitle \"+ = ) ( - = ( )\"\n");
fkinkl = xvgropen(opt2fn("-okl",NFILE,fnm),"Lateral kink angles",
output_env_get_xvgr_tlabel(oenv),"(degrees)",oenv);
}
if (opt2bSet("-oa",NFILE,fnm)) {
init_t_atoms(&outatoms,3*n,FALSE);
outatoms.nr = 3*n;
for(i=0; i<3*n; i++) {
outatoms.atomname[i] = &anm;
outatoms.atom[i].resind = i/3;
outatoms.resinfo[i/3].name = &rnm;
outatoms.resinfo[i/3].nr = i/3 + 1;
outatoms.resinfo[i/3].ic = ' ';
}
fpdb = open_trx(opt2fn("-oa",NFILE,fnm),"w");
} else
fpdb = NULL;
read_first_frame(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&fr,TRX_NEED_X);
gpbc = gmx_rmpbc_init(&top.idef,ePBC,fr.natoms,fr.box);
do {
gmx_rmpbc_trxfr(gpbc,&fr);
calc_axes(fr.x,top.atoms.atom,gnx,index,!bZ,&bun);
t = output_env_conv_time(oenv,fr.time);
fprintf(flen," %10g",t);
fprintf(fdist," %10g",t);
fprintf(fz," %10g",t);
fprintf(ftilt," %10g",t);
fprintf(ftiltr," %10g",t);
fprintf(ftiltl," %10g",t);
if (bKink) {
fprintf(fkink," %10g",t);
fprintf(fkinkr," %10g",t);
fprintf(fkinkl," %10g",t);
}
for(i=0; i<bun.n; i++) {
fprintf(flen," %6g",bun.len[i]);
fprintf(fdist," %6g",norm(bun.mid[i]));
fprintf(fz," %6g",bun.mid[i][ZZ]);
fprintf(ftilt," %6g",RAD2DEG*acos(bun.dir[i][ZZ]));
comp = bun.mid[i][XX]*bun.dir[i][XX]+bun.mid[i][YY]*bun.dir[i][YY];
fprintf(ftiltr," %6g",RAD2DEG*
asin(comp/sqrt(sqr(comp)+sqr(bun.dir[i][ZZ]))));
comp = bun.mid[i][YY]*bun.dir[i][XX]-bun.mid[i][XX]*bun.dir[i][YY];
fprintf(ftiltl," %6g",RAD2DEG*
asin(comp/sqrt(sqr(comp)+sqr(bun.dir[i][ZZ]))));
if (bKink) {
rvec_sub(bun.end[0][i],bun.end[2][i],va);
rvec_sub(bun.end[2][i],bun.end[1][i],vb);
unitv_no_table(va,va);
unitv_no_table(vb,vb);
fprintf(fkink," %6g",RAD2DEG*acos(iprod(va,vb)));
cprod(va,vb,vc);
copy_rvec(bun.mid[i],vr);
vr[ZZ] = 0;
unitv_no_table(vr,vr);
fprintf(fkinkr," %6g",RAD2DEG*asin(iprod(vc,vr)));
vl[XX] = vr[YY];
vl[YY] = -vr[XX];
vl[ZZ] = 0;
fprintf(fkinkl," %6g",RAD2DEG*asin(iprod(vc,vl)));
}
}
fprintf(flen,"\n");
fprintf(fdist,"\n");
fprintf(fz,"\n");
fprintf(ftilt,"\n");
fprintf(ftiltr,"\n");
fprintf(ftiltl,"\n");
if (bKink) {
fprintf(fkink,"\n");
fprintf(fkinkr,"\n");
fprintf(fkinkl,"\n");
}
if (fpdb )
dump_axes(fpdb,&fr,&outatoms,&bun);
} while(read_next_frame(oenv,status,&fr));
gmx_rmpbc_done(gpbc);
close_trx(status);
if (fpdb )
close_trx(fpdb);
ffclose(flen);
ffclose(fdist);
ffclose(fz);
ffclose(ftilt);
ffclose(ftiltr);
ffclose(ftiltl);
if (bKink) {
ffclose(fkink);
ffclose(fkinkr);
ffclose(fkinkl);
}
thanx(stderr);
return 0;
}
int main(int argn, char* args[])
{
static char *desc[] = {
"This script will read the xtc trajectory from an MD simulation",
"performed by GROMACS and output all data related to the analysis",
"of preferential interactions.",
"[PAR]",
"Generated: Thu Aug 20 16:49:21 EDT 2015.[BR]",
"Last updated: Thu Aug 27 17:26:01 EDT 2015.",
"[PAR]",
"Future Developments:[BR]",
"[BB]1.[bb] Partition calculation into groups (constituent amino acids).[BR]",
"[BB]2.[bb] Calculate residence times.[BR]",
"[BB]3.[bb] Include a measure for geometric orientation.[BR]",
"[BB]4.[bb] Calculate molecular distributions.[BR]",
"[BB]5.[bb] Parallelize it.",
"[PAR]",
"Remember to check the dependencie of the results on the number of block",
" used by using [TT]-block[tt].",
"Also, check that your simulation has been properly equilibrated by using [TT]-f0[tt].",
"In terms of reducing the computational cost of the analysis, use the option",
"[TT]-skip[tt] to only use every nr[TT]-th[tt] frame from the trajectory."
};
unsigned int protein_sequence=20; /* parse tpr.itp for info */
unsigned int N_co=4; /* look at topology for number of co-solvents */
unsigned int num_sol=7906; /* look at topology as well */
unsigned int skip_nr=1;
unsigned int granularity=2*100;
unsigned int f0=0;
bool bIndex=false;
t_pargs pa[] = {
{"-start", FALSE, etINT, {&f0}, "Start after n-th frame."},
{"-skip", FALSE, etINT, {&skip_nr}, "Only write every nr-th frame."},
{"-grid", FALSE, etINT, {&granularity}, "Number points to calculate."},
{"-seq", FALSE, etINT,{&protein_sequence}, "Number of amino acids in protein sequence."},
{"-Nco", FALSE, etINT,{&N_co}, "Number of cosolvent molecules."},
{"-Sol", FALSE, etINT,{&num_sol}, "Number of water molecules."}
};
char title[STRLEN];
t_topology top;
int ePBC;
rvec *xtop;
matrix box;
t_filenm fnm[] = { /* See filenm.h */
{ efTOP, NULL, NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD }, /* topology */
{ efTRX, "-f", NULL, ffREAD }, /* trajcetory */
{ efNDX, "-n", NULL, ffOPTRD } /* index file */
};
#define NFILE asize(fnm)
/* Interface. Adds default options. */
CopyRight(stderr,args[0]);
parse_common_args(&argn,args,PCA_CAN_TIME | PCA_CAN_VIEW, NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL);
read_tps_conf( ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC, &xtop, NULL, box, TRUE);
sfree(xtop);
/*******************************************************************************************************************/
/*
int iter;
for (iter=0;iter<top.atoms.nr/100;++iter)
{
printf("Atom name: %s\tAtom charge: %f\n", *(top.atoms.atomname[iter]), top.atoms.atom[iter].q );
printf("Atom type: %d\tAtomic Residue NUmber: %d\n", top.atoms.atom[iter].type, top.atoms.atom[iter].resnr );
printf("Chain Identifier: %u\tNr of residues names: %d\n", top.atoms.atom[iter].ptype, top.atoms.nres );
printf("Residue name: %s\n\n", *(top.atoms.resname[iter]) );
}
*/
/*******************************************************************************************************************/
int status;
t_trxframe fr;
int flags = TRX_READ_X;
/* Count Number of Frames */
unsigned int bframes=0, frames=0;
int bwrite;
read_first_frame(&status, ftp2fn(efTRX,NFILE,fnm), &fr, flags);
do {
bwrite = bframes % skip_nr;
++bframes;
if ((bframes>f0) && (bwrite==0)){ ++frames; }
} while ( read_next_frame(status,&fr) );
/* Preparing Block Analysis */
bIndex = ftp2bSet(efNDX,NFILE,fnm);
std::vector<int> blocks_list;
if (bIndex)
{
FILE *fp = ffopen(opt2fn("-n",NFILE,fnm),"r");
int numblock;
while(fscanf(fp,"%d",&numblock)!=EOF)
{
blocks_list.push_back(numblock);
}
fclose(fp);
} else {
blocks_list.push_back(1);
}
/* Actual Calculation */
std::vector<Info> protein;
std::vector<Info> cosolvent;
std::vector<Info> solvent;
std::vector<double> cutoff, coefficients;
double molals=0, molars=0;
/* BLOCK AVERAGE */
typedef std::vector<double> Row;
typedef std::vector<Row> Matrix;
unsigned int num_blocks;
/////////////
//////////// std::ofstream test_partition("partition.txt");
for (unsigned int iter=0; iter<blocks_list.size(); ++iter)
{
num_blocks = blocks_list[iter];
unsigned int partition = (frames)/num_blocks;
unsigned int frame_counter=0;
std::vector<double> positions(granularity), averages(granularity), averages_sqr(granularity), sigma(granularity);
Matrix values(num_blocks,Row(granularity)), values_sqr(num_blocks,Row(granularity));
unsigned int frame=0, twrite=0;
read_first_frame(&status, ftp2fn(efTRX,NFILE,fnm), &fr, flags);
do
{
twrite = frame % skip_nr; /* if twrite==0 then read frame. */
++frame;
if ((frame > f0) && (twrite==0))
{
/* READING */
unsigned int protein_co=protein_sequence+N_co;
unsigned int solvated=protein_co+num_sol;
for (unsigned int n=0; n<top.atoms.nr; ++n)
{
/* Parsing */
Info atomo;
atomo.setAtom( (std::string) *(top.atoms.atomname[n]) );
atomo.setResnum( (unsigned int) top.atoms.atom[n].resnr );
atomo.setResname( (std::string) *(top.atoms.resname[atomo.getResnum()]) );
atomo.setCoords( (double) fr.x[n][XX], (double) fr.x[n][YY], (double) fr.x[n][ZZ] );
/* Testing for partition of groups */
/////// atomo.print(test_partition);
/* Appending */
// if
if ( atomo.getAtom()[0]!='H') // atomo.atom[0]!='H')
{
if ( atomo.getResnum() < protein_sequence ){
protein.push_back(atomo);
} else if ( (atomo.getResnum() >= protein_sequence) && (atomo.getResnum() < protein_co) ){
cosolvent.push_back(atomo);
} else if ( (atomo.getResnum() >= protein_co) && (atomo.getResnum() < solvated) ){
// if (atomo.getResname().compare("SOL")!=0)
// we want to avoid inputing number of waters for analysis
solvent.push_back(atomo);
}
}
}
/* MAIN */
double box_size = fr.box[0][0];
/* Local calculation for cosolvents */
std::vector<double> close_co; /* Stores Distances of closest */
for (unsigned int i=0; i<N_co; ++i)
{
std::vector<double> local_co;
double minimum_calculated = box_size*box_size;
unsigned int Nco_size=cosolvent.size()/N_co;
for (unsigned int n=(i*Nco_size); n<((i+1)*Nco_size); ++n)
{
for (unsigned int j=0; j<protein.size(); ++j)
{
double dist = cosolvent[n].distance(protein[j],box_size);
if (dist < minimum_calculated ){ minimum_calculated = dist; }
}
local_co.push_back(minimum_calculated);
}
close_co.push_back( *min_element(local_co.begin(), local_co.end()) );
}
/* Local calculation for water */
std::vector<double> local_wat;
for (unsigned int i=0; i<solvent.size(); ++i)
{
double minimum_calculated = box_size*box_size;
for (unsigned int j=0; j<protein.size(); ++j)
{
double dist = solvent[i].distance(protein[j],box_size);
if (dist < minimum_calculated){ minimum_calculated = dist; }
}
local_wat.push_back(minimum_calculated);
}
/* Preferential Interaction Coefficient */
double N_wat = solvent.size();
linspace(0,box_size,granularity,cutoff);
for (unsigned int x=0; x<granularity; ++x)
{
unsigned int n3=0, n1=0;
for (unsigned int i=0; i<close_co.size(); ++i){ if (close_co[i] < (cutoff[x]*cutoff[x])) ++n3; }
for (unsigned int i=0; i<local_wat.size(); ++i){ if (local_wat[i] < (cutoff[x]*cutoff[x])) ++n1; }
coefficients.push_back(pref_coef(N_co, N_wat, n3, n1));
}
molals+= molality(N_co, (int) N_wat);
molars+= molarity(N_co, box_size);
/* Storage */
for (unsigned int i=0; i<granularity; ++i){ positions[i] += cutoff[i]; }
for (unsigned int j=0; j<granularity; ++j)
{
values[(int) (frame_counter/(partition+1))][j] += coefficients[j];
values_sqr[(int) (frame_counter/(partition+1))][j] += coefficients[j]*coefficients[j];
}
cutoff.clear();
coefficients.clear();
protein.clear();
cosolvent.clear();
solvent.clear();
++frame_counter;
}
} while ( read_next_frame(status,&fr) );
//thanx(stderr);
/* FINAL REUSLTS */
double normalization = partition;
molals /= (num_blocks*normalization);
molars /= (num_blocks*normalization);
for (unsigned int i=0; i<granularity; ++i){ positions[i] /= (num_blocks*normalization); }
for (unsigned int i=0; i<num_blocks; ++i)
{
for (unsigned int j=0; j<granularity; ++j)
{
values[i][j] /= normalization;
values_sqr[i][j] /= normalization;
}
}
/* AVERAGES */
for (unsigned int i=0; i<granularity; ++i)
{
for (unsigned int j=0; j<num_blocks; ++j)
{
averages[i] += values[j][i];
averages_sqr[i] += values_sqr[j][i];
}
averages[i] /= (double) num_blocks;
averages_sqr[i] /= (double) num_blocks;
}
/* STANDARD DEVIATIONS */
for (unsigned int i=0; i<granularity; ++i)
{
sigma[i] += sqrt( averages_sqr[i] - averages[i]*averages[i] );
}
/* OUTPUT */
std::ofstream distances("dimensions.dat");
for (unsigned int i=0; i<granularity/2; ++i){ distances << std::setw(1) << positions[i] <<'\n'; }
distances.close();
std::string output1="preferential_val.dat";
std::string output2="preferential_sig.dat";
std::string result;
std::ostringstream convert;
convert << num_blocks; //skip;
result = convert.str();
output1.insert(16,result);
output2.insert(16,result);
std::ofstream pic1(output1.c_str());
std::ofstream pic2(output2.c_str());
for (unsigned int i=0; i<granularity/2; ++i)
{
pic1 << std::setw(10)<< averages[i] <<'\n';
pic2 << std::setw(10)<< sigma[i] <<'\n';
}
pic1.close();
pic2.close();
std::ofstream concentrations("concentrations.dat");
concentrations<< std::setw(10) << "Molality" <<'\t'<< std::setw(10) << "Molarity" <<'\n';
concentrations<< std::setw(10) << molals <<'\t'<< std::setw(10) << molars << '\n';
concentrations.close();
std::cout << "ANALYSIS COMPLETED!" <<'\n';
std::cout<<"Total number of frames: "<<frame_counter<<'\n';
}
//////////////// test_partition.close();
thanx(stderr);
return 0;
}
static void clust_size(const char *ndx, const char *trx, const char *xpm,
const char *xpmw, const char *ncl, const char *acl,
const char *mcl, const char *histo, const char *tempf,
const char *mcn, gmx_bool bMol, gmx_bool bPBC, const char *tpr,
real cut, int nskip, int nlevels,
t_rgb rmid, t_rgb rhi, int ndf,
const output_env_t oenv)
{
FILE *fp, *gp, *hp, *tp;
atom_id *index = NULL;
int nindex, natoms;
t_trxstatus *status;
rvec *x = NULL, *v = NULL, dx;
t_pbc pbc;
char *gname;
char timebuf[32];
gmx_bool bSame, bTPRwarn = TRUE;
/* Topology stuff */
t_trxframe fr;
t_tpxheader tpxh;
gmx_mtop_t *mtop = NULL;
int ePBC = -1;
t_block *mols = NULL;
gmx_mtop_atomlookup_t alook;
t_atom *atom;
int version, generation, ii, jj;
real temp, tfac;
/* Cluster size distribution (matrix) */
real **cs_dist = NULL;
real tf, dx2, cut2, *t_x = NULL, *t_y, cmid, cmax, cav, ekin;
int i, j, k, ai, aj, ci, cj, nframe, nclust, n_x, max_size = 0;
int *clust_index, *clust_size, max_clust_size, max_clust_ind, nav, nhisto;
t_rgb rlo = { 1.0, 1.0, 1.0 };
clear_trxframe(&fr, TRUE);
sprintf(timebuf, "Time (%s)", output_env_get_time_unit(oenv));
tf = output_env_get_time_factor(oenv);
fp = xvgropen(ncl, "Number of clusters", timebuf, "N", oenv);
gp = xvgropen(acl, "Average cluster size", timebuf, "#molecules", oenv);
hp = xvgropen(mcl, "Max cluster size", timebuf, "#molecules", oenv);
tp = xvgropen(tempf, "Temperature of largest cluster", timebuf, "T (K)",
oenv);
if (!read_first_frame(oenv, &status, trx, &fr, TRX_NEED_X | TRX_READ_V))
{
gmx_file(trx);
}
natoms = fr.natoms;
x = fr.x;
if (tpr)
{
snew(mtop, 1);
read_tpxheader(tpr, &tpxh, TRUE, &version, &generation);
if (tpxh.natoms != natoms)
{
gmx_fatal(FARGS, "tpr (%d atoms) and trajectory (%d atoms) do not match!",
tpxh.natoms, natoms);
}
ePBC = read_tpx(tpr, NULL, NULL, &natoms, NULL, NULL, mtop);
}
if (ndf <= -1)
{
tfac = 1;
}
else
{
tfac = ndf/(3.0*natoms);
}
if (bMol)
{
if (ndx)
{
printf("Using molecules rather than atoms. Not reading index file %s\n",
ndx);
}
GMX_RELEASE_ASSERT(mtop != NULL, "Trying to access mtop->mols from NULL mtop pointer");
mols = &(mtop->mols);
/* Make dummy index */
nindex = mols->nr;
snew(index, nindex);
for (i = 0; (i < nindex); i++)
{
index[i] = i;
}
gname = gmx_strdup("mols");
}
else
{
rd_index(ndx, 1, &nindex, &index, &gname);
}
alook = gmx_mtop_atomlookup_init(mtop);
snew(clust_index, nindex);
snew(clust_size, nindex);
cut2 = cut*cut;
nframe = 0;
n_x = 0;
snew(t_y, nindex);
for (i = 0; (i < nindex); i++)
{
t_y[i] = i+1;
}
max_clust_size = 1;
max_clust_ind = -1;
do
{
if ((nskip == 0) || ((nskip > 0) && ((nframe % nskip) == 0)))
{
if (bPBC)
{
set_pbc(&pbc, ePBC, fr.box);
}
max_clust_size = 1;
max_clust_ind = -1;
/* Put all atoms/molecules in their own cluster, with size 1 */
for (i = 0; (i < nindex); i++)
{
/* Cluster index is indexed with atom index number */
clust_index[i] = i;
/* Cluster size is indexed with cluster number */
clust_size[i] = 1;
}
/* Loop over atoms */
for (i = 0; (i < nindex); i++)
{
ai = index[i];
ci = clust_index[i];
/* Loop over atoms (only half a matrix) */
for (j = i+1; (j < nindex); j++)
{
cj = clust_index[j];
/* If they are not in the same cluster already */
if (ci != cj)
{
aj = index[j];
/* Compute distance */
if (bMol)
{
GMX_RELEASE_ASSERT(mols != NULL, "Cannot access index[] from NULL mols pointer");
bSame = FALSE;
for (ii = mols->index[ai]; !bSame && (ii < mols->index[ai+1]); ii++)
{
for (jj = mols->index[aj]; !bSame && (jj < mols->index[aj+1]); jj++)
{
if (bPBC)
{
pbc_dx(&pbc, x[ii], x[jj], dx);
}
else
{
rvec_sub(x[ii], x[jj], dx);
}
dx2 = iprod(dx, dx);
bSame = (dx2 < cut2);
}
}
}
else
{
if (bPBC)
{
pbc_dx(&pbc, x[ai], x[aj], dx);
}
else
{
rvec_sub(x[ai], x[aj], dx);
}
dx2 = iprod(dx, dx);
bSame = (dx2 < cut2);
}
/* If distance less than cut-off */
if (bSame)
{
/* Merge clusters: check for all atoms whether they are in
* cluster cj and if so, put them in ci
*/
for (k = 0; (k < nindex); k++)
{
if (clust_index[k] == cj)
{
if (clust_size[cj] <= 0)
{
gmx_fatal(FARGS, "negative cluster size %d for element %d",
clust_size[cj], cj);
}
clust_size[cj]--;
clust_index[k] = ci;
clust_size[ci]++;
}
}
}
}
}
}
n_x++;
srenew(t_x, n_x);
t_x[n_x-1] = fr.time*tf;
srenew(cs_dist, n_x);
snew(cs_dist[n_x-1], nindex);
nclust = 0;
cav = 0;
nav = 0;
for (i = 0; (i < nindex); i++)
{
ci = clust_size[i];
if (ci > max_clust_size)
{
max_clust_size = ci;
max_clust_ind = i;
}
if (ci > 0)
{
nclust++;
cs_dist[n_x-1][ci-1] += 1.0;
max_size = std::max(max_size, ci);
if (ci > 1)
{
cav += ci;
nav++;
}
}
}
fprintf(fp, "%14.6e %10d\n", fr.time, nclust);
if (nav > 0)
{
fprintf(gp, "%14.6e %10.3f\n", fr.time, cav/nav);
}
fprintf(hp, "%14.6e %10d\n", fr.time, max_clust_size);
}
/* Analyse velocities, if present */
if (fr.bV)
{
if (!tpr)
{
if (bTPRwarn)
{
printf("You need a [REF].tpr[ref] file to analyse temperatures\n");
bTPRwarn = FALSE;
}
}
else
{
v = fr.v;
/* Loop over clusters and for each cluster compute 1/2 m v^2 */
if (max_clust_ind >= 0)
{
ekin = 0;
for (i = 0; (i < nindex); i++)
{
if (clust_index[i] == max_clust_ind)
{
ai = index[i];
gmx_mtop_atomnr_to_atom(alook, ai, &atom);
ekin += 0.5*atom->m*iprod(v[ai], v[ai]);
}
}
temp = (ekin*2.0)/(3.0*tfac*max_clust_size*BOLTZ);
fprintf(tp, "%10.3f %10.3f\n", fr.time, temp);
}
}
}
nframe++;
}
while (read_next_frame(oenv, status, &fr));
close_trx(status);
xvgrclose(fp);
xvgrclose(gp);
xvgrclose(hp);
xvgrclose(tp);
gmx_mtop_atomlookup_destroy(alook);
if (max_clust_ind >= 0)
{
fp = gmx_ffopen(mcn, "w");
fprintf(fp, "[ max_clust ]\n");
for (i = 0; (i < nindex); i++)
{
if (clust_index[i] == max_clust_ind)
{
if (bMol)
{
GMX_RELEASE_ASSERT(mols != NULL, "Cannot access index[] from NULL mols pointer");
for (j = mols->index[i]; (j < mols->index[i+1]); j++)
{
fprintf(fp, "%d\n", j+1);
}
}
else
{
fprintf(fp, "%d\n", index[i]+1);
}
}
}
gmx_ffclose(fp);
}
/* Print the real distribution cluster-size/numer, averaged over the trajectory. */
fp = xvgropen(histo, "Cluster size distribution", "Cluster size", "()", oenv);
nhisto = 0;
fprintf(fp, "%5d %8.3f\n", 0, 0.0);
for (j = 0; (j < max_size); j++)
{
real nelem = 0;
for (i = 0; (i < n_x); i++)
{
nelem += cs_dist[i][j];
}
fprintf(fp, "%5d %8.3f\n", j+1, nelem/n_x);
nhisto += static_cast<int>((j+1)*nelem/n_x);
}
fprintf(fp, "%5d %8.3f\n", j+1, 0.0);
xvgrclose(fp);
fprintf(stderr, "Total number of atoms in clusters = %d\n", nhisto);
/* Look for the smallest entry that is not zero
* This will make that zero is white, and not zero is coloured.
*/
cmid = 100.0;
cmax = 0.0;
for (i = 0; (i < n_x); i++)
{
for (j = 0; (j < max_size); j++)
{
if ((cs_dist[i][j] > 0) && (cs_dist[i][j] < cmid))
{
cmid = cs_dist[i][j];
}
cmax = std::max(cs_dist[i][j], cmax);
}
}
fprintf(stderr, "cmid: %g, cmax: %g, max_size: %d\n", cmid, cmax, max_size);
cmid = 1;
fp = gmx_ffopen(xpm, "w");
write_xpm3(fp, 0, "Cluster size distribution", "# clusters", timebuf, "Size",
n_x, max_size, t_x, t_y, cs_dist, 0, cmid, cmax,
rlo, rmid, rhi, &nlevels);
gmx_ffclose(fp);
cmid = 100.0;
cmax = 0.0;
for (i = 0; (i < n_x); i++)
{
for (j = 0; (j < max_size); j++)
{
cs_dist[i][j] *= (j+1);
if ((cs_dist[i][j] > 0) && (cs_dist[i][j] < cmid))
{
cmid = cs_dist[i][j];
}
cmax = std::max(cs_dist[i][j], cmax);
}
}
fprintf(stderr, "cmid: %g, cmax: %g, max_size: %d\n", cmid, cmax, max_size);
fp = gmx_ffopen(xpmw, "w");
write_xpm3(fp, 0, "Weighted cluster size distribution", "Fraction", timebuf,
"Size", n_x, max_size, t_x, t_y, cs_dist, 0, cmid, cmax,
rlo, rmid, rhi, &nlevels);
gmx_ffclose(fp);
sfree(clust_index);
sfree(clust_size);
sfree(index);
}
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;
}
bool read_first_frame(const gmx_output_env_t *oenv, t_trxstatus **status,
const char *fn, t_trxframe *fr, int flags)
{
t_fileio *fio = nullptr;
gmx_bool bFirst, bOK;
int ftp = fn2ftp(fn);
clear_trxframe(fr, TRUE);
bFirst = TRUE;
snew((*status), 1);
status_init( *status );
initcount(*status);
(*status)->flags = flags;
if (efTNG == ftp)
{
/* Special treatment for TNG files */
gmx_tng_open(fn, 'r', &(*status)->tng);
}
else
{
fio = (*status)->fio = gmx_fio_open(fn, "r");
}
switch (ftp)
{
case efTRR:
break;
case efCPT:
read_checkpoint_trxframe(fio, fr);
bFirst = FALSE;
break;
case efG96:
{
/* Can not rewind a compressed file, so open it twice */
if (!(*status)->persistent_line)
{
/* allocate the persistent line */
snew((*status)->persistent_line, STRLEN+1);
}
t_symtab *symtab = nullptr;
read_g96_conf(gmx_fio_getfp(fio), fn, nullptr, fr, symtab, (*status)->persistent_line);
gmx_fio_close(fio);
clear_trxframe(fr, FALSE);
if (flags & (TRX_READ_X | TRX_NEED_X))
{
snew(fr->x, fr->natoms);
}
if (flags & (TRX_READ_V | TRX_NEED_V))
{
snew(fr->v, fr->natoms);
}
(*status)->fio = gmx_fio_open(fn, "r");
break;
}
case efXTC:
if (read_first_xtc(fio, &fr->natoms, &fr->step, &fr->time, fr->box, &fr->x,
&fr->prec, &bOK) == 0)
{
GMX_RELEASE_ASSERT(!bOK, "Inconsistent results - OK status from read_first_xtc, but 0 atom coords read");
fr->not_ok = DATA_NOT_OK;
}
if (fr->not_ok)
{
fr->natoms = 0;
printincomp(*status, fr);
}
else
{
fr->bPrec = (fr->prec > 0);
fr->bStep = TRUE;
fr->bTime = TRUE;
fr->bX = TRUE;
fr->bBox = TRUE;
printcount(*status, oenv, fr->time, FALSE);
}
bFirst = FALSE;
break;
case efTNG:
fr->step = -1;
if (!gmx_read_next_tng_frame((*status)->tng, fr, nullptr, 0))
{
fr->not_ok = DATA_NOT_OK;
fr->natoms = 0;
printincomp(*status, fr);
}
else
{
printcount(*status, oenv, fr->time, FALSE);
}
bFirst = FALSE;
break;
case efPDB:
pdb_first_x(*status, gmx_fio_getfp(fio), fr);
if (fr->natoms)
{
printcount(*status, oenv, fr->time, FALSE);
}
bFirst = FALSE;
break;
case efGRO:
if (gro_first_x_or_v(gmx_fio_getfp(fio), fr))
{
printcount(*status, oenv, fr->time, FALSE);
}
bFirst = FALSE;
break;
default:
#if GMX_USE_PLUGINS
fprintf(stderr, "The file format of %s is not a known trajectory format to GROMACS.\n"
"Please make sure that the file is a trajectory!\n"
"GROMACS will now assume it to be a trajectory and will try to open it using the VMD plug-ins.\n"
"This will only work in case the VMD plugins are found and it is a trajectory format supported by VMD.\n", fn);
gmx_fio_fp_close(fio); /*only close the file without removing FIO entry*/
if (!read_first_vmd_frame(fn, &(*status)->vmdplugin, fr))
{
gmx_fatal(FARGS, "Not supported in read_first_frame: %s", fn);
}
#else
gmx_fatal(FARGS, "Not supported in read_first_frame: %s. Please make sure that the file is a trajectory.\n"
"GROMACS is not compiled with plug-in support. Thus it cannot read non-GROMACS trajectory formats using the VMD plug-ins.\n"
"Please compile with plug-in support if you want to read non-GROMACS trajectory formats.\n", fn);
#endif
break;
}
(*status)->tf = fr->time;
/* Return FALSE if we read a frame that's past the set ending time. */
if (!bFirst && (!(flags & TRX_DONT_SKIP) && check_times(fr->time) > 0))
{
(*status)->t0 = fr->time;
return FALSE;
}
if (bFirst ||
(!(flags & TRX_DONT_SKIP) && check_times(fr->time) < 0))
{
/* Read a frame when no frame was read or the first was skipped */
if (!read_next_frame(oenv, *status, fr))
{
return FALSE;
}
}
(*status)->t0 = fr->time;
/* We need the number of atoms for random-access XTC searching, even when
* we don't have access to the actual frame data.
*/
(*status)->natoms = fr->natoms;
return (fr->natoms > 0);
}
void DataIOStanford::extract_parts() {
/* initialize random seed: */
srand (time(NULL));
// Creating directory structure
const std::string kTrainingDataPathHead = kPath + "/training";
boost::filesystem::path training_data_path_head(kTrainingDataPathHead);
boost::filesystem::create_directory(training_data_path_head);
std::ofstream data((kTrainingDataPathHead + "/data.txt").c_str());
if (!data.is_open()) {
std::cerr << "Unable to create training data files!" << std::endl;
}
int head_idx, hand_idx, leg_idx;
head_idx = hand_idx = leg_idx = 1;
cv::Mat frame, frame_dummy;
while (read_next_frame(frame_dummy, frame)) {
//if(!) { stanford_eval::next_file(); };
stanford_eval::Frame f = stanford_eval::frame;
// cv::Mat frame(cv::Size(f.C, f.R), CV_32F);
//
// for (int i = 0; i < f.N; ++i) {
// frame.at<float>(i % f.R, i/f.R) = -(static_cast<float>(f.points[i][2]) + 2.f);
// }
//
// cv::normalize(frame, frame, 0, 1.f, cv::NORM_MINMAX);
std::vector<int> positive_centres;
// Head
if (f.markers[3].cond > 0 && f.markers[1].cond > 0) {
extract_positive_part(frame, data,
f.markers[3].x, f.markers[3].y + 0.1,
f.markers[1].x, f.markers[1].y + 0.1,
classifier::HEAD, true);
extract_positive_part(frame, data,
f.markers[3].x, f.markers[3].y + 0.1,
f.markers[3].x, f.markers[1].y + 0.1,
classifier::HEAD, true);
positive_centres.push_back(to_x(f.markers[1].x));
positive_centres.push_back(to_y(f.markers[1].y + 0.1));
positive_centres.push_back(to_x(f.markers[3].x));
positive_centres.push_back(to_y(f.markers[3].y + 0.1));
}
// Left hand
if (f.markers[28].cond > 0 && f.markers[24].cond > 0) {
extract_positive_part(frame, data,
f.markers[28].x, f.markers[28].y,
f.markers[24].x, f.markers[24].y,
classifier::LEFT_HAND, true);
positive_centres.push_back(to_x(f.markers[24].x));
positive_centres.push_back(to_y(f.markers[24].y));
}
// Right hand
if (f.markers[19].cond > 0 && f.markers[16].cond > 0) {
extract_positive_part(frame, data,
f.markers[19].x, f.markers[19].y,
f.markers[16].x, f.markers[16].y,
classifier::RIGHT_HAND, true);
positive_centres.push_back(to_x(f.markers[16].x));
positive_centres.push_back(to_y(f.markers[16].y));
}
// Left foot
if (f.markers[35].cond > 0 && f.markers[37].cond > 0) {
extract_positive_part(frame, data,
f.markers[37].x, f.markers[37].y - 0.2,
f.markers[35].x, f.markers[35].y - 0.2,
classifier::LEFT_FOOT, true);
positive_centres.push_back(to_x(f.markers[35].x));
positive_centres.push_back(to_y(f.markers[35].y - 0.2));
}
// Right foot
if (f.markers[43].cond > 0 && f.markers[41].cond > 0) {
extract_positive_part(frame, data,
f.markers[41].x, f.markers[41].y - 0.2,
f.markers[43].x, f.markers[43].y - 0.2,
classifier::RIGHT_FOOT, true);
positive_centres.push_back(to_x(f.markers[43].x));
positive_centres.push_back(to_y(f.markers[43].y - 0.2));
}
for (int j = 0; j < 12; j++) {
extract_negative_part(frame, data, positive_centres);
}
}
}
void chk_trj(const output_env_t oenv, const char *fn, const char *tpr, real tol)
{
t_trxframe fr;
t_count count;
t_fr_time first, last;
int j = -1, new_natoms, natoms;
real rdum, tt, old_t1, old_t2, prec;
gmx_bool bShowTimestep = TRUE, bOK, newline = FALSE;
t_trxstatus *status;
gmx_mtop_t mtop;
gmx_localtop_t *top = NULL;
t_state state;
t_inputrec ir;
if (tpr)
{
read_tpx_state(tpr, &ir, &state, NULL, &mtop);
top = gmx_mtop_generate_local_top(&mtop, &ir);
}
new_natoms = -1;
natoms = -1;
printf("Checking file %s\n", fn);
j = 0;
old_t2 = -2.0;
old_t1 = -1.0;
count.bStep = 0;
count.bTime = 0;
count.bLambda = 0;
count.bX = 0;
count.bV = 0;
count.bF = 0;
count.bBox = 0;
first.bStep = 0;
first.bTime = 0;
first.bLambda = 0;
first.bX = 0;
first.bV = 0;
first.bF = 0;
first.bBox = 0;
last.bStep = 0;
last.bTime = 0;
last.bLambda = 0;
last.bX = 0;
last.bV = 0;
last.bF = 0;
last.bBox = 0;
read_first_frame(oenv, &status, fn, &fr, TRX_READ_X | TRX_READ_V | TRX_READ_F);
do
{
if (j == 0)
{
fprintf(stderr, "\n# Atoms %d\n", fr.natoms);
if (fr.bPrec)
{
fprintf(stderr, "Precision %g (nm)\n", 1/fr.prec);
}
}
newline = TRUE;
if ((natoms > 0) && (new_natoms != natoms))
{
fprintf(stderr, "\nNumber of atoms at t=%g don't match (%d, %d)\n",
old_t1, natoms, new_natoms);
newline = FALSE;
}
if (j >= 2)
{
if (fabs((fr.time-old_t1)-(old_t1-old_t2)) >
0.1*(fabs(fr.time-old_t1)+fabs(old_t1-old_t2)) )
{
bShowTimestep = FALSE;
fprintf(stderr, "%sTimesteps at t=%g don't match (%g, %g)\n",
newline ? "\n" : "", old_t1, old_t1-old_t2, fr.time-old_t1);
}
}
natoms = new_natoms;
if (tpr)
{
chk_bonds(&top->idef, ir.ePBC, fr.x, fr.box, tol);
}
if (fr.bX)
{
chk_coords(j, natoms, fr.x, fr.box, 1e5, tol);
}
if (fr.bV)
{
chk_vels(j, natoms, fr.v);
}
if (fr.bF)
{
chk_forces(j, natoms, fr.f);
}
old_t2 = old_t1;
old_t1 = fr.time;
j++;
new_natoms = fr.natoms;
#define INC(s, n, f, l, item) if (s.item != 0) { if (n.item == 0) { first.item = fr.time; } last.item = fr.time; n.item++; \
}
INC(fr, count, first, last, bStep);
INC(fr, count, first, last, bTime);
INC(fr, count, first, last, bLambda);
INC(fr, count, first, last, bX);
INC(fr, count, first, last, bV);
INC(fr, count, first, last, bF);
INC(fr, count, first, last, bBox);
#undef INC
}
while (read_next_frame(oenv, status, &fr));
fprintf(stderr, "\n");
close_trj(status);
fprintf(stderr, "\nItem #frames");
if (bShowTimestep)
{
fprintf(stderr, " Timestep (ps)");
}
fprintf(stderr, "\n");
#define PRINTITEM(label, item) fprintf(stderr, "%-10s %6d", label, count.item); if ((bShowTimestep) && (count.item > 1)) {fprintf(stderr, " %g\n", (last.item-first.item)/(count.item-1)); }else fprintf(stderr, "\n")
PRINTITEM ( "Step", bStep );
PRINTITEM ( "Time", bTime );
PRINTITEM ( "Lambda", bLambda );
PRINTITEM ( "Coords", bX );
PRINTITEM ( "Velocities", bV );
PRINTITEM ( "Forces", bF );
PRINTITEM ( "Box", bBox );
}
int read_first_frame(const output_env_t oenv, t_trxstatus **status,
const char *fn, t_trxframe *fr, int flags)
{
t_fileio *fio;
gmx_bool bFirst, bOK;
int dummy = 0;
clear_trxframe(fr, TRUE);
fr->flags = flags;
bFirst = TRUE;
snew((*status), 1);
status_init( *status );
(*status)->nxframe = 1;
initcount(*status);
fio = (*status)->fio = gmx_fio_open(fn, "r");
switch (gmx_fio_getftp(fio))
{
case efTRJ:
case efTRR:
break;
case efCPT:
read_checkpoint_trxframe(fio, fr);
bFirst = FALSE;
break;
case efG96:
/* Can not rewind a compressed file, so open it twice */
if (!(*status)->persistent_line)
{
/* allocate the persistent line */
snew((*status)->persistent_line, STRLEN+1);
}
read_g96_conf(gmx_fio_getfp(fio), fn, fr, (*status)->persistent_line);
gmx_fio_close(fio);
clear_trxframe(fr, FALSE);
if (flags & (TRX_READ_X | TRX_NEED_X))
{
snew(fr->x, fr->natoms);
}
if (flags & (TRX_READ_V | TRX_NEED_V))
{
snew(fr->v, fr->natoms);
}
fio = (*status)->fio = gmx_fio_open(fn, "r");
break;
case efG87:
fr->natoms = xyz_first_x(*status, gmx_fio_getfp(fio), oenv, &fr->time,
&fr->x, fr->box);
if (fr->natoms)
{
fr->bTime = TRUE;
fr->bX = TRUE;
fr->bBox = TRUE;
printcount(*status, oenv, fr->time, FALSE);
}
bFirst = FALSE;
break;
case efXTC:
if (read_first_xtc(fio, &fr->natoms, &fr->step, &fr->time, fr->box, &fr->x,
&fr->prec, &bOK) == 0)
{
if (bOK)
{
gmx_fatal(FARGS, "No XTC!\n");
}
else
{
fr->not_ok = DATA_NOT_OK;
}
}
if (fr->not_ok)
{
fr->natoms = 0;
printincomp(*status, fr);
}
else
{
fr->bPrec = (fr->prec > 0);
fr->bStep = TRUE;
fr->bTime = TRUE;
fr->bX = TRUE;
fr->bBox = TRUE;
printcount(*status, oenv, fr->time, FALSE);
}
bFirst = FALSE;
break;
case efPDB:
pdb_first_x(*status, gmx_fio_getfp(fio), fr);
if (fr->natoms)
{
printcount(*status, oenv, fr->time, FALSE);
}
bFirst = FALSE;
break;
case efGRO:
if (gro_first_x_or_v(gmx_fio_getfp(fio), fr))
{
printcount(*status, oenv, fr->time, FALSE);
}
bFirst = FALSE;
break;
default:
#ifdef GMX_USE_PLUGINS
fprintf(stderr, "The file format of %s is not a known trajectory format to GROMACS.\n"
"Please make sure that the file is a trajectory!\n"
"GROMACS will now assume it to be a trajectory and will try to open it using the VMD plug-ins.\n"
"This will only work in case the VMD plugins are found and it is a trajectory format supported by VMD.\n", fn);
gmx_fio_fp_close(fio); /*only close the file without removing FIO entry*/
if (!read_first_vmd_frame(fn, fr))
{
gmx_fatal(FARGS, "Not supported in read_first_frame: %s", fn);
}
#else
gmx_fatal(FARGS, "Not supported in read_first_frame: %s. Please make sure that the file is a trajectory.\n"
"GROMACS is not compiled with plug-in support. Thus it cannot read non-GROMACS trajectory formats using the VMD plug-ins.\n"
"Please compile with plug-in support if you want to read non-GROMACS trajectory formats.\n", fn);
#endif
break;
}
/* Return FALSE if we read a frame that's past the set ending time. */
if (!bFirst && (!(fr->flags & TRX_DONT_SKIP) && check_times(fr->time) > 0))
{
fr->t0 = fr->time;
return FALSE;
}
if (bFirst ||
(!(fr->flags & TRX_DONT_SKIP) && check_times(fr->time) < 0))
{
/* Read a frame when no frame was read or the first was skipped */
if (!read_next_frame(oenv, *status, fr))
{
return FALSE;
}
}
fr->t0 = fr->time;
return (fr->natoms > 0);
}
static void do_demux(int nset,char *fnms[],char *fnms_out[],
int nval,real **value,real *time,real dt_remd,
int isize,atom_id index[],real dt)
{
int i,j,k,natoms,nnn;
int *fp_in,*fp_out;
bool bCont,*bSet;
real t,first_time=0;
t_trxframe *trx;
snew(fp_in,nset);
snew(trx,nset);
snew(bSet,nset);
natoms = -1;
t = -1;
for(i=0; (i<nset); i++) {
nnn = read_first_frame(&(fp_in[i]),fnms[i],&(trx[i]),TRX_NEED_X);
if (natoms == -1) {
natoms = nnn;
first_time = trx[i].time;
}
else if (natoms != nnn)
gmx_fatal(FARGS,"Trajectory file %s has %d atoms while previous trajs had %d atoms",fnms[i],nnn,natoms);
if (t == -1)
t = trx[i].time;
else if (t != trx[i].time)
gmx_fatal(FARGS,"Trajectory file %s has time %f while previous trajs had time %f",fnms[i],trx[i].time,t);
}
snew(fp_out,nset);
for(i=0; (i<nset); i++)
fp_out[i] = open_trx(fnms_out[i],"w");
k = 0;
if (gmx_nint(time[k] - t) != 0)
gmx_fatal(FARGS,"First time in demuxing table does not match trajectories");
do {
while ((k+1 < nval) && ((trx[0].time - time[k+1]) > dt_remd*0.1))
k++;
if (debug)
fprintf(debug,"trx[0].time = %g, time[k] = %g\n",trx[0].time,time[k]);
for(i=0; (i<nset); i++)
bSet[i] = FALSE;
for(i=0; (i<nset); i++) {
j = gmx_nint(value[i][k]);
range_check(j,0,nset);
if (bSet[j])
gmx_fatal(FARGS,"Demuxing the same replica %d twice at time %f",
j,trx[0].time);
bSet[j] = TRUE;
if (dt==0 || bRmod(trx[i].time,first_time,dt)) {
if (index)
write_trxframe_indexed(fp_out[j],&trx[i],isize,index);
else
write_trxframe(fp_out[j],&trx[i]);
}
}
bCont = (k < nval);
for(i=0; (i<nset); i++)
bCont = bCont && read_next_frame(fp_in[i],&trx[i]);
} while (bCont);
for(i=0; (i<nset); i++) {
close_trx(fp_in[i]);
close_trx(fp_out[i]);
}
}
int gmx_spatial(int argc,char *argv[])
{
const char *desc[] = {
"g_spatial calculates the spatial distribution function and ",
"outputs it in a form that can be read by VMD as Gaussian98 cube format. ",
"This was developed from template.c (gromacs-3.3). ",
"For a system of 32K atoms and a 50ns trajectory, the SDF can be generated ",
"in about 30 minutes, with most of the time dedicated to the two runs through ",
"trjconv that are required to center everything properly. ",
"This also takes a whole bunch of space (3 copies of the xtc file). ",
"Still, the pictures are pretty and very informative when the fitted selection is properly made. ",
"3-4 atoms in a widely mobile group like a free amino acid in solution works ",
"well, or select the protein backbone in a stable folded structure to get the SDF ",
"of solvent and look at the time-averaged solvation shell. ",
"It is also possible using this program to generate the SDF based on some arbitrarty ",
"Cartesian coordinate. To do that, simply omit the preliminary trjconv steps. \n",
"USAGE: \n",
"1. Use make_ndx to create a group containing the atoms around which you want the SDF \n",
"2. trjconv -s a.tpr -f a.xtc -o b.xtc -center tric -ur compact -pbc none \n",
"3. trjconv -s a.tpr -f b.xtc -o c.xtc -fit rot+trans \n",
"4. run g_spatial on the xtc output of step #3. \n",
"5. Load grid.cube into VMD and view as an isosurface. \n",
"*** Systems such as micelles will require trjconv -pbc cluster between steps 1 and 2\n",
"WARNINGS: \n",
"The SDF will be generated for a cube that contains all bins that have some non-zero occupancy. ",
"However, the preparatory -fit rot+trans option to trjconv implies that your system will be rotating ",
"and translating in space (in order that the selected group does not). Therefore the values that are ",
"returned will only be valid for some region around your central group/coordinate that has full overlap ",
"with system volume throughout the entire translated/rotated system over the course of the trajectory. ",
"It is up to the user to ensure that this is the case. \n",
"BUGS: \n",
"When the allocated memory is not large enough, a segmentation fault may occur. This is usually detected ",
"and the program is halted prior to the fault while displaying a warning message suggesting the use of the -nab ",
"option. However, the program does not detect all such events. If you encounter a segmentation fault, run it again ",
"with an increased -nab value. \n",
"RISKY OPTIONS: \n",
"To reduce the amount of space and time required, you can output only the coords ",
"that are going to be used in the first and subsequent run through trjconv. ",
"However, be sure to set the -nab option to a sufficiently high value since ",
"memory is allocated for cube bins based on the initial coords and the -nab ",
"(Number of Additional Bins) option value. \n"
};
static gmx_bool bPBC=FALSE;
static gmx_bool bSHIFT=FALSE;
static int iIGNOREOUTER=-1; /*Positive values may help if the surface is spikey */
static gmx_bool bCUTDOWN=TRUE;
static real rBINWIDTH=0.05; /* nm */
static gmx_bool bCALCDIV=TRUE;
static int iNAB=4;
t_pargs pa[] = {
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Use periodic boundary conditions for computing distances" },
{ "-div", FALSE, etBOOL, {&bCALCDIV},
"Calculate and apply the divisor for bin occupancies based on atoms/minimal cube size. Set as TRUE for visualization and as FALSE (-nodiv) to get accurate counts per frame" },
{ "-ign", FALSE, etINT, {&iIGNOREOUTER},
"Do not display this number of outer cubes (positive values may reduce boundary speckles; -1 ensures outer surface is visible)" },
/* { "-cut", bCUTDOWN, etBOOL, {&bCUTDOWN},*/
/* "Display a total cube that is of minimal size" }, */
{ "-bin", FALSE, etREAL, {&rBINWIDTH},
"Width of the bins in nm" },
{ "-nab", FALSE, etINT, {&iNAB},
"Number of additional bins to ensure proper memory allocation" }
};
double MINBIN[3];
double MAXBIN[3];
t_topology top;
int ePBC;
char title[STRLEN];
t_trxframe fr;
rvec *xtop,*shx[26];
matrix box,box_pbc;
t_trxstatus *status;
int flags = TRX_READ_X;
t_pbc pbc;
t_atoms *atoms;
int natoms;
char *grpnm,*grpnmp;
atom_id *index,*indexp;
int i,nidx,nidxp;
int v;
int j,k;
long ***bin=(long ***)NULL;
long nbin[3];
FILE *flp;
long x,y,z,minx,miny,minz,maxx,maxy,maxz;
long numfr, numcu;
long tot,max,min;
double norm;
output_env_t oenv;
gmx_rmpbc_t gpbc=NULL;
t_filenm fnm[] = {
{ efTPS, NULL, NULL, ffREAD }, /* this is for the topology */
{ efTRX, "-f", NULL, ffREAD }, /* and this for the trajectory */
{ efNDX, NULL, NULL, ffOPTRD }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
/* This is the routine responsible for adding default options,
* calling the X/motif interface, etc. */
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL,&oenv);
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xtop,NULL,box,TRUE);
sfree(xtop);
atoms=&(top.atoms);
printf("Select group to generate SDF:\n");
get_index(atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&nidx,&index,&grpnm);
printf("Select group to output coords (e.g. solute):\n");
get_index(atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&nidxp,&indexp,&grpnmp);
/* The first time we read data is a little special */
natoms=read_first_frame(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&fr,flags);
/* Memory Allocation */
MINBIN[XX]=MAXBIN[XX]=fr.x[0][XX];
MINBIN[YY]=MAXBIN[YY]=fr.x[0][YY];
MINBIN[ZZ]=MAXBIN[ZZ]=fr.x[0][ZZ];
for(i=1; i<top.atoms.nr; ++i) {
if(fr.x[i][XX]<MINBIN[XX])MINBIN[XX]=fr.x[i][XX];
if(fr.x[i][XX]>MAXBIN[XX])MAXBIN[XX]=fr.x[i][XX];
if(fr.x[i][YY]<MINBIN[YY])MINBIN[YY]=fr.x[i][YY];
if(fr.x[i][YY]>MAXBIN[YY])MAXBIN[YY]=fr.x[i][YY];
if(fr.x[i][ZZ]<MINBIN[ZZ])MINBIN[ZZ]=fr.x[i][ZZ];
if(fr.x[i][ZZ]>MAXBIN[ZZ])MAXBIN[ZZ]=fr.x[i][ZZ];
}
for (i=ZZ; i>=XX; --i){
MAXBIN[i]=(ceil((MAXBIN[i]-MINBIN[i])/rBINWIDTH)+(double)iNAB)*rBINWIDTH+MINBIN[i];
MINBIN[i]-=(double)iNAB*rBINWIDTH;
nbin[i]=(long)ceil((MAXBIN[i]-MINBIN[i])/rBINWIDTH);
}
bin=(long ***)malloc(nbin[XX]*sizeof(long **));
if(!bin)mequit();
for(i=0; i<nbin[XX]; ++i){
bin[i]=(long **)malloc(nbin[YY]*sizeof(long *));
if(!bin[i])mequit();
for(j=0; j<nbin[YY]; ++j){
bin[i][j]=(long *)calloc(nbin[ZZ],sizeof(long));
if(!bin[i][j])mequit();
}
}
copy_mat(box,box_pbc);
numfr=0;
minx=miny=minz=999;
maxx=maxy=maxz=0;
if (bPBC)
gpbc = gmx_rmpbc_init(&top.idef,ePBC,natoms,box);
/* This is the main loop over frames */
do {
/* Must init pbc every step because of pressure coupling */
copy_mat(box,box_pbc);
if (bPBC) {
gmx_rmpbc_trxfr(gpbc,&fr);
set_pbc(&pbc,ePBC,box_pbc);
}
for(i=0; i<nidx; i++) {
if(fr.x[index[i]][XX]<MINBIN[XX]||fr.x[index[i]][XX]>MAXBIN[XX]||
fr.x[index[i]][YY]<MINBIN[YY]||fr.x[index[i]][YY]>MAXBIN[YY]||
fr.x[index[i]][ZZ]<MINBIN[ZZ]||fr.x[index[i]][ZZ]>MAXBIN[ZZ])
{
printf("There was an item outside of the allocated memory. Increase the value given with the -nab option.\n");
printf("Memory was allocated for [%f,%f,%f]\tto\t[%f,%f,%f]\n",MINBIN[XX],MINBIN[YY],MINBIN[ZZ],MAXBIN[XX],MAXBIN[YY],MAXBIN[ZZ]);
printf("Memory was required for [%f,%f,%f]\n",fr.x[index[i]][XX],fr.x[index[i]][YY],fr.x[index[i]][ZZ]);
exit(1);
}
x=(long)ceil((fr.x[index[i]][XX]-MINBIN[XX])/rBINWIDTH);
y=(long)ceil((fr.x[index[i]][YY]-MINBIN[YY])/rBINWIDTH);
z=(long)ceil((fr.x[index[i]][ZZ]-MINBIN[ZZ])/rBINWIDTH);
++bin[x][y][z];
if(x<minx)minx=x;
if(x>maxx)maxx=x;
if(y<miny)miny=y;
if(y>maxy)maxy=y;
if(z<minz)minz=z;
if(z>maxz)maxz=z;
}
numfr++;
/* printf("%f\t%f\t%f\n",box[XX][XX],box[YY][YY],box[ZZ][ZZ]); */
} while(read_next_frame(oenv,status,&fr));
if (bPBC)
gmx_rmpbc_done(gpbc);
if(!bCUTDOWN){
minx=miny=minz=0;
maxx=nbin[XX];
maxy=nbin[YY];
maxz=nbin[ZZ];
}
/* OUTPUT */
flp=ffopen("grid.cube","w");
fprintf(flp,"Spatial Distribution Function\n");
fprintf(flp,"test\n");
fprintf(flp,"%5d%12.6f%12.6f%12.6f\n",nidxp,(MINBIN[XX]+(minx+iIGNOREOUTER)*rBINWIDTH)*10./bohr,(MINBIN[YY]+(miny+iIGNOREOUTER)*rBINWIDTH)*10./bohr,(MINBIN[ZZ]+(minz+iIGNOREOUTER)*rBINWIDTH)*10./bohr);
fprintf(flp,"%5ld%12.6f%12.6f%12.6f\n",maxx-minx+1-(2*iIGNOREOUTER),rBINWIDTH*10./bohr,0.,0.);
fprintf(flp,"%5ld%12.6f%12.6f%12.6f\n",maxy-miny+1-(2*iIGNOREOUTER),0.,rBINWIDTH*10./bohr,0.);
fprintf(flp,"%5ld%12.6f%12.6f%12.6f\n",maxz-minz+1-(2*iIGNOREOUTER),0.,0.,rBINWIDTH*10./bohr);
for(i=0; i<nidxp; i++){
v=2;
if(*(top.atoms.atomname[indexp[i]][0])=='C')v=6;
if(*(top.atoms.atomname[indexp[i]][0])=='N')v=7;
if(*(top.atoms.atomname[indexp[i]][0])=='O')v=8;
if(*(top.atoms.atomname[indexp[i]][0])=='H')v=1;
if(*(top.atoms.atomname[indexp[i]][0])=='S')v=16;
fprintf(flp,"%5d%12.6f%12.6f%12.6f%12.6f\n",v,0.,(double)fr.x[indexp[i]][XX]*10./bohr,(double)fr.x[indexp[i]][YY]*10./bohr,(double)fr.x[indexp[i]][ZZ]*10./bohr);
}
tot=0;
for(k=0;k<nbin[XX];k++) {
if(!(k<minx||k>maxx))continue;
for(j=0;j<nbin[YY];j++) {
if(!(j<miny||j>maxy))continue;
for(i=0;i<nbin[ZZ];i++) {
if(!(i<minz||i>maxz))continue;
if(bin[k][j][i]!=0){
printf("A bin was not empty when it should have been empty. Programming error.\n");
printf("bin[%d][%d][%d] was = %ld\n",k,j,i,bin[k][j][i]);
exit(1);
}
}
}
}
min=999;
max=0;
for(k=0;k<nbin[XX];k++) {
if(k<minx+iIGNOREOUTER||k>maxx-iIGNOREOUTER)continue;
for(j=0;j<nbin[YY];j++) {
if(j<miny+iIGNOREOUTER||j>maxy-iIGNOREOUTER)continue;
for(i=0;i<nbin[ZZ];i++) {
if(i<minz+iIGNOREOUTER||i>maxz-iIGNOREOUTER)continue;
tot+=bin[k][j][i];
if(bin[k][j][i]>max)max=bin[k][j][i];
if(bin[k][j][i]<min)min=bin[k][j][i];
}
}
}
numcu=(maxx-minx+1-(2*iIGNOREOUTER))*(maxy-miny+1-(2*iIGNOREOUTER))*(maxz-minz+1-(2*iIGNOREOUTER));
if(bCALCDIV){
norm=((double)numcu*(double)numfr) / (double)tot;
}else{
norm=1.0;
}
for(k=0;k<nbin[XX];k++) {
if(k<minx+iIGNOREOUTER||k>maxx-iIGNOREOUTER)continue;
for(j=0;j<nbin[YY];j++) {
if(j<miny+iIGNOREOUTER||j>maxy-iIGNOREOUTER)continue;
for(i=0;i<nbin[ZZ];i++) {
if(i<minz+iIGNOREOUTER||i>maxz-iIGNOREOUTER)continue;
fprintf(flp,"%12.6f ",norm*(double)bin[k][j][i]/(double)numfr);
}
fprintf(flp,"\n");
}
fprintf(flp,"\n");
}
ffclose(flp);
/* printf("x=%d to %d\n",minx,maxx); */
/* printf("y=%d to %d\n",miny,maxy); */
/* printf("z=%d to %d\n",minz,maxz); */
if(bCALCDIV){
printf("Counts per frame in all %ld cubes divided by %le\n",numcu,1.0/norm);
printf("Normalized data: average %le, min %le, max %le\n",1.0,norm*(double)min/(double)numfr,norm*(double)max/(double)numfr);
}else{
printf("grid.cube contains counts per frame in all %ld cubes\n",numcu);
printf("Raw data: average %le, min %le, max %le\n",1.0/norm,(double)min/(double)numfr,(double)max/(double)numfr);
}
thanx(stderr);
return 0;
}
int main (int argc,char *argv[])
{
const char *desc[] = {
"[TT]g_protonate[tt] reads (a) conformation(s) and adds all missing",
"hydrogens as defined in [TT]gmx2.ff/aminoacids.hdb[tt]. If only [TT]-s[tt] is",
"specified, this conformation will be protonated, if also [TT]-f[tt]",
"is specified, the conformation(s) will be read from this file, ",
"which can be either a single conformation or a trajectory.",
"[PAR]",
"If a [TT].pdb[tt] file is supplied, residue names might not correspond to",
"to the GROMACS naming conventions, in which case these residues will",
"probably not be properly protonated.",
"[PAR]",
"If an index file is specified, please note that the atom numbers",
"should correspond to the [BB]protonated[bb] state."
};
char title[STRLEN+1];
const char *infile;
char *grpnm;
t_topology top;
int ePBC;
t_atoms *atoms,*iatoms;
t_protonate protdata;
atom_id *index;
t_trxstatus *status;
t_trxstatus *out;
t_trxframe fr,frout;
rvec *x,*ix;
int nidx,natoms,natoms_out;
matrix box;
int i,frame,resind;
gmx_bool bReadMultiple;
output_env_t oenv;
const char *bugs[] = {
"For the moment, only .pdb files are accepted to the -s flag"
};
t_filenm fnm[] = {
{ efTPS, NULL, NULL, ffREAD },
{ efTRX, "-f", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTRO, "-o", "protonated", ffWRITE }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME,
NFILE,fnm,0,NULL,asize(desc),desc,asize(bugs),bugs,&oenv);
infile=opt2fn("-s",NFILE,fnm);
read_tps_conf(infile,title,&top,&ePBC,&x,NULL,box,FALSE);
atoms=&(top.atoms);
printf("Select group to process:\n");
get_index(atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&nidx,&index,&grpnm);
bReadMultiple = opt2bSet("-f",NFILE,fnm);
if (bReadMultiple) {
infile = opt2fn("-f",NFILE,fnm);
if ( !read_first_frame(oenv,&status, infile, &fr, TRX_NEED_X ) ) {
gmx_fatal(FARGS,"cannot read coordinate file %s",infile);
}
natoms = fr.natoms;
} else {
clear_trxframe(&fr,TRUE);
fr.natoms = atoms->nr;
fr.bTitle = TRUE;
fr.title = title;
fr.bX = TRUE;
fr.x = x;
fr.bBox = TRUE;
copy_mat(box, fr.box);
natoms = fr.natoms;
}
/* check input */
if ( natoms == 0 ) {
gmx_fatal(FARGS,"no atoms in coordinate file %s",infile);
}
if ( natoms > atoms->nr ) {
gmx_fatal(FARGS,"topology with %d atoms does not match "
"coordinates with %d atoms",atoms->nr,natoms);
}
for(i=0; i<nidx; i++) {
if (index[i] > natoms) {
gmx_fatal(FARGS,"An atom number in group %s is larger than the number of "
"atoms (%d) in the coordinate file %s",grpnm,natoms,infile);
}
}
/* get indexed copy of atoms */
snew(iatoms,1);
init_t_atoms(iatoms,nidx,FALSE);
snew(iatoms->atom, iatoms->nr);
resind = 0;
for(i=0; i<nidx; i++) {
iatoms->atom[i] = atoms->atom[index[i]];
iatoms->atomname[i] = atoms->atomname[index[i]];
if ( i>0 && (atoms->atom[index[i]].resind!=atoms->atom[index[i-1]].resind) ) {
resind++;
}
iatoms->atom[i].resind = resind;
iatoms->resinfo[resind] = atoms->resinfo[atoms->atom[index[i]].resind];
/* allocate some space for the rtp name and copy from name */
snew(iatoms->resinfo[resind].rtp,1);
*iatoms->resinfo[resind].rtp = gmx_strdup(*atoms->resinfo[resind].name);
iatoms->nres = max(iatoms->nres, iatoms->atom[i].resind+1);
}
init_t_protonate(&protdata);
out = open_trx(opt2fn("-o",NFILE,fnm),"w");
snew(ix, nidx);
frame=0;
do {
if (debug) {
fprintf(debug,"FRAME %d (%d %g)\n",frame,fr.step,fr.time);
}
/* get indexed copy of x */
for(i=0; i<nidx; i++) {
copy_rvec(fr.x[index[i]], ix[i]);
}
/* protonate */
natoms_out = protonate(&iatoms, &ix, &protdata);
/* setup output frame */
frout = fr;
frout.natoms = natoms_out;
frout.bAtoms = TRUE;
frout.atoms = iatoms;
frout.bV = FALSE;
frout.bF = FALSE;
frout.x = ix;
/* write output */
write_trxframe(out,&frout,NULL);
frame++;
} while ( bReadMultiple && read_next_frame(oenv,status, &fr) );
sfree(ix);
sfree(iatoms);
thanx(stderr);
return 0;
}
int gmx_dos(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes the Density of States from a simulations.",
"In order for this to be meaningful the velocities must be saved",
"in the trajecotry with sufficiently high frequency such as to cover",
"all vibrations. For flexible systems that would be around a few fs",
"between saving. Properties based on the DoS are printed on the",
"standard output."
"Note that the density of states is calculated from the mass-weighted",
"autocorrelation, and by default only from the square of the real",
"component rather than absolute value. This means the shape can differ",
"substantially from the plain vibrational power spectrum you can",
"calculate with gmx velacc."
};
const char *bugs[] = {
"This program needs a lot of memory: total usage equals the number of atoms times 3 times number of frames times 4 (or 8 when run in double precision)."
};
FILE *fp, *fplog;
t_topology top;
int ePBC = -1;
t_trxframe fr;
matrix box;
int gnx;
real t0, t1;
t_trxstatus *status;
int nV, nframes, n_alloc, i, j, fftcode, Nmol, Natom;
double rho, dt, Vsum, V, tmass, dostot, dos2;
real **c1, **dos, mi, beta, bfac, *nu, *tt, stddev, c1j;
gmx_output_env_t *oenv;
gmx_fft_t fft;
double cP, DiffCoeff, Delta, f, y, z, sigHS, Shs, Sig, DoS0, recip_fac;
double wCdiff, wSdiff, wAdiff, wEdiff;
int grpNatoms;
int *index;
char *grpname;
double invNormalize;
gmx_bool normalizeAutocorrelation;
static gmx_bool bVerbose = TRUE, bAbsolute = FALSE, bNormalizeDos = FALSE;
static gmx_bool bRecip = FALSE;
static real Temp = 298.15, toler = 1e-6;
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"Be loud and noisy."
},
{ "-recip", FALSE, etBOOL, {&bRecip},
"Use cm^-1 on X-axis instead of 1/ps for DoS plots."
},
{ "-abs", FALSE, etBOOL, {&bAbsolute},
"Use the absolute value of the Fourier transform of the VACF as the Density of States. Default is to use the real component only"
},
{ "-normdos", FALSE, etBOOL, {&bNormalizeDos},
"Normalize the DoS such that it adds up to 3N. This should usually not be necessary."
},
{ "-T", FALSE, etREAL, {&Temp},
"Temperature in the simulation"
},
{ "-toler", FALSE, etREAL, {&toler},
"[HIDDEN]Tolerance when computing the fluidicity using bisection algorithm"
}
};
t_filenm fnm[] = {
{ efTRN, "-f", NULL, ffREAD },
{ efTPR, "-s", NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-vacf", "vacf", ffWRITE },
{ efXVG, "-mvacf", "mvacf", ffWRITE },
{ efXVG, "-dos", "dos", ffWRITE },
{ efLOG, "-g", "dos", ffWRITE },
};
#define NFILE asize(fnm)
int npargs;
t_pargs *ppa;
const char *DoSlegend[] = {
"DoS(v)", "DoS(v)[Solid]", "DoS(v)[Diff]"
};
npargs = asize(pa);
ppa = add_acf_pargs(&npargs, pa);
if (!parse_common_args(&argc, argv, PCA_CAN_VIEW | PCA_CAN_TIME,
NFILE, fnm, npargs, ppa, asize(desc), desc,
asize(bugs), bugs, &oenv))
{
return 0;
}
beta = 1/(Temp*BOLTZ);
fplog = gmx_fio_fopen(ftp2fn(efLOG, NFILE, fnm), "w");
fprintf(fplog, "Doing density of states analysis based on trajectory.\n");
please_cite(fplog, "Pascal2011a");
please_cite(fplog, "Caleman2011b");
read_tps_conf(ftp2fn(efTPR, NFILE, fnm), &top, &ePBC, NULL, NULL, box, TRUE);
/* Handle index groups */
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &grpNatoms, &index, &grpname);
V = det(box);
tmass = 0;
for (i = 0; i < grpNatoms; i++)
{
tmass += top.atoms.atom[index[i]].m;
}
Natom = grpNatoms;
Nmol = calcMoleculesInIndexGroup(&top.mols, top.atoms.nr, index, grpNatoms);
gnx = Natom*DIM;
/* Correlation stuff */
snew(c1, gnx);
for (i = 0; (i < gnx); i++)
{
c1[i] = NULL;
}
read_first_frame(oenv, &status, ftp2fn(efTRN, NFILE, fnm), &fr, TRX_NEED_V);
t0 = fr.time;
n_alloc = 0;
nframes = 0;
Vsum = 0;
nV = 0;
do
{
if (fr.bBox)
{
V = det(fr.box);
Vsum += V;
nV++;
}
if (nframes >= n_alloc)
{
n_alloc += 100;
for (i = 0; i < gnx; i++)
{
srenew(c1[i], n_alloc);
}
}
for (i = 0; i < gnx; i += DIM)
{
c1[i+XX][nframes] = fr.v[index[i/DIM]][XX];
c1[i+YY][nframes] = fr.v[index[i/DIM]][YY];
c1[i+ZZ][nframes] = fr.v[index[i/DIM]][ZZ];
}
t1 = fr.time;
nframes++;
}
while (read_next_frame(oenv, status, &fr));
close_trj(status);
dt = (t1-t0)/(nframes-1);
if (nV > 0)
{
V = Vsum/nV;
}
if (bVerbose)
{
printf("Going to do %d fourier transforms of length %d. Hang on.\n",
gnx, nframes);
}
/* Unfortunately the -normalize program option for the autocorrelation
* function calculation is added as a hack with a static variable in the
* autocorrelation.c source. That would work if we called the normal
* do_autocorr(), but this routine overrides that by directly calling
* the low-level functionality. That unfortunately leads to ignoring the
* default value for the option (which is to normalize).
* Since the absolute value seems to be important for the subsequent
* analysis below, we detect the value directly from the option, calculate
* the autocorrelation without normalization, and then apply the
* normalization just to the autocorrelation output
* (or not, if the user asked for a non-normalized autocorrelation).
*/
normalizeAutocorrelation = opt2parg_bool("-normalize", npargs, ppa);
/* Note that we always disable normalization here, regardless of user settings */
low_do_autocorr(NULL, oenv, NULL, nframes, gnx, nframes, c1, dt, eacNormal, 0, FALSE,
FALSE, FALSE, -1, -1, 0);
snew(dos, DOS_NR);
for (j = 0; (j < DOS_NR); j++)
{
snew(dos[j], nframes+4);
}
if (bVerbose)
{
printf("Going to merge the ACFs into the mass-weighted and plain ACF\n");
}
for (i = 0; (i < gnx); i += DIM)
{
mi = top.atoms.atom[index[i/DIM]].m;
for (j = 0; (j < nframes/2); j++)
{
c1j = (c1[i+XX][j] + c1[i+YY][j] + c1[i+ZZ][j]);
dos[VACF][j] += c1j/Natom;
dos[MVACF][j] += mi*c1j;
}
}
fp = xvgropen(opt2fn("-vacf", NFILE, fnm), "Velocity autocorrelation function",
"Time (ps)", "C(t)", oenv);
snew(tt, nframes/2);
invNormalize = normalizeAutocorrelation ? 1.0/dos[VACF][0] : 1.0;
for (j = 0; (j < nframes/2); j++)
{
tt[j] = j*dt;
fprintf(fp, "%10g %10g\n", tt[j], dos[VACF][j] * invNormalize);
}
xvgrclose(fp);
fp = xvgropen(opt2fn("-mvacf", NFILE, fnm), "Mass-weighted velocity autocorrelation function",
"Time (ps)", "C(t)", oenv);
invNormalize = normalizeAutocorrelation ? 1.0/dos[VACF][0] : 1.0;
for (j = 0; (j < nframes/2); j++)
{
fprintf(fp, "%10g %10g\n", tt[j], dos[MVACF][j] * invNormalize);
}
xvgrclose(fp);
if ((fftcode = gmx_fft_init_1d_real(&fft, nframes/2,
GMX_FFT_FLAG_NONE)) != 0)
{
gmx_fatal(FARGS, "gmx_fft_init_1d_real returned %d", fftcode);
}
if ((fftcode = gmx_fft_1d_real(fft, GMX_FFT_REAL_TO_COMPLEX,
(void *)dos[MVACF], (void *)dos[DOS])) != 0)
{
gmx_fatal(FARGS, "gmx_fft_1d_real returned %d", fftcode);
}
/* First compute the DoS */
/* Magic factor of 8 included now. */
bfac = 8*dt*beta/2;
dos2 = 0;
snew(nu, nframes/4);
for (j = 0; (j < nframes/4); j++)
{
nu[j] = 2*j/(t1-t0);
dos2 += gmx::square(dos[DOS][2*j]) + gmx::square(dos[DOS][2*j+1]);
if (bAbsolute)
{
dos[DOS][j] = bfac*std::hypot(dos[DOS][2*j], dos[DOS][2*j+1]);
}
else
{
dos[DOS][j] = bfac*dos[DOS][2*j];
}
}
/* Normalize it */
dostot = evaluate_integral(nframes/4, nu, dos[DOS], NULL, nframes/4, &stddev);
if (bNormalizeDos)
{
for (j = 0; (j < nframes/4); j++)
{
dos[DOS][j] *= 3*Natom/dostot;
}
}
/* Now analyze it */
DoS0 = dos[DOS][0];
/* Note this eqn. is incorrect in Pascal2011a! */
Delta = ((2*DoS0/(9*Natom))*std::sqrt(M_PI*BOLTZ*Temp*Natom/tmass)*
std::pow((Natom/V), 1.0/3.0)*std::pow(6.0/M_PI, 2.0/3.0));
f = calc_fluidicity(Delta, toler);
y = calc_y(f, Delta, toler);
z = calc_compress(y);
Sig = BOLTZ*(5.0/2.0+std::log(2*M_PI*BOLTZ*Temp/(gmx::square(PLANCK))*V/(f*Natom)));
Shs = Sig+calc_Shs(f, y);
rho = (tmass*AMU)/(V*NANO*NANO*NANO);
sigHS = std::cbrt(6*y*V/(M_PI*Natom));
fprintf(fplog, "System = \"%s\"\n", *top.name);
fprintf(fplog, "Nmol = %d\n", Nmol);
fprintf(fplog, "Natom = %d\n", Natom);
fprintf(fplog, "dt = %g ps\n", dt);
fprintf(fplog, "tmass = %g amu\n", tmass);
fprintf(fplog, "V = %g nm^3\n", V);
fprintf(fplog, "rho = %g g/l\n", rho);
fprintf(fplog, "T = %g K\n", Temp);
fprintf(fplog, "beta = %g mol/kJ\n", beta);
fprintf(fplog, "\nDoS parameters\n");
fprintf(fplog, "Delta = %g\n", Delta);
fprintf(fplog, "fluidicity = %g\n", f);
fprintf(fplog, "hard sphere packing fraction = %g\n", y);
fprintf(fplog, "hard sphere compressibility = %g\n", z);
fprintf(fplog, "ideal gas entropy = %g\n", Sig);
fprintf(fplog, "hard sphere entropy = %g\n", Shs);
fprintf(fplog, "sigma_HS = %g nm\n", sigHS);
fprintf(fplog, "DoS0 = %g\n", DoS0);
fprintf(fplog, "Dos2 = %g\n", dos2);
fprintf(fplog, "DoSTot = %g\n", dostot);
/* Now compute solid (2) and diffusive (3) components */
fp = xvgropen(opt2fn("-dos", NFILE, fnm), "Density of states",
bRecip ? "E (cm\\S-1\\N)" : "\\f{12}n\\f{4} (1/ps)",
"\\f{4}S(\\f{12}n\\f{4})", oenv);
xvgr_legend(fp, asize(DoSlegend), DoSlegend, oenv);
recip_fac = bRecip ? (1e7/SPEED_OF_LIGHT) : 1.0;
for (j = 0; (j < nframes/4); j++)
{
dos[DOS_DIFF][j] = DoS0/(1+gmx::square(DoS0*M_PI*nu[j]/(6*f*Natom)));
dos[DOS_SOLID][j] = dos[DOS][j]-dos[DOS_DIFF][j];
fprintf(fp, "%10g %10g %10g %10g\n",
recip_fac*nu[j],
dos[DOS][j]/recip_fac,
dos[DOS_SOLID][j]/recip_fac,
dos[DOS_DIFF][j]/recip_fac);
}
xvgrclose(fp);
/* Finally analyze the results! */
wCdiff = 0.5;
wSdiff = Shs/(3*BOLTZ); /* Is this correct? */
wEdiff = 0.5;
wAdiff = wEdiff-wSdiff;
for (j = 0; (j < nframes/4); j++)
{
dos[DOS_CP][j] = (dos[DOS_DIFF][j]*wCdiff +
dos[DOS_SOLID][j]*wCsolid(nu[j], beta));
dos[DOS_S][j] = (dos[DOS_DIFF][j]*wSdiff +
dos[DOS_SOLID][j]*wSsolid(nu[j], beta));
dos[DOS_A][j] = (dos[DOS_DIFF][j]*wAdiff +
dos[DOS_SOLID][j]*wAsolid(nu[j], beta));
dos[DOS_E][j] = (dos[DOS_DIFF][j]*wEdiff +
dos[DOS_SOLID][j]*wEsolid(nu[j], beta));
}
DiffCoeff = evaluate_integral(nframes/2, tt, dos[VACF], NULL, nframes/2, &stddev);
DiffCoeff = 1000*DiffCoeff/3.0;
fprintf(fplog, "Diffusion coefficient from VACF %g 10^-5 cm^2/s\n",
DiffCoeff);
fprintf(fplog, "Diffusion coefficient from DoS %g 10^-5 cm^2/s\n",
1000*DoS0/(12*tmass*beta));
cP = BOLTZ * evaluate_integral(nframes/4, nu, dos[DOS_CP], NULL,
nframes/4, &stddev);
fprintf(fplog, "Heat capacity %g J/mol K\n", 1000*cP/Nmol);
fprintf(fplog, "\nArrivederci!\n");
gmx_fio_fclose(fplog);
do_view(oenv, ftp2fn(efXVG, NFILE, fnm), "-nxy");
return 0;
}
