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 bTPS, bTop; /* ,bCubic; */
int gnx;
atom_id *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 **c1, **tc;
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 | PCA_BE_NICE,
NFILE, fnm, npargs, ppa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &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;
/* bCubic = TRUE; */
do
{
/*
bCubic = bCubic && !TRICLINIC(fr.box) &&
fabs(fr.box[XX][XX]-fr.box[YY][YY]) < 0.001*fr.box[XX][XX] &&
fabs(fr.box[XX][XX]-fr.box[ZZ][ZZ]) < 0.001*fr.box[XX][XX];
*/
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 = sin(iprod(kfac[k], cm_mol));
cx = 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 gmx_genion(int argc, char *argv[])
{
const char *desc[] = {
"genion replaces solvent molecules by monoatomic ions at",
"the position of the first atoms with the most favorable electrostatic",
"potential or at random. The potential is calculated on all atoms, using",
"normal GROMACS particle based methods (in contrast to other methods",
"based on solving the Poisson-Boltzmann equation).",
"The potential is recalculated after every ion insertion.",
"If specified in the run input file, a reaction field, shift function",
"or user function can be used. For the user function a table file",
"can be specified with the option [TT]-table[tt].",
"The group of solvent molecules should be continuous and all molecules",
"should have the same number of atoms.",
"The user should add the ion molecules to the topology file and include",
"the file [TT]ions.itp[tt].",
"Ion names for Gromos96 should include the charge.[PAR]",
"With the option [TT]-pot[tt] the potential can be written as B-factors",
"in a pdb file (for visualisation using e.g. rasmol).",
"The unit of the potential is 1000 kJ/(mol e), the scaling be changed",
"with the [TT]-scale[tt] option.[PAR]",
"For larger ions, e.g. sulfate we recommended to use genbox."
};
const char *bugs[] = {
"Calculation of the potential is not reliable, therefore the [TT]-random[tt] option is now turned on by default.",
"If you specify a salt concentration existing ions are not taken into account. In effect you therefore specify the amount of salt to be added."
};
static int p_num=0,n_num=0,p_q=1,n_q=-1;
static const char *p_name="Na",*n_name="Cl";
static real rmin=0.6,scale=0.001,conc=0;
static int seed=1993;
static bool bRandom=TRUE,bNeutral=FALSE;
static t_pargs pa[] = {
{ "-np", FALSE, etINT, {&p_num}, "Number of positive ions" },
{ "-pname", FALSE, etSTR, {&p_name},"Name of the positive ion" },
{ "-pq", FALSE, etINT, {&p_q}, "Charge of the positive ion" },
{ "-nn", FALSE, etINT, {&n_num}, "Number of negative ions" },
{ "-nname", FALSE, etSTR, {&n_name},"Name of the negative ion" },
{ "-nq", FALSE, etINT, {&n_q}, "Charge of the negative ion" },
{ "-rmin", FALSE, etREAL, {&rmin}, "Minimum distance between ions" },
{ "-random",FALSE,etBOOL, {&bRandom},"Use random placement of ions instead of based on potential. The rmin option should still work" },
{ "-seed", FALSE, etINT, {&seed}, "Seed for random number generator" },
{ "-scale", FALSE, etREAL, {&scale}, "Scaling factor for the potential for -pot" },
{ "-conc", FALSE, etREAL, {&conc},
"Specify salt concentration (mol/liter). This will add sufficient ions to reach up to the specified concentration as computed from the volume of the cell in the input tpr file. Overrides the -np and nn options." },
{ "-neutral", FALSE, etBOOL, {&bNeutral},
"This option will add enough ions to neutralize the system. In combination with the concentration option a neutral system at a given salt concentration will be generated." }
};
gmx_mtop_t *mtop;
gmx_localtop_t *top;
t_inputrec inputrec;
t_commrec *cr;
t_mdatoms *mdatoms;
gmx_enerdata_t enerd;
t_graph *graph;
t_forcerec *fr;
rvec *x,*v;
real *pot,vol,qtot;
matrix box;
t_atoms atoms;
t_pbc pbc;
int *repl;
atom_id *index;
char *grpname;
bool *bSet,bPDB;
int i,nw,nwa,nsa,nsalt,iqtot;
FILE *fplog;
t_filenm fnm[] = {
{ efTPX, NULL, NULL, ffREAD },
{ efXVG, "-table","table", ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efSTO, "-o", NULL, ffWRITE },
{ efLOG, "-g", "genion", ffWRITE },
{ efPDB, "-pot", "pot", ffOPTWR },
{ efTOP, "-p", "topol", ffOPTRW }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_BE_NICE,NFILE,fnm,asize(pa),pa,asize(desc),desc,
asize(bugs),bugs);
bPDB = ftp2bSet(efPDB,NFILE,fnm);
if (bRandom && bPDB) {
fprintf(stderr,"Not computing potential with random option!\n");
bPDB = FALSE;
}
/* Check input for something sensible */
if ((p_num<0) || (n_num<0))
gmx_fatal(FARGS,"Negative number of ions to add?");
snew(mtop,1);
snew(top,1);
fplog = init_calcpot(ftp2fn(efLOG,NFILE,fnm),ftp2fn(efTPX,NFILE,fnm),
opt2fn("-table",NFILE,fnm),mtop,top,&inputrec,&cr,
&graph,&mdatoms,&fr,&enerd,&pot,box,&x);
atoms = gmx_mtop_global_atoms(mtop);
qtot = 0;
for(i=0; (i<atoms.nr); i++)
qtot += atoms.atom[i].q;
iqtot = gmx_nint(qtot);
if ((conc > 0) || bNeutral) {
/* Compute number of ions to be added */
vol = det(box);
if (conc > 0) {
nsalt = gmx_nint(conc*vol*AVOGADRO/1e24);
p_num = abs(nsalt*n_q);
n_num = abs(nsalt*p_q);
if (bNeutral) {
int qdelta = 0;
do {
qdelta = (p_num*p_q + n_num*n_q + iqtot);
if (qdelta < 0) {
p_num += abs(qdelta/p_q);
qdelta = (p_num*p_q + n_num*n_q + iqtot);
}
if (qdelta > 0) {
n_num += abs(qdelta/n_q);
qdelta = (p_num*p_q + n_num*n_q + iqtot);
}
} while (qdelta != 0);
}
}
}
if ((p_num == 0) && (n_num == 0)) {
if (!bPDB) {
fprintf(stderr,"No ions to add and no potential to calculate.\n");
exit(0);
}
nw = 0;
nsa = 0; /* to keep gcc happy */
} else {
printf("Will try to add %d %s ions and %d %s ions.\n",
p_num,p_name,n_num,n_name);
printf("Select a continuous group of solvent molecules\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&nwa,&index,&grpname);
for(i=1; i<nwa; i++)
if (index[i] != index[i-1]+1)
gmx_fatal(FARGS,"The solvent group %s is not continuous: "
"index[%d]=%d, index[%d]=%d",
grpname,i,index[i-1]+1,i+1,index[i]+1);
nsa = 1;
while ((nsa<nwa) &&
(atoms.atom[index[nsa]].resind ==
atoms.atom[index[nsa-1]].resind))
nsa++;
if (nwa % nsa)
gmx_fatal(FARGS,"Your solvent group size (%d) is not a multiple of %d",
nwa,nsa);
nw = nwa/nsa;
fprintf(stderr,"Number of (%d-atomic) solvent molecules: %d\n",nsa,nw);
if (p_num+n_num > nw)
gmx_fatal(FARGS,"Not enough solvent for adding ions");
}
if (opt2bSet("-p",NFILE,fnm))
update_topol(opt2fn("-p",NFILE,fnm),p_num,n_num,p_name,n_name,grpname);
snew(bSet,nw);
snew(repl,nw);
snew(v,atoms.nr);
snew(atoms.pdbinfo,atoms.nr);
set_pbc(&pbc,inputrec.ePBC,box);
/* Now loop over the ions that have to be placed */
do {
if (!bRandom) {
calc_pot(fplog,cr,mtop,&inputrec,top,x,fr,&enerd,mdatoms,pot,box,graph);
if (bPDB || debug) {
char buf[STRLEN];
if (debug)
sprintf(buf,"%d_%s",p_num+n_num,ftp2fn(efPDB,NFILE,fnm));
else
strcpy(buf,ftp2fn(efPDB,NFILE,fnm));
for(i=0; (i<atoms.nr); i++)
atoms.pdbinfo[i].bfac = pot[i]*scale;
write_sto_conf(buf,"Potential calculated by genion",
&atoms,x,v,inputrec.ePBC,box);
bPDB = FALSE;
}
}
if ((p_num > 0) && (p_num >= n_num)) {
insert_ion(nsa,&nw,bSet,repl,index,pot,x,&pbc,
1,p_q,p_name,mdatoms,rmin,bRandom,&seed);
p_num--;
}
else if (n_num > 0) {
insert_ion(nsa,&nw,bSet,repl,index,pot,x,&pbc,
-1,n_q,n_name,mdatoms,rmin,bRandom,&seed);
n_num--;
}
} while (p_num+n_num > 0);
fprintf(stderr,"\n");
if (nw)
sort_ions(nsa,nw,repl,index,&atoms,x,p_name,n_name);
sfree(atoms.pdbinfo);
atoms.pdbinfo = NULL;
write_sto_conf(ftp2fn(efSTO,NFILE,fnm),*mtop->name,&atoms,x,NULL,
inputrec.ePBC,box);
thanx(stderr);
gmx_log_close(fplog);
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;
atom_id *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;
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))
{
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_editconf(int argc, char *argv[])
{
const char *desc[] = {
"editconf converts generic structure format to [TT].gro[tt], [TT].g96[tt]",
"or [TT].pdb[tt].",
"[PAR]",
"The box can be modified with options [TT]-box[tt], [TT]-d[tt] and",
"[TT]-angles[tt]. Both [TT]-box[tt] and [TT]-d[tt]",
"will center the system in the box, unless [TT]-noc[tt] is used.",
"[PAR]",
"Option [TT]-bt[tt] determines the box type: [TT]triclinic[tt] is a",
"triclinic box, [TT]cubic[tt] is a rectangular box with all sides equal",
"[TT]dodecahedron[tt] represents a rhombic dodecahedron and "
"[TT]octahedron[tt] is a truncated octahedron.",
"The last two are special cases of a triclinic box.",
"The length of the three box vectors of the truncated octahedron is the",
"shortest distance between two opposite hexagons.",
"The volume of a dodecahedron is 0.71 and that of a truncated octahedron",
"is 0.77 of that of a cubic box with the same periodic image distance.",
"[PAR]",
"Option [TT]-box[tt] requires only",
"one value for a cubic box, dodecahedron and a truncated octahedron.",
"[PAR]",
"With [TT]-d[tt] and a [TT]triclinic[tt] box the size of the system in the x, y",
"and z directions is used. With [TT]-d[tt] and [TT]cubic[tt],",
"[TT]dodecahedron[tt] or [TT]octahedron[tt] boxes, the dimensions are set",
"to the diameter of the system (largest distance between atoms) plus twice",
"the specified distance.",
"[PAR]",
"Option [TT]-angles[tt] is only meaningful with option [TT]-box[tt] and",
"a triclinic box and can not be used with option [TT]-d[tt].",
"[PAR]",
"When [TT]-n[tt] or [TT]-ndef[tt] is set, a group",
"can be selected for calculating the size and the geometric center,",
"otherwise the whole system is used.",
"[PAR]",
"[TT]-rotate[tt] rotates the coordinates and velocities.",
"[PAR]",
"[TT]-princ[tt] aligns the principal axes of the system along the",
"coordinate axes, this may allow you to decrease the box volume,",
"but beware that molecules can rotate significantly in a nanosecond.",
"[PAR]",
"Scaling is applied before any of the other operations are",
"performed. Boxes and coordinates can be scaled to give a certain density (option",
"[TT]-density[tt]). Note that this may be inaccurate in case a gro",
"file is given as input. A special feature of the scaling option, when the",
"factor -1 is given in one dimension, one obtains a mirror image,",
"mirrored in one of the plains, when one uses -1 in three dimensions",
"a point-mirror image is obtained.[PAR]",
"Groups are selected after all operations have been applied.[PAR]",
"Periodicity can be removed in a crude manner.",
"It is important that the box sizes at the bottom of your input file",
"are correct when the periodicity is to be removed.",
"[PAR]",
"When writing [TT].pdb[tt] files, B-factors can be",
"added with the [TT]-bf[tt] option. B-factors are read",
"from a file with with following format: first line states number of",
"entries in the file, next lines state an index",
"followed by a B-factor. The B-factors will be attached per residue",
"unless an index is larger than the number of residues or unless the",
"[TT]-atom[tt] option is set. Obviously, any type of numeric data can",
"be added instead of B-factors. [TT]-legend[tt] will produce",
"a row of CA atoms with B-factors ranging from the minimum to the",
"maximum value found, effectively making a legend for viewing.",
"[PAR]",
"With the option -mead a special pdb (pqr) file for the MEAD electrostatics",
"program (Poisson-Boltzmann solver) can be made. A further prerequisite",
"is that the input file is a run input file.",
"The B-factor field is then filled with the Van der Waals radius",
"of the atoms while the occupancy field will hold the charge.",
"[PAR]",
"The option -grasp is similar, but it puts the charges in the B-factor",
"and the radius in the occupancy.",
"[PAR]",
"Finally with option [TT]-label[tt] editconf can add a chain identifier",
"to a pdb file, which can be useful for analysis with e.g. rasmol."
"[PAR]",
"To convert a truncated octrahedron file produced by a package which uses",
"a cubic box with the corners cut off (such as Gromos) use:[BR]",
"[TT]editconf -f <in> -rotate 0 45 35.264 -bt o -box <veclen> -o <out>[tt][BR]",
"where [TT]veclen[tt] is the size of the cubic box times sqrt(3)/2."
};
const char *bugs[] = {
"For complex molecules, the periodicity removal routine may break down, "
"in that case you can use trjconv"
};
static real dist=0.0,rbox=0.0,to_diam=0.0;
static bool bNDEF=FALSE,bRMPBC=FALSE,bCenter=FALSE,bReadVDW=FALSE,bCONECT=FALSE;
static bool peratom=FALSE,bLegend=FALSE,bOrient=FALSE,bMead=FALSE,bGrasp=FALSE,bSig56=FALSE;
static rvec scale={1,1,1},newbox={0,0,0},newang={90,90,90};
static real rho=1000.0,rvdw=0.12;
static rvec center={0,0,0},translation={0,0,0},rotangles={0,0,0};
static const char *btype[]={ NULL, "triclinic", "cubic", "dodecahedron", "octahedron", NULL },*label="A";
static rvec visbox={0,0,0};
t_pargs pa[] = {
{ "-ndef", FALSE, etBOOL, {&bNDEF},
"Choose output from default index groups" },
{ "-visbox", FALSE, etRVEC, {visbox},
"HIDDENVisualize a grid of boxes, -1 visualizes the 14 box images" },
{ "-bt", FALSE, etENUM, {btype},
"Box type for -box and -d" },
{ "-box", FALSE, etRVEC, {newbox}, "Box vector lengths (a,b,c)" },
{ "-angles", FALSE, etRVEC, {newang},
"Angles between the box vectors (bc,ac,ab)" },
{ "-d", FALSE, etREAL, {&dist},
"Distance between the solute and the box" },
{ "-c", FALSE, etBOOL, {&bCenter},
"Center molecule in box (implied by -box and -d)" },
{ "-center", FALSE, etRVEC, {center}, "Coordinates of geometrical center"},
{ "-translate", FALSE, etRVEC, {translation},
"Translation" },
{ "-rotate", FALSE, etRVEC, {rotangles},
"Rotation around the X, Y and Z axes in degrees" },
{ "-princ", FALSE, etBOOL, {&bOrient}, "Orient molecule(s) along their principal axes" },
{ "-scale", FALSE, etRVEC, {scale}, "Scaling factor" },
{ "-density",FALSE, etREAL, {&rho},
"Density (g/l) of the output box achieved by scaling" },
{ "-pbc", FALSE, etBOOL, {&bRMPBC},
"Remove the periodicity (make molecule whole again)" },
{ "-grasp", FALSE, etBOOL, {&bGrasp},
"Store the charge of the atom in the B-factor field and the radius of the atom in the occupancy field" },
{ "-rvdw", FALSE, etREAL, {&rvdw},
"Default Van der Waals radius (in nm) if one can not be found in the database or if no parameters are present in the topology file" },
{ "-sig56", FALSE, etREAL, {&bSig56},
"Use rmin/2 (minimum in the Van der Waals potential) rather than sigma/2 " },
{ "-vdwread",FALSE, etBOOL, {&bReadVDW},
"Read the Van der Waals radii from the file vdwradii.dat rather than computing the radii based on the force field" },
{ "-atom", FALSE, etBOOL, {&peratom}, "Force B-factor attachment per atom" },
{ "-legend", FALSE, etBOOL, {&bLegend}, "Make B-factor legend" },
{ "-label", FALSE, etSTR, {&label}, "Add chain label for all residues" },
{ "-conect", FALSE, etBOOL, {&bCONECT}, "Add CONECT records to a pdb file when written. Can only be done when a topology is present" }
};
#define NPA asize(pa)
FILE *out;
char *infile,*outfile,title[STRLEN];
int outftp,inftp,natom,i,j,n_bfac,itype,ntype;
double *bfac=NULL,c6,c12;
int *bfac_nr=NULL;
t_topology *top=NULL;
t_atoms atoms;
char *grpname,*sgrpname;
int isize,ssize,tsize;
atom_id *index,*sindex,*tindex;
rvec *x,*v,gc,min,max,size;
int ePBC;
matrix box;
bool bIndex,bSetSize,bSetAng,bCubic,bDist,bSetCenter;
bool bHaveV,bScale,bRho,bTranslate,bRotate,bCalcGeom,bCalcDiam;
real xs,ys,zs,xcent,ycent,zcent,diam=0,mass=0,d,vdw;
gmx_atomprop_t aps;
gmx_conect conect;
t_filenm fnm[] = {
{ efSTX, "-f", NULL, ffREAD },
{ efNDX, "-n", NULL, ffOPTRD },
{ efSTO, NULL, NULL, ffOPTWR },
{ efPQR, "-mead", "mead", ffOPTWR },
{ efDAT, "-bf", "bfact", ffOPTRD }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_VIEW,NFILE,fnm,NPA,pa,
asize(desc),desc,asize(bugs),bugs);
bIndex = opt2bSet("-n",NFILE,fnm) || bNDEF;
bMead = opt2bSet("-mead",NFILE,fnm);
bSetSize = opt2parg_bSet("-box" ,NPA,pa);
bSetAng = opt2parg_bSet("-angles" ,NPA,pa);
bSetCenter= opt2parg_bSet("-center" ,NPA,pa);
bDist = opt2parg_bSet("-d" ,NPA,pa);
/* Only automatically turn on centering without -noc */
if ((bDist || bSetSize || bSetCenter) && !opt2parg_bSet("-c",NPA,pa)) {
bCenter = TRUE;
}
bScale = opt2parg_bSet("-scale" ,NPA,pa);
bRho = opt2parg_bSet("-density",NPA,pa);
bTranslate= opt2parg_bSet("-translate",NPA,pa);
bRotate = opt2parg_bSet("-rotate",NPA,pa);
if (bScale && bRho)
fprintf(stderr,"WARNING: setting -density overrides -scale\n");
bScale = bScale || bRho;
bCalcGeom = bCenter || bRotate || bOrient || bScale;
bCalcDiam = btype[0][0]=='c' || btype[0][0]=='d' || btype[0][0]=='o';
infile = ftp2fn(efSTX,NFILE,fnm);
if (bMead)
outfile = ftp2fn(efPQR,NFILE,fnm);
else
outfile = ftp2fn(efSTO,NFILE,fnm);
outftp = fn2ftp(outfile);
inftp = fn2ftp(infile);
aps = gmx_atomprop_init();
if (bMead && bGrasp) {
printf("Incompatible options -mead and -grasp. Turning off -grasp\n");
bGrasp = FALSE;
}
if (bGrasp && (outftp != efPDB))
gmx_fatal(FARGS,"Output file should be a .pdb file"
" when using the -grasp option\n");
if ((bMead || bGrasp) && !((fn2ftp(infile) == efTPR) ||
(fn2ftp(infile) == efTPA) ||
(fn2ftp(infile) == efTPB)))
gmx_fatal(FARGS,"Input file should be a .tp[abr] file"
" when using the -mead option\n");
get_stx_coordnum(infile,&natom);
init_t_atoms(&atoms,natom,TRUE);
snew(x,natom);
snew(v,natom);
read_stx_conf(infile,title,&atoms,x,v,&ePBC,box);
if (fn2ftp(infile) == efPDB)
{
get_pdb_atomnumber(&atoms,aps);
}
printf("Read %d atoms\n",atoms.nr);
/* Get the element numbers if available in a pdb file */
if (fn2ftp(infile) == efPDB)
get_pdb_atomnumber(&atoms,aps);
if (ePBC != epbcNONE) {
real vol = det(box);
printf("Volume: %g nm^3, corresponds to roughly %d electrons\n",
vol,100*((int)(vol*4.5)));
}
if (bMead || bGrasp || bCONECT)
top = read_top(infile,NULL);
if (bMead || bGrasp) {
if (atoms.nr != top->atoms.nr)
gmx_fatal(FARGS,"Atom numbers don't match (%d vs. %d)",atoms.nr,top->atoms.nr);
snew(atoms.pdbinfo,top->atoms.nr);
ntype = top->idef.atnr;
for(i=0; (i<atoms.nr); i++) {
/* Determine the Van der Waals radius from the force field */
if (bReadVDW) {
if (!gmx_atomprop_query(aps,epropVDW,
*top->atoms.resinfo[top->atoms.atom[i].resind].name,
*top->atoms.atomname[i],&vdw))
vdw = rvdw;
}
else {
itype = top->atoms.atom[i].type;
c12 = top->idef.iparams[itype*ntype+itype].lj.c12;
c6 = top->idef.iparams[itype*ntype+itype].lj.c6;
if ((c6 != 0) && (c12 != 0)) {
real sig6;
if (bSig56)
sig6 = 2*c12/c6;
else
sig6 = c12/c6;
vdw = 0.5*pow(sig6,1.0/6.0);
}
else
vdw = rvdw;
}
/* Factor of 10 for nm -> Angstroms */
vdw *= 10;
if (bMead) {
atoms.pdbinfo[i].occup = top->atoms.atom[i].q;
atoms.pdbinfo[i].bfac = vdw;
}
else {
atoms.pdbinfo[i].occup = vdw;
atoms.pdbinfo[i].bfac = top->atoms.atom[i].q;
}
}
}
bHaveV=FALSE;
for (i=0; (i<natom) && !bHaveV; i++)
for (j=0; (j<DIM) && !bHaveV; j++)
bHaveV=bHaveV || (v[i][j]!=0);
printf("%selocities found\n",bHaveV?"V":"No v");
if (visbox[0] > 0) {
if (bIndex)
gmx_fatal(FARGS,"Sorry, can not visualize box with index groups");
if (outftp != efPDB)
gmx_fatal(FARGS,"Sorry, can only visualize box with a pdb file");
} else if (visbox[0] == -1)
visualize_images("images.pdb",ePBC,box);
/* remove pbc */
if (bRMPBC)
rm_gropbc(&atoms,x,box);
if (bCalcGeom) {
if (bIndex) {
fprintf(stderr,"\nSelect a group for determining the system size:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&ssize,&sindex,&sgrpname);
} else {
ssize = atoms.nr;
sindex = NULL;
}
diam=calc_geom(ssize,sindex,x,gc,min,max,bCalcDiam);
rvec_sub(max, min, size);
printf(" system size :%7.3f%7.3f%7.3f (nm)\n",
size[XX], size[YY], size[ZZ]);
if (bCalcDiam)
printf(" diameter :%7.3f (nm)\n",diam);
printf(" center :%7.3f%7.3f%7.3f (nm)\n", gc[XX], gc[YY], gc[ZZ]);
printf(" box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf(" box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[YY],box[ZZ])),
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[ZZ])),
norm2(box[YY])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[YY])));
printf(" box volume :%7.2f (nm^3)\n",det(box));
}
if (bRho || bOrient)
mass = calc_mass(&atoms,!fn2bTPX(infile),aps);
if (bOrient) {
atom_id *index;
char *grpnames;
/* Get a group for principal component analysis */
fprintf(stderr,"\nSelect group for the determining the orientation\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&isize,&index,&grpnames);
/* Orient the principal axes along the coordinate axes */
orient_princ(&atoms,isize,index,natom,x,bHaveV ? v : NULL, NULL);
sfree(index);
sfree(grpnames);
}
if ( bScale ) {
/* scale coordinates and box */
if (bRho) {
/* Compute scaling constant */
real vol,dens;
vol = det(box);
dens = (mass*AMU)/(vol*NANO*NANO*NANO);
fprintf(stderr,"Volume of input %g (nm^3)\n",vol);
fprintf(stderr,"Mass of input %g (a.m.u.)\n",mass);
fprintf(stderr,"Density of input %g (g/l)\n",dens);
if (vol==0 || mass==0)
gmx_fatal(FARGS,"Cannot scale density with "
"zero mass (%g) or volume (%g)\n",mass,vol);
scale[XX] = scale[YY] = scale[ZZ] = pow(dens/rho,1.0/3.0);
fprintf(stderr,"Scaling all box vectors by %g\n",scale[XX]);
}
scale_conf(atoms.nr,x,box,scale);
}
if (bTranslate) {
if (bIndex) {
fprintf(stderr,"\nSelect a group that you want to translate:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&ssize,&sindex,&sgrpname);
} else {
ssize = atoms.nr;
sindex = NULL;
}
printf("Translating %d atoms (out of %d) by %g %g %g nm\n",ssize,natom,
translation[XX],translation[YY],translation[ZZ]);
if (sindex) {
for(i=0; i<ssize; i++)
rvec_inc(x[sindex[i]],translation);
}
else {
for(i=0; i<natom; i++)
rvec_inc(x[i],translation);
}
}
if (bRotate) {
/* Rotate */
printf("Rotating %g, %g, %g degrees around the X, Y and Z axis respectively\n",rotangles[XX],rotangles[YY],rotangles[ZZ]);
for(i=0; i<DIM; i++)
rotangles[i] *= DEG2RAD;
rotate_conf(natom,x,v,rotangles[XX],rotangles[YY],rotangles[ZZ]);
}
if (bCalcGeom) {
/* recalc geometrical center and max and min coordinates and size */
calc_geom(ssize,sindex,x,gc,min,max,FALSE);
rvec_sub(max, min, size);
if (bScale || bOrient || bRotate)
printf("new system size : %6.3f %6.3f %6.3f\n",
size[XX],size[YY],size[ZZ]);
}
if (bSetSize || bDist || (btype[0][0]=='t' && bSetAng)) {
ePBC = epbcXYZ;
if (!(bSetSize || bDist))
for (i=0; i<DIM; i++)
newbox[i] = norm(box[i]);
clear_mat(box);
/* calculate new boxsize */
switch(btype[0][0]){
case 't':
if (bDist)
for(i=0; i<DIM; i++)
newbox[i] = size[i]+2*dist;
if (!bSetAng) {
box[XX][XX] = newbox[XX];
box[YY][YY] = newbox[YY];
box[ZZ][ZZ] = newbox[ZZ];
} else {
svmul(DEG2RAD,newang,newang);
box[XX][XX] = newbox[XX];
box[YY][XX] = newbox[YY]*cos(newang[ZZ]);
box[YY][YY] = newbox[YY]*sin(newang[ZZ]);
box[ZZ][XX] = newbox[ZZ]*cos(newang[YY]);
box[ZZ][YY] = newbox[ZZ]
*(cos(newang[XX])-cos(newang[YY])*cos(newang[ZZ]))/sin(newang[ZZ]);
box[ZZ][ZZ] = sqrt(sqr(newbox[ZZ])
-box[ZZ][XX]*box[ZZ][XX]-box[ZZ][YY]*box[ZZ][YY]);
}
break;
case 'c':
case 'd':
case 'o':
if (bSetSize)
d = newbox[0];
else
d = diam+2*dist;
if (btype[0][0] == 'c')
for(i=0; i<DIM; i++)
box[i][i] = d;
else if (btype[0][0] == 'd') {
box[XX][XX] = d;
box[YY][YY] = d;
box[ZZ][XX] = d/2;
box[ZZ][YY] = d/2;
box[ZZ][ZZ] = d*sqrt(2)/2;
} else {
box[XX][XX] = d;
box[YY][XX] = d/3;
box[YY][YY] = d*sqrt(2)*2/3;
box[ZZ][XX] = -d/3;
box[ZZ][YY] = d*sqrt(2)/3;
box[ZZ][ZZ] = d*sqrt(6)/3;
}
break;
}
}
/* calculate new coords for geometrical center */
if (!bSetCenter)
calc_box_center(ecenterDEF,box,center);
/* center molecule on 'center' */
if (bCenter)
center_conf(natom,x,center,gc);
/* print some */
if (bCalcGeom) {
calc_geom(ssize,sindex,x, gc, min, max, FALSE);
printf("new center :%7.3f%7.3f%7.3f (nm)\n",gc[XX],gc[YY],gc[ZZ]);
}
if (bOrient || bScale || bDist || bSetSize) {
printf("new box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf("new box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[YY],box[ZZ])),
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[ZZ])),
norm2(box[YY])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[YY])));
printf("new box volume :%7.2f (nm^3)\n",det(box));
}
if (check_box(epbcXYZ,box))
printf("\nWARNING: %s\n",check_box(epbcXYZ,box));
if (bDist && btype[0][0]=='t')
{
if(TRICLINIC(box))
{
printf("\nWARNING: Your box is triclinic with non-orthogonal axes. In this case, the\n"
"distance from the solute to a box surface along the corresponding normal\n"
"vector might be somewhat smaller than your specified value %f.\n"
"You can check the actual value with g_mindist -pi\n",dist);
}
else
{
printf("\nWARNING: No boxtype specified - distance condition applied in each dimension.\n"
"If the molecule rotates the actual distance will be smaller. You might want\n"
"to use a cubic box instead, or why not try a dodecahedron today?\n");
}
}
if (bCONECT && (outftp == efPDB) && (inftp == efTPR))
conect = gmx_conect_generate(top);
else
conect = NULL;
if (bIndex) {
fprintf(stderr,"\nSelect a group for output:\n");
get_index(&atoms,opt2fn_null("-n",NFILE,fnm),
1,&isize,&index,&grpname);
if (opt2bSet("-bf",NFILE,fnm))
gmx_fatal(FARGS,"combination not implemented: -bf -n or -bf -ndef");
else {
if (outftp == efPDB) {
out=ffopen(outfile,"w");
write_pdbfile_indexed(out,title,&atoms,x,ePBC,box,' ',1,isize,index,conect);
fclose(out);
}
else
write_sto_conf_indexed(outfile,title,&atoms,x,bHaveV?v:NULL,ePBC,box,
isize,index);
}
}
else {
if ((outftp == efPDB) || (outftp == efPQR)) {
out=ffopen(outfile,"w");
if (bMead) {
set_pdb_wide_format(TRUE);
fprintf(out,"REMARK "
"The B-factors in this file hold atomic radii\n");
fprintf(out,"REMARK "
"The occupancy in this file hold atomic charges\n");
}
else if (bGrasp) {
fprintf(out,"GRASP PDB FILE\nFORMAT NUMBER=1\n");
fprintf(out,"REMARK "
"The B-factors in this file hold atomic charges\n");
fprintf(out,"REMARK "
"The occupancy in this file hold atomic radii\n");
}
else if (opt2bSet("-bf",NFILE,fnm)) {
read_bfac(opt2fn("-bf",NFILE,fnm),&n_bfac,&bfac,&bfac_nr);
set_pdb_conf_bfac(atoms.nr,atoms.nres,&atoms,
n_bfac,bfac,bfac_nr,peratom);
}
if (opt2parg_bSet("-label",NPA,pa)) {
for(i=0; (i<atoms.nr); i++)
atoms.resinfo[atoms.atom[i].resind].chain=label[0];
}
write_pdbfile(out,title,&atoms,x,ePBC,box,0,-1,conect);
if (bLegend)
pdb_legend(out,atoms.nr,atoms.nres,&atoms,x);
if (visbox[0] > 0)
visualize_box(out,bLegend ? atoms.nr+12 : atoms.nr,
bLegend? atoms.nres=12 : atoms.nres,box,visbox);
fclose(out);
}
else
write_sto_conf(outfile,title,&atoms,x,bHaveV?v:NULL,ePBC,box);
}
gmx_atomprop_destroy(aps);
do_view(outfile,NULL);
thanx(stderr);
return 0;
}
int gmx_spol(int argc, char *argv[])
{
t_topology *top;
t_inputrec *ir;
t_atom *atom;
t_trxstatus *status;
int nrefat, natoms, nf, ntot;
real t;
rvec *x, xref, trial, dx = {0}, dip, dir;
matrix box;
FILE *fp;
int *isize, nrefgrp;
atom_id **index, *molindex;
char **grpname;
real rmin2, rmax2, rcut, rcut2, rdx2 = 0, rtry2, qav, q, dip2, invbw;
int nbin, i, m, mol, a0, a1, a, d;
double sdip, sdip2, sinp, sdinp, nmol;
int *hist;
t_pbc pbc;
gmx_rmpbc_t gpbc = NULL;
const char *desc[] = {
"[THISMODULE] analyzes dipoles around a solute; it is especially useful",
"for polarizable water. A group of reference atoms, or a center",
"of mass reference (option [TT]-com[tt]) and a group of solvent",
"atoms is required. The program splits the group of solvent atoms",
"into molecules. For each solvent molecule the distance to the",
"closest atom in reference group or to the COM is determined.",
"A cumulative distribution of these distances is plotted.",
"For each distance between [TT]-rmin[tt] and [TT]-rmax[tt]",
"the inner product of the distance vector",
"and the dipole of the solvent molecule is determined.",
"For solvent molecules with net charge (ions), the net charge of the ion",
"is subtracted evenly from all atoms in the selection of each ion.",
"The average of these dipole components is printed.",
"The same is done for the polarization, where the average dipole is",
"subtracted from the instantaneous dipole. The magnitude of the average",
"dipole is set with the option [TT]-dip[tt], the direction is defined",
"by the vector from the first atom in the selected solvent group",
"to the midpoint between the second and the third atom."
};
gmx_output_env_t *oenv;
static gmx_bool bCom = FALSE;
static int srefat = 1;
static real rmin = 0.0, rmax = 0.32, refdip = 0, bw = 0.01;
t_pargs pa[] = {
{ "-com", FALSE, etBOOL, {&bCom},
"Use the center of mass as the reference postion"
},
{ "-refat", FALSE, etINT, {&srefat},
"The reference atom of the solvent molecule"
},
{ "-rmin", FALSE, etREAL, {&rmin}, "Maximum distance (nm)" },
{ "-rmax", FALSE, etREAL, {&rmax}, "Maximum distance (nm)" },
{ "-dip", FALSE, etREAL, {&refdip}, "The average dipole (D)" },
{ "-bw", FALSE, etREAL, {&bw}, "The bin width" }
};
t_filenm fnm[] = {
{ efTRX, NULL, NULL, ffREAD },
{ efTPR, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "scdist", ffWRITE }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_CAN_VIEW,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
snew(top, 1);
snew(ir, 1);
read_tpx_top(ftp2fn(efTPR, NFILE, fnm),
ir, box, &natoms, NULL, NULL, top);
/* get index groups */
printf("Select a group of reference particles and a solvent group:\n");
snew(grpname, 2);
snew(index, 2);
snew(isize, 2);
get_index(&top->atoms, ftp2fn_null(efNDX, NFILE, fnm), 2, isize, index, grpname);
if (bCom)
{
nrefgrp = 1;
nrefat = isize[0];
}
else
{
nrefgrp = isize[0];
nrefat = 1;
}
spol_atom2molindex(&(isize[1]), index[1], &(top->mols));
srefat--;
/* initialize reading trajectory: */
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
rcut = 0.99*std::sqrt(max_cutoff2(ir->ePBC, box));
if (rcut == 0)
{
rcut = 10*rmax;
}
rcut2 = sqr(rcut);
invbw = 1/bw;
nbin = static_cast<int>(rcut*invbw)+2;
snew(hist, nbin);
rmin2 = sqr(rmin);
rmax2 = sqr(rmax);
nf = 0;
ntot = 0;
sdip = 0;
sdip2 = 0;
sinp = 0;
sdinp = 0;
molindex = top->mols.index;
atom = top->atoms.atom;
gpbc = gmx_rmpbc_init(&top->idef, ir->ePBC, natoms);
/* start analysis of trajectory */
do
{
/* make molecules whole again */
gmx_rmpbc(gpbc, natoms, box, x);
set_pbc(&pbc, ir->ePBC, box);
if (bCom)
{
calc_com_pbc(nrefat, top, x, &pbc, index[0], xref, ir->ePBC);
}
for (m = 0; m < isize[1]; m++)
{
mol = index[1][m];
a0 = molindex[mol];
a1 = molindex[mol+1];
for (i = 0; i < nrefgrp; i++)
{
pbc_dx(&pbc, x[a0+srefat], bCom ? xref : x[index[0][i]], trial);
rtry2 = norm2(trial);
if (i == 0 || rtry2 < rdx2)
{
copy_rvec(trial, dx);
rdx2 = rtry2;
}
}
if (rdx2 < rcut2)
{
hist[static_cast<int>(std::sqrt(rdx2)*invbw)+1]++;
}
if (rdx2 >= rmin2 && rdx2 < rmax2)
{
unitv(dx, dx);
clear_rvec(dip);
qav = 0;
for (a = a0; a < a1; a++)
{
qav += atom[a].q;
}
qav /= (a1 - a0);
for (a = a0; a < a1; a++)
{
q = atom[a].q - qav;
for (d = 0; d < DIM; d++)
{
dip[d] += q*x[a][d];
}
}
for (d = 0; d < DIM; d++)
{
dir[d] = -x[a0][d];
}
for (a = a0+1; a < a0+3; a++)
{
for (d = 0; d < DIM; d++)
{
dir[d] += 0.5*x[a][d];
}
}
unitv(dir, dir);
svmul(ENM2DEBYE, dip, dip);
dip2 = norm2(dip);
sdip += std::sqrt(dip2);
sdip2 += dip2;
for (d = 0; d < DIM; d++)
{
sinp += dx[d]*dip[d];
sdinp += dx[d]*(dip[d] - refdip*dir[d]);
}
ntot++;
}
}
nf++;
}
while (read_next_x(oenv, status, &t, x, box));
gmx_rmpbc_done(gpbc);
/* clean up */
sfree(x);
close_trj(status);
fprintf(stderr, "Average number of molecules within %g nm is %.1f\n",
rmax, static_cast<real>(ntot)/nf);
if (ntot > 0)
{
sdip /= ntot;
sdip2 /= ntot;
sinp /= ntot;
sdinp /= ntot;
fprintf(stderr, "Average dipole: %f (D), std.dev. %f\n",
sdip, std::sqrt(sdip2-sqr(sdip)));
fprintf(stderr, "Average radial component of the dipole: %f (D)\n",
sinp);
fprintf(stderr, "Average radial component of the polarization: %f (D)\n",
sdinp);
}
fp = xvgropen(opt2fn("-o", NFILE, fnm),
"Cumulative solvent distribution", "r (nm)", "molecules", oenv);
nmol = 0;
for (i = 0; i <= nbin; i++)
{
nmol += hist[i];
fprintf(fp, "%g %g\n", i*bw, nmol/nf);
}
xvgrclose(fp);
do_view(oenv, opt2fn("-o", NFILE, fnm), NULL);
return 0;
}
int gmx_density(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes partial densities across the box, using an index file.[PAR]",
"For the total density of NPT simulations, use [gmx-energy] instead.",
"[PAR]",
"Option [TT]-center[tt] performs the histogram binning relative to the center",
"of an arbitrary group, in absolute box coordinates. If you are calculating",
"profiles along the Z axis box dimension bZ, output would be from -bZ/2 to",
"bZ/2 if you center based on the entire system.",
"Note that this behaviour has changed in Gromacs 5.0; earlier versions",
"merely performed a static binning in (0,bZ) and shifted the output. Now",
"we compute the center for each frame and bin in (-bZ/2,bZ/2).[PAR]",
"Option [TT]-symm[tt] symmetrizes the output around the center. This will",
"automatically turn on [TT]-center[tt] too.",
"Option [TT]-relative[tt] performs the binning in relative instead of absolute",
"box coordinates, and scales the final output with the average box dimension",
"along the output axis. This can be used in combination with [TT]-center[tt].[PAR]",
"Densities are in kg/m^3, and number densities or electron densities can also be",
"calculated. For electron densities, a file describing the number of",
"electrons for each type of atom should be provided using [TT]-ei[tt].",
"It should look like:[BR]",
" [TT]2[tt][BR]",
" [TT]atomname = nrelectrons[tt][BR]",
" [TT]atomname = nrelectrons[tt][BR]",
"The first line contains the number of lines to read from the file.",
"There should be one line for each unique atom name in your system.",
"The number of electrons for each atom is modified by its atomic",
"partial charge.[PAR]",
"IMPORTANT CONSIDERATIONS FOR BILAYERS[PAR]",
"One of the most common usage scenarios is to calculate the density of various",
"groups across a lipid bilayer, typically with the z axis being the normal",
"direction. For short simulations, small systems, and fixed box sizes this",
"will work fine, but for the more general case lipid bilayers can be complicated.",
"The first problem that while both proteins and lipids have low volume",
"compressibility, lipids have quite high area compressiblity. This means the",
"shape of the box (thickness and area/lipid) will fluctuate substantially even",
"for a fully relaxed system. Since Gromacs places the box between the origin",
"and positive coordinates, this in turn means that a bilayer centered in the",
"box will move a bit up/down due to these fluctuations, and smear out your",
"profile. The easiest way to fix this (if you want pressure coupling) is",
"to use the [TT]-center[tt] option that calculates the density profile with",
"respect to the center of the box. Note that you can still center on the",
"bilayer part even if you have a complex non-symmetric system with a bilayer",
"and, say, membrane proteins - then our output will simply have more values",
"on one side of the (center) origin reference.[PAR]",
"Even the centered calculation will lead to some smearing out the output",
"profiles, as lipids themselves are compressed and expanded. In most cases",
"you probably want this (since it corresponds to macroscopic experiments),",
"but if you want to look at molecular details you can use the [TT]-relative[tt]",
"option to attempt to remove even more of the effects of volume fluctuations.[PAR]",
"Finally, large bilayers that are not subject to a surface tension will exhibit",
"undulatory fluctuations, where there are 'waves' forming in the system.",
"This is a fundamental property of the biological system, and if you are",
"comparing against experiments you likely want to include the undulation",
"smearing effect.",
"",
};
output_env_t oenv;
static const char *dens_opt[] =
{ NULL, "mass", "number", "charge", "electron", NULL };
static int axis = 2; /* normal to memb. default z */
static const char *axtitle = "Z";
static int nslices = 50; /* nr of slices defined */
static int ngrps = 1; /* nr. of groups */
static gmx_bool bSymmetrize = FALSE;
static gmx_bool bCenter = FALSE;
static gmx_bool bRelative = FALSE;
t_pargs pa[] = {
{ "-d", FALSE, etSTR, {&axtitle},
"Take the normal on the membrane in direction X, Y or Z." },
{ "-sl", FALSE, etINT, {&nslices},
"Divide the box in this number of slices." },
{ "-dens", FALSE, etENUM, {dens_opt},
"Density"},
{ "-ng", FALSE, etINT, {&ngrps},
"Number of groups of which to compute densities." },
{ "-center", FALSE, etBOOL, {&bCenter},
"Perform the binning relative to the center of the (changing) box. Useful for bilayers." },
{ "-symm", FALSE, etBOOL, {&bSymmetrize},
"Symmetrize the density along the axis, with respect to the center. Useful for bilayers." },
{ "-relative", FALSE, etBOOL, {&bRelative},
"Use relative coordinates for changing boxes and scale output by average dimensions." }
};
const char *bugs[] = {
"When calculating electron densities, atomnames are used instead of types. This is bad.",
};
double **density; /* density per slice */
real slWidth; /* width of one slice */
char *grpname_center; /* centering group name */
char **grpname; /* groupnames */
int nr_electrons; /* nr. electrons */
int ncenter; /* size of centering group */
int *ngx; /* sizes of groups */
t_electron *el_tab; /* tabel with nr. of electrons*/
t_topology *top; /* topology */
int ePBC;
atom_id *index_center; /* index for centering group */
atom_id **index; /* indices for all groups */
int i;
t_filenm fnm[] = { /* files for g_density */
{ efTRX, "-f", NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTPR, NULL, NULL, ffREAD },
{ efDAT, "-ei", "electrons", ffOPTRD }, /* file with nr. of electrons */
{ efXVG, "-o", "density", ffWRITE },
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_VIEW | PCA_CAN_TIME,
NFILE, fnm, asize(pa), pa, asize(desc), desc, asize(bugs), bugs,
&oenv))
{
return 0;
}
if (bSymmetrize && !bCenter)
{
fprintf(stderr, "Can not symmetrize without centering. Turning on -center\n");
bCenter = TRUE;
}
/* Calculate axis */
axis = toupper(axtitle[0]) - 'X';
top = read_top(ftp2fn(efTPR, NFILE, fnm), &ePBC); /* read topology file */
if (dens_opt[0][0] == 'n')
{
for (i = 0; (i < top->atoms.nr); i++)
{
top->atoms.atom[i].m = 1;
}
}
else if (dens_opt[0][0] == 'c')
{
for (i = 0; (i < top->atoms.nr); i++)
{
top->atoms.atom[i].m = top->atoms.atom[i].q;
}
}
snew(grpname, ngrps);
snew(index, ngrps);
snew(ngx, ngrps);
if (bCenter)
{
fprintf(stderr,
"\nNote: that the center of mass is calculated inside the box without applying\n"
"any special periodicity. If necessary, it is your responsibility to first use\n"
"trjconv to make sure atoms in this group are placed in the right periodicity.\n\n"
"Select the group to center density profiles around:\n");
get_index(&top->atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &ncenter,
&index_center, &grpname_center);
}
else
{
ncenter = 0;
}
fprintf(stderr, "\nSelect %d group%s to calculate density for:\n", ngrps, (ngrps > 1) ? "s" : "");
get_index(&top->atoms, ftp2fn_null(efNDX, NFILE, fnm), ngrps, ngx, index, grpname);
if (dens_opt[0][0] == 'e')
{
nr_electrons = get_electrons(&el_tab, ftp2fn(efDAT, NFILE, fnm));
fprintf(stderr, "Read %d atomtypes from datafile\n", nr_electrons);
calc_electron_density(ftp2fn(efTRX, NFILE, fnm), index, ngx, &density,
&nslices, top, ePBC, axis, ngrps, &slWidth, el_tab,
nr_electrons, bCenter, index_center, ncenter,
bRelative, oenv);
}
else
{
calc_density(ftp2fn(efTRX, NFILE, fnm), index, ngx, &density, &nslices, top,
ePBC, axis, ngrps, &slWidth, bCenter, index_center, ncenter,
bRelative, oenv);
}
plot_density(density, opt2fn("-o", NFILE, fnm),
nslices, ngrps, grpname, slWidth, dens_opt,
bCenter, bRelative, bSymmetrize, oenv);
do_view(oenv, opt2fn("-o", NFILE, fnm), "-nxy"); /* view xvgr file */
return 0;
}
int gmx_covar(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] calculates and diagonalizes the (mass-weighted)",
"covariance matrix.",
"All structures are fitted to the structure in the structure file.",
"When this is not a run input file periodicity will not be taken into",
"account. When the fit and analysis groups are identical and the analysis",
"is non mass-weighted, the fit will also be non mass-weighted.",
"[PAR]",
"The eigenvectors are written to a trajectory file ([TT]-v[tt]).",
"When the same atoms are used for the fit and the covariance analysis,",
"the reference structure for the fit is written first with t=-1.",
"The average (or reference when [TT]-ref[tt] is used) structure is",
"written with t=0, the eigenvectors",
"are written as frames with the eigenvector number as timestamp.",
"[PAR]",
"The eigenvectors can be analyzed with [gmx-anaeig].",
"[PAR]",
"Option [TT]-ascii[tt] writes the whole covariance matrix to",
"an ASCII file. The order of the elements is: x1x1, x1y1, x1z1, x1x2, ...",
"[PAR]",
"Option [TT]-xpm[tt] writes the whole covariance matrix to an [REF].xpm[ref] file.",
"[PAR]",
"Option [TT]-xpma[tt] writes the atomic covariance matrix to an [REF].xpm[ref] file,",
"i.e. for each atom pair the sum of the xx, yy and zz covariances is",
"written.",
"[PAR]",
"Note that the diagonalization of a matrix requires memory and time",
"that will increase at least as fast as than the square of the number",
"of atoms involved. It is easy to run out of memory, in which",
"case this tool will probably exit with a 'Segmentation fault'. You",
"should consider carefully whether a reduced set of atoms will meet",
"your needs for lower costs."
};
static gmx_bool bFit = TRUE, bRef = FALSE, bM = FALSE, bPBC = TRUE;
static int end = -1;
t_pargs pa[] = {
{ "-fit", FALSE, etBOOL, {&bFit},
"Fit to a reference structure"},
{ "-ref", FALSE, etBOOL, {&bRef},
"Use the deviation from the conformation in the structure file instead of from the average" },
{ "-mwa", FALSE, etBOOL, {&bM},
"Mass-weighted covariance analysis"},
{ "-last", FALSE, etINT, {&end},
"Last eigenvector to write away (-1 is till the last)" },
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Apply corrections for periodic boundary conditions" }
};
FILE *out = NULL; /* initialization makes all compilers happy */
t_trxstatus *status;
t_trxstatus *trjout;
t_topology top;
int ePBC;
t_atoms *atoms;
rvec *x, *xread, *xref, *xav, *xproj;
matrix box, zerobox;
real *sqrtm, *mat, *eigenvalues, sum, trace, inv_nframes;
real t, tstart, tend, **mat2;
real xj, *w_rls = NULL;
real min, max, *axis;
int ntopatoms, step;
int natoms, nat, count, nframes0, nframes, nlevels;
gmx_int64_t ndim, i, j, k, l;
int WriteXref;
const char *fitfile, *trxfile, *ndxfile;
const char *eigvalfile, *eigvecfile, *averfile, *logfile;
const char *asciifile, *xpmfile, *xpmafile;
char str[STRLEN], *fitname, *ananame, *pcwd;
int d, dj, nfit;
atom_id *index, *ifit;
gmx_bool bDiffMass1, bDiffMass2;
char timebuf[STRLEN];
t_rgb rlo, rmi, rhi;
real *eigenvectors;
output_env_t oenv;
gmx_rmpbc_t gpbc = NULL;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "eigenval", ffWRITE },
{ efTRN, "-v", "eigenvec", ffWRITE },
{ efSTO, "-av", "average.pdb", ffWRITE },
{ efLOG, NULL, "covar", ffWRITE },
{ efDAT, "-ascii", "covar", ffOPTWR },
{ efXPM, "-xpm", "covar", ffOPTWR },
{ efXPM, "-xpma", "covara", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_TIME_UNIT,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
clear_mat(zerobox);
fitfile = ftp2fn(efTPS, NFILE, fnm);
trxfile = ftp2fn(efTRX, NFILE, fnm);
ndxfile = ftp2fn_null(efNDX, NFILE, fnm);
eigvalfile = ftp2fn(efXVG, NFILE, fnm);
eigvecfile = ftp2fn(efTRN, NFILE, fnm);
averfile = ftp2fn(efSTO, NFILE, fnm);
logfile = ftp2fn(efLOG, NFILE, fnm);
asciifile = opt2fn_null("-ascii", NFILE, fnm);
xpmfile = opt2fn_null("-xpm", NFILE, fnm);
xpmafile = opt2fn_null("-xpma", NFILE, fnm);
read_tps_conf(fitfile, str, &top, &ePBC, &xref, NULL, box, TRUE);
atoms = &top.atoms;
if (bFit)
{
printf("\nChoose a group for the least squares fit\n");
get_index(atoms, ndxfile, 1, &nfit, &ifit, &fitname);
if (nfit < 3)
{
gmx_fatal(FARGS, "Need >= 3 points to fit!\n");
}
}
else
{
nfit = 0;
}
printf("\nChoose a group for the covariance analysis\n");
get_index(atoms, ndxfile, 1, &natoms, &index, &ananame);
bDiffMass1 = FALSE;
if (bFit)
{
snew(w_rls, atoms->nr);
for (i = 0; (i < nfit); i++)
{
w_rls[ifit[i]] = atoms->atom[ifit[i]].m;
if (i)
{
bDiffMass1 = bDiffMass1 || (w_rls[ifit[i]] != w_rls[ifit[i-1]]);
}
}
}
bDiffMass2 = FALSE;
snew(sqrtm, natoms);
for (i = 0; (i < natoms); i++)
{
if (bM)
{
sqrtm[i] = sqrt(atoms->atom[index[i]].m);
if (i)
{
bDiffMass2 = bDiffMass2 || (sqrtm[i] != sqrtm[i-1]);
}
}
else
{
sqrtm[i] = 1.0;
}
}
if (bFit && bDiffMass1 && !bDiffMass2)
{
bDiffMass1 = natoms != nfit;
i = 0;
for (i = 0; (i < natoms) && !bDiffMass1; i++)
{
bDiffMass1 = index[i] != ifit[i];
}
if (!bDiffMass1)
{
fprintf(stderr, "\n"
"Note: the fit and analysis group are identical,\n"
" while the fit is mass weighted and the analysis is not.\n"
" Making the fit non mass weighted.\n\n");
for (i = 0; (i < nfit); i++)
{
w_rls[ifit[i]] = 1.0;
}
}
}
/* Prepare reference frame */
if (bPBC)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, atoms->nr);
gmx_rmpbc(gpbc, atoms->nr, box, xref);
}
if (bFit)
{
reset_x(nfit, ifit, atoms->nr, NULL, xref, w_rls);
}
snew(x, natoms);
snew(xav, natoms);
ndim = natoms*DIM;
if (sqrt(GMX_INT64_MAX) < ndim)
{
gmx_fatal(FARGS, "Number of degrees of freedoms to large for matrix.\n");
}
snew(mat, ndim*ndim);
fprintf(stderr, "Calculating the average structure ...\n");
nframes0 = 0;
nat = read_first_x(oenv, &status, trxfile, &t, &xread, box);
if (nat != atoms->nr)
{
fprintf(stderr, "\nWARNING: number of atoms in tpx (%d) and trajectory (%d) do not match\n", natoms, nat);
}
do
{
nframes0++;
/* calculate x: a fitted struture of the selected atoms */
if (bPBC)
{
gmx_rmpbc(gpbc, nat, box, xread);
}
if (bFit)
{
reset_x(nfit, ifit, nat, NULL, xread, w_rls);
do_fit(nat, w_rls, xref, xread);
}
for (i = 0; i < natoms; i++)
{
rvec_inc(xav[i], xread[index[i]]);
}
}
while (read_next_x(oenv, status, &t, xread, box));
close_trj(status);
inv_nframes = 1.0/nframes0;
for (i = 0; i < natoms; i++)
{
for (d = 0; d < DIM; d++)
{
xav[i][d] *= inv_nframes;
xread[index[i]][d] = xav[i][d];
}
}
write_sto_conf_indexed(opt2fn("-av", NFILE, fnm), "Average structure",
atoms, xread, NULL, epbcNONE, zerobox, natoms, index);
sfree(xread);
fprintf(stderr, "Constructing covariance matrix (%dx%d) ...\n", (int)ndim, (int)ndim);
nframes = 0;
nat = read_first_x(oenv, &status, trxfile, &t, &xread, box);
tstart = t;
do
{
nframes++;
tend = t;
/* calculate x: a (fitted) structure of the selected atoms */
if (bPBC)
{
gmx_rmpbc(gpbc, nat, box, xread);
}
if (bFit)
{
reset_x(nfit, ifit, nat, NULL, xread, w_rls);
do_fit(nat, w_rls, xref, xread);
}
if (bRef)
{
for (i = 0; i < natoms; i++)
{
rvec_sub(xread[index[i]], xref[index[i]], x[i]);
}
}
else
{
for (i = 0; i < natoms; i++)
{
rvec_sub(xread[index[i]], xav[i], x[i]);
}
}
for (j = 0; j < natoms; j++)
{
for (dj = 0; dj < DIM; dj++)
{
k = ndim*(DIM*j+dj);
xj = x[j][dj];
for (i = j; i < natoms; i++)
{
l = k+DIM*i;
for (d = 0; d < DIM; d++)
{
mat[l+d] += x[i][d]*xj;
}
}
}
}
}
while (read_next_x(oenv, status, &t, xread, box) &&
(bRef || nframes < nframes0));
close_trj(status);
gmx_rmpbc_done(gpbc);
fprintf(stderr, "Read %d frames\n", nframes);
if (bRef)
{
/* copy the reference structure to the ouput array x */
snew(xproj, natoms);
for (i = 0; i < natoms; i++)
{
copy_rvec(xref[index[i]], xproj[i]);
}
}
else
{
xproj = xav;
}
/* correct the covariance matrix for the mass */
inv_nframes = 1.0/nframes;
for (j = 0; j < natoms; j++)
{
for (dj = 0; dj < DIM; dj++)
{
for (i = j; i < natoms; i++)
{
k = ndim*(DIM*j+dj)+DIM*i;
for (d = 0; d < DIM; d++)
{
mat[k+d] = mat[k+d]*inv_nframes*sqrtm[i]*sqrtm[j];
}
}
}
}
/* symmetrize the matrix */
for (j = 0; j < ndim; j++)
{
for (i = j; i < ndim; i++)
{
mat[ndim*i+j] = mat[ndim*j+i];
}
}
trace = 0;
for (i = 0; i < ndim; i++)
{
trace += mat[i*ndim+i];
}
fprintf(stderr, "\nTrace of the covariance matrix: %g (%snm^2)\n",
trace, bM ? "u " : "");
if (asciifile)
{
out = gmx_ffopen(asciifile, "w");
for (j = 0; j < ndim; j++)
{
for (i = 0; i < ndim; i += 3)
{
fprintf(out, "%g %g %g\n",
mat[ndim*j+i], mat[ndim*j+i+1], mat[ndim*j+i+2]);
}
}
gmx_ffclose(out);
}
if (xpmfile)
{
min = 0;
max = 0;
snew(mat2, ndim);
for (j = 0; j < ndim; j++)
{
mat2[j] = &(mat[ndim*j]);
for (i = 0; i <= j; i++)
{
if (mat2[j][i] < min)
{
min = mat2[j][i];
}
if (mat2[j][j] > max)
{
max = mat2[j][i];
}
}
}
snew(axis, ndim);
for (i = 0; i < ndim; i++)
{
axis[i] = i+1;
}
rlo.r = 0; rlo.g = 0; rlo.b = 1;
rmi.r = 1; rmi.g = 1; rmi.b = 1;
rhi.r = 1; rhi.g = 0; rhi.b = 0;
out = gmx_ffopen(xpmfile, "w");
nlevels = 80;
write_xpm3(out, 0, "Covariance", bM ? "u nm^2" : "nm^2",
"dim", "dim", ndim, ndim, axis, axis,
mat2, min, 0.0, max, rlo, rmi, rhi, &nlevels);
gmx_ffclose(out);
sfree(axis);
sfree(mat2);
}
if (xpmafile)
{
min = 0;
max = 0;
snew(mat2, ndim/DIM);
for (i = 0; i < ndim/DIM; i++)
{
snew(mat2[i], ndim/DIM);
}
for (j = 0; j < ndim/DIM; j++)
{
for (i = 0; i <= j; i++)
{
mat2[j][i] = 0;
for (d = 0; d < DIM; d++)
{
mat2[j][i] += mat[ndim*(DIM*j+d)+DIM*i+d];
}
if (mat2[j][i] < min)
{
min = mat2[j][i];
}
if (mat2[j][j] > max)
{
max = mat2[j][i];
}
mat2[i][j] = mat2[j][i];
}
}
snew(axis, ndim/DIM);
for (i = 0; i < ndim/DIM; i++)
{
axis[i] = i+1;
}
rlo.r = 0; rlo.g = 0; rlo.b = 1;
rmi.r = 1; rmi.g = 1; rmi.b = 1;
rhi.r = 1; rhi.g = 0; rhi.b = 0;
out = gmx_ffopen(xpmafile, "w");
nlevels = 80;
write_xpm3(out, 0, "Covariance", bM ? "u nm^2" : "nm^2",
"atom", "atom", ndim/DIM, ndim/DIM, axis, axis,
mat2, min, 0.0, max, rlo, rmi, rhi, &nlevels);
gmx_ffclose(out);
sfree(axis);
for (i = 0; i < ndim/DIM; i++)
{
sfree(mat2[i]);
}
sfree(mat2);
}
/* call diagonalization routine */
snew(eigenvalues, ndim);
snew(eigenvectors, ndim*ndim);
memcpy(eigenvectors, mat, ndim*ndim*sizeof(real));
fprintf(stderr, "\nDiagonalizing ...\n");
fflush(stderr);
eigensolver(eigenvectors, ndim, 0, ndim, eigenvalues, mat);
sfree(eigenvectors);
/* now write the output */
sum = 0;
for (i = 0; i < ndim; i++)
{
sum += eigenvalues[i];
}
fprintf(stderr, "\nSum of the eigenvalues: %g (%snm^2)\n",
sum, bM ? "u " : "");
if (fabs(trace-sum) > 0.01*trace)
{
fprintf(stderr, "\nWARNING: eigenvalue sum deviates from the trace of the covariance matrix\n");
}
/* Set 'end', the maximum eigenvector and -value index used for output */
if (end == -1)
{
if (nframes-1 < ndim)
{
end = nframes-1;
fprintf(out, "WARNING: there are fewer frames in your trajectory than there are\n");
fprintf(out, "degrees of freedom in your system. Only generating the first\n");
fprintf(out, "%d out of %d eigenvectors and eigenvalues.\n", end, (int)ndim);
}
else
{
end = ndim;
}
}
fprintf(stderr, "\nWriting eigenvalues to %s\n", eigvalfile);
sprintf(str, "(%snm\\S2\\N)", bM ? "u " : "");
out = xvgropen(eigvalfile,
"Eigenvalues of the covariance matrix",
"Eigenvector index", str, oenv);
for (i = 0; (i < end); i++)
{
fprintf (out, "%10d %g\n", (int)i+1, eigenvalues[ndim-1-i]);
}
xvgrclose(out);
if (bFit)
{
/* misuse lambda: 0/1 mass weighted analysis no/yes */
if (nfit == natoms)
{
WriteXref = eWXR_YES;
for (i = 0; i < nfit; i++)
{
copy_rvec(xref[ifit[i]], x[i]);
}
}
else
{
WriteXref = eWXR_NO;
}
}
else
{
/* misuse lambda: -1 for no fit */
WriteXref = eWXR_NOFIT;
}
write_eigenvectors(eigvecfile, natoms, mat, TRUE, 1, end,
WriteXref, x, bDiffMass1, xproj, bM, eigenvalues);
out = gmx_ffopen(logfile, "w");
gmx_format_current_time(timebuf, STRLEN);
fprintf(out, "Covariance analysis log, written %s\n", timebuf);
fprintf(out, "Program: %s\n", argv[0]);
gmx_getcwd(str, STRLEN);
fprintf(out, "Working directory: %s\n\n", str);
fprintf(out, "Read %d frames from %s (time %g to %g %s)\n", nframes, trxfile,
output_env_conv_time(oenv, tstart), output_env_conv_time(oenv, tend), output_env_get_time_unit(oenv));
if (bFit)
{
fprintf(out, "Read reference structure for fit from %s\n", fitfile);
}
if (ndxfile)
{
fprintf(out, "Read index groups from %s\n", ndxfile);
}
fprintf(out, "\n");
fprintf(out, "Analysis group is '%s' (%d atoms)\n", ananame, natoms);
if (bFit)
{
fprintf(out, "Fit group is '%s' (%d atoms)\n", fitname, nfit);
}
else
{
fprintf(out, "No fit was used\n");
}
fprintf(out, "Analysis is %smass weighted\n", bDiffMass2 ? "" : "non-");
if (bFit)
{
fprintf(out, "Fit is %smass weighted\n", bDiffMass1 ? "" : "non-");
}
fprintf(out, "Diagonalized the %dx%d covariance matrix\n", (int)ndim, (int)ndim);
fprintf(out, "Trace of the covariance matrix before diagonalizing: %g\n",
trace);
fprintf(out, "Trace of the covariance matrix after diagonalizing: %g\n\n",
sum);
fprintf(out, "Wrote %d eigenvalues to %s\n", (int)end, eigvalfile);
if (WriteXref == eWXR_YES)
{
fprintf(out, "Wrote reference structure to %s\n", eigvecfile);
}
fprintf(out, "Wrote average structure to %s and %s\n", averfile, eigvecfile);
fprintf(out, "Wrote eigenvectors %d to %d to %s\n", 1, end, eigvecfile);
gmx_ffclose(out);
fprintf(stderr, "Wrote the log to %s\n", logfile);
return 0;
}
int gmx_convert_tpr(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] can edit run input files in three ways.[PAR]",
"[BB]1.[bb] by modifying the number of steps in a run input file",
"with options [TT]-extend[tt], [TT]-until[tt] or [TT]-nsteps[tt]",
"(nsteps=-1 means unlimited number of steps)[PAR]",
"[BB]2.[bb] by creating a [REF].tpx[ref] file for a subset of your original",
"tpx file, which is useful when you want to remove the solvent from",
"your [REF].tpx[ref] file, or when you want to make e.g. a pure C[GRK]alpha[grk] [REF].tpx[ref] file.",
"Note that you may need to use [TT]-nsteps -1[tt] (or similar) to get",
"this to work.",
"[BB]WARNING: this [REF].tpx[ref] file is not fully functional[bb].[PAR]",
"[BB]3.[bb] by setting the charges of a specified group",
"to zero. This is useful when doing free energy estimates",
"using the LIE (Linear Interaction Energy) method."
};
const char *top_fn;
int i;
gmx_int64_t nsteps_req, run_step;
double run_t, state_t;
gmx_bool bSel;
gmx_bool bNsteps, bExtend, bUntil;
gmx_mtop_t mtop;
t_atoms atoms;
t_inputrec *ir;
t_state state;
int gnx;
char *grpname;
int *index = NULL;
char buf[200], buf2[200];
gmx_output_env_t *oenv;
t_filenm fnm[] = {
{ efTPR, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTPR, "-o", "tprout", ffWRITE }
};
#define NFILE asize(fnm)
/* Command line options */
static int nsteps_req_int = 0;
static real extend_t = 0.0, until_t = 0.0;
static gmx_bool bZeroQ = FALSE;
static t_pargs pa[] = {
{ "-extend", FALSE, etREAL, {&extend_t},
"Extend runtime by this amount (ps)" },
{ "-until", FALSE, etREAL, {&until_t},
"Extend runtime until this ending time (ps)" },
{ "-nsteps", FALSE, etINT, {&nsteps_req_int},
"Change the number of steps" },
{ "-zeroq", FALSE, etBOOL, {&bZeroQ},
"Set the charges of a group (from the index) to zero" }
};
/* Parse the command line */
if (!parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
/* Convert int to gmx_int64_t */
nsteps_req = nsteps_req_int;
bNsteps = opt2parg_bSet("-nsteps", asize(pa), pa);
bExtend = opt2parg_bSet("-extend", asize(pa), pa);
bUntil = opt2parg_bSet("-until", asize(pa), pa);
top_fn = ftp2fn(efTPR, NFILE, fnm);
fprintf(stderr, "Reading toplogy and stuff from %s\n", top_fn);
gmx::MDModules mdModules;
ir = mdModules.inputrec();
read_tpx_state(top_fn, ir, &state, &mtop);
run_step = ir->init_step;
run_t = ir->init_step*ir->delta_t + ir->init_t;
if (bNsteps)
{
fprintf(stderr, "Setting nsteps to %s\n", gmx_step_str(nsteps_req, buf));
ir->nsteps = nsteps_req;
}
else
{
/* Determine total number of steps remaining */
if (bExtend)
{
ir->nsteps = ir->nsteps - (run_step - ir->init_step) + (gmx_int64_t)(extend_t/ir->delta_t + 0.5);
printf("Extending remaining runtime of by %g ps (now %s steps)\n",
extend_t, gmx_step_str(ir->nsteps, buf));
}
else if (bUntil)
{
printf("nsteps = %s, run_step = %s, current_t = %g, until = %g\n",
gmx_step_str(ir->nsteps, buf),
gmx_step_str(run_step, buf2),
run_t, until_t);
ir->nsteps = (gmx_int64_t)((until_t - run_t)/ir->delta_t + 0.5);
printf("Extending remaining runtime until %g ps (now %s steps)\n",
until_t, gmx_step_str(ir->nsteps, buf));
}
else
{
ir->nsteps -= run_step - ir->init_step;
/* Print message */
printf("%s steps (%g ps) remaining from first run.\n",
gmx_step_str(ir->nsteps, buf), ir->nsteps*ir->delta_t);
}
}
if (bNsteps || bZeroQ || (ir->nsteps > 0))
{
ir->init_step = run_step;
if (ftp2bSet(efNDX, NFILE, fnm) ||
!(bNsteps || bExtend || bUntil))
{
atoms = gmx_mtop_global_atoms(&mtop);
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm), 1,
&gnx, &index, &grpname);
if (!bZeroQ)
{
bSel = (gnx != state.natoms);
for (i = 0; ((i < gnx) && (!bSel)); i++)
{
bSel = (i != index[i]);
}
}
else
{
bSel = FALSE;
}
if (bSel)
{
fprintf(stderr, "Will write subset %s of original tpx containing %d "
"atoms\n", grpname, gnx);
reduce_topology_x(gnx, index, &mtop, as_rvec_array(state.x.data()), as_rvec_array(state.v.data()));
state.natoms = gnx;
}
else if (bZeroQ)
{
zeroq(index, &mtop);
fprintf(stderr, "Zero-ing charges for group %s\n", grpname);
}
else
{
fprintf(stderr, "Will write full tpx file (no selection)\n");
}
}
state_t = ir->init_t + ir->init_step*ir->delta_t;
sprintf(buf, "Writing statusfile with starting step %s%s and length %s%s steps...\n", "%10", GMX_PRId64, "%10", GMX_PRId64);
fprintf(stderr, buf, ir->init_step, ir->nsteps);
fprintf(stderr, " time %10.3f and length %10.3f ps\n",
state_t, ir->nsteps*ir->delta_t);
write_tpx_state(opt2fn("-o", NFILE, fnm), ir, &state, &mtop);
}
else
{
printf("You've simulated long enough. Not writing tpr file\n");
}
return 0;
}
int gmx_bundle(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] 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 [TT].pdb[tt] file each frame. The residue numbers correspond",
"to the axis numbers. When viewing this file with Rasmol, 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 [IT]z[it]-axis as reference instead of 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)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_TIME_UNIT,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
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);
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);
}
gmx_ffclose(flen);
gmx_ffclose(fdist);
gmx_ffclose(fz);
gmx_ffclose(ftilt);
gmx_ffclose(ftiltr);
gmx_ffclose(ftiltl);
if (bKink)
{
gmx_ffclose(fkink);
gmx_ffclose(fkinkr);
gmx_ffclose(fkinkl);
}
return 0;
}
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 [TT].pdb[tt] 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 [TT].xvg[tt] 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 [TT].pdb[tt] 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;
char title[STRLEN];
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, n;
int nr_xfr, nr_vfr, nr_ffr;
char **grpname;
int *isize0, *isize;
atom_id **index0, **index;
atom_id *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, sffmt6[1024];
const char *box_leg[6] = { "XX", "YY", "ZZ", "YX", "ZX", "ZY" };
output_env_t oenv;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-ox", "coord.xvg", ffOPTWR },
{ efTRX, "-oxt", "coord.xtc", ffOPTWR },
{ efXVG, "-ov", "veloc.xvg", ffOPTWR },
{ efXVG, "-of", "force.xvg", ffOPTWR },
{ efXVG, "-ob", "box.xvg", ffOPTWR },
{ efXVG, "-ot", "temp.xvg", ffOPTWR },
{ efXVG, "-ekt", "ektrans.xvg", ffOPTWR },
{ efXVG, "-ekr", "ekrot.xvg", ffOPTWR },
{ efXVG, "-vd", "veldist.xvg", ffOPTWR },
{ efPDB, "-cv", "veloc.pdb", ffOPTWR },
{ efPDB, "-cf", "force.pdb", ffOPTWR },
{ efXVG, "-av", "all_veloc.xvg", ffOPTWR },
{ efXVG, "-af", "all_force.xvg", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv,
PCA_CAN_TIME | PCA_TIME_UNIT | PCA_CAN_VIEW | PCA_BE_NICE,
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)
{
sffmt = "\t" gmx_real_fullprecision_pfmt;
}
else
{
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), title, &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 (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)
{
ffclose(outx);
}
if (bOXT)
{
close_trx(status_out);
}
if (bOV)
{
ffclose(outv);
}
if (bOF)
{
ffclose(outf);
}
if (bOB)
{
ffclose(outb);
}
if (bOT)
{
ffclose(outt);
}
if (bEKT)
{
ffclose(outekt);
}
if (bEKR)
{
ffclose(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_gyrate(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes the radius of gyration of a molecule",
"and the radii of gyration about the [IT]x[it]-, [IT]y[it]- and [IT]z[it]-axes,",
"as a function of time. The atoms are explicitly mass weighted.[PAR]",
"The axis components corresponds to the mass-weighted root-mean-square",
"of the radii components orthogonal to each axis, for example:[PAR]",
"Rg(x) = sqrt((sum_i m_i (R_i(y)^2 + R_i(z)^2))/(sum_i m_i)).[PAR]",
"With the [TT]-nmol[tt] option the radius of gyration will be calculated",
"for multiple molecules by splitting the analysis group in equally",
"sized parts.[PAR]",
"With the option [TT]-nz[tt] 2D radii of gyration in the [IT]x-y[it] plane",
"of slices along the [IT]z[it]-axis are calculated."
};
static int nmol = 1, nz = 0;
static gmx_bool bQ = FALSE, bRot = FALSE, bMOI = FALSE;
t_pargs pa[] = {
{ "-nmol", FALSE, etINT, {&nmol},
"The number of molecules to analyze" },
{ "-q", FALSE, etBOOL, {&bQ},
"Use absolute value of the charge of an atom as weighting factor instead of mass" },
{ "-p", FALSE, etBOOL, {&bRot},
"Calculate the radii of gyration about the principal axes." },
{ "-moi", FALSE, etBOOL, {&bMOI},
"Calculate the moments of inertia (defined by the principal axes)." },
{ "-nz", FALSE, etINT, {&nz},
"Calculate the 2D radii of gyration of this number of slices along the z-axis" },
};
FILE *out;
t_trxstatus *status;
t_topology top;
int ePBC;
rvec *x, *x_s;
rvec xcm, gvec, gvec1;
matrix box, trans;
gmx_bool bACF;
real **moi_trans = NULL;
int max_moi = 0, delta_moi = 100;
rvec d, d1; /* eigenvalues of inertia tensor */
real t, t0, tm, gyro;
int natoms;
char *grpname;
int j, m, gnx, nam, mol;
int *index;
gmx_output_env_t *oenv;
gmx_rmpbc_t gpbc = NULL;
const char *leg[] = { "Rg", "Rg\\sX\\N", "Rg\\sY\\N", "Rg\\sZ\\N" };
const char *legI[] = { "Itot", "I1", "I2", "I3" };
#define NLEG asize(leg)
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "gyrate", ffWRITE },
{ efXVG, "-acf", "moi-acf", ffOPTWR },
};
#define NFILE asize(fnm)
int npargs;
t_pargs *ppa;
npargs = asize(pa);
ppa = add_acf_pargs(&npargs, pa);
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_CAN_VIEW,
NFILE, fnm, npargs, ppa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
bACF = opt2bSet("-acf", NFILE, fnm);
if (bACF && nmol != 1)
{
gmx_fatal(FARGS, "Can only do acf with nmol=1");
}
bRot = bRot || bMOI || bACF;
/*
if (nz > 0)
bMOI = TRUE;
*/
if (bRot)
{
printf("Will rotate system along principal axes\n");
snew(moi_trans, DIM);
}
if (bMOI)
{
printf("Will print moments of inertia\n");
bQ = FALSE;
}
if (bQ)
{
printf("Will print radius normalised by charge\n");
}
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, &x, NULL, box, TRUE);
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &gnx, &index, &grpname);
if (nmol > gnx || gnx % nmol != 0)
{
gmx_fatal(FARGS, "The number of atoms in the group (%d) is not a multiple of nmol (%d)", gnx, nmol);
}
nam = gnx/nmol;
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
snew(x_s, natoms);
j = 0;
t0 = t;
if (bQ)
{
out = xvgropen(ftp2fn(efXVG, NFILE, fnm),
"Radius of Charge (total and around axes)", "Time (ps)", "Rg (nm)", oenv);
}
else if (bMOI)
{
out = xvgropen(ftp2fn(efXVG, NFILE, fnm),
"Moments of inertia (total and around axes)", "Time (ps)", "I (a.m.u. nm\\S2\\N)", oenv);
}
else
{
out = xvgropen(ftp2fn(efXVG, NFILE, fnm),
"Radius of gyration (total and around axes)", "Time (ps)", "Rg (nm)", oenv);
}
if (bMOI)
{
xvgr_legend(out, NLEG, legI, oenv);
}
else
{
if (bRot)
{
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(out, "@ subtitle \"Axes are principal component axes\"\n");
}
}
xvgr_legend(out, NLEG, leg, oenv);
}
if (nz == 0)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
}
do
{
if (nz == 0)
{
gmx_rmpbc_copy(gpbc, natoms, box, x, x_s);
}
gyro = 0;
clear_rvec(gvec);
clear_rvec(gvec1);
clear_rvec(d);
clear_rvec(d1);
for (mol = 0; mol < nmol; mol++)
{
tm = sub_xcm(nz == 0 ? x_s : x, nam, index+mol*nam, top.atoms.atom, xcm, bQ);
if (nz == 0)
{
gyro += calc_gyro(x_s, nam, index+mol*nam, top.atoms.atom,
tm, gvec1, d1, bQ, bRot, bMOI, trans);
}
else
{
calc_gyro_z(x, box, nam, index+mol*nam, top.atoms.atom, nz, t, out);
}
rvec_inc(gvec, gvec1);
rvec_inc(d, d1);
}
if (nmol > 0)
{
gyro /= nmol;
svmul(1.0/nmol, gvec, gvec);
svmul(1.0/nmol, d, d);
}
if (nz == 0)
{
if (bRot)
{
if (j >= max_moi)
{
max_moi += delta_moi;
for (m = 0; (m < DIM); m++)
{
srenew(moi_trans[m], max_moi*DIM);
}
}
for (m = 0; (m < DIM); m++)
{
copy_rvec(trans[m], moi_trans[m]+DIM*j);
}
fprintf(out, "%10g %10g %10g %10g %10g\n",
t, gyro, d[XX], d[YY], d[ZZ]);
}
else
{
fprintf(out, "%10g %10g %10g %10g %10g\n",
t, gyro, gvec[XX], gvec[YY], gvec[ZZ]);
}
}
j++;
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (nz == 0)
{
gmx_rmpbc_done(gpbc);
}
xvgrclose(out);
if (bACF)
{
int mode = eacVector;
do_autocorr(opt2fn("-acf", NFILE, fnm), oenv,
"Moment of inertia vector ACF",
j, 3, moi_trans, (t-t0)/j, mode, FALSE);
do_view(oenv, opt2fn("-acf", NFILE, fnm), "-nxy");
}
do_view(oenv, ftp2fn(efXVG, NFILE, fnm), "-nxy");
return 0;
}
int gmx_make_edi(int argc, char *argv[])
{
static const char *desc[] = {
"[TT]make_edi[tt] generates an essential dynamics (ED) sampling input file to be used with [TT]mdrun[tt]",
"based on eigenvectors of a covariance matrix ([TT]g_covar[tt]) or from a",
"normal modes analysis ([TT]g_nmeig[tt]).",
"ED sampling can be used to manipulate the position along collective coordinates",
"(eigenvectors) of (biological) macromolecules during a simulation. Particularly,",
"it may be used to enhance the sampling efficiency of MD simulations by stimulating",
"the system to explore new regions along these collective coordinates. A number",
"of different algorithms are implemented to drive the system along the eigenvectors",
"([TT]-linfix[tt], [TT]-linacc[tt], [TT]-radfix[tt], [TT]-radacc[tt], [TT]-radcon[tt]),",
"to keep the position along a certain (set of) coordinate(s) fixed ([TT]-linfix[tt]),",
"or to only monitor the projections of the positions onto",
"these coordinates ([TT]-mon[tt]).[PAR]",
"References:[BR]",
"A. Amadei, A.B.M. Linssen, B.L. de Groot, D.M.F. van Aalten and ",
"H.J.C. Berendsen; An efficient method for sampling the essential subspace ",
"of proteins., J. Biomol. Struct. Dyn. 13:615-626 (1996)[BR]",
"B.L. de Groot, A. Amadei, D.M.F. van Aalten and H.J.C. Berendsen; ",
"Towards an exhaustive sampling of the configurational spaces of the ",
"two forms of the peptide hormone guanylin,",
"J. Biomol. Struct. Dyn. 13 : 741-751 (1996)[BR]",
"B.L. de Groot, A.Amadei, R.M. Scheek, N.A.J. van Nuland and H.J.C. Berendsen; ",
"An extended sampling of the configurational space of HPr from E. coli",
"Proteins: Struct. Funct. Gen. 26: 314-322 (1996)",
"[PAR]You will be prompted for one or more index groups that correspond to the eigenvectors,",
"reference structure, target positions, etc.[PAR]",
"[TT]-mon[tt]: monitor projections of the coordinates onto selected eigenvectors.[PAR]",
"[TT]-linfix[tt]: perform fixed-step linear expansion along selected eigenvectors.[PAR]",
"[TT]-linacc[tt]: perform acceptance linear expansion along selected eigenvectors.",
"(steps in the desired directions will be accepted, others will be rejected).[PAR]",
"[TT]-radfix[tt]: perform fixed-step radius expansion along selected eigenvectors.[PAR]",
"[TT]-radacc[tt]: perform acceptance radius expansion along selected eigenvectors.",
"(steps in the desired direction will be accepted, others will be rejected).",
"[BB]Note:[bb] by default the starting MD structure will be taken as origin of the first",
"expansion cycle for radius expansion. If [TT]-ori[tt] is specified, you will be able",
"to read in a structure file that defines an external origin.[PAR]",
"[TT]-radcon[tt]: perform acceptance radius contraction along selected eigenvectors",
"towards a target structure specified with [TT]-tar[tt].[PAR]",
"NOTE: each eigenvector can be selected only once. [PAR]",
"[TT]-outfrq[tt]: frequency (in steps) of writing out projections etc. to [TT].xvg[tt] file[PAR]",
"[TT]-slope[tt]: minimal slope in acceptance radius expansion. A new expansion",
"cycle will be started if the spontaneous increase of the radius (in nm/step)",
"is less than the value specified.[PAR]",
"[TT]-maxedsteps[tt]: maximum number of steps per cycle in radius expansion",
"before a new cycle is started.[PAR]",
"Note on the parallel implementation: since ED sampling is a 'global' thing",
"(collective coordinates etc.), at least on the 'protein' side, ED sampling",
"is not very parallel-friendly from an implementation point of view. Because",
"parallel ED requires some extra communication, expect the performance to be",
"lower as in a free MD simulation, especially on a large number of nodes and/or",
"when the ED group contains a lot of atoms. [PAR]",
"Please also note that if your ED group contains more than a single protein,",
"then the [TT].tpr[tt] file must contain the correct PBC representation of the ED group.",
"Take a look on the initial RMSD from the reference structure, which is printed",
"out at the start of the simulation; if this is much higher than expected, one",
"of the ED molecules might be shifted by a box vector. [PAR]",
"All ED-related output of [TT]mdrun[tt] (specify with [TT]-eo[tt]) is written to a [TT].xvg[tt] file",
"as a function of time in intervals of OUTFRQ steps.[PAR]",
"[BB]Note[bb] that you can impose multiple ED constraints and flooding potentials in",
"a single simulation (on different molecules) if several [TT].edi[tt] files were concatenated",
"first. The constraints are applied in the order they appear in the [TT].edi[tt] file. ",
"Depending on what was specified in the [TT].edi[tt] input file, the output file contains for each ED dataset[PAR]",
"[TT]*[tt] the RMSD of the fitted molecule to the reference structure (for atoms involved in fitting prior to calculating the ED constraints)[BR]",
"[TT]*[tt] projections of the positions onto selected eigenvectors[BR]",
"[PAR][PAR]",
"FLOODING:[PAR]",
"with [TT]-flood[tt], you can specify which eigenvectors are used to compute a flooding potential,",
"which will lead to extra forces expelling the structure out of the region described",
"by the covariance matrix. If you switch -restrain the potential is inverted and the structure",
"is kept in that region.",
"[PAR]",
"The origin is normally the average structure stored in the [TT]eigvec.trr[tt] file.",
"It can be changed with [TT]-ori[tt] to an arbitrary position in configuration space.",
"With [TT]-tau[tt], [TT]-deltaF0[tt], and [TT]-Eflnull[tt] you control the flooding behaviour.",
"Efl is the flooding strength, it is updated according to the rule of adaptive flooding.",
"Tau is the time constant of adaptive flooding, high [GRK]tau[grk] means slow adaption (i.e. growth). ",
"DeltaF0 is the flooding strength you want to reach after tau ps of simulation.",
"To use constant Efl set [TT]-tau[tt] to zero.",
"[PAR]",
"[TT]-alpha[tt] is a fudge parameter to control the width of the flooding potential. A value of 2 has been found",
"to give good results for most standard cases in flooding of proteins.",
"[GRK]alpha[grk] basically accounts for incomplete sampling, if you sampled further the width of the ensemble would",
"increase, this is mimicked by [GRK]alpha[grk] > 1.",
"For restraining, [GRK]alpha[grk] < 1 can give you smaller width in the restraining potential.",
"[PAR]",
"RESTART and FLOODING:",
"If you want to restart a crashed flooding simulation please find the values deltaF and Efl in",
"the output file and manually put them into the [TT].edi[tt] file under DELTA_F0 and EFL_NULL."
};
/* Save all the params in this struct and then save it in an edi file.
* ignoring fields nmass,massnrs,mass,tmass,nfit,fitnrs,edo
*/
static t_edipar edi_params;
enum {
evStepNr = evRADFIX + 1
};
static const char* evSelections[evNr] = {NULL, NULL, NULL, NULL, NULL, NULL};
static const char* evOptions[evNr] = {"-linfix", "-linacc", "-flood", "-radfix", "-radacc", "-radcon", "-mon"};
static const char* evParams[evStepNr] = {NULL, NULL};
static const char* evStepOptions[evStepNr] = {"-linstep", "-accdir", "-not_used", "-radstep"};
static const char* ConstForceStr;
static real * evStepList[evStepNr];
static real radfix = 0.0;
static real deltaF0 = 150;
static real deltaF = 0;
static real tau = .1;
static real constEfl = 0.0;
static real alpha = 1;
static int eqSteps = 0;
static int * listen[evNr];
static real T = 300.0;
const real kB = 2.5 / 300.0; /* k_boltzmann in MD units */
static gmx_bool bRestrain = FALSE;
static gmx_bool bHesse = FALSE;
static gmx_bool bHarmonic = FALSE;
t_pargs pa[] = {
{ "-mon", FALSE, etSTR, {&evSelections[evMON]},
"Indices of eigenvectors for projections of x (e.g. 1,2-5,9) or 1-100:10 means 1 11 21 31 ... 91" },
{ "-linfix", FALSE, etSTR, {&evSelections[0]},
"Indices of eigenvectors for fixed increment linear sampling" },
{ "-linacc", FALSE, etSTR, {&evSelections[1]},
"Indices of eigenvectors for acceptance linear sampling" },
{ "-radfix", FALSE, etSTR, {&evSelections[3]},
"Indices of eigenvectors for fixed increment radius expansion" },
{ "-radacc", FALSE, etSTR, {&evSelections[4]},
"Indices of eigenvectors for acceptance radius expansion" },
{ "-radcon", FALSE, etSTR, {&evSelections[5]},
"Indices of eigenvectors for acceptance radius contraction" },
{ "-flood", FALSE, etSTR, {&evSelections[2]},
"Indices of eigenvectors for flooding"},
{ "-outfrq", FALSE, etINT, {&edi_params.outfrq},
"Freqency (in steps) of writing output in [TT].xvg[tt] file" },
{ "-slope", FALSE, etREAL, { &edi_params.slope},
"Minimal slope in acceptance radius expansion"},
{ "-linstep", FALSE, etSTR, {&evParams[0]},
"Stepsizes (nm/step) for fixed increment linear sampling (put in quotes! \"1.0 2.3 5.1 -3.1\")"},
{ "-accdir", FALSE, etSTR, {&evParams[1]},
"Directions for acceptance linear sampling - only sign counts! (put in quotes! \"-1 +1 -1.1\")"},
{ "-radstep", FALSE, etREAL, {&radfix},
"Stepsize (nm/step) for fixed increment radius expansion"},
{ "-maxedsteps", FALSE, etINT, {&edi_params.maxedsteps},
"Maximum number of steps per cycle" },
{ "-eqsteps", FALSE, etINT, {&eqSteps},
"Number of steps to run without any perturbations "},
{ "-deltaF0", FALSE, etREAL, {&deltaF0},
"Target destabilization energy for flooding"},
{ "-deltaF", FALSE, etREAL, {&deltaF},
"Start deltaF with this parameter - default 0, nonzero values only needed for restart"},
{ "-tau", FALSE, etREAL, {&tau},
"Coupling constant for adaption of flooding strength according to deltaF0, 0 = infinity i.e. constant flooding strength"},
{ "-Eflnull", FALSE, etREAL, {&constEfl},
"The starting value of the flooding strength. The flooding strength is updated "
"according to the adaptive flooding scheme. For a constant flooding strength use [TT]-tau[tt] 0. "},
{ "-T", FALSE, etREAL, {&T},
"T is temperature, the value is needed if you want to do flooding "},
{ "-alpha", FALSE, etREAL, {&alpha},
"Scale width of gaussian flooding potential with alpha^2 "},
{ "-restrain", FALSE, etBOOL, {&bRestrain},
"Use the flooding potential with inverted sign -> effects as quasiharmonic restraining potential"},
{ "-hessian", FALSE, etBOOL, {&bHesse},
"The eigenvectors and eigenvalues are from a Hessian matrix"},
{ "-harmonic", FALSE, etBOOL, {&bHarmonic},
"The eigenvalues are interpreted as spring constant"},
{ "-constF", FALSE, etSTR, {&ConstForceStr},
"Constant force flooding: manually set the forces for the eigenvectors selected with -flood "
"(put in quotes! \"1.0 2.3 5.1 -3.1\"). No other flooding parameters are needed when specifying the forces directly."}
};
#define NPA asize(pa)
rvec *xref1;
int nvec1, *eignr1 = NULL;
rvec *xav1, **eigvec1 = NULL;
t_atoms *atoms = NULL;
int nav; /* Number of atoms in the average structure */
char *grpname;
const char *indexfile;
int i;
atom_id *index, *ifit;
int nfit; /* Number of atoms in the reference/fit structure */
int ev_class; /* parameter _class i.e. evMON, evRADFIX etc. */
int nvecs;
real *eigval1 = NULL; /* in V3.3 this is parameter of read_eigenvectors */
const char *EdiFile;
const char *TargetFile;
const char *OriginFile;
const char *EigvecFile;
output_env_t oenv;
/*to read topology file*/
t_topology top;
int ePBC;
char title[STRLEN];
matrix topbox;
rvec *xtop;
gmx_bool bTop, bFit1;
t_filenm fnm[] = {
{ efTRN, "-f", "eigenvec", ffREAD },
{ efXVG, "-eig", "eigenval", ffOPTRD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efSTX, "-tar", "target", ffOPTRD},
{ efSTX, "-ori", "origin", ffOPTRD},
{ efEDI, "-o", "sam", ffWRITE }
};
#define NFILE asize(fnm)
edi_params.outfrq = 100; edi_params.slope = 0.0; edi_params.maxedsteps = 0;
parse_common_args(&argc, argv, 0,
NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv);
indexfile = ftp2fn_null(efNDX, NFILE, fnm);
EdiFile = ftp2fn(efEDI, NFILE, fnm);
TargetFile = opt2fn_null("-tar", NFILE, fnm);
OriginFile = opt2fn_null("-ori", NFILE, fnm);
for (ev_class = 0; ev_class < evNr; ++ev_class)
{
if (opt2parg_bSet(evOptions[ev_class], NPA, pa))
{
/*get list of eigenvectors*/
nvecs = sscan_list(&(listen[ev_class]), opt2parg_str(evOptions[ev_class], NPA, pa), evOptions[ev_class]);
if (ev_class < evStepNr-2)
{
/*if apropriate get list of stepsizes for these eigenvectors*/
if (opt2parg_bSet(evStepOptions[ev_class], NPA, pa))
{
evStepList[ev_class] =
scan_vecparams(opt2parg_str(evStepOptions[ev_class], NPA, pa), evStepOptions[ev_class], nvecs);
}
else /*if list is not given fill with zeros */
{
snew(evStepList[ev_class], nvecs);
for (i = 0; i < nvecs; i++)
{
evStepList[ev_class][i] = 0.0;
}
}
}
else if (ev_class == evRADFIX && opt2parg_bSet(evStepOptions[ev_class], NPA, pa))
{
snew(evStepList[ev_class], nvecs);
for (i = 0; i < nvecs; i++)
{
evStepList[ev_class][i] = radfix;
}
}
else if (ev_class == evFLOOD)
{
snew(evStepList[ev_class], nvecs);
/* Are we doing constant force flooding? In that case, we read in
* the fproj values from the command line */
if (opt2parg_bSet("-constF", NPA, pa))
{
evStepList[ev_class] = scan_vecparams(opt2parg_str("-constF", NPA, pa), "-constF", nvecs);
}
}
else
{
}; /*to avoid ambiguity */
}
else /* if there are no eigenvectors for this option set list to zero */
{
listen[ev_class] = NULL;
snew(listen[ev_class], 1);
listen[ev_class][0] = 0;
}
}
/* print the interpreted list of eigenvectors - to give some feedback*/
for (ev_class = 0; ev_class < evNr; ++ev_class)
{
printf("Eigenvector list %7s consists of the indices: ", evOptions[ev_class]);
i = 0;
while (listen[ev_class][i])
{
printf("%d ", listen[ev_class][i++]);
}
printf("\n");
}
EigvecFile = NULL;
EigvecFile = opt2fn("-f", NFILE, fnm);
/*read eigenvectors from eigvec.trr*/
read_eigenvectors(EigvecFile, &nav, &bFit1,
&xref1, &edi_params.fitmas, &xav1, &edi_params.pcamas, &nvec1, &eignr1, &eigvec1, &eigval1);
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm),
title, &top, &ePBC, &xtop, NULL, topbox, 0);
atoms = &top.atoms;
printf("\nSelect an index group of %d elements that corresponds to the eigenvectors\n", nav);
get_index(atoms, indexfile, 1, &i, &index, &grpname); /*if indexfile != NULL parameter 'atoms' is ignored */
if (i != nav)
{
gmx_fatal(FARGS, "you selected a group with %d elements instead of %d",
i, nav);
}
printf("\n");
if (xref1 == NULL)
{
if (bFit1)
{
/* if g_covar used different coordinate groups to fit and to do the PCA */
printf("\nNote: the structure in %s should be the same\n"
" as the one used for the fit in g_covar\n", ftp2fn(efTPS, NFILE, fnm));
printf("\nSelect the index group that was used for the least squares fit in g_covar\n");
}
else
{
printf("\nNote: Apparently no fitting was done in g_covar.\n"
" However, you need to select a reference group for fitting in mdrun\n");
}
get_index(atoms, indexfile, 1, &nfit, &ifit, &grpname);
snew(xref1, nfit);
for (i = 0; i < nfit; i++)
{
copy_rvec(xtop[ifit[i]], xref1[i]);
}
}
else
{
nfit = nav;
ifit = index;
}
if (opt2parg_bSet("-constF", NPA, pa))
{
/* Constant force flooding is special: Most of the normal flooding
* options are not needed. */
edi_params.flood.bConstForce = TRUE;
}
else
{
/* For normal flooding read eigenvalues and store them in evSteplist[evFLOOD] */
if (listen[evFLOOD][0] != 0)
{
read_eigenvalues(listen[evFLOOD], opt2fn("-eig", NFILE, fnm), evStepList[evFLOOD], bHesse, kB*T);
}
edi_params.flood.tau = tau;
edi_params.flood.deltaF0 = deltaF0;
edi_params.flood.deltaF = deltaF;
edi_params.presteps = eqSteps;
edi_params.flood.kT = kB*T;
edi_params.flood.bHarmonic = bHarmonic;
if (bRestrain)
{
/* Trick: invert sign of Efl and alpha2 then this will give the same sign in the exponential and inverted sign outside */
edi_params.flood.constEfl = -constEfl;
edi_params.flood.alpha2 = -sqr(alpha);
}
else
{
edi_params.flood.constEfl = constEfl;
edi_params.flood.alpha2 = sqr(alpha);
}
}
edi_params.ned = nav;
/*number of system atoms */
edi_params.nini = atoms->nr;
/*store reference and average structure in edi_params*/
make_t_edx(&edi_params.sref, nfit, xref1, ifit );
make_t_edx(&edi_params.sav, nav, xav1, index);
/* Store target positions in edi_params */
if (opt2bSet("-tar", NFILE, fnm))
{
if (0 != listen[evFLOOD][0])
{
fprintf(stderr, "\nNote: Providing a TARGET structure has no effect when using flooding.\n"
" You may want to use -ori to define the flooding potential center.\n\n");
}
get_structure(atoms, indexfile, TargetFile, &edi_params.star, nfit, ifit, nav, index);
}
else
{
make_t_edx(&edi_params.star, 0, NULL, index);
}
/* Store origin positions */
if (opt2bSet("-ori", NFILE, fnm))
{
get_structure(atoms, indexfile, OriginFile, &edi_params.sori, nfit, ifit, nav, index);
}
else
{
make_t_edx(&edi_params.sori, 0, NULL, index);
}
/* Write edi-file */
write_the_whole_thing(ffopen(EdiFile, "w"), &edi_params, eigvec1, nvec1, listen, evStepList);
thanx(stderr);
return 0;
}
int gmx_helixorient(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] calculates the coordinates and direction of the average",
"axis inside an alpha helix, and the direction/vectors of both the",
"C[GRK]alpha[grk] and (optionally) a sidechain atom relative to the axis.[PAR]",
"As input, you need to specify an index group with C[GRK]alpha[grk] atoms",
"corresponding to an [GRK]alpha[grk]-helix of continuous residues. Sidechain",
"directions require a second index group of the same size, containing",
"the heavy atom in each residue that should represent the sidechain.[PAR]",
"[BB]Note[bb] that this program does not do any fitting of structures.[PAR]",
"We need four C[GRK]alpha[grk] coordinates to define the local direction of the helix",
"axis.[PAR]",
"The tilt/rotation is calculated from Euler rotations, where we define",
"the helix axis as the local [IT]x[it]-axis, the residues/C[GRK]alpha[grk] vector as [IT]y[it], and the",
"[IT]z[it]-axis from their cross product. We use the Euler Y-Z-X rotation, meaning",
"we first tilt the helix axis (1) around and (2) orthogonal to the residues",
"vector, and finally apply the (3) rotation around it. For debugging or other",
"purposes, we also write out the actual Euler rotation angles as [TT]theta[1-3].xvg[tt]"
};
t_topology *top = NULL;
real t;
rvec *x = NULL;
matrix box;
t_trxstatus *status;
int natoms;
real theta1, theta2, theta3;
int i, j, teller = 0;
int iCA, iSC;
atom_id *ind_CA;
atom_id *ind_SC;
char *gn_CA;
char *gn_SC;
rvec v1, v2;
rvec *x_CA, *x_SC;
rvec *r12;
rvec *r23;
rvec *r34;
rvec *diff13;
rvec *diff24;
rvec *helixaxis;
rvec *residuehelixaxis;
rvec *residueorigin;
rvec *residuevector;
rvec *sidechainvector;
rvec *residuehelixaxis_t0;
rvec *residuevector_t0;
rvec *axis3_t0;
rvec *residuehelixaxis_tlast;
rvec *residuevector_tlast;
rvec *axis3_tlast;
rvec refaxes[3], newaxes[3];
rvec unitaxes[3];
rvec rot_refaxes[3], rot_newaxes[3];
real tilt, rotation;
rvec *axis3;
real *twist, *residuetwist;
real *radius, *residueradius;
real *rise, *residuerise;
real *residuebending;
real tmp;
real weight[3];
t_pbc pbc;
matrix A;
FILE *fpaxis, *fpcenter, *fptilt, *fprotation;
FILE *fpradius, *fprise, *fptwist;
FILE *fptheta1, *fptheta2, *fptheta3;
FILE *fpbending;
int ePBC;
gmx_output_env_t *oenv;
gmx_rmpbc_t gpbc = NULL;
static gmx_bool bSC = FALSE;
static gmx_bool bIncremental = FALSE;
static t_pargs pa[] = {
{ "-sidechain", FALSE, etBOOL, {&bSC},
"Calculate sidechain directions relative to helix axis too." },
{ "-incremental", FALSE, etBOOL, {&bIncremental},
"Calculate incremental rather than total rotation/tilt." },
};
#define NPA asize(pa)
t_filenm fnm[] = {
{ efTPR, NULL, NULL, ffREAD },
{ efTRX, "-f", NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efDAT, "-oaxis", "helixaxis", ffWRITE },
{ efDAT, "-ocenter", "center", ffWRITE },
{ efXVG, "-orise", "rise", ffWRITE },
{ efXVG, "-oradius", "radius", ffWRITE },
{ efXVG, "-otwist", "twist", ffWRITE },
{ efXVG, "-obending", "bending", ffWRITE },
{ efXVG, "-otilt", "tilt", ffWRITE },
{ efXVG, "-orot", "rotation", ffWRITE }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME,
NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
top = read_top(ftp2fn(efTPR, NFILE, fnm), &ePBC);
for (i = 0; i < 3; i++)
{
weight[i] = 1.0;
}
/* read index files */
printf("Select a group of Calpha atoms corresponding to a single continuous helix:\n");
get_index(&(top->atoms), ftp2fn_null(efNDX, NFILE, fnm), 1, &iCA, &ind_CA, &gn_CA);
snew(x_CA, iCA);
snew(x_SC, iCA); /* sic! */
snew(r12, iCA-3);
snew(r23, iCA-3);
snew(r34, iCA-3);
snew(diff13, iCA-3);
snew(diff24, iCA-3);
snew(helixaxis, iCA-3);
snew(twist, iCA);
snew(residuetwist, iCA);
snew(radius, iCA);
snew(residueradius, iCA);
snew(rise, iCA);
snew(residuerise, iCA);
snew(residueorigin, iCA);
snew(residuehelixaxis, iCA);
snew(residuevector, iCA);
snew(sidechainvector, iCA);
snew(residuebending, iCA);
snew(residuehelixaxis_t0, iCA);
snew(residuevector_t0, iCA);
snew(axis3_t0, iCA);
snew(residuehelixaxis_tlast, iCA);
snew(residuevector_tlast, iCA);
snew(axis3_tlast, iCA);
snew(axis3, iCA);
if (bSC)
{
printf("Select a group of atoms defining the sidechain direction (1/residue):\n");
get_index(&(top->atoms), ftp2fn_null(efNDX, NFILE, fnm), 1, &iSC, &ind_SC, &gn_SC);
if (iSC != iCA)
{
gmx_fatal(FARGS, "Number of sidechain atoms (%d) != number of CA atoms (%d)", iSC, iCA);
}
}
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
fpaxis = gmx_ffopen(opt2fn("-oaxis", NFILE, fnm), "w");
fpcenter = gmx_ffopen(opt2fn("-ocenter", NFILE, fnm), "w");
fprise = gmx_ffopen(opt2fn("-orise", NFILE, fnm), "w");
fpradius = gmx_ffopen(opt2fn("-oradius", NFILE, fnm), "w");
fptwist = gmx_ffopen(opt2fn("-otwist", NFILE, fnm), "w");
fpbending = gmx_ffopen(opt2fn("-obending", NFILE, fnm), "w");
fptheta1 = gmx_ffopen("theta1.xvg", "w");
fptheta2 = gmx_ffopen("theta2.xvg", "w");
fptheta3 = gmx_ffopen("theta3.xvg", "w");
if (bIncremental)
{
fptilt = xvgropen(opt2fn("-otilt", NFILE, fnm),
"Incremental local helix tilt", "Time(ps)", "Tilt (degrees)",
oenv);
fprotation = xvgropen(opt2fn("-orot", NFILE, fnm),
"Incremental local helix rotation", "Time(ps)",
"Rotation (degrees)", oenv);
}
else
{
fptilt = xvgropen(opt2fn("-otilt", NFILE, fnm),
"Cumulative local helix tilt", "Time(ps)", "Tilt (degrees)", oenv);
fprotation = xvgropen(opt2fn("-orot", NFILE, fnm),
"Cumulative local helix rotation", "Time(ps)",
"Rotation (degrees)", oenv);
}
clear_rvecs(3, unitaxes);
unitaxes[0][0] = 1;
unitaxes[1][1] = 1;
unitaxes[2][2] = 1;
gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
do
{
/* initialisation for correct distance calculations */
set_pbc(&pbc, ePBC, box);
/* make molecules whole again */
gmx_rmpbc(gpbc, natoms, box, x);
/* copy coords to our smaller arrays */
for (i = 0; i < iCA; i++)
{
copy_rvec(x[ind_CA[i]], x_CA[i]);
if (bSC)
{
copy_rvec(x[ind_SC[i]], x_SC[i]);
}
}
for (i = 0; i < iCA-3; i++)
{
rvec_sub(x_CA[i+1], x_CA[i], r12[i]);
rvec_sub(x_CA[i+2], x_CA[i+1], r23[i]);
rvec_sub(x_CA[i+3], x_CA[i+2], r34[i]);
rvec_sub(r12[i], r23[i], diff13[i]);
rvec_sub(r23[i], r34[i], diff24[i]);
/* calculate helix axis */
cprod(diff13[i], diff24[i], helixaxis[i]);
svmul(1.0/norm(helixaxis[i]), helixaxis[i], helixaxis[i]);
tmp = cos_angle(diff13[i], diff24[i]);
twist[i] = 180.0/M_PI * std::acos( tmp );
radius[i] = std::sqrt( norm(diff13[i])*norm(diff24[i]) ) / (2.0* (1.0-tmp) );
rise[i] = std::abs(iprod(r23[i], helixaxis[i]));
svmul(radius[i]/norm(diff13[i]), diff13[i], v1);
svmul(radius[i]/norm(diff24[i]), diff24[i], v2);
rvec_sub(x_CA[i+1], v1, residueorigin[i+1]);
rvec_sub(x_CA[i+2], v2, residueorigin[i+2]);
}
residueradius[0] = residuetwist[0] = residuerise[0] = 0;
residueradius[1] = radius[0];
residuetwist[1] = twist[0];
residuerise[1] = rise[0];
residuebending[0] = residuebending[1] = 0;
for (i = 2; i < iCA-2; i++)
{
residueradius[i] = 0.5*(radius[i-2]+radius[i-1]);
residuetwist[i] = 0.5*(twist[i-2]+twist[i-1]);
residuerise[i] = 0.5*(rise[i-2]+rise[i-1]);
residuebending[i] = 180.0/M_PI*std::acos( cos_angle(helixaxis[i-2], helixaxis[i-1]) );
}
residueradius[iCA-2] = radius[iCA-4];
residuetwist[iCA-2] = twist[iCA-4];
residuerise[iCA-2] = rise[iCA-4];
residueradius[iCA-1] = residuetwist[iCA-1] = residuerise[iCA-1] = 0;
residuebending[iCA-2] = residuebending[iCA-1] = 0;
clear_rvec(residueorigin[0]);
clear_rvec(residueorigin[iCA-1]);
/* average helix axes to define them on the residues.
* Just extrapolate second first/list atom.
*/
copy_rvec(helixaxis[0], residuehelixaxis[0]);
copy_rvec(helixaxis[0], residuehelixaxis[1]);
for (i = 2; i < iCA-2; i++)
{
rvec_add(helixaxis[i-2], helixaxis[i-1], residuehelixaxis[i]);
svmul(0.5, residuehelixaxis[i], residuehelixaxis[i]);
}
copy_rvec(helixaxis[iCA-4], residuehelixaxis[iCA-2]);
copy_rvec(helixaxis[iCA-4], residuehelixaxis[iCA-1]);
/* Normalize the axis */
for (i = 0; i < iCA; i++)
{
svmul(1.0/norm(residuehelixaxis[i]), residuehelixaxis[i], residuehelixaxis[i]);
}
/* calculate vector from origin to residue CA */
fprintf(fpaxis, "%15.12g ", t);
fprintf(fpcenter, "%15.12g ", t);
fprintf(fprise, "%15.12g ", t);
fprintf(fpradius, "%15.12g ", t);
fprintf(fptwist, "%15.12g ", t);
fprintf(fpbending, "%15.12g ", t);
for (i = 0; i < iCA; i++)
{
if (i == 0 || i == iCA-1)
{
fprintf(fpaxis, "%15.12g %15.12g %15.12g ", 0.0, 0.0, 0.0);
fprintf(fpcenter, "%15.12g %15.12g %15.12g ", 0.0, 0.0, 0.0);
fprintf(fprise, "%15.12g ", 0.0);
fprintf(fpradius, "%15.12g ", 0.0);
fprintf(fptwist, "%15.12g ", 0.0);
fprintf(fpbending, "%15.12g ", 0.0);
}
else
{
rvec_sub( bSC ? x_SC[i] : x_CA[i], residueorigin[i], residuevector[i]);
svmul(1.0/norm(residuevector[i]), residuevector[i], residuevector[i]);
cprod(residuehelixaxis[i], residuevector[i], axis3[i]);
fprintf(fpaxis, "%15.12g %15.12g %15.12g ", residuehelixaxis[i][0], residuehelixaxis[i][1], residuehelixaxis[i][2]);
fprintf(fpcenter, "%15.12g %15.12g %15.12g ", residueorigin[i][0], residueorigin[i][1], residueorigin[i][2]);
fprintf(fprise, "%15.12g ", residuerise[i]);
fprintf(fpradius, "%15.12g ", residueradius[i]);
fprintf(fptwist, "%15.12g ", residuetwist[i]);
fprintf(fpbending, "%15.12g ", residuebending[i]);
}
}
fprintf(fprise, "\n");
fprintf(fpradius, "\n");
fprintf(fpaxis, "\n");
fprintf(fpcenter, "\n");
fprintf(fptwist, "\n");
fprintf(fpbending, "\n");
if (teller == 0)
{
for (i = 0; i < iCA; i++)
{
copy_rvec(residuehelixaxis[i], residuehelixaxis_t0[i]);
copy_rvec(residuevector[i], residuevector_t0[i]);
copy_rvec(axis3[i], axis3_t0[i]);
}
}
else
{
fprintf(fptilt, "%15.12g ", t);
fprintf(fprotation, "%15.12g ", t);
fprintf(fptheta1, "%15.12g ", t);
fprintf(fptheta2, "%15.12g ", t);
fprintf(fptheta3, "%15.12g ", t);
for (i = 0; i < iCA; i++)
{
if (i == 0 || i == iCA-1)
{
tilt = rotation = 0;
}
else
{
if (!bIncremental)
{
/* Total rotation & tilt */
copy_rvec(residuehelixaxis_t0[i], refaxes[0]);
copy_rvec(residuevector_t0[i], refaxes[1]);
copy_rvec(axis3_t0[i], refaxes[2]);
}
else
{
/* Rotation/tilt since last step */
copy_rvec(residuehelixaxis_tlast[i], refaxes[0]);
copy_rvec(residuevector_tlast[i], refaxes[1]);
copy_rvec(axis3_tlast[i], refaxes[2]);
}
copy_rvec(residuehelixaxis[i], newaxes[0]);
copy_rvec(residuevector[i], newaxes[1]);
copy_rvec(axis3[i], newaxes[2]);
/* rotate reference frame onto unit axes */
calc_fit_R(3, 3, weight, unitaxes, refaxes, A);
for (j = 0; j < 3; j++)
{
mvmul(A, refaxes[j], rot_refaxes[j]);
mvmul(A, newaxes[j], rot_newaxes[j]);
}
/* Determine local rotation matrix A */
calc_fit_R(3, 3, weight, rot_newaxes, rot_refaxes, A);
/* Calculate euler angles, from rotation order y-z-x, where
* x is helixaxis, y residuevector, and z axis3.
*
* A contains rotation column vectors.
*/
theta1 = 180.0/M_PI*std::atan2(A[0][2], A[0][0]);
theta2 = 180.0/M_PI*std::asin(-A[0][1]);
theta3 = 180.0/M_PI*std::atan2(A[2][1], A[1][1]);
tilt = std::sqrt(theta1*theta1+theta2*theta2);
rotation = theta3;
fprintf(fptheta1, "%15.12g ", theta1);
fprintf(fptheta2, "%15.12g ", theta2);
fprintf(fptheta3, "%15.12g ", theta3);
}
fprintf(fptilt, "%15.12g ", tilt);
fprintf(fprotation, "%15.12g ", rotation);
}
fprintf(fptilt, "\n");
fprintf(fprotation, "\n");
fprintf(fptheta1, "\n");
fprintf(fptheta2, "\n");
fprintf(fptheta3, "\n");
}
for (i = 0; i < iCA; i++)
{
copy_rvec(residuehelixaxis[i], residuehelixaxis_tlast[i]);
copy_rvec(residuevector[i], residuevector_tlast[i]);
copy_rvec(axis3[i], axis3_tlast[i]);
}
teller++;
}
while (read_next_x(oenv, status, &t, x, box));
gmx_rmpbc_done(gpbc);
gmx_ffclose(fpaxis);
gmx_ffclose(fpcenter);
xvgrclose(fptilt);
xvgrclose(fprotation);
gmx_ffclose(fprise);
gmx_ffclose(fpradius);
gmx_ffclose(fptwist);
gmx_ffclose(fpbending);
gmx_ffclose(fptheta1);
gmx_ffclose(fptheta2);
gmx_ffclose(fptheta3);
close_trj(status);
return 0;
}
int gmx_do_dssp(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] ",
"reads a trajectory file and computes the secondary structure for",
"each time frame ",
"calling the dssp program. If you do not have the dssp program,",
"get it from http://swift.cmbi.ru.nl/gv/dssp. [THISMODULE] assumes ",
"that the dssp executable is located in ",
"[TT]/usr/local/bin/dssp[tt]. If this is not the case, then you should",
"set an environment variable [TT]DSSP[tt] pointing to the dssp",
"executable, e.g.: [PAR]",
"[TT]setenv DSSP /opt/dssp/bin/dssp[tt][PAR]",
"Since version 2.0.0, dssp is invoked with a syntax that differs",
"from earlier versions. If you have an older version of dssp,",
"use the [TT]-ver[tt] option to direct do_dssp to use the older syntax.",
"By default, do_dssp uses the syntax introduced with version 2.0.0.",
"Even newer versions (which at the time of writing are not yet released)",
"are assumed to have the same syntax as 2.0.0.[PAR]",
"The structure assignment for each residue and time is written to an",
"[REF].xpm[ref] matrix file. This file can be visualized with for instance",
"[TT]xv[tt] and can be converted to postscript with [TT]xpm2ps[tt].",
"Individual chains are separated by light grey lines in the [REF].xpm[ref] and",
"postscript files.",
"The number of residues with each secondary structure type and the",
"total secondary structure ([TT]-sss[tt]) count as a function of",
"time are also written to file ([TT]-sc[tt]).[PAR]",
"Solvent accessible surface (SAS) per residue can be calculated, both in",
"absolute values (A^2) and in fractions of the maximal accessible",
"surface of a residue. The maximal accessible surface is defined as",
"the accessible surface of a residue in a chain of glycines.",
"[BB]Note[bb] that the program [gmx-sas] can also compute SAS",
"and that is more efficient.[PAR]",
"Finally, this program can dump the secondary structure in a special file",
"[TT]ssdump.dat[tt] for usage in the program [gmx-chi]. Together",
"these two programs can be used to analyze dihedral properties as a",
"function of secondary structure type."
};
static gmx_bool bVerbose;
static const char *ss_string = "HEBT";
static int dsspVersion = 2;
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"HIDDENGenerate miles of useless information" },
{ "-sss", FALSE, etSTR, {&ss_string},
"Secondary structures for structure count"},
{ "-ver", FALSE, etINT, {&dsspVersion},
"DSSP major version. Syntax changed with version 2"}
};
t_trxstatus *status;
FILE *tapein;
FILE *ss, *acc, *fTArea, *tmpf;
const char *fnSCount, *fnArea, *fnTArea, *fnAArea;
const char *leg[] = { "Phobic", "Phylic" };
t_topology top;
int ePBC;
t_atoms *atoms;
t_matrix mat;
int nres, nr0, naccr, nres_plus_separators;
gmx_bool *bPhbres, bDoAccSurf;
real t;
int i, j, natoms, nframe = 0;
matrix box = {{0}};
int gnx;
char *grpnm, *ss_str;
atom_id *index;
rvec *xp, *x;
int *average_area;
real **accr, *accr_ptr = NULL, *av_area, *norm_av_area;
char pdbfile[32], tmpfile[32], title[256];
char dssp[256];
const char *dptr;
output_env_t oenv;
gmx_rmpbc_t gpbc = NULL;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efDAT, "-ssdump", "ssdump", ffOPTWR },
{ efMAP, "-map", "ss", ffLIBRD },
{ efXPM, "-o", "ss", ffWRITE },
{ efXVG, "-sc", "scount", ffWRITE },
{ efXPM, "-a", "area", ffOPTWR },
{ efXVG, "-ta", "totarea", ffOPTWR },
{ efXVG, "-aa", "averarea", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv,
PCA_CAN_TIME | PCA_CAN_VIEW | PCA_TIME_UNIT,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
fnSCount = opt2fn("-sc", NFILE, fnm);
fnArea = opt2fn_null("-a", NFILE, fnm);
fnTArea = opt2fn_null("-ta", NFILE, fnm);
fnAArea = opt2fn_null("-aa", NFILE, fnm);
bDoAccSurf = (fnArea || fnTArea || fnAArea);
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC, &xp, NULL, box, FALSE);
atoms = &(top.atoms);
check_oo(atoms);
bPhbres = bPhobics(atoms);
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);
std::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
{
fclose(tmpf);
}
std::strcpy(tmpfile, "ddXXXXXX");
gmx_tmpnam(tmpfile);
if ((tmpf = fopen(tmpfile, "w")) == NULL)
{
sprintf(tmpfile, "%ctmp%cfilterXXXXXX", DIR_SEPARATOR, DIR_SEPARATOR);
gmx_tmpnam(tmpfile);
if ((tmpf = fopen(tmpfile, "w")) == NULL)
{
gmx_fatal(FARGS, "Can not open tmp file %s", tmpfile);
}
}
else
{
fclose(tmpf);
}
if ((dptr = getenv("DSSP")) == NULL)
{
dptr = "/usr/local/bin/dssp";
}
if (!gmx_fexist(dptr))
{
gmx_fatal(FARGS, "DSSP executable (%s) does not exist (use setenv DSSP)",
dptr);
}
if (dsspVersion >= 2)
{
if (dsspVersion > 2)
{
printf("\nWARNING: You use DSSP version %d, which is not explicitly\nsupported by do_dssp. Assuming version 2 syntax.\n\n", dsspVersion);
}
sprintf(dssp, "%s -i %s -o %s > /dev/null %s",
dptr, pdbfile, tmpfile, bVerbose ? "" : "2> /dev/null");
}
else
{
sprintf(dssp, "%s %s %s %s > /dev/null %s",
dptr, bDoAccSurf ? "" : "-na", pdbfile, tmpfile, bVerbose ? "" : "2> /dev/null");
}
fprintf(stderr, "dssp cmd='%s'\n", dssp);
if (fnTArea)
{
fTArea = xvgropen(fnTArea, "Solvent Accessible Surface Area",
output_env_get_xvgr_tlabel(oenv), "Area (nm\\S2\\N)", oenv);
xvgr_legend(fTArea, 2, leg, oenv);
}
else
{
fTArea = NULL;
}
mat.map = NULL;
mat.nmap = readcmap(opt2fn("-map", NFILE, fnm), &(mat.map));
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
if (natoms > atoms->nr)
{
gmx_fatal(FARGS, "\nTrajectory does not match topology!");
}
if (gnx > natoms)
{
gmx_fatal(FARGS, "\nTrajectory does not match selected group!");
}
snew(average_area, atoms->nres);
snew(av_area, atoms->nres);
snew(norm_av_area, atoms->nres);
accr = NULL;
naccr = 0;
gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
do
{
t = output_env_conv_time(oenv, t);
if (bDoAccSurf && nframe >= naccr)
{
naccr += 10;
srenew(accr, naccr);
for (i = naccr-10; i < naccr; i++)
{
snew(accr[i], 2*atoms->nres-1);
}
}
gmx_rmpbc(gpbc, natoms, box, x);
tapein = gmx_ffopen(pdbfile, "w");
write_pdbfile_indexed(tapein, NULL, atoms, x, ePBC, box, ' ', -1, gnx, index, NULL, TRUE);
gmx_ffclose(tapein);
if (0 != system(dssp))
{
gmx_fatal(FARGS, "Failed to execute command: %s\n",
"Try specifying your dssp version with the -ver option.", dssp);
}
/* strip_dssp returns the number of lines found in the dssp file, i.e.
* the number of residues plus the separator lines */
if (bDoAccSurf)
{
accr_ptr = accr[nframe];
}
nres_plus_separators = strip_dssp(tmpfile, nres, bPhbres, t,
accr_ptr, fTArea, &mat, average_area, oenv);
remove(tmpfile);
remove(pdbfile);
nframe++;
}
while (read_next_x(oenv, status, &t, x, box));
fprintf(stderr, "\n");
close_trj(status);
if (fTArea)
{
xvgrclose(fTArea);
}
gmx_rmpbc_done(gpbc);
prune_ss_legend(&mat);
ss = opt2FILE("-o", NFILE, fnm, "w");
mat.flags = 0;
write_xpm_m(ss, mat);
gmx_ffclose(ss);
if (opt2bSet("-ssdump", NFILE, fnm))
{
ss = opt2FILE("-ssdump", NFILE, fnm, "w");
snew(ss_str, nres+1);
fprintf(ss, "%d\n", nres);
for (j = 0; j < mat.nx; j++)
{
for (i = 0; (i < mat.ny); i++)
{
ss_str[i] = mat.map[mat.matrix[j][i]].code.c1;
}
ss_str[i] = '\0';
fprintf(ss, "%s\n", ss_str);
}
gmx_ffclose(ss);
sfree(ss_str);
}
analyse_ss(fnSCount, &mat, ss_string, oenv);
if (bDoAccSurf)
{
write_sas_mat(fnArea, accr, nframe, nres_plus_separators, &mat);
for (i = 0; i < atoms->nres; i++)
{
av_area[i] = (average_area[i] / static_cast<real>(nframe));
}
norm_acc(atoms, nres, av_area, norm_av_area);
if (fnAArea)
{
acc = xvgropen(fnAArea, "Average Accessible Area",
"Residue", "A\\S2", oenv);
for (i = 0; (i < nres); i++)
{
fprintf(acc, "%5d %10g %10g\n", i+1, av_area[i], norm_av_area[i]);
}
xvgrclose(acc);
}
}
view_all(oenv, NFILE, fnm);
return 0;
}
int gmx_filter(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] performs frequency filtering on a trajectory.",
"The filter shape is cos([GRK]pi[grk] t/A) + 1 from -A to +A, where A is given",
"by the option [TT]-nf[tt] times the time step in the input trajectory.",
"This filter reduces fluctuations with period A by 85%, with period",
"2*A by 50% and with period 3*A by 17% for low-pass filtering.",
"Both a low-pass and high-pass filtered trajectory can be written.[PAR]",
"Option [TT]-ol[tt] writes a low-pass filtered trajectory.",
"A frame is written every [TT]-nf[tt] input frames.",
"This ratio of filter length and output interval ensures a good",
"suppression of aliasing of high-frequency motion, which is useful for",
"making smooth movies. Also averages of properties which are linear",
"in the coordinates are preserved, since all input frames are weighted",
"equally in the output.",
"When all frames are needed, use the [TT]-all[tt] option.[PAR]",
"Option [TT]-oh[tt] writes a high-pass filtered trajectory.",
"The high-pass filtered coordinates are added to the coordinates",
"from the structure file. When using high-pass filtering use [TT]-fit[tt]",
"or make sure you use a trajectory that has been fitted on",
"the coordinates in the structure file."
};
static int nf = 10;
static gmx_bool bNoJump = TRUE, bFit = FALSE, bLowAll = FALSE;
t_pargs pa[] = {
{ "-nf", FALSE, etINT, {&nf},
"Sets the filter length as well as the output interval for low-pass filtering" },
{ "-all", FALSE, etBOOL, {&bLowAll},
"Write all low-pass filtered frames" },
{ "-nojump", FALSE, etBOOL, {&bNoJump},
"Remove jumps of atoms across the box" },
{ "-fit", FALSE, etBOOL, {&bFit},
"Fit all frames to a reference structure" }
};
const char *topfile, *lowfile, *highfile;
gmx_bool bTop = FALSE;
t_topology top;
int ePBC = -1;
rvec *xtop;
matrix topbox, *box, boxf;
char title[256], *grpname;
int isize;
atom_id *index;
real *w_rls = NULL;
t_trxstatus *in;
t_trxstatus *outl, *outh;
int nffr, i, fr, nat, j, d, m;
atom_id *ind;
real flen, *filt, sum, *t;
rvec xcmtop, xcm, **x, *ptr, *xf, *xn, *xp, hbox;
output_env_t oenv;
gmx_rmpbc_t gpbc = NULL;
#define NLEG asize(leg)
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTRO, "-ol", "lowpass", ffOPTWR },
{ efTRO, "-oh", "highpass", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_CAN_VIEW | PCA_BE_NICE,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
highfile = opt2fn_null("-oh", NFILE, fnm);
if (highfile)
{
topfile = ftp2fn(efTPS, NFILE, fnm);
lowfile = opt2fn_null("-ol", NFILE, fnm);
}
else
{
topfile = ftp2fn_null(efTPS, NFILE, fnm);
lowfile = opt2fn("-ol", NFILE, fnm);
}
if (topfile)
{
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC,
&xtop, NULL, topbox, TRUE);
if (bTop)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr);
gmx_rmpbc(gpbc, top.atoms.nr, topbox, xtop);
}
}
clear_rvec(xcmtop);
if (bFit)
{
fprintf(stderr, "Select group for least squares fit\n");
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &isize, &index, &grpname);
/* Set the weight */
snew(w_rls, top.atoms.nr);
for (i = 0; i < isize; i++)
{
w_rls[index[i]] = top.atoms.atom[index[i]].m;
}
calc_xcm(xtop, isize, index, top.atoms.atom, xcmtop, FALSE);
for (j = 0; j < top.atoms.nr; j++)
{
rvec_dec(xtop[j], xcmtop);
}
}
/* The actual filter length flen can actually be any real number */
flen = 2*nf;
/* nffr is the number of frames that we filter over */
nffr = 2*nf - 1;
snew(filt, nffr);
sum = 0;
for (i = 0; i < nffr; i++)
{
filt[i] = cos(2*M_PI*(i - nf + 1)/(real)flen) + 1;
sum += filt[i];
}
fprintf(stdout, "filter weights:");
for (i = 0; i < nffr; i++)
{
filt[i] /= sum;
fprintf(stdout, " %5.3f", filt[i]);
}
fprintf(stdout, "\n");
snew(t, nffr);
snew(x, nffr);
snew(box, nffr);
nat = read_first_x(oenv, &in, opt2fn("-f", NFILE, fnm),
&(t[nffr - 1]), &(x[nffr - 1]), box[nffr - 1]);
snew(ind, nat);
for (i = 0; i < nat; i++)
{
ind[i] = i;
}
/* x[nffr - 1] was already allocated by read_first_x */
for (i = 0; i < nffr-1; i++)
{
snew(x[i], nat);
}
snew(xf, nat);
if (lowfile)
{
outl = open_trx(lowfile, "w");
}
else
{
outl = 0;
}
if (highfile)
{
outh = open_trx(highfile, "w");
}
else
{
outh = 0;
}
fr = 0;
do
{
xn = x[nffr - 1];
if (bNoJump && fr > 0)
{
xp = x[nffr - 2];
for (j = 0; j < nat; j++)
{
for (d = 0; d < DIM; d++)
{
hbox[d] = 0.5*box[nffr - 1][d][d];
}
}
for (i = 0; i < nat; i++)
{
for (m = DIM-1; m >= 0; m--)
{
if (hbox[m] > 0)
{
while (xn[i][m] - xp[i][m] <= -hbox[m])
{
for (d = 0; d <= m; d++)
{
xn[i][d] += box[nffr - 1][m][d];
}
}
while (xn[i][m] - xp[i][m] > hbox[m])
{
for (d = 0; d <= m; d++)
{
xn[i][d] -= box[nffr - 1][m][d];
}
}
}
}
}
}
if (bTop)
{
gmx_rmpbc(gpbc, nat, box[nffr - 1], xn);
}
if (bFit)
{
calc_xcm(xn, isize, index, top.atoms.atom, xcm, FALSE);
for (j = 0; j < nat; j++)
{
rvec_dec(xn[j], xcm);
}
do_fit(nat, w_rls, xtop, xn);
for (j = 0; j < nat; j++)
{
rvec_inc(xn[j], xcmtop);
}
}
if (fr >= nffr && (outh || bLowAll || fr % nf == nf - 1))
{
/* Lowpass filtering */
for (j = 0; j < nat; j++)
{
clear_rvec(xf[j]);
}
clear_mat(boxf);
for (i = 0; i < nffr; i++)
{
for (j = 0; j < nat; j++)
{
for (d = 0; d < DIM; d++)
{
xf[j][d] += filt[i]*x[i][j][d];
}
}
for (j = 0; j < DIM; j++)
{
for (d = 0; d < DIM; d++)
{
boxf[j][d] += filt[i]*box[i][j][d];
}
}
}
if (outl && (bLowAll || fr % nf == nf - 1))
{
write_trx(outl, nat, ind, topfile ? &(top.atoms) : NULL,
0, t[nf - 1], bFit ? topbox : boxf, xf, NULL, NULL);
}
if (outh)
{
/* Highpass filtering */
for (j = 0; j < nat; j++)
{
for (d = 0; d < DIM; d++)
{
xf[j][d] = xtop[j][d] + x[nf - 1][j][d] - xf[j][d];
}
}
if (bFit)
{
for (j = 0; j < nat; j++)
{
rvec_inc(xf[j], xcmtop);
}
}
for (j = 0; j < DIM; j++)
{
for (d = 0; d < DIM; d++)
{
boxf[j][d] = topbox[j][d] + box[nf - 1][j][d] - boxf[j][d];
}
}
write_trx(outh, nat, ind, topfile ? &(top.atoms) : NULL,
0, t[nf - 1], bFit ? topbox : boxf, xf, NULL, NULL);
}
}
/* Cycle all the pointer and the box by one */
ptr = x[0];
for (i = 0; i < nffr-1; i++)
{
t[i] = t[i+1];
x[i] = x[i+1];
copy_mat(box[i+1], box[i]);
}
x[nffr - 1] = ptr;
fr++;
}
while (read_next_x(oenv, in, &(t[nffr - 1]), x[nffr - 1], box[nffr - 1]));
if (bTop)
{
gmx_rmpbc_done(gpbc);
}
if (outh)
{
close_trx(outh);
}
if (outl)
{
close_trx(outl);
}
close_trx(in);
return 0;
}
int gmx_trjorder(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] orders molecules according to the smallest distance",
"to atoms in a reference group",
"or on z-coordinate (with option [TT]-z[tt]).",
"With distance ordering, it will ask for a group of reference",
"atoms and a group of molecules. For each frame of the trajectory",
"the selected molecules will be reordered according to the shortest",
"distance between atom number [TT]-da[tt] in the molecule and all the",
"atoms in the reference group. The center of mass of the molecules can",
"be used instead of a reference atom by setting [TT]-da[tt] to 0.",
"All atoms in the trajectory are written",
"to the output trajectory.[PAR]",
"[THISMODULE] can be useful for e.g. analyzing the n waters closest to a",
"protein.",
"In that case the reference group would be the protein and the group",
"of molecules would consist of all the water atoms. When an index group",
"of the first n waters is made, the ordered trajectory can be used",
"with any Gromacs program to analyze the n closest waters.",
"[PAR]",
"If the output file is a [TT].pdb[tt] file, the distance to the reference target",
"will be stored in the B-factor field in order to color with e.g. Rasmol.",
"[PAR]",
"With option [TT]-nshell[tt] the number of molecules within a shell",
"of radius [TT]-r[tt] around the reference group are printed."
};
static int na = 3, ref_a = 1;
static real rcut = 0;
static gmx_bool bCOM = FALSE, bZ = FALSE;
t_pargs pa[] = {
{ "-na", FALSE, etINT, {&na},
"Number of atoms in a molecule" },
{ "-da", FALSE, etINT, {&ref_a},
"Atom used for the distance calculation, 0 is COM" },
{ "-com", FALSE, etBOOL, {&bCOM},
"Use the distance to the center of mass of the reference group" },
{ "-r", FALSE, etREAL, {&rcut},
"Cutoff used for the distance calculation when computing the number of molecules in a shell around e.g. a protein" },
{ "-z", FALSE, etBOOL, {&bZ},
"Order molecules on z-coordinate" }
};
FILE *fp;
t_trxstatus *out;
t_trxstatus *status;
gmx_bool bNShell, bPDBout;
t_topology top;
int ePBC;
rvec *x, *xsol, xcom, dx;
matrix box;
t_pbc pbc;
gmx_rmpbc_t gpbc;
real t, totmass, mass, rcut2 = 0, n2;
int natoms, nwat, ncut;
char **grpname, title[256];
int i, j, d, *isize, isize_ref = 0, isize_sol;
atom_id sa, sr, *swi, **index, *ind_ref = NULL, *ind_sol;
output_env_t oenv;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTRO, "-o", "ordered", ffOPTWR },
{ efXVG, "-nshell", "nshell", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_BE_NICE,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC, &x, NULL, box, TRUE);
sfree(x);
/* get index groups */
printf("Select %sa group of molecules to be ordered:\n",
bZ ? "" : "a group of reference atoms and ");
snew(grpname, 2);
snew(index, 2);
snew(isize, 2);
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), bZ ? 1 : 2,
isize, index, grpname);
if (!bZ)
{
isize_ref = isize[0];
isize_sol = isize[1];
ind_ref = index[0];
ind_sol = index[1];
}
else
{
isize_sol = isize[0];
ind_sol = index[0];
}
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
if (natoms > top.atoms.nr)
{
gmx_fatal(FARGS, "Number of atoms in the run input file is larger than in the trjactory");
}
for (i = 0; (i < 2); i++)
{
for (j = 0; (j < isize[i]); j++)
{
if (index[i][j] > natoms)
{
gmx_fatal(FARGS, "An atom number in group %s is larger than the number of atoms in the trajectory");
}
}
}
if ((isize_sol % na) != 0)
{
gmx_fatal(FARGS, "Number of atoms in the molecule group (%d) is not a multiple of na (%d)",
isize[1], na);
}
nwat = isize_sol/na;
if (ref_a > na)
{
gmx_fatal(FARGS, "The reference atom can not be larger than the number of atoms in a molecule");
}
ref_a--;
snew(xsol, nwat);
snew(order, nwat);
snew(swi, natoms);
for (i = 0; (i < natoms); i++)
{
swi[i] = i;
}
out = NULL;
fp = NULL;
bNShell = ((opt2bSet("-nshell", NFILE, fnm)) ||
(opt2parg_bSet("-r", asize(pa), pa)));
bPDBout = FALSE;
if (bNShell)
{
rcut2 = rcut*rcut;
fp = xvgropen(opt2fn("-nshell", NFILE, fnm), "Number of molecules",
"Time (ps)", "N", oenv);
printf("Will compute the number of molecules within a radius of %g\n",
rcut);
}
if (!bNShell || opt2bSet("-o", NFILE, fnm))
{
bPDBout = (fn2ftp(opt2fn("-o", NFILE, fnm)) == efPDB);
if (bPDBout && !top.atoms.pdbinfo)
{
fprintf(stderr, "Creating pdbfino records\n");
snew(top.atoms.pdbinfo, top.atoms.nr);
}
out = open_trx(opt2fn("-o", NFILE, fnm), "w");
}
gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
do
{
gmx_rmpbc(gpbc, natoms, box, x);
set_pbc(&pbc, ePBC, box);
if (ref_a == -1)
{
/* Calculate the COM of all solvent molecules */
for (i = 0; i < nwat; i++)
{
totmass = 0;
clear_rvec(xsol[i]);
for (j = 0; j < na; j++)
{
sa = ind_sol[i*na+j];
mass = top.atoms.atom[sa].m;
totmass += mass;
for (d = 0; d < DIM; d++)
{
xsol[i][d] += mass*x[sa][d];
}
}
svmul(1/totmass, xsol[i], xsol[i]);
}
}
else
{
/* Copy the reference atom of all solvent molecules */
for (i = 0; i < nwat; i++)
{
copy_rvec(x[ind_sol[i*na+ref_a]], xsol[i]);
}
}
if (bZ)
{
for (i = 0; (i < nwat); i++)
{
sa = ind_sol[na*i];
order[i].i = sa;
order[i].d2 = xsol[i][ZZ];
}
}
else if (bCOM)
{
totmass = 0;
clear_rvec(xcom);
for (i = 0; i < isize_ref; i++)
{
mass = top.atoms.atom[ind_ref[i]].m;
totmass += mass;
for (j = 0; j < DIM; j++)
{
xcom[j] += mass*x[ind_ref[i]][j];
}
}
svmul(1/totmass, xcom, xcom);
for (i = 0; (i < nwat); i++)
{
sa = ind_sol[na*i];
pbc_dx(&pbc, xcom, xsol[i], dx);
order[i].i = sa;
order[i].d2 = norm2(dx);
}
}
else
{
/* Set distance to first atom */
for (i = 0; (i < nwat); i++)
{
sa = ind_sol[na*i];
pbc_dx(&pbc, x[ind_ref[0]], xsol[i], dx);
order[i].i = sa;
order[i].d2 = norm2(dx);
}
for (j = 1; (j < isize_ref); j++)
{
sr = ind_ref[j];
for (i = 0; (i < nwat); i++)
{
sa = ind_sol[na*i];
pbc_dx(&pbc, x[sr], xsol[i], dx);
n2 = norm2(dx);
if (n2 < order[i].d2)
{
order[i].d2 = n2;
}
}
}
}
if (bNShell)
{
ncut = 0;
for (i = 0; (i < nwat); i++)
{
if (order[i].d2 <= rcut2)
{
ncut++;
}
}
fprintf(fp, "%10.3f %8d\n", t, ncut);
}
if (out)
{
qsort(order, nwat, sizeof(*order), ocomp);
for (i = 0; (i < nwat); i++)
{
for (j = 0; (j < na); j++)
{
swi[ind_sol[na*i]+j] = order[i].i+j;
}
}
/* Store the distance as the B-factor */
if (bPDBout)
{
for (i = 0; (i < nwat); i++)
{
for (j = 0; (j < na); j++)
{
top.atoms.pdbinfo[order[i].i+j].bfac = sqrt(order[i].d2);
}
}
}
write_trx(out, natoms, swi, &top.atoms, 0, t, box, x, NULL, NULL);
}
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (out)
{
close_trx(out);
}
if (fp)
{
gmx_ffclose(fp);
}
gmx_rmpbc_done(gpbc);
return 0;
}
int gmx_genion(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] randomly replaces solvent molecules with monoatomic ions.",
"The group of solvent molecules should be continuous and all molecules",
"should have the same number of atoms.",
"The user should add the ion molecules to the topology file or use",
"the [TT]-p[tt] option to automatically modify the topology.[PAR]",
"The ion molecule type, residue and atom names in all force fields",
"are the capitalized element names without sign. This molecule name",
"should be given with [TT]-pname[tt] or [TT]-nname[tt], and the",
"[TT][molecules][tt] section of your topology updated accordingly,",
"either by hand or with [TT]-p[tt]. Do not use an atom name instead!",
"[PAR]Ions which can have multiple charge states get the multiplicity",
"added, without sign, for the uncommon states only.[PAR]",
"For larger ions, e.g. sulfate we recommended using [gmx-insert-molecules]."
};
const char *bugs[] = {
"If you specify a salt concentration existing ions are not taken into "
"account. In effect you therefore specify the amount of salt to be added.",
};
static int p_num = 0, n_num = 0, p_q = 1, n_q = -1;
static const char *p_name = "NA", *n_name = "CL";
static real rmin = 0.6, conc = 0;
static int seed = 1993;
static gmx_bool bNeutral = FALSE;
static t_pargs pa[] = {
{ "-np", FALSE, etINT, {&p_num}, "Number of positive ions" },
{ "-pname", FALSE, etSTR, {&p_name}, "Name of the positive ion" },
{ "-pq", FALSE, etINT, {&p_q}, "Charge of the positive ion" },
{ "-nn", FALSE, etINT, {&n_num}, "Number of negative ions" },
{ "-nname", FALSE, etSTR, {&n_name}, "Name of the negative ion" },
{ "-nq", FALSE, etINT, {&n_q}, "Charge of the negative ion" },
{ "-rmin", FALSE, etREAL, {&rmin}, "Minimum distance between ions" },
{ "-seed", FALSE, etINT, {&seed}, "Seed for random number generator" },
{ "-conc", FALSE, etREAL, {&conc},
"Specify salt concentration (mol/liter). This will add sufficient ions to reach up to the specified concentration as computed from the volume of the cell in the input [REF].tpr[ref] file. Overrides the [TT]-np[tt] and [TT]-nn[tt] options." },
{ "-neutral", FALSE, etBOOL, {&bNeutral}, "This option will add enough ions to neutralize the system. These ions are added on top of those specified with [TT]-np[tt]/[TT]-nn[tt] or [TT]-conc[tt]. "}
};
t_topology top;
rvec *x, *v;
real vol, qtot;
matrix box;
t_atoms atoms;
t_pbc pbc;
int *repl, ePBC;
atom_id *index;
char *grpname;
gmx_bool *bSet;
int i, nw, nwa, nsa, nsalt, iqtot;
gmx_output_env_t *oenv;
gmx_rng_t rng;
t_filenm fnm[] = {
{ efTPR, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efSTO, "-o", NULL, ffWRITE },
{ efTOP, "-p", "topol", ffOPTRW }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, asize(bugs), bugs, &oenv))
{
return 0;
}
/* Check input for something sensible */
if ((p_num < 0) || (n_num < 0))
{
gmx_fatal(FARGS, "Negative number of ions to add?");
}
if (conc > 0 && (p_num > 0 || n_num > 0))
{
fprintf(stderr, "WARNING: -conc specified, overriding -nn and -np.\n");
}
/* Read atom positions and charges */
read_tps_conf(ftp2fn(efTPR, NFILE, fnm), &top, &ePBC, &x, &v, box, FALSE);
atoms = top.atoms;
/* Compute total charge */
qtot = 0;
for (i = 0; (i < atoms.nr); i++)
{
qtot += atoms.atom[i].q;
}
iqtot = std::round(qtot);
if (conc > 0)
{
/* Compute number of ions to be added */
vol = det(box);
nsalt = std::round(conc*vol*AVOGADRO/1e24);
p_num = abs(nsalt*n_q);
n_num = abs(nsalt*p_q);
}
if (bNeutral)
{
int qdelta = p_num*p_q + n_num*n_q + iqtot;
/* Check if the system is neutralizable
* is (qdelta == p_q*p_num + n_q*n_num) solvable for p_num and n_num? */
int gcd = gmx_greatest_common_divisor(n_q, p_q);
if ((qdelta % gcd) != 0)
{
gmx_fatal(FARGS, "Can't neutralize this system using -nq %d and"
" -pq %d.\n", n_q, p_q);
}
while (qdelta != 0)
{
while (qdelta < 0)
{
p_num++;
qdelta += p_q;
}
while (qdelta > 0)
{
n_num++;
qdelta += n_q;
}
}
}
if ((p_num == 0) && (n_num == 0))
{
fprintf(stderr, "No ions to add, will just copy input configuration.\n");
}
else
{
printf("Will try to add %d %s ions and %d %s ions.\n",
p_num, p_name, n_num, n_name);
printf("Select a continuous group of solvent molecules\n");
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &nwa, &index, &grpname);
for (i = 1; i < nwa; i++)
{
if (index[i] != index[i-1]+1)
{
gmx_fatal(FARGS, "The solvent group %s is not continuous: "
"index[%d]=%d, index[%d]=%d",
grpname, i, index[i-1]+1, i+1, index[i]+1);
}
}
nsa = 1;
while ((nsa < nwa) &&
(atoms.atom[index[nsa]].resind ==
atoms.atom[index[nsa-1]].resind))
{
nsa++;
}
if (nwa % nsa)
{
gmx_fatal(FARGS, "Your solvent group size (%d) is not a multiple of %d",
nwa, nsa);
}
nw = nwa/nsa;
fprintf(stderr, "Number of (%d-atomic) solvent molecules: %d\n", nsa, nw);
if (p_num+n_num > nw)
{
gmx_fatal(FARGS, "Not enough solvent for adding ions");
}
if (opt2bSet("-p", NFILE, fnm))
{
update_topol(opt2fn("-p", NFILE, fnm), p_num, n_num, p_name, n_name, grpname);
}
snew(bSet, nw);
snew(repl, nw);
snew(v, atoms.nr);
snew(atoms.pdbinfo, atoms.nr);
set_pbc(&pbc, ePBC, box);
if (seed == 0)
{
rng = gmx_rng_init(gmx_rng_make_seed());
}
else
{
rng = gmx_rng_init(seed);
}
/* Now loop over the ions that have to be placed */
while (p_num-- > 0)
{
insert_ion(nsa, &nw, bSet, repl, index, x, &pbc,
1, p_q, p_name, &atoms, rmin, rng);
}
while (n_num-- > 0)
{
insert_ion(nsa, &nw, bSet, repl, index, x, &pbc,
-1, n_q, n_name, &atoms, rmin, rng);
}
gmx_rng_destroy(rng);
fprintf(stderr, "\n");
if (nw)
{
sort_ions(nsa, nw, repl, index, &atoms, x, p_name, n_name);
}
sfree(atoms.pdbinfo);
atoms.pdbinfo = NULL;
}
write_sto_conf(ftp2fn(efSTO, NFILE, fnm), *top.name, &atoms, x, NULL, ePBC, box);
return 0;
}
int cmain (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_convert_tpr(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] can edit run input files in four ways.[PAR]",
"[BB]1.[bb] by modifying the number of steps in a run input file",
"with options [TT]-extend[tt], [TT]-until[tt] or [TT]-nsteps[tt]",
"(nsteps=-1 means unlimited number of steps)[PAR]",
"[BB]2.[bb] (OBSOLETE) by creating a run input file",
"for a continuation run when your simulation has crashed due to e.g.",
"a full disk, or by making a continuation run input file.",
"This option is obsolete, since mdrun now writes and reads",
"checkpoint files.",
"[BB]Note[bb] that a frame with coordinates and velocities is needed.",
"When pressure and/or Nose-Hoover temperature coupling is used",
"an energy file can be supplied to get an exact continuation",
"of the original run.[PAR]",
"[BB]3.[bb] by creating a [TT].tpx[tt] file for a subset of your original",
"tpx file, which is useful when you want to remove the solvent from",
"your [TT].tpx[tt] file, or when you want to make e.g. a pure C[GRK]alpha[grk] [TT].tpx[tt] file.",
"Note that you may need to use [TT]-nsteps -1[tt] (or similar) to get",
"this to work.",
"[BB]WARNING: this [TT].tpx[tt] file is not fully functional[bb].[PAR]",
"[BB]4.[bb] by setting the charges of a specified group",
"to zero. This is useful when doing free energy estimates",
"using the LIE (Linear Interaction Energy) method."
};
const char *top_fn, *frame_fn;
t_fileio *fp;
ener_file_t fp_ener = NULL;
t_trnheader head;
int i;
gmx_int64_t nsteps_req, run_step, frame;
double run_t, state_t;
gmx_bool bOK, bNsteps, bExtend, bUntil, bTime, bTraj;
gmx_bool bFrame, bUse, bSel, bNeedEner, bReadEner, bScanEner, bFepState;
gmx_mtop_t mtop;
t_atoms atoms;
t_inputrec *ir, *irnew = NULL;
t_gromppopts *gopts;
t_state state;
rvec *newx = NULL, *newv = NULL, *tmpx, *tmpv;
matrix newbox;
int gnx;
char *grpname;
atom_id *index = NULL;
int nre;
gmx_enxnm_t *enm = NULL;
t_enxframe *fr_ener = NULL;
char buf[200], buf2[200];
output_env_t oenv;
t_filenm fnm[] = {
{ efTPX, NULL, NULL, ffREAD },
{ efTRN, "-f", NULL, ffOPTRD },
{ efEDR, "-e", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTPX, "-o", "tpxout", ffWRITE }
};
#define NFILE asize(fnm)
/* Command line options */
static int nsteps_req_int = 0;
static real start_t = -1.0, extend_t = 0.0, until_t = 0.0;
static int init_fep_state = 0;
static gmx_bool bContinuation = TRUE, bZeroQ = FALSE, bVel = TRUE;
static t_pargs pa[] = {
{ "-extend", FALSE, etREAL, {&extend_t},
"Extend runtime by this amount (ps)" },
{ "-until", FALSE, etREAL, {&until_t},
"Extend runtime until this ending time (ps)" },
{ "-nsteps", FALSE, etINT, {&nsteps_req_int},
"Change the number of steps" },
{ "-time", FALSE, etREAL, {&start_t},
"Continue from frame at this time (ps) instead of the last frame" },
{ "-zeroq", FALSE, etBOOL, {&bZeroQ},
"Set the charges of a group (from the index) to zero" },
{ "-vel", FALSE, etBOOL, {&bVel},
"Require velocities from trajectory" },
{ "-cont", FALSE, etBOOL, {&bContinuation},
"For exact continuation, the constraints should not be applied before the first step" },
{ "-init_fep_state", FALSE, etINT, {&init_fep_state},
"fep state to initialize from" },
};
int nerror = 0;
/* Parse the command line */
if (!parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
/* Convert int to gmx_int64_t */
nsteps_req = nsteps_req_int;
bNsteps = opt2parg_bSet("-nsteps", asize(pa), pa);
bExtend = opt2parg_bSet("-extend", asize(pa), pa);
bUntil = opt2parg_bSet("-until", asize(pa), pa);
bFepState = opt2parg_bSet("-init_fep_state", asize(pa), pa);
bTime = opt2parg_bSet("-time", asize(pa), pa);
bTraj = (opt2bSet("-f", NFILE, fnm) || bTime);
top_fn = ftp2fn(efTPX, NFILE, fnm);
fprintf(stderr, "Reading toplogy and stuff from %s\n", top_fn);
snew(ir, 1);
read_tpx_state(top_fn, ir, &state, NULL, &mtop);
run_step = ir->init_step;
run_t = ir->init_step*ir->delta_t + ir->init_t;
if (!EI_STATE_VELOCITY(ir->eI))
{
bVel = FALSE;
}
if (bTraj)
{
fprintf(stderr, "\n"
"NOTE: Reading the state from trajectory is an obsolete feature of gmx convert-tpr.\n"
" Continuation should be done by loading a checkpoint file with mdrun -cpi\n"
" This guarantees that all state variables are transferred.\n"
" gmx convert-tpr is now only useful for increasing nsteps,\n"
" but even that can often be avoided by using mdrun -maxh\n"
"\n");
if (ir->bContinuation != bContinuation)
{
fprintf(stderr, "Modifying ir->bContinuation to %s\n",
bool_names[bContinuation]);
}
ir->bContinuation = bContinuation;
bNeedEner = (ir->epc == epcPARRINELLORAHMAN || ir->etc == etcNOSEHOOVER);
bReadEner = (bNeedEner && ftp2bSet(efEDR, NFILE, fnm));
bScanEner = (bReadEner && !bTime);
if (ir->epc != epcNO || EI_SD(ir->eI) || ir->eI == eiBD)
{
fprintf(stderr, "NOTE: The simulation uses pressure coupling and/or stochastic dynamics.\n"
"gmx convert-tpr can not provide binary identical continuation.\n"
"If you want that, supply a checkpoint file to mdrun\n\n");
}
if (EI_SD(ir->eI) || ir->eI == eiBD)
{
fprintf(stderr, "\nChanging ld-seed from %"GMX_PRId64 " ", ir->ld_seed);
ir->ld_seed = (gmx_int64_t)gmx_rng_make_seed();
fprintf(stderr, "to %"GMX_PRId64 "\n\n", ir->ld_seed);
}
frame_fn = ftp2fn(efTRN, NFILE, fnm);
if (fn2ftp(frame_fn) == efCPT)
{
int sim_part;
fprintf(stderr,
"\nREADING STATE FROM CHECKPOINT %s...\n\n",
frame_fn);
read_checkpoint_state(frame_fn, &sim_part,
&run_step, &run_t, &state);
}
else
{
fprintf(stderr,
"\nREADING COORDS, VELS AND BOX FROM TRAJECTORY %s...\n\n",
frame_fn);
fp = open_trn(frame_fn, "r");
if (bScanEner)
{
fp_ener = open_enx(ftp2fn(efEDR, NFILE, fnm), "r");
do_enxnms(fp_ener, &nre, &enm);
snew(fr_ener, 1);
fr_ener->t = -1e-12;
}
/* Now scan until the last set of x and v (step == 0)
* or the ones at step step.
*/
bFrame = TRUE;
frame = 0;
while (bFrame)
{
bFrame = fread_trnheader(fp, &head, &bOK);
if (bOK && frame == 0)
{
if (mtop.natoms != head.natoms)
{
gmx_fatal(FARGS, "Number of atoms in Topology (%d) "
"is not the same as in Trajectory (%d)\n",
mtop.natoms, head.natoms);
}
snew(newx, head.natoms);
snew(newv, head.natoms);
}
bFrame = bFrame && bOK;
if (bFrame)
{
bOK = fread_htrn(fp, &head, newbox, newx, newv, NULL);
}
bFrame = bFrame && bOK;
bUse = FALSE;
if (bFrame &&
(head.x_size) && (head.v_size || !bVel))
{
bUse = TRUE;
if (bScanEner)
{
/* Read until the energy time is >= the trajectory time */
while (fr_ener->t < head.t && do_enx(fp_ener, fr_ener))
{
;
}
bUse = (fr_ener->t == head.t);
}
if (bUse)
{
tmpx = newx;
newx = state.x;
state.x = tmpx;
tmpv = newv;
newv = state.v;
state.v = tmpv;
run_t = head.t;
run_step = head.step;
state.fep_state = head.fep_state;
state.lambda[efptFEP] = head.lambda;
copy_mat(newbox, state.box);
}
}
if (bFrame || !bOK)
{
sprintf(buf, "\r%s %s frame %s%s: step %s%s time %s",
"%s", "%s", "%6", GMX_PRId64, "%6", GMX_PRId64, " %8.3f");
fprintf(stderr, buf,
bUse ? "Read " : "Skipped", ftp2ext(fn2ftp(frame_fn)),
frame, head.step, head.t);
frame++;
if (bTime && (head.t >= start_t))
{
bFrame = FALSE;
}
}
}
if (bScanEner)
{
close_enx(fp_ener);
free_enxframe(fr_ener);
free_enxnms(nre, enm);
}
close_trn(fp);
fprintf(stderr, "\n");
if (!bOK)
{
fprintf(stderr, "%s frame %s (step %s, time %g) is incomplete\n",
ftp2ext(fn2ftp(frame_fn)), gmx_step_str(frame-1, buf2),
gmx_step_str(head.step, buf), head.t);
}
fprintf(stderr, "\nUsing frame of step %s time %g\n",
gmx_step_str(run_step, buf), run_t);
if (bNeedEner)
{
if (bReadEner)
{
get_enx_state(ftp2fn(efEDR, NFILE, fnm), run_t, &mtop.groups, ir, &state);
}
else
{
fprintf(stderr, "\nWARNING: The simulation uses %s temperature and/or %s pressure coupling,\n"
" the continuation will only be exact when an energy file is supplied\n\n",
ETCOUPLTYPE(etcNOSEHOOVER),
EPCOUPLTYPE(epcPARRINELLORAHMAN));
}
}
if (bFepState)
{
ir->fepvals->init_fep_state = init_fep_state;
}
}
}
if (bNsteps)
{
fprintf(stderr, "Setting nsteps to %s\n", gmx_step_str(nsteps_req, buf));
ir->nsteps = nsteps_req;
}
else
{
/* Determine total number of steps remaining */
if (bExtend)
{
ir->nsteps = ir->nsteps - (run_step - ir->init_step) + (gmx_int64_t)(extend_t/ir->delta_t + 0.5);
printf("Extending remaining runtime of by %g ps (now %s steps)\n",
extend_t, gmx_step_str(ir->nsteps, buf));
}
else if (bUntil)
{
printf("nsteps = %s, run_step = %s, current_t = %g, until = %g\n",
gmx_step_str(ir->nsteps, buf),
gmx_step_str(run_step, buf2),
run_t, until_t);
ir->nsteps = (gmx_int64_t)((until_t - run_t)/ir->delta_t + 0.5);
printf("Extending remaining runtime until %g ps (now %s steps)\n",
until_t, gmx_step_str(ir->nsteps, buf));
}
else
{
ir->nsteps -= run_step - ir->init_step;
/* Print message */
printf("%s steps (%g ps) remaining from first run.\n",
gmx_step_str(ir->nsteps, buf), ir->nsteps*ir->delta_t);
}
}
if (bNsteps || bZeroQ || (ir->nsteps > 0))
{
ir->init_step = run_step;
if (ftp2bSet(efNDX, NFILE, fnm) ||
!(bNsteps || bExtend || bUntil || bTraj))
{
atoms = gmx_mtop_global_atoms(&mtop);
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm), 1,
&gnx, &index, &grpname);
if (!bZeroQ)
{
bSel = (gnx != state.natoms);
for (i = 0; ((i < gnx) && (!bSel)); i++)
{
bSel = (i != index[i]);
}
}
else
{
bSel = FALSE;
}
if (bSel)
{
fprintf(stderr, "Will write subset %s of original tpx containing %d "
"atoms\n", grpname, gnx);
reduce_topology_x(gnx, index, &mtop, state.x, state.v);
state.natoms = gnx;
}
else if (bZeroQ)
{
zeroq(index, &mtop);
fprintf(stderr, "Zero-ing charges for group %s\n", grpname);
}
else
{
fprintf(stderr, "Will write full tpx file (no selection)\n");
}
}
state_t = ir->init_t + ir->init_step*ir->delta_t;
sprintf(buf, "Writing statusfile with starting step %s%s and length %s%s steps...\n", "%10", GMX_PRId64, "%10", GMX_PRId64);
fprintf(stderr, buf, ir->init_step, ir->nsteps);
fprintf(stderr, " time %10.3f and length %10.3f ps\n",
state_t, ir->nsteps*ir->delta_t);
write_tpx_state(opt2fn("-o", NFILE, fnm), ir, &state, &mtop);
}
else
{
printf("You've simulated long enough. Not writing tpr file\n");
}
return 0;
}
int gmx_densmap(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes 2D number-density maps.",
"It can make planar and axial-radial density maps.",
"The output [REF].xpm[ref] file can be visualized with for instance xv",
"and can be converted to postscript with [TT]xpm2ps[tt].",
"Optionally, output can be in text form to a [REF].dat[ref] file with [TT]-od[tt], instead of the usual [REF].xpm[ref] file with [TT]-o[tt].",
"[PAR]",
"The default analysis is a 2-D number-density map for a selected",
"group of atoms in the x-y plane.",
"The averaging direction can be changed with the option [TT]-aver[tt].",
"When [TT]-xmin[tt] and/or [TT]-xmax[tt] are set only atoms that are",
"within the limit(s) in the averaging direction are taken into account.",
"The grid spacing is set with the option [TT]-bin[tt].",
"When [TT]-n1[tt] or [TT]-n2[tt] is non-zero, the grid",
"size is set by this option.",
"Box size fluctuations are properly taken into account.",
"[PAR]",
"When options [TT]-amax[tt] and [TT]-rmax[tt] are set, an axial-radial",
"number-density map is made. Three groups should be supplied, the centers",
"of mass of the first two groups define the axis, the third defines the",
"analysis group. The axial direction goes from -amax to +amax, where",
"the center is defined as the midpoint between the centers of mass and",
"the positive direction goes from the first to the second center of mass.",
"The radial direction goes from 0 to rmax or from -rmax to +rmax",
"when the [TT]-mirror[tt] option has been set.",
"[PAR]",
"The normalization of the output is set with the [TT]-unit[tt] option.",
"The default produces a true number density. Unit [TT]nm-2[tt] leaves out",
"the normalization for the averaging or the angular direction.",
"Option [TT]count[tt] produces the count for each grid cell.",
"When you do not want the scale in the output to go",
"from zero to the maximum density, you can set the maximum",
"with the option [TT]-dmax[tt]."
};
static int n1 = 0, n2 = 0;
static real xmin = -1, xmax = -1, bin = 0.02, dmin = 0, dmax = 0, amax = 0, rmax = 0;
static gmx_bool bMirror = FALSE, bSums = FALSE;
static const char *eaver[] = { NULL, "z", "y", "x", NULL };
static const char *eunit[] = { NULL, "nm-3", "nm-2", "count", NULL };
t_pargs pa[] = {
{ "-bin", FALSE, etREAL, {&bin},
"Grid size (nm)" },
{ "-aver", FALSE, etENUM, {eaver},
"The direction to average over" },
{ "-xmin", FALSE, etREAL, {&xmin},
"Minimum coordinate for averaging" },
{ "-xmax", FALSE, etREAL, {&xmax},
"Maximum coordinate for averaging" },
{ "-n1", FALSE, etINT, {&n1},
"Number of grid cells in the first direction" },
{ "-n2", FALSE, etINT, {&n2},
"Number of grid cells in the second direction" },
{ "-amax", FALSE, etREAL, {&amax},
"Maximum axial distance from the center"},
{ "-rmax", FALSE, etREAL, {&rmax},
"Maximum radial distance" },
{ "-mirror", FALSE, etBOOL, {&bMirror},
"Add the mirror image below the axial axis" },
{ "-sums", FALSE, etBOOL, {&bSums},
"Print density sums (1D map) to stdout" },
{ "-unit", FALSE, etENUM, {eunit},
"Unit for the output" },
{ "-dmin", FALSE, etREAL, {&dmin},
"Minimum density in output"},
{ "-dmax", FALSE, etREAL, {&dmax},
"Maximum density in output (0 means calculate it)"},
};
gmx_bool bXmin, bXmax, bRadial;
FILE *fp;
t_trxstatus *status;
t_topology top;
int ePBC = -1;
rvec *x, xcom[2], direction, center, dx;
matrix box;
real t, m, mtot;
t_pbc pbc;
int cav = 0, c1 = 0, c2 = 0;
char **grpname, buf[STRLEN];
const char *unit;
int i, j, k, l, ngrps, anagrp, *gnx = NULL, nindex, nradial = 0, nfr, nmpower;
atom_id **ind = NULL, *index;
real **grid, maxgrid, m1, m2, box1, box2, *tickx, *tickz, invcellvol;
real invspa = 0, invspz = 0, axial, r, vol_old, vol, rowsum;
int nlev = 51;
t_rgb rlo = {1, 1, 1}, rhi = {0, 0, 0};
output_env_t oenv;
const char *label[] = { "x (nm)", "y (nm)", "z (nm)" };
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efDAT, "-od", "densmap", ffOPTWR },
{ efXPM, "-o", "densmap", ffWRITE }
};
#define NFILE asize(fnm)
int npargs;
npargs = asize(pa);
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_CAN_VIEW,
NFILE, fnm, npargs, pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
bXmin = opt2parg_bSet("-xmin", npargs, pa);
bXmax = opt2parg_bSet("-xmax", npargs, pa);
bRadial = (amax > 0 || rmax > 0);
if (bRadial)
{
if (amax <= 0 || rmax <= 0)
{
gmx_fatal(FARGS, "Both amax and rmax should be larger than zero");
}
}
GMX_RELEASE_ASSERT(eunit[0] != NULL, "Option setting inconsistency; eunit[0] is NULL");
if (std::strcmp(eunit[0], "nm-3") == 0)
{
nmpower = -3;
unit = "(nm^-3)";
}
else if (std::strcmp(eunit[0], "nm-2") == 0)
{
nmpower = -2;
unit = "(nm^-2)";
}
else
{
nmpower = 0;
unit = "count";
}
if (ftp2bSet(efTPS, NFILE, fnm) || !ftp2bSet(efNDX, NFILE, fnm))
{
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, &x, NULL, box,
bRadial);
}
if (!bRadial)
{
ngrps = 1;
fprintf(stderr, "\nSelect an analysis group\n");
}
else
{
ngrps = 3;
fprintf(stderr,
"\nSelect two groups to define the axis and an analysis group\n");
}
snew(gnx, ngrps);
snew(grpname, ngrps);
snew(ind, ngrps);
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), ngrps, gnx, ind, grpname);
anagrp = ngrps - 1;
nindex = gnx[anagrp];
index = ind[anagrp];
if (bRadial)
{
if ((gnx[0] > 1 || gnx[1] > 1) && !ftp2bSet(efTPS, NFILE, fnm))
{
gmx_fatal(FARGS, "No run input file was supplied (option -s), this is required for the center of mass calculation");
}
}
GMX_RELEASE_ASSERT(eaver[0] != NULL, "Option setting inconsistency; eaver[0] is NULL");
switch (eaver[0][0])
{
case 'x': cav = XX; c1 = YY; c2 = ZZ; break;
case 'y': cav = YY; c1 = XX; c2 = ZZ; break;
case 'z': cav = ZZ; c1 = XX; c2 = YY; break;
}
read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
if (!bRadial)
{
if (n1 == 0)
{
n1 = static_cast<int>(box[c1][c1]/bin + 0.5);
}
if (n2 == 0)
{
n2 = static_cast<int>(box[c2][c2]/bin + 0.5);
}
}
else
{
n1 = static_cast<int>(2*amax/bin + 0.5);
nradial = static_cast<int>(rmax/bin + 0.5);
/* cppcheck-suppress zerodiv fixed in 1.68-dev */
invspa = n1/(2*amax);
/* cppcheck-suppress zerodiv fixed in 1.68-dev */
invspz = nradial/rmax;
if (bMirror)
{
n2 = 2*nradial;
}
else
{
n2 = nradial;
}
}
snew(grid, n1);
for (i = 0; i < n1; i++)
{
snew(grid[i], n2);
}
box1 = 0;
box2 = 0;
nfr = 0;
do
{
if (!bRadial)
{
box1 += box[c1][c1];
box2 += box[c2][c2];
invcellvol = n1*n2;
if (nmpower == -3)
{
invcellvol /= det(box);
}
else if (nmpower == -2)
{
invcellvol /= box[c1][c1]*box[c2][c2];
}
for (i = 0; i < nindex; i++)
{
j = index[i];
if ((!bXmin || x[j][cav] >= xmin) &&
(!bXmax || x[j][cav] <= xmax))
{
m1 = x[j][c1]/box[c1][c1];
if (m1 >= 1)
{
m1 -= 1;
}
if (m1 < 0)
{
m1 += 1;
}
m2 = x[j][c2]/box[c2][c2];
if (m2 >= 1)
{
m2 -= 1;
}
if (m2 < 0)
{
m2 += 1;
}
grid[static_cast<int>(m1*n1)][static_cast<int>(m2*n2)] += invcellvol;
}
}
}
else
{
set_pbc(&pbc, ePBC, box);
for (i = 0; i < 2; i++)
{
if (gnx[i] == 1)
{
/* One atom, just copy the coordinates */
copy_rvec(x[ind[i][0]], xcom[i]);
}
else
{
/* Calculate the center of mass */
clear_rvec(xcom[i]);
mtot = 0;
for (j = 0; j < gnx[i]; j++)
{
k = ind[i][j];
m = top.atoms.atom[k].m;
for (l = 0; l < DIM; l++)
{
xcom[i][l] += m*x[k][l];
}
mtot += m;
}
svmul(1/mtot, xcom[i], xcom[i]);
}
}
pbc_dx(&pbc, xcom[1], xcom[0], direction);
for (i = 0; i < DIM; i++)
{
center[i] = xcom[0][i] + 0.5*direction[i];
}
unitv(direction, direction);
for (i = 0; i < nindex; i++)
{
j = index[i];
pbc_dx(&pbc, x[j], center, dx);
axial = iprod(dx, direction);
r = std::sqrt(norm2(dx) - axial*axial);
if (axial >= -amax && axial < amax && r < rmax)
{
if (bMirror)
{
r += rmax;
}
grid[static_cast<int>((axial + amax)*invspa)][static_cast<int>(r*invspz)] += 1;
}
}
}
nfr++;
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
/* normalize gridpoints */
maxgrid = 0;
if (!bRadial)
{
for (i = 0; i < n1; i++)
{
for (j = 0; j < n2; j++)
{
grid[i][j] /= nfr;
if (grid[i][j] > maxgrid)
{
maxgrid = grid[i][j];
}
}
}
}
else
{
for (i = 0; i < n1; i++)
{
vol_old = 0;
for (j = 0; j < nradial; j++)
{
switch (nmpower)
{
case -3: vol = M_PI*(j+1)*(j+1)/(invspz*invspz*invspa); break;
case -2: vol = (j+1)/(invspz*invspa); break;
default: vol = j+1; break;
}
if (bMirror)
{
k = j + nradial;
}
else
{
k = j;
}
grid[i][k] /= nfr*(vol - vol_old);
if (bMirror)
{
grid[i][nradial-1-j] = grid[i][k];
}
vol_old = vol;
if (grid[i][k] > maxgrid)
{
maxgrid = grid[i][k];
}
}
}
}
fprintf(stdout, "\n The maximum density is %f %s\n", maxgrid, unit);
if (dmax > 0)
{
maxgrid = dmax;
}
snew(tickx, n1+1);
snew(tickz, n2+1);
if (!bRadial)
{
/* normalize box-axes */
box1 /= nfr;
box2 /= nfr;
for (i = 0; i <= n1; i++)
{
tickx[i] = i*box1/n1;
}
for (i = 0; i <= n2; i++)
{
tickz[i] = i*box2/n2;
}
}
else
{
for (i = 0; i <= n1; i++)
{
tickx[i] = i/invspa - amax;
}
if (bMirror)
{
for (i = 0; i <= n2; i++)
{
tickz[i] = i/invspz - rmax;
}
}
else
{
for (i = 0; i <= n2; i++)
{
tickz[i] = i/invspz;
}
}
}
if (bSums)
{
for (i = 0; i < n1; ++i)
{
fprintf(stdout, "Density sums:\n");
rowsum = 0;
for (j = 0; j < n2; ++j)
{
rowsum += grid[i][j];
}
fprintf(stdout, "%g\t", rowsum);
}
fprintf(stdout, "\n");
}
sprintf(buf, "%s number density", grpname[anagrp]);
if (!bRadial && (bXmin || bXmax))
{
if (!bXmax)
{
sprintf(buf+std::strlen(buf), ", %c > %g nm", eaver[0][0], xmin);
}
else if (!bXmin)
{
sprintf(buf+std::strlen(buf), ", %c < %g nm", eaver[0][0], xmax);
}
else
{
sprintf(buf+std::strlen(buf), ", %c: %g - %g nm", eaver[0][0], xmin, xmax);
}
}
if (ftp2bSet(efDAT, NFILE, fnm))
{
fp = gmx_ffopen(ftp2fn(efDAT, NFILE, fnm), "w");
/*optional text form output: first row is tickz; first col is tickx */
fprintf(fp, "0\t");
for (j = 0; j < n2; ++j)
{
fprintf(fp, "%g\t", tickz[j]);
}
fprintf(fp, "\n");
for (i = 0; i < n1; ++i)
{
fprintf(fp, "%g\t", tickx[i]);
for (j = 0; j < n2; ++j)
{
fprintf(fp, "%g\t", grid[i][j]);
}
fprintf(fp, "\n");
}
gmx_ffclose(fp);
}
else
{
fp = gmx_ffopen(ftp2fn(efXPM, NFILE, fnm), "w");
write_xpm(fp, MAT_SPATIAL_X | MAT_SPATIAL_Y, buf, unit,
bRadial ? "axial (nm)" : label[c1], bRadial ? "r (nm)" : label[c2],
n1, n2, tickx, tickz, grid, dmin, maxgrid, rlo, rhi, &nlev);
gmx_ffclose(fp);
}
do_view(oenv, opt2fn("-o", NFILE, fnm), NULL);
return 0;
}
int gmx_sorient(int argc,char *argv[])
{
t_topology top;
int ePBC;
char title[STRLEN];
int status;
int natoms;
real t;
rvec *xtop,*x;
matrix box;
FILE *fp;
int i,j,p,sa0,sa1,sa2,n,ntot,nf,m,*hist1,*hist2,*histn,nbin1,nbin2,nrbin;
real *histi1,*histi2,invbw,invrbw;
double sum1,sum2;
int *isize,nrefgrp,nrefat;
atom_id **index;
char **grpname;
real inp,outp,two_pi,nav,normfac,rmin2,rmax2,rcut,rcut2,r2,r,mass,mtot;
real c1,c2;
char str[STRLEN];
bool bTPS;
rvec xref,dx,dxh1,dxh2,outer;
t_pbc pbc;
char *legr[] = { "<cos(\\8q\\4\\s1\\N)>",
"<3cos\\S2\\N(\\8q\\4\\s2\\N)-1>" };
char *legc[] = { "cos(\\8q\\4\\s1\\N)",
"3cos\\S2\\N(\\8q\\4\\s2\\N)-1" };
static char *desc[] = {
"g_sorient analyzes solvent orientation around solutes.",
"It calculates two angles between the vector from one or more",
"reference positions to the first atom of each solvent molecule:[BR]"
"theta1: the angle with the vector from the first atom of the solvent",
"molecule to the midpoint between atoms 2 and 3.[BR]",
"theta2: the angle with the normal of the solvent plane, defined by the",
"same three atoms, or when the option [TT]-v23[tt] is set",
"the angle with the vector between atoms 2 and 3.[BR]",
"The reference can be a set of atoms or",
"the center of mass of a set of atoms. The group of solvent atoms should",
"consist of 3 atoms per solvent molecule.",
"Only solvent molecules between [TT]-rmin[tt] and [TT]-rmax[tt] are",
"considered for [TT]-o[tt] and [TT]-no[tt] each frame.[PAR]",
"[TT]-o[tt]: distribtion of cos(theta1) for rmin<=r<=rmax.[PAR]",
"[TT]-no[tt]: distribution of cos(theta2) for rmin<=r<=rmax.[PAR]",
"[TT]-ro[tt]: <cos(theta1)> and <3cos^2(theta2)-1> as a function of the",
"distance.[PAR]",
"[TT]-co[tt]: the sum over all solvent molecules within distance r",
"of cos(theta1) and 3cos^2(theta2)-1 as a function of r.[PAR]",
"[TT]-rc[tt]: the distribution of the solvent molecules as a function of r"
};
static bool bCom = FALSE,bVec23=FALSE,bPBC = FALSE;
static real rmin=0.0,rmax=0.5,binwidth=0.02,rbinw=0.02;
t_pargs pa[] = {
{ "-com", FALSE, etBOOL, {&bCom},
"Use the center of mass as the reference postion" },
{ "-v23", FALSE, etBOOL, {&bVec23},
"Use the vector between atoms 2 and 3" },
{ "-rmin", FALSE, etREAL, {&rmin}, "Minimum distance (nm)" },
{ "-rmax", FALSE, etREAL, {&rmax}, "Maximum distance (nm)" },
{ "-cbin", FALSE, etREAL, {&binwidth}, "Binwidth for the cosine" },
{ "-rbin", FALSE, etREAL, {&rbinw}, "Binwidth for r (nm)" },
{ "-pbc", FALSE, etBOOL, {&bPBC}, "Check PBC for the center of mass calculation. Only necessary when your reference group consists of several molecules." }
};
t_filenm fnm[] = {
{ efTRX, NULL, NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "sori.xvg", ffWRITE },
{ efXVG, "-no", "snor.xvg", ffWRITE },
{ efXVG, "-ro", "sord.xvg", ffWRITE },
{ efXVG, "-co", "scum.xvg", ffWRITE },
{ efXVG, "-rc", "scount.xvg", ffWRITE }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL);
two_pi = 2/M_PI;
bTPS = (opt2bSet("-s",NFILE,fnm) || !opt2bSet("-n",NFILE,fnm) || bCom);
if (bTPS) {
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xtop,NULL,box,
bCom);
}
/* get index groups */
printf("Select a group of reference particles and a solvent group:\n");
snew(grpname,2);
snew(index,2);
snew(isize,2);
if (bTPS) {
get_index(&top.atoms,ftp2fn_null(efNDX,NFILE,fnm),2,isize,index,grpname);
} else {
get_index(NULL,ftp2fn(efNDX,NFILE,fnm),2,isize,index,grpname);
}
if (bCom) {
nrefgrp = 1;
nrefat = isize[0];
} else {
nrefgrp = isize[0];
nrefat = 1;
}
if (isize[1] % 3)
gmx_fatal(FARGS,"The number of solvent atoms (%d) is not a multiple of 3",
isize[1]);
/* initialize reading trajectory: */
natoms=read_first_x(&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
rmin2 = sqr(rmin);
rmax2 = sqr(rmax);
rcut = 0.99*sqrt(max_cutoff2(guess_ePBC(box),box));
if (rcut == 0)
rcut = 10*rmax;
rcut2 = sqr(rcut);
invbw = 1/binwidth;
nbin1 = (int)(2*invbw + 0.5);
nbin2 = (int)(invbw + 0.5);
invrbw = 1/rbinw;
snew(hist1,nbin1+1);
snew(hist2,nbin2+1);
nrbin = rcut/rbinw;
if (nrbin == 0)
nrbin = 1;
snew(histi1,nrbin);
snew(histi2,nrbin);
snew(histn,nrbin);
ntot = 0;
nf = 0;
sum1 = 0;
sum2 = 0;
/* start analysis of trajectory */
do {
if (bTPS) {
/* make molecules whole again */
rm_pbc(&top.idef,ePBC,natoms,box,x,x);
}
set_pbc(&pbc,ePBC,box);
n = 0;
inp = 0;
outp = 0;
for(p=0; (p<nrefgrp); p++) {
if (bCom)
calc_com_pbc(nrefat,&top,x,&pbc,index[0],xref,bPBC,box);
else
copy_rvec(x[index[0][p]],xref);
for(m=0; m<isize[1]; m+=3) {
sa0 = index[1][m];
sa1 = index[1][m+1];
sa2 = index[1][m+2];
pbc_dx(&pbc,x[sa0],xref,dx);
r2 = norm2(dx);
if (r2 < rcut2) {
r = sqrt(r2);
if (!bVec23) {
/* Determine the normal to the plain */
rvec_sub(x[sa1],x[sa0],dxh1);
rvec_sub(x[sa2],x[sa0],dxh2);
rvec_inc(dxh1,dxh2);
svmul(1/r,dx,dx);
unitv(dxh1,dxh1);
inp = iprod(dx,dxh1);
cprod(dxh1,dxh2,outer);
unitv(outer,outer);
outp = iprod(dx,outer);
} else {
/* Use the vector between the 2nd and 3rd atom */
rvec_sub(x[sa2],x[sa1],dxh2);
unitv(dxh2,dxh2);
outp = iprod(dx,dxh2)/r;
}
(histi1[(int)(invrbw*r)]) += inp;
(histi2[(int)(invrbw*r)]) += 3*sqr(outp) - 1;
(histn[(int)(invrbw*r)])++;
if (r2>=rmin2 && r2<rmax2) {
(hist1[(int)(invbw*(inp + 1))])++;
(hist2[(int)(invbw*fabs(outp))])++;
sum1 += inp;
sum2 += outp;
n++;
}
}
}
}
ntot += n;
nf++;
} while (read_next_x(status,&t,natoms,x,box));
/* clean up */
sfree(x);
close_trj(status);
/* Add the bin for the exact maximum to the previous bin */
hist1[nbin1-1] += hist1[nbin1];
hist2[nbin2-1] += hist2[nbin2];
nav = (real)ntot/(nrefgrp*nf);
normfac = invbw/ntot;
fprintf(stderr, "Average nr of molecules between %g and %g nm: %.1f\n",
rmin,rmax,nav);
if (ntot > 0) {
sum1 /= ntot;
sum2 /= ntot;
fprintf(stderr,"Average cos(theta1) between %g and %g nm: %6.3f\n",
rmin,rmax,sum1);
fprintf(stderr,"Average 3cos2(theta2)-1 between %g and %g nm: %6.3f\n",
rmin,rmax,sum2);
}
sprintf(str,"Solvent orientation between %g and %g nm",rmin,rmax);
fp=xvgropen(opt2fn("-o",NFILE,fnm),
str,"cos(\\8q\\4\\s1\\N)","");
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"average shell size %.1f molecules\"\n",nav);
for(i=0; i<nbin1; i++) {
fprintf(fp,"%g %g\n",(i+0.5)*binwidth-1,2*normfac*hist1[i]);
}
fclose(fp);
sprintf(str,"Solvent normal orientation between %g and %g nm",rmin,rmax);
fp=xvgropen(opt2fn("-no",NFILE,fnm),
str,"cos(\\8q\\4\\s2\\N)","");
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"average shell size %.1f molecules\"\n",nav);
for(i=0; i<nbin2; i++) {
fprintf(fp,"%g %g\n",(i+0.5)*binwidth,normfac*hist2[i]);
}
fclose(fp);
sprintf(str,"Solvent orientation");
fp=xvgropen(opt2fn("-ro",NFILE,fnm),str,"r (nm)","");
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"as a function of distance\"\n");
xvgr_legend(fp,2,legr);
for(i=0; i<nrbin; i++)
fprintf(fp,"%g %g %g\n",(i+0.5)*rbinw,
histn[i] ? histi1[i]/histn[i] : 0,
histn[i] ? histi2[i]/histn[i] : 0);
fclose(fp);
sprintf(str,"Cumulative solvent orientation");
fp=xvgropen(opt2fn("-co",NFILE,fnm),str,"r (nm)","");
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"as a function of distance\"\n");
xvgr_legend(fp,2,legc);
normfac = 1.0/(nrefgrp*nf);
c1 = 0;
c2 = 0;
fprintf(fp,"%g %g %g\n",0.0,c1,c2);
for(i=0; i<nrbin; i++) {
c1 += histi1[i]*normfac;
c2 += histi2[i]*normfac;
fprintf(fp,"%g %g %g\n",(i+1)*rbinw,c1,c2);
}
fclose(fp);
sprintf(str,"Solvent distribution");
fp=xvgropen(opt2fn("-rc",NFILE,fnm),str,"r (nm)","molecules/nm");
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"as a function of distance\"\n");
normfac = 1.0/(rbinw*nf);
for(i=0; i<nrbin; i++) {
fprintf(fp,"%g %g\n",(i+0.5)*rbinw,histn[i]*normfac);
}
fclose(fp);
do_view(opt2fn("-o",NFILE,fnm),NULL);
do_view(opt2fn("-no",NFILE,fnm),NULL);
do_view(opt2fn("-ro",NFILE,fnm),"-nxy");
do_view(opt2fn("-co",NFILE,fnm),"-nxy");
thanx(stderr);
return 0;
}
int gmx_rmsf(int argc,char *argv[])
{
static char *desc[] = {
"g_rmsf computes the root mean square fluctuation (RMSF, i.e. standard ",
"deviation) of atomic positions ",
"after (optionally) fitting to a reference frame.[PAR]",
"With option [TT]-oq[tt] the RMSF values are converted to B-factor",
"values, which are written to a pdb file with the coordinates, of the",
"structure file, or of a pdb file when [TT]-q[tt] is specified.",
"Option [TT]-ox[tt] writes the B-factors to a file with the average",
"coordinates.[PAR]",
"With the option [TT]-od[tt] the root mean square deviation with",
"respect to the reference structure is calculated.[PAR]",
"With the option [TT]aniso[tt] g_rmsf will compute anisotropic",
"temperature factors and then it will also output average coordinates",
"and a pdb file with ANISOU records (corresonding to the [TT]-oq[tt]",
"or [TT]-ox[tt] option). Please note that the U values",
"are orientation dependent, so before comparison with experimental data",
"you should verify that you fit to the experimental coordinates.[PAR]",
"When a pdb input file is passed to the program and the [TT]-aniso[tt]",
"flag is set",
"a correlation plot of the Uij will be created, if any anisotropic",
"temperature factors are present in the pdb file.[PAR]",
"With option [TT]-dir[tt] the average MSF (3x3) matrix is diagonalized.",
"This shows the directions in which the atoms fluctuate the most and",
"the least."
};
static bool bRes=FALSE,bAniso=FALSE,bdevX=FALSE,bFit=TRUE;
t_pargs pargs[] = {
{ "-res", FALSE, etBOOL, {&bRes},
"Calculate averages for each residue" },
{ "-aniso",FALSE, etBOOL, {&bAniso},
"Compute anisotropic termperature factors" },
{ "-fit", FALSE, etBOOL, {&bFit},
"Do a least squares superposition before computing RMSF. Without this you must make sure that the reference structure and the trajectory match." }
};
int step,nre,natom,natoms,i,g,m,teller=0;
real t,lambda,*w_rls,*w_rms;
t_tpxheader header;
t_inputrec ir;
t_topology top;
int ePBC;
t_atoms *pdbatoms,*refatoms;
bool bCont;
matrix box,pdbbox;
rvec *x,*pdbx,*xref;
int status,npdbatoms,res0;
char buf[256],*label;
char title[STRLEN];
FILE *fp; /* the graphics file */
char *devfn,*dirfn;
int resnr;
bool bReadPDB;
atom_id *index;
int isize;
char *grpnames;
real bfac,pdb_bfac,*Uaver;
double **U,*xav;
atom_id aid;
rvec *rmsd_x=NULL;
real *rmsf,invcount,totmass;
int d;
real count=0;
rvec xcm;
char *leg[2] = { "MD", "X-Ray" };
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efPDB, "-q", NULL, ffOPTRD },
{ efPDB, "-oq", "bfac", ffOPTWR },
{ efPDB, "-ox", "xaver", ffOPTWR },
{ efXVG, "-o", "rmsf", ffWRITE },
{ efXVG, "-od", "rmsdev", ffOPTWR },
{ efXVG, "-oc", "correl", ffOPTWR },
{ efLOG, "-dir", "rmsf", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_BE_NICE ,
NFILE,fnm,asize(pargs),pargs,asize(desc),desc,0,NULL);
bReadPDB = ftp2bSet(efPDB,NFILE,fnm);
devfn = opt2fn_null("-od",NFILE,fnm);
dirfn = opt2fn_null("-dir",NFILE,fnm);
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xref,NULL,box,TRUE);
snew(w_rls,top.atoms.nr);
fprintf(stderr,"Select group(s) for root mean square calculation\n");
get_index(&top.atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&isize,&index,&grpnames);
/* Set the weight */
for(i=0; i<isize; i++)
w_rls[index[i]]=top.atoms.atom[index[i]].m;
/* Malloc the rmsf arrays */
snew(xav,isize*DIM);
snew(U,isize);
for(i=0; i<isize; i++)
snew(U[i],DIM*DIM);
snew(rmsf,isize);
if (devfn)
snew(rmsd_x, isize);
if (bReadPDB) {
get_stx_coordnum(opt2fn("-q",NFILE,fnm),&npdbatoms);
snew(pdbatoms,1);
snew(refatoms,1);
init_t_atoms(pdbatoms,npdbatoms,TRUE);
init_t_atoms(refatoms,npdbatoms,TRUE);
snew(pdbx,npdbatoms);
/* Read coordinates twice */
read_stx_conf(opt2fn("-q",NFILE,fnm),title,pdbatoms,pdbx,NULL,NULL,pdbbox);
read_stx_conf(opt2fn("-q",NFILE,fnm),title,refatoms,pdbx,NULL,NULL,pdbbox);
} else {
pdbatoms = &top.atoms;
refatoms = &top.atoms;
pdbx = xref;
npdbatoms = pdbatoms->nr;
snew(pdbatoms->pdbinfo,npdbatoms);
copy_mat(box,pdbbox);
}
if (bFit)
sub_xcm(xref,isize,index,top.atoms.atom,xcm,FALSE);
natom = read_first_x(&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
/* Now read the trj again to compute fluctuations */
teller = 0;
do {
if (bFit) {
/* Remove periodic boundary */
rm_pbc(&(top.idef),ePBC,natom,box,x,x);
/* Set center of mass to zero */
sub_xcm(x,isize,index,top.atoms.atom,xcm,FALSE);
/* Fit to reference structure */
do_fit(natom,w_rls,xref,x);
}
/* Calculate Anisotropic U Tensor */
for(i=0; i<isize; i++) {
aid = index[i];
for(d=0; d<DIM; d++) {
xav[i*DIM + d] += x[aid][d];
for(m=0; m<DIM; m++)
U[i][d*DIM + m] += x[aid][d]*x[aid][m];
}
}
if (devfn) {
/* Calculate RMS Deviation */
for(i=0;(i<isize);i++) {
aid = index[i];
for(d=0;(d<DIM);d++) {
rmsd_x[i][d] += sqr(x[aid][d]-xref[aid][d]);
}
}
}
count += 1.0;
teller++;
} while(read_next_x(status,&t,natom,x,box));
close_trj(status);
invcount = 1.0/count;
snew(Uaver,DIM*DIM);
totmass = 0;
for(i=0; i<isize; i++) {
for(d=0; d<DIM; d++)
xav[i*DIM + d] *= invcount;
for(d=0; d<DIM; d++)
for(m=0; m<DIM; m++) {
U[i][d*DIM + m] = U[i][d*DIM + m]*invcount
- xav[i*DIM + d]*xav[i*DIM + m];
Uaver[3*d+m] += top.atoms.atom[index[i]].m*U[i][d*DIM + m];
}
totmass += top.atoms.atom[index[i]].m;
}
for(d=0; d<DIM*DIM; d++)
Uaver[d] /= totmass;
if (bAniso) {
for(i=0; i<isize; i++) {
aid = index[i];
pdbatoms->pdbinfo[aid].bAnisotropic = TRUE;
pdbatoms->pdbinfo[aid].uij[U11] = 1e6*U[i][XX*DIM + XX];
pdbatoms->pdbinfo[aid].uij[U22] = 1e6*U[i][YY*DIM + YY];
pdbatoms->pdbinfo[aid].uij[U33] = 1e6*U[i][ZZ*DIM + ZZ];
pdbatoms->pdbinfo[aid].uij[U12] = 1e6*U[i][XX*DIM + YY];
pdbatoms->pdbinfo[aid].uij[U13] = 1e6*U[i][XX*DIM + ZZ];
pdbatoms->pdbinfo[aid].uij[U23] = 1e6*U[i][YY*DIM + ZZ];
}
}
if (bRes) {
average_residues(rmsf,isize,index,w_rls,&top.atoms);
label = "Residue";
} else
label = "Atom";
for(i=0; i<isize; i++)
rmsf[i] = U[i][XX*DIM + XX] + U[i][YY*DIM + YY] + U[i][ZZ*DIM + ZZ];
if (dirfn) {
fprintf(stdout,"\n");
print_dir(stdout,Uaver);
fp = ffopen(dirfn,"w");
print_dir(fp,Uaver);
fclose(fp);
}
for(i=0; i<isize; i++)
sfree(U[i]);
sfree(U);
/* Write RMSF output */
if (bReadPDB) {
bfac = 8.0*M_PI*M_PI/3.0*100;
fp = xvgropen(ftp2fn(efXVG,NFILE,fnm),"B-Factors",
label,"(A\\b\\S\\So\\N\\S2\\N)");
xvgr_legend(fp,2,leg);
for(i=0;(i<isize);i++) {
if (!bRes || i+1==isize ||
top.atoms.atom[index[i]].resnr!=top.atoms.atom[index[i+1]].resnr) {
resnr = top.atoms.atom[index[i]].resnr;
pdb_bfac = find_pdb_bfac(pdbatoms,*(top.atoms.resname[resnr]),resnr,
*(top.atoms.atomname[index[i]]));
fprintf(fp,"%5d %10.5f %10.5f\n",
bRes ? top.atoms.atom[index[i]].resnr+1 : i+1,rmsf[i]*bfac,
pdb_bfac);
}
}
fclose(fp);
} else {
fp = xvgropen(ftp2fn(efXVG,NFILE,fnm),"RMS fluctuation",label,"(nm)");
for(i=0; i<isize; i++)
if (!bRes || i+1==isize ||
top.atoms.atom[index[i]].resnr!=top.atoms.atom[index[i+1]].resnr)
fprintf(fp,"%5d %8.4f\n",
bRes ? top.atoms.atom[index[i]].resnr+1 : i+1,sqrt(rmsf[i]));
fclose(fp);
}
for(i=0; i<isize; i++)
pdbatoms->pdbinfo[index[i]].bfac = 800*M_PI*M_PI/3.0*rmsf[i];
if (devfn) {
for(i=0; i<isize; i++)
rmsf[i] = (rmsd_x[i][XX]+rmsd_x[i][YY]+rmsd_x[i][ZZ])/count;
if (bRes)
average_residues(rmsf,isize,index,w_rls,&top.atoms);
/* Write RMSD output */
fp = xvgropen(devfn,"RMS Deviation",label,"(nm)");
for(i=0; i<isize; i++)
if (!bRes || i+1==isize ||
top.atoms.atom[index[i]].resnr!=top.atoms.atom[index[i+1]].resnr)
fprintf(fp,"%5d %8.4f\n",
bRes ? top.atoms.atom[index[i]].resnr+1 : i+1,sqrt(rmsf[i]));
fclose(fp);
}
if (opt2bSet("-oq",NFILE,fnm)) {
/* Write a pdb file with B-factors and optionally anisou records */
for(i=0; i<isize; i++)
rvec_inc(xref[index[i]],xcm);
write_sto_conf_indexed(opt2fn("-oq",NFILE,fnm),title,pdbatoms,pdbx,
NULL,ePBC,pdbbox,isize,index);
}
if (opt2bSet("-ox",NFILE,fnm)) {
/* Misuse xref as a temporary array */
for(i=0; i<isize; i++)
for(d=0; d<DIM; d++)
xref[index[i]][d] = xcm[d] + xav[i*DIM + d];
/* Write a pdb file with B-factors and optionally anisou records */
write_sto_conf_indexed(opt2fn("-ox",NFILE,fnm),title,pdbatoms,xref,NULL,
ePBC,pdbbox,isize,index);
}
if (bAniso) {
correlate_aniso(opt2fn("-oc",NFILE,fnm),refatoms,pdbatoms);
do_view(opt2fn("-oc",NFILE,fnm),"-nxy");
}
do_view(opt2fn("-o",NFILE,fnm),"-nxy");
if (devfn)
do_view(opt2fn("-od",NFILE,fnm),"-nxy");
thanx(stderr);
return 0;
}
int gmx_spatial(int argc,char *argv[])
{
const char *desc[] = {
"[TT]g_spatial[tt] 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 32,000 atoms and a 50 ns trajectory, the SDF can be generated ",
"in about 30 minutes, with most of the time dedicated to the two runs through ",
"[TT]trjconv[tt] that are required to center everything properly. ",
"This also takes a whole bunch of space (3 copies of the [TT].xtc[tt] 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 arbitrary ",
"Cartesian coordinate. To do that, simply omit the preliminary [TT]trjconv[tt] steps. \n",
"USAGE: \n",
"1. Use [TT]make_ndx[tt] to create a group containing the atoms around which you want the SDF \n",
"2. [TT]trjconv -s a.tpr -f a.xtc -o b.xtc -center tric -ur compact -pbc none[tt] \n",
"3. [TT]trjconv -s a.tpr -f b.xtc -o c.xtc -fit rot+trans[tt] \n",
"4. run [TT]g_spatial[tt] on the [TT].xtc[tt] output of step #3. \n",
"5. Load [TT]grid.cube[tt] into VMD and view as an isosurface. \n",
"[BB]Note[bb] that systems such as micelles will require [TT]trjconv -pbc cluster[tt] between steps 1 and 2\n",
"WARNINGS:[BR]",
"The SDF will be generated for a cube that contains all bins that have some non-zero occupancy. ",
"However, the preparatory [TT]-fit rot+trans[tt] option to [TT]trjconv[tt] 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:[BR]",
"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 [TT]-nab[tt] (Number of Additional Bins)",
"option. However, the program does not detect all such events. If you encounter a segmentation fault, run it again ",
"with an increased [TT]-nab[tt] value. \n",
"RISKY OPTIONS:[BR]",
"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 [TT]trjconv[tt]. ",
"However, be sure to set the [TT]-nab[tt] option to a sufficiently high value since ",
"memory is allocated for cube bins based on the initial coordinates and the [TT]-nab[tt] ",
"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 ([TT]-nodiv[tt]) 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;
}
