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_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_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 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_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;
}
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_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_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_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;
}
extern int do_scattering_intensity (const char* fnTPS, const char* fnNDX,
const char* fnXVG, const char *fnTRX,
const char* fnDAT,
real start_q, real end_q,
real energy, int ng, const output_env_t oenv)
{
int i, *isize, flags = TRX_READ_X, **index_atp;
t_trxstatus *status;
char **grpname, title[STRLEN];
atom_id **index;
t_topology top;
int ePBC;
t_trxframe fr;
reduced_atom_t **red;
structure_factor *sf;
rvec *xtop;
real **sf_table;
int nsftable;
matrix box;
double r_tmp;
gmx_structurefactors_t *gmx_sf;
real *a, *b, c;
int success;
snew(a, 4);
snew(b, 4);
gmx_sf = gmx_structurefactors_init(fnDAT);
success = gmx_structurefactors_get_sf(gmx_sf, 0, a, b, &c);
snew (sf, 1);
sf->energy = energy;
/* Read the topology informations */
read_tps_conf (fnTPS, title, &top, &ePBC, &xtop, NULL, box, TRUE);
sfree (xtop);
/* groups stuff... */
snew (isize, ng);
snew (index, ng);
snew (grpname, ng);
fprintf (stderr, "\nSelect %d group%s\n", ng,
ng == 1 ? "" : "s");
if (fnTPS)
{
get_index (&top.atoms, fnNDX, ng, isize, index, grpname);
}
else
{
rd_index (fnNDX, ng, isize, index, grpname);
}
/* The first time we read data is a little special */
read_first_frame (oenv, &status, fnTRX, &fr, flags);
sf->total_n_atoms = fr.natoms;
snew (red, ng);
snew (index_atp, ng);
r_tmp = max (box[XX][XX], box[YY][YY]);
r_tmp = (double) max (box[ZZ][ZZ], r_tmp);
sf->ref_k = (2.0 * M_PI) / (r_tmp);
/* ref_k will be the reference momentum unit */
sf->n_angles = (int) (end_q / sf->ref_k + 0.5);
snew (sf->F, ng);
for (i = 0; i < ng; i++)
{
snew (sf->F[i], sf->n_angles);
}
for (i = 0; i < ng; i++)
{
snew (red[i], isize[i]);
rearrange_atoms (red[i], &fr, index[i], isize[i], &top, TRUE, gmx_sf);
index_atp[i] = create_indexed_atom_type (red[i], isize[i]);
}
sf_table = compute_scattering_factor_table (gmx_sf, (structure_factor_t *)sf);
/* This is the main loop over frames */
do
{
sf->nSteps++;
for (i = 0; i < ng; i++)
{
rearrange_atoms (red[i], &fr, index[i], isize[i], &top, FALSE, gmx_sf);
compute_structure_factor ((structure_factor_t *)sf, box, red[i], isize[i],
start_q, end_q, i, sf_table);
}
}
while (read_next_frame (oenv, status, &fr));
save_data ((structure_factor_t *)sf, fnXVG, ng, start_q, end_q, oenv);
sfree(a);
sfree(b);
gmx_structurefactors_done(gmx_sf);
return 0;
}
int gmx_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_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_confrms(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes the root mean square deviation (RMSD) of two",
"structures after least-squares fitting the second structure on the first one.",
"The two structures do NOT need to have the same number of atoms,",
"only the two index groups used for the fit need to be identical.",
"With [TT]-name[tt] only matching atom names from the selected groups",
"will be used for the fit and RMSD calculation. This can be useful ",
"when comparing mutants of a protein.",
"[PAR]",
"The superimposed structures are written to file. In a [REF].pdb[ref] file",
"the two structures will be written as separate models",
"(use [TT]rasmol -nmrpdb[tt]). Also in a [REF].pdb[ref] file, B-factors",
"calculated from the atomic MSD values can be written with [TT]-bfac[tt].",
};
static gmx_bool bOne = FALSE, bRmpbc = FALSE, bMW = TRUE, bName = FALSE,
bBfac = FALSE, bFit = TRUE, bLabel = FALSE;
t_pargs pa[] = {
{ "-one", FALSE, etBOOL, {&bOne}, "Only write the fitted structure to file" },
{ "-mw", FALSE, etBOOL, {&bMW}, "Mass-weighted fitting and RMSD" },
{ "-pbc", FALSE, etBOOL, {&bRmpbc}, "Try to make molecules whole again" },
{ "-fit", FALSE, etBOOL, {&bFit},
"Do least squares superposition of the target structure to the reference" },
{ "-name", FALSE, etBOOL, {&bName},
"Only compare matching atom names" },
{ "-label", FALSE, etBOOL, {&bLabel},
"Added chain labels A for first and B for second structure"},
{ "-bfac", FALSE, etBOOL, {&bBfac},
"Output B-factors from atomic MSD values" }
};
t_filenm fnm[] = {
{ efTPS, "-f1", "conf1.gro", ffREAD },
{ efSTX, "-f2", "conf2", ffREAD },
{ efSTO, "-o", "fit.pdb", ffWRITE },
{ efNDX, "-n1", "fit1", ffOPTRD },
{ efNDX, "-n2", "fit2", ffOPTRD },
{ efNDX, "-no", "match", ffOPTWR }
};
#define NFILE asize(fnm)
/* the two structure files */
const char *conf1file, *conf2file, *matchndxfile, *outfile;
FILE *fp;
char *name1, *name2;
t_topology *top1, *top2;
int ePBC1, ePBC2;
t_atoms *atoms1, *atoms2;
int warn = 0;
atom_id at;
real *w_rls, mass, totmass;
rvec *x1, *v1, *x2, *v2, *fit_x;
matrix box1, box2;
output_env_t oenv;
/* counters */
int i, m;
/* center of mass calculation */
rvec xcm1, xcm2;
/* variables for fit */
char *groupnames1, *groupnames2;
int isize1, isize2;
atom_id *index1, *index2;
real rms, msd, minmsd, maxmsd;
real *msds;
if (!parse_common_args(&argc, argv, PCA_CAN_VIEW,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
matchndxfile = opt2fn_null("-no", NFILE, fnm);
conf1file = ftp2fn(efTPS, NFILE, fnm);
conf2file = ftp2fn(efSTX, NFILE, fnm);
/* reading reference structure from first structure file */
fprintf(stderr, "\nReading first structure file\n");
snew(top1, 1);
read_tps_conf(conf1file, top1, &ePBC1, &x1, &v1, box1, TRUE);
atoms1 = &(top1->atoms);
fprintf(stderr, "%s\nContaining %d atoms in %d residues\n",
*top1->name, atoms1->nr, atoms1->nres);
if (bRmpbc)
{
rm_gropbc(atoms1, x1, box1);
}
fprintf(stderr, "Select group from first structure\n");
get_index(atoms1, opt2fn_null("-n1", NFILE, fnm),
1, &isize1, &index1, &groupnames1);
printf("\n");
if (bFit && (isize1 < 3))
{
gmx_fatal(FARGS, "Need >= 3 points to fit!\n");
}
/* reading second structure file */
fprintf(stderr, "\nReading second structure file\n");
snew(top2, 1);
read_tps_conf(conf2file, top2, &ePBC2, &x2, &v2, box2, TRUE);
atoms2 = &(top2->atoms);
fprintf(stderr, "%s\nContaining %d atoms in %d residues\n",
*top2->name, atoms2->nr, atoms2->nres);
if (bRmpbc)
{
rm_gropbc(atoms2, x2, box2);
}
fprintf(stderr, "Select group from second structure\n");
get_index(atoms2, opt2fn_null("-n2", NFILE, fnm),
1, &isize2, &index2, &groupnames2);
if (bName)
{
find_matching_names(&isize1, index1, atoms1, &isize2, index2, atoms2);
if (matchndxfile)
{
fp = gmx_ffopen(matchndxfile, "w");
fprintf(fp, "; Matching atoms between %s from %s and %s from %s\n",
groupnames1, conf1file, groupnames2, conf2file);
fprintf(fp, "[ Match_%s_%s ]\n", conf1file, groupnames1);
for (i = 0; i < isize1; i++)
{
fprintf(fp, "%4d%s", index1[i]+1, (i%15 == 14 || i == isize1-1) ? "\n" : " ");
}
fprintf(fp, "[ Match_%s_%s ]\n", conf2file, groupnames2);
for (i = 0; i < isize2; i++)
{
fprintf(fp, "%4d%s", index2[i]+1, (i%15 == 14 || i == isize2-1) ? "\n" : " ");
}
}
}
/* check isizes, must be equal */
if (isize2 != isize1)
{
gmx_fatal(FARGS, "You selected groups with differen number of atoms.\n");
}
for (i = 0; i < isize1; i++)
{
name1 = *atoms1->atomname[index1[i]];
name2 = *atoms2->atomname[index2[i]];
if (std::strcmp(name1, name2))
{
if (warn < 20)
{
fprintf(stderr,
"Warning: atomnames at index %d don't match: %d %s, %d %s\n",
i+1, index1[i]+1, name1, index2[i]+1, name2);
}
warn++;
}
if (!bMW)
{
atoms1->atom[index1[i]].m = 1;
atoms2->atom[index2[i]].m = 1;
}
}
if (warn)
{
fprintf(stderr, "%d atomname%s did not match\n", warn, (warn == 1) ? "" : "s");
}
if (bFit)
{
/* calculate and remove center of mass of structures */
calc_rm_cm(isize1, index1, atoms1, x1, xcm1);
calc_rm_cm(isize2, index2, atoms2, x2, xcm2);
snew(w_rls, atoms2->nr);
snew(fit_x, atoms2->nr);
for (at = 0; (at < isize1); at++)
{
w_rls[index2[at]] = atoms1->atom[index1[at]].m;
copy_rvec(x1[index1[at]], fit_x[index2[at]]);
}
/* do the least squares fit to the reference structure */
do_fit(atoms2->nr, w_rls, fit_x, x2);
sfree(fit_x);
sfree(w_rls);
w_rls = NULL;
}
else
{
clear_rvec(xcm1);
clear_rvec(xcm2);
w_rls = NULL;
}
/* calculate the rms deviation */
rms = 0;
totmass = 0;
maxmsd = -1e18;
minmsd = 1e18;
snew(msds, isize1);
for (at = 0; at < isize1; at++)
{
mass = atoms1->atom[index1[at]].m;
for (m = 0; m < DIM; m++)
{
msd = sqr(x1[index1[at]][m] - x2[index2[at]][m]);
rms += msd*mass;
msds[at] += msd;
}
maxmsd = std::max(maxmsd, msds[at]);
minmsd = std::min(minmsd, msds[at]);
totmass += mass;
}
rms = std::sqrt(rms/totmass);
printf("Root mean square deviation after lsq fit = %g nm\n", rms);
if (bBfac)
{
printf("Atomic MSD's range from %g to %g nm^2\n", minmsd, maxmsd);
}
if (bFit)
{
/* reset coordinates of reference and fitted structure */
for (i = 0; i < atoms1->nr; i++)
{
for (m = 0; m < DIM; m++)
{
x1[i][m] += xcm1[m];
}
}
for (i = 0; i < atoms2->nr; i++)
{
for (m = 0; m < DIM; m++)
{
x2[i][m] += xcm1[m];
}
}
}
outfile = ftp2fn(efSTO, NFILE, fnm);
switch (fn2ftp(outfile))
{
case efPDB:
case efBRK:
case efENT:
if (bBfac || bLabel)
{
srenew(atoms1->pdbinfo, atoms1->nr);
srenew(atoms1->atom, atoms1->nr); /* Why renew atom? */
/* Avoid segfaults when writing the pdb-file */
for (i = 0; i < atoms1->nr; i++)
{
atoms1->pdbinfo[i].type = eptAtom;
atoms1->pdbinfo[i].occup = 1.00;
atoms1->pdbinfo[i].bAnisotropic = FALSE;
if (bBfac)
{
atoms1->pdbinfo[i].bfac = 0;
}
if (bLabel)
{
atoms1->resinfo[atoms1->atom[i].resind].chainid = 'A';
}
}
for (i = 0; i < isize1; i++)
{
/* atoms1->pdbinfo[index1[i]].type = eptAtom; */
/* atoms1->pdbinfo[index1[i]].bAnisotropic = FALSE; */
if (bBfac)
{
atoms1->pdbinfo[index1[i]].bfac = (800*M_PI*M_PI/3.0)*msds[i];
}
/* if (bLabel) */
/* atoms1->resinfo[atoms1->atom[index1[i]].resind].chain = 'A'; */
}
srenew(atoms2->pdbinfo, atoms2->nr);
srenew(atoms2->atom, atoms2->nr); /* Why renew atom? */
for (i = 0; i < atoms2->nr; i++)
{
atoms2->pdbinfo[i].type = eptAtom;
atoms2->pdbinfo[i].occup = 1.00;
atoms2->pdbinfo[i].bAnisotropic = FALSE;
if (bBfac)
{
atoms2->pdbinfo[i].bfac = 0;
}
if (bLabel)
{
atoms2->resinfo[atoms1->atom[i].resind].chainid = 'B';
}
}
for (i = 0; i < isize2; i++)
{
/* atoms2->pdbinfo[index2[i]].type = eptAtom; */
/* atoms2->pdbinfo[index2[i]].bAnisotropic = FALSE; */
if (bBfac)
{
atoms2->pdbinfo[index2[i]].bfac = (800*M_PI*M_PI/3.0)*msds[i];
}
/* if (bLabel) */
/* atoms2->resinfo[atoms2->atom[index2[i]].resind].chain = 'B'; */
}
}
fp = gmx_ffopen(outfile, "w");
if (!bOne)
{
write_pdbfile(fp, *top1->name, atoms1, x1, ePBC1, box1, ' ', 1, NULL, TRUE);
}
write_pdbfile(fp, *top2->name, atoms2, x2, ePBC2, box2, ' ', bOne ? -1 : 2, NULL, TRUE);
gmx_ffclose(fp);
break;
case efGRO:
if (bBfac)
{
fprintf(stderr, "WARNING: cannot write B-factor values to gro file\n");
}
fp = gmx_ffopen(outfile, "w");
if (!bOne)
{
write_hconf_p(fp, *top1->name, atoms1, 3, x1, v1, box1);
}
write_hconf_p(fp, *top2->name, atoms2, 3, x2, v2, box2);
gmx_ffclose(fp);
break;
default:
if (bBfac)
{
fprintf(stderr, "WARNING: cannot write B-factor values to %s file\n",
ftp2ext(fn2ftp(outfile)));
}
if (!bOne)
{
fprintf(stderr,
"WARNING: cannot write the reference structure to %s file\n",
ftp2ext(fn2ftp(outfile)));
}
write_sto_conf(outfile, *top2->name, atoms2, x2, v2, ePBC2, box2);
break;
}
view_all(oenv, NFILE, fnm);
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_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_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_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_trjorder(int argc,char *argv[])
{
const char *desc[] = {
"[TT]trjorder[tt] 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]",
"[TT]trjorder[tt] 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)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL,&oenv);
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,box);
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,natoms,x,box));
close_trj(status);
if (out)
close_trx(out);
if (fp)
ffclose(fp);
gmx_rmpbc_done(gpbc);
thanx(stderr);
return 0;
}
int gmx_nmeig(int argc,char *argv[])
{
const char *desc[] = {
"g_nmeig calculates the eigenvectors/values of a (Hessian) matrix,",
"which can be calculated with [TT]mdrun[tt].",
"The eigenvectors are written to a trajectory file ([TT]-v[tt]).",
"The structure is written first with t=0. The eigenvectors",
"are written as frames with the eigenvector number as timestamp.",
"The eigenvectors can be analyzed with [TT]g_anaeig[tt].",
"An ensemble of structures can be generated from the eigenvectors with",
"[TT]g_nmens[tt]. When mass weighting is used, the generated eigenvectors",
"will be scaled back to plain cartesian coordinates before generating the",
"output - in this case they will no longer be exactly orthogonal in the",
"standard cartesian norm (But in the mass weighted norm they would be)."
};
static bool bM=TRUE;
static int begin=1,end=50;
t_pargs pa[] =
{
{ "-m", FALSE, etBOOL, {&bM},
"Divide elements of Hessian by product of sqrt(mass) of involved "
"atoms prior to diagonalization. This should be used for 'Normal Modes' "
"analysis" },
{ "-first", FALSE, etINT, {&begin},
"First eigenvector to write away" },
{ "-last", FALSE, etINT, {&end},
"Last eigenvector to write away" }
};
FILE *out;
int status,trjout;
t_topology top;
int ePBC;
rvec *top_x;
matrix box;
real *eigenvalues;
real *eigenvectors;
real rdum,mass_fac;
int natoms,ndim,nrow,ncol,count;
char *grpname,title[256];
int i,j,k,l,d,gnx;
bool bSuck;
atom_id *index;
real value;
real factor_gmx_to_omega2;
real factor_omega_to_wavenumber;
t_commrec *cr;
real * full_hessian = NULL;
gmx_sparsematrix_t * sparse_hessian = NULL;
t_filenm fnm[] = {
{ efMTX, "-f", "hessian", ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efXVG, "-of", "eigenfreq", ffWRITE },
{ efXVG, "-ol", "eigenval", ffWRITE },
{ efTRN, "-v", "eigenvec", ffWRITE }
};
#define NFILE asize(fnm)
cr = init_par(&argc,&argv);
if(MASTER(cr))
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_BE_NICE | (MASTER(cr) ? 0 : PCA_QUIET),
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL);
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&top_x,NULL,box,bM);
natoms = top.atoms.nr;
ndim = DIM*natoms;
if(begin<1)
begin = 1;
if(end>ndim)
end = ndim;
/*open Hessian matrix */
gmx_mtxio_read(ftp2fn(efMTX,NFILE,fnm),&nrow,&ncol,&full_hessian,&sparse_hessian);
/* Memory for eigenvalues and eigenvectors (begin..end) */
snew(eigenvalues,nrow);
snew(eigenvectors,nrow*(end-begin+1));
/* If the Hessian is in sparse format we can calculate max (ndim-1) eigenvectors,
* and they must start at the first one. If this is not valid we convert to full matrix
* storage, but warn the user that we might run out of memory...
*/
if((sparse_hessian != NULL) && (begin!=1 || end==ndim))
{
if(begin!=1)
{
fprintf(stderr,"Cannot use sparse Hessian with first eigenvector != 1.\n");
}
else if(end==ndim)
{
fprintf(stderr,"Cannot use sparse Hessian to calculate all eigenvectors.\n");
}
fprintf(stderr,"Will try to allocate memory and convert to full matrix representation...\n");
snew(full_hessian,nrow*ncol);
for(i=0;i<nrow*ncol;i++)
full_hessian[i] = 0;
for(i=0;i<sparse_hessian->nrow;i++)
{
for(j=0;j<sparse_hessian->ndata[i];j++)
{
k = sparse_hessian->data[i][j].col;
value = sparse_hessian->data[i][j].value;
full_hessian[i*ndim+k] = value;
full_hessian[k*ndim+i] = value;
}
}
gmx_sparsematrix_destroy(sparse_hessian);
sparse_hessian = NULL;
fprintf(stderr,"Converted sparse to full matrix storage.\n");
}
if(full_hessian != NULL)
{
/* Using full matrix storage */
nma_full_hessian(full_hessian,nrow,bM,&top,begin,end,eigenvalues,eigenvectors);
}
else
{
/* Sparse memory storage, allocate memory for eigenvectors */
snew(eigenvectors,ncol*end);
nma_sparse_hessian(sparse_hessian,bM,&top,end,eigenvalues,eigenvectors);
}
/* check the output, first 6 eigenvalues should be reasonably small */
bSuck=FALSE;
for (i=begin-1; (i<6); i++)
{
if (fabs(eigenvalues[i]) > 1.0e-3)
bSuck=TRUE;
}
if (bSuck)
{
fprintf(stderr,"\nOne of the lowest 6 eigenvalues has a non-zero value.\n");
fprintf(stderr,"This could mean that the reference structure was not\n");
fprintf(stderr,"properly energy minimized.\n");
}
/* now write the output */
fprintf (stderr,"Writing eigenvalues...\n");
out=xvgropen(opt2fn("-ol",NFILE,fnm),
"Eigenvalues","Eigenvalue index","Eigenvalue [Gromacs units]");
if (bPrintXvgrCodes()) {
if (bM)
fprintf(out,"@ subtitle \"mass weighted\"\n");
else
fprintf(out,"@ subtitle \"not mass weighted\"\n");
}
for (i=0; i<=(end-begin); i++)
fprintf (out,"%6d %15g\n",begin+i,eigenvalues[i]);
fclose(out);
fprintf(stderr,"Writing eigenfrequencies - negative eigenvalues will be set to zero.\n");
out=xvgropen(opt2fn("-of",NFILE,fnm),
"Eigenfrequencies","Eigenvector index","Wavenumber [cm\\S-1\\N]");
if (bPrintXvgrCodes()) {
if (bM)
fprintf(out,"@ subtitle \"mass weighted\"\n");
else
fprintf(out,"@ subtitle \"not mass weighted\"\n");
}
/* Gromacs units are kJ/(mol*nm*nm*amu),
* where amu is the atomic mass unit.
*
* For the eigenfrequencies we want to convert this to spectroscopic absorption
* wavenumbers given in cm^(-1), which is the frequency divided by the speed of
* light. Do this by first converting to omega^2 (units 1/s), take the square
* root, and finally divide by the speed of light (nm/ps in gromacs).
*/
factor_gmx_to_omega2 = 1.0E21/(AVOGADRO*AMU);
factor_omega_to_wavenumber = 1.0E-5/(2.0*M_PI*SPEED_OF_LIGHT);
for (i=0; i<=(end-begin); i++)
{
value = eigenvalues[i];
if(value < 0)
value = 0;
value=sqrt(value*factor_gmx_to_omega2)*factor_omega_to_wavenumber;
fprintf (out,"%6d %15g\n",begin+i,value);
}
fclose(out);
/* Writing eigenvectors. Note that if mass scaling was used, the eigenvectors
* were scaled back from mass weighted cartesian to plain cartesian in the
* nma_full_hessian() or nma_sparse_hessian() routines. Mass scaled vectors
* will not be strictly orthogonal in plain cartesian scalar products.
*/
write_eigenvectors(opt2fn("-v",NFILE,fnm),natoms,eigenvectors,FALSE,begin,end,
eWXR_NO,NULL,FALSE,top_x,bM,eigenvalues);
thanx(stderr);
return 0;
}