int gmx_rdf(int argc,char *argv[])
{
static char *desc[] = {
"The structure of liquids can be studied by either neutron or X-ray",
"scattering. The most common way to describe liquid structure is by a",
"radial distribution function. However, this is not easy to obtain from",
"a scattering experiment.[PAR]",
"g_rdf calculates radial distribution functions in different ways.",
"The normal method is around a (set of) particle(s), the other method",
"is around the center of mass of a set of particles.",
"With both methods rdf's can also be calculated around axes parallel",
"to the z-axis with option [TT]-xy[tt].[PAR]",
"The option [TT]-rdf[tt] sets the type of rdf to be computed.",
"Default is for atoms or particles, but one can also select center",
"of mass or geometry of molecules or residues. In all cases only",
"the atoms in the index groups are taken into account.",
"For molecules and/or the center of mass option a run input file",
"is required.",
"Other weighting than COM or COG can currently only be achieved",
"by providing a run input file with different masses.",
"Option [TT]-com[tt] also works in conjunction with [TT]-rdf[tt].[PAR]"
"If a run input file is supplied ([TT]-s[tt]) and [TT]-rdf[tt] is set",
"to [TT]atom[tt], exclusions defined",
"in that file are taken into account when calculating the rdf.",
"The option [TT]-cut[tt] is meant as an alternative way to avoid",
"intramolecular peaks in the rdf plot.",
"It is however better to supply a run input file with a higher number of",
"exclusions. For eg. benzene a topology with nrexcl set to 5",
"would eliminate all intramolecular contributions to the rdf.",
"Note that all atoms in the selected groups are used, also the ones",
"that don't have Lennard-Jones interactions.[PAR]",
"Option [TT]-cn[tt] produces the cumulative number rdf,",
"i.e. the average number of particles within a distance r.[PAR]",
"To bridge the gap between theory and experiment structure factors can",
"be computed (option [TT]-sq[tt]). The algorithm uses FFT, the grid"
"spacing of which is determined by option [TT]-grid[tt]."
};
static bool bCM=FALSE,bXY=FALSE,bPBC=TRUE,bNormalize=TRUE;
static real cutoff=0,binwidth=0.002,grid=0.05,fade=0.0,lambda=0.1,distance=10;
static int npixel=256,nlevel=20,ngroups=1;
static real start_q=0.0, end_q=60.0, energy=12.0;
static char *rdft[]={ NULL, "atom", "mol_com", "mol_cog", "res_com", "res_cog", NULL };
t_pargs pa[] = {
{ "-bin", FALSE, etREAL, {&binwidth},
"Binwidth (nm)" },
{ "-com", FALSE, etBOOL, {&bCM},
"RDF with respect to the center of mass of first group" },
{ "-rdf", FALSE, etENUM, {rdft},
"RDF type" },
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Use periodic boundary conditions for computing distances. Without PBC the maximum range will be three times the larges box edge." },
{ "-norm", FALSE, etBOOL, {&bNormalize},
"Normalize for volume and density" },
{ "-xy", FALSE, etBOOL, {&bXY},
"Use only the x and y components of the distance" },
{ "-cut", FALSE, etREAL, {&cutoff},
"Shortest distance (nm) to be considered"},
{ "-ng", FALSE, etINT, {&ngroups},
"Number of secondary groups to compute RDFs around a central group" },
{ "-fade", FALSE, etREAL, {&fade},
"From this distance onwards the RDF is tranformed by g'(r) = 1 + [g(r)-1] exp(-(r/fade-1)^2 to make it go to 1 smoothly. If fade is 0.0 nothing is done." },
{ "-grid", FALSE, etREAL, {&grid},
"[HIDDEN]Grid spacing (in nm) for FFTs when computing structure factors" },
{ "-npixel", FALSE, etINT, {&npixel},
"[HIDDEN]# pixels per edge of the square detector plate" },
{ "-nlevel", FALSE, etINT, {&nlevel},
"Number of different colors in the diffraction image" },
{ "-distance", FALSE, etREAL, {&distance},
"[HIDDEN]Distance (in cm) from the sample to the detector" },
{ "-wave", FALSE, etREAL, {&lambda},
"[HIDDEN]Wavelength for X-rays/Neutrons for scattering. 0.1 nm corresponds to roughly 12 keV" },
{"-startq", FALSE, etREAL, {&start_q},
"Starting q (1/nm) "},
{"-endq", FALSE, etREAL, {&end_q},
"Ending q (1/nm)"},
{"-energy", FALSE, etREAL, {&energy},
"Energy of the incoming X-ray (keV) "}
};
#define NPA asize(pa)
char *fnTPS,*fnNDX;
bool bSQ,bRDF;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-o", "rdf", ffOPTWR },
{ efXVG, "-sq", "sq", ffOPTWR },
{ efXVG, "-cn", "rdf_cn", ffOPTWR },
{ efXVG, "-hq", "hq", ffOPTWR },
/* { efXPM, "-image", "sq", ffOPTWR }*/
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_VIEW | PCA_CAN_TIME | PCA_BE_NICE,
NFILE,fnm,NPA,pa,asize(desc),desc,0,NULL);
bSQ = opt2bSet("-sq",NFILE,fnm);
bRDF = opt2bSet("-o",NFILE,fnm) || !bSQ;
if (bSQ || bCM || rdft[0][0]=='m' || rdft[0][6]=='m') {
fnTPS = ftp2fn(efTPS,NFILE,fnm);
} else {
fnTPS = ftp2fn_null(efTPS,NFILE,fnm);
}
fnNDX = ftp2fn_null(efNDX,NFILE,fnm);
if (!bSQ && (!fnTPS && !fnNDX))
gmx_fatal(FARGS,"Neither index file nor topology file specified\n"
"Nothing to do!");
if (bSQ)
do_scattering_intensity(fnTPS,fnNDX,opt2fn("-sq",NFILE,fnm),ftp2fn(efTRX,NFILE,fnm),
start_q, end_q, energy, ngroups );
if (bRDF)
do_rdf(fnNDX,fnTPS,ftp2fn(efTRX,NFILE,fnm),
opt2fn("-o",NFILE,fnm),opt2fn_null("-cn",NFILE,fnm),
opt2fn_null("-hq",NFILE,fnm),
bCM,rdft,bXY,bPBC,bNormalize,cutoff,binwidth,fade,ngroups);
thanx(stderr);
return 0;
}
int gmx_sdf(int argc,char *argv[])
{
const char *desc[] = {
"g_sdf calculates the spatial distribution function (SDF) of a set of atoms",
"within a coordinate system defined by three atoms. There is single body, ",
"two body and three body SDF implemented (select with option -mode). ",
"In the single body case the local coordinate system is defined by using",
"a triple of atoms from one single molecule, for the two and three body case",
"the configurations are dynamically searched complexes of two or three",
"molecules (or residues) meeting certain distance consitions (see below).[PAR]",
"The program needs a trajectory, a GROMACS run input file and an index ",
"file to work. ",
"You have to setup 4 groups in the index file before using g_sdf: [PAR]",
"The first three groups are used to define the SDF coordinate system.",
"The programm will dynamically generate the atom tripels according to ",
"the selected -mode: ",
"In -mode 1 the triples will be just the 1st, 2nd, 3rd, ... atoms from ",
"groups 1, 2 and 3. Hence the nth entries in groups 1, 2 and 3 must be from the",
"same residue. In -mode 2 the triples will be 1st, 2nd, 3rd, ... atoms from",
"groups 1 and 2 (with the nth entries in groups 1 and 2 having the same res-id).",
"For each pair from groups 1 and 2 group 3 is searched for an atom meeting the",
"distance conditions set with -triangle and -dtri relative to atoms 1 and 2. In",
"-mode 3 for each atom in group 1 group 2 is searched for an atom meeting the",
"distance condition and if a pair is found group 3 is searched for an atom",
"meeting the further conditions. The triple will only be used if all three atoms",
"have different res-id's.[PAR]",
"The local coordinate system is always defined using the following scheme:",
"Atom 1 will be used as the point of origin for the SDF. "
"Atom 1 and 2 will define the principle axis (Z) of the coordinate system.",
"The other two axis will be defined inplane (Y) and normal (X) to the plane through",
"Atoms 1, 2 and 3. "
"The fourth group",
"contains the atoms for which the SDF will be evaluated.[PAR]",
"For -mode 2 and 3 you have to define the distance conditions for the ",
"2 resp. 3 molecule complexes to be searched for using -triangle and -dtri.[PAR]",
"The SDF will be sampled in cartesian coordinates.",
"Use '-grid x y z' to define the size of the SDF grid around the ",
"reference molecule. ",
"The Volume of the SDF grid will be V=x*y*z (nm^3). "
"Use -bin to set the binwidth for grid.[PAR]",
"The output will be a binary 3D-grid file (gom_plt.dat) in the .plt format that can be be",
"read directly by gOpenMol. ",
"The option -r will generate a .gro file with the reference molecule(s) transfered to",
"the SDF coordinate system. Load this file into gOpenMol and display the",
"SDF as a contour plot (see http://www.csc.fi/gopenmol/index.phtml for ",
"further documentation). [PAR]",
"For further information about SDF's have a look at: A. Vishnyakov, JPC A, 105,",
"2001, 1702 and the references cited within."
};
static bool bRef=FALSE;
static int mode=1;
static rvec triangle={0.0,0.0,0.0};
static rvec dtri={0.03,0.03,0.03};
static rvec cutoff={1,1,1};
static real binwidth=0.05;
t_pargs pa[] = {
{ "-mode", FALSE, etINT, {&mode},
"SDF in [1,2,3] particle mode"},
{ "-triangle", FALSE, etRVEC, {&triangle},
"r(1,3), r(2,3), r(1,2)"},
{ "-dtri", FALSE, etRVEC, {&dtri},
"dr(1,3), dr(2,3), dr(1,2)"},
{ "-bin", FALSE, etREAL, {&binwidth},
"Binwidth for the 3D-grid (nm)" },
{ "-grid", FALSE, etRVEC, {&cutoff},
"Size of the 3D-grid (nm,nm,nm)"}
};
#define NPA asize(pa)
char *fnTPS,*fnNDX,*fnREF;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efNDX, NULL, NULL, ffREAD },
{ efTPS, NULL, NULL, ffOPTRD },
{ efDAT, "-o", "gom_plt", ffWRITE },
{ efSTO, "-r", "refmol", ffOPTWR },
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_BE_NICE,
NFILE,fnm,NPA,pa,asize(desc),desc,0,NULL);
fnTPS = ftp2fn_null(efTPS,NFILE,fnm);
fnNDX = ftp2fn_null(efNDX,NFILE,fnm);
fnREF = opt2fn_null("-r",NFILE,fnm);
bRef = opt2bSet("-r",NFILE,fnm);
if (!fnNDX)
gmx_fatal(FARGS,"No index file specified\n"
" Nothing to do!");
if (!fnTPS)
gmx_fatal(FARGS,"No topology file specified\n"
" Nothing to do!");
if ( bRef && fn2ftp(fnREF) != efGRO)
{
fprintf(stderr,"\nOnly GROMACS format is supported for reference structures.\n");
fprintf(stderr,"Option -r will be ignored!\n");
bRef = FALSE;
}
if (mode < 1 || mode > 3)
gmx_fatal(FARGS,"Wrong -mode selection. Chose 1-, 2- oder 3-praticle mode.\n");
do_sdf(fnNDX,fnTPS,ftp2fn(efTRX,NFILE,fnm),opt2fn("-o",NFILE,fnm),
fnREF,bRef,cutoff,binwidth,mode,triangle,dtri);
thanx(stderr);
return 0;
}
int gmx_sgangle(int argc,char *argv[])
{
static char *desc[] = {
"Compute the angle and distance between two groups. ",
"The groups are defined by a number of atoms given in an index file and",
"may be two or three atoms in size.",
"If -one is set, only one group should be specified in the index",
"file and the angle between this group at time 0 and t will be computed.",
"The angles calculated depend on the order in which the atoms are ",
"given. Giving for instance 5 6 will rotate the vector 5-6 with ",
"180 degrees compared to giving 6 5. [PAR]If three atoms are given, ",
"the normal on the plane spanned by those three atoms will be",
"calculated, using the formula P1P2 x P1P3.",
"The cos of the angle is calculated, using the inproduct of the two",
"normalized vectors.[PAR]",
"Here is what some of the file options do:[BR]",
"-oa: Angle between the two groups specified in the index file. If a group contains three atoms the normal to the plane defined by those three atoms will be used. If a group contains two atoms, the vector defined by those two atoms will be used.[BR]",
"-od: Distance between two groups. Distance is taken from the center of one group to the center of the other group.[BR]",
"-od1: If one plane and one vector is given, the distances for each of the atoms from the center of the plane is given seperately.[BR]",
"-od2: For two planes this option has no meaning."
};
char *fna, *fnd, *fnd1, *fnd2;
char *grpname[2]; /* name of the two groups */
int gnx[2]; /* size of the two groups */
t_topology *top; /* topology */
int ePBC;
atom_id *index[2];
static bool bOne = FALSE, bZ=FALSE;
t_pargs pa[] = {
{ "-one", FALSE, etBOOL, {&bOne},
"Only one group compute angle between vector at time zero and time t"},
{ "-z", FALSE, etBOOL, {&bZ},
"Use the Z-axis as reference" }
};
#define NPA asize(pa)
t_filenm fnm[] = { /* files for g_sgangle */
{ efTRX, "-f", NULL, ffREAD }, /* trajectory file */
{ efNDX, NULL, NULL, ffREAD }, /* index file */
{ efTPX, NULL, NULL, ffREAD }, /* topology file */
{ efXVG,"-oa","sg_angle",ffWRITE }, /* xvgr output file */
{ efXVG, "-od","sg_dist",ffOPTWR }, /* xvgr output file */
{ efXVG, "-od1", "sg_dist1",ffOPTWR }, /* xvgr output file */
{ efXVG, "-od2", "sg_dist2",ffOPTWR } /* xvgr output file */
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_VIEW | PCA_CAN_TIME | PCA_BE_NICE,
NFILE,fnm,NPA,pa,asize(desc),desc,0,NULL);
top = read_top(ftp2fn(efTPX,NFILE,fnm),&ePBC); /* read topology file */
fna = opt2fn("-oa",NFILE,fnm);
fnd = opt2fn_null("-od",NFILE,fnm);
fnd1 = opt2fn_null("-od1",NFILE,fnm);
fnd2 = opt2fn_null("-od2",NFILE,fnm);
/* read index file. */
if(bOne) {
rd_index(ftp2fn(efNDX,NFILE,fnm),1,gnx,index,grpname);
print_types(index[0],gnx[0],grpname[0],
index[0],gnx[0],grpname[0],top);
sgangle_plot_single(ftp2fn(efTRX,NFILE,fnm), fna, fnd, fnd1, fnd2,
index[0],gnx[0],grpname[0],
index[0],gnx[0],grpname[0],
top,ePBC);
} else {
rd_index(ftp2fn(efNDX,NFILE,fnm),bZ ? 1 : 2,gnx,index,grpname);
if (!bZ)
print_types(index[0],gnx[0],grpname[0],
index[1],gnx[1],grpname[1],top);
else {
gnx[1] = 0;
grpname[1] = "Z-axis";
}
sgangle_plot(ftp2fn(efTRX,NFILE,fnm), fna, fnd, fnd1, fnd2,
index[0],gnx[0],grpname[0],
index[1],gnx[1],grpname[1],
top,ePBC);
}
do_view(fna,"-nxy"); /* view xvgr file */
do_view(fnd,"-nxy"); /* view xvgr file */
do_view(fnd1,"-nxy"); /* view xvgr file */
do_view(fnd2,"-nxy"); /* view xvgr file */
thanx(stderr);
return 0;
}
int gmx_editconf(int argc, char *argv[])
{
const char
*desc[] =
{
"[TT]editconf[tt] converts generic structure format to [TT].gro[tt], [TT].g96[tt]",
"or [TT].pdb[tt].",
"[PAR]",
"The box can be modified with options [TT]-box[tt], [TT]-d[tt] and",
"[TT]-angles[tt]. Both [TT]-box[tt] and [TT]-d[tt]",
"will center the system in the box, unless [TT]-noc[tt] is used.",
"[PAR]",
"Option [TT]-bt[tt] determines the box type: [TT]triclinic[tt] is a",
"triclinic box, [TT]cubic[tt] is a rectangular box with all sides equal",
"[TT]dodecahedron[tt] represents a rhombic dodecahedron and",
"[TT]octahedron[tt] is a truncated octahedron.",
"The last two are special cases of a triclinic box.",
"The length of the three box vectors of the truncated octahedron is the",
"shortest distance between two opposite hexagons.",
"Relative to a cubic box with some periodic image distance, the volume of a ",
"dodecahedron with this same periodic distance is 0.71 times that of the cube, ",
"and that of a truncated octahedron is 0.77 times.",
"[PAR]",
"Option [TT]-box[tt] requires only",
"one value for a cubic, rhombic dodecahedral, or truncated octahedral box.",
"[PAR]",
"With [TT]-d[tt] and a [TT]triclinic[tt] box the size of the system in the [IT]x[it]-, [IT]y[it]-,",
"and [IT]z[it]-directions is used. With [TT]-d[tt] and [TT]cubic[tt],",
"[TT]dodecahedron[tt] or [TT]octahedron[tt] boxes, the dimensions are set",
"to the diameter of the system (largest distance between atoms) plus twice",
"the specified distance.",
"[PAR]",
"Option [TT]-angles[tt] is only meaningful with option [TT]-box[tt] and",
"a triclinic box and cannot be used with option [TT]-d[tt].",
"[PAR]",
"When [TT]-n[tt] or [TT]-ndef[tt] is set, a group",
"can be selected for calculating the size and the geometric center,",
"otherwise the whole system is used.",
"[PAR]",
"[TT]-rotate[tt] rotates the coordinates and velocities.",
"[PAR]",
"[TT]-princ[tt] aligns the principal axes of the system along the",
"coordinate axes, with the longest axis aligned with the [IT]x[it]-axis. ",
"This may allow you to decrease the box volume,",
"but beware that molecules can rotate significantly in a nanosecond.",
"[PAR]",
"Scaling is applied before any of the other operations are",
"performed. Boxes and coordinates can be scaled to give a certain density (option",
"[TT]-density[tt]). Note that this may be inaccurate in case a [TT].gro[tt]",
"file is given as input. A special feature of the scaling option is that when the",
"factor -1 is given in one dimension, one obtains a mirror image,",
"mirrored in one of the planes. When one uses -1 in three dimensions, ",
"a point-mirror image is obtained.[PAR]",
"Groups are selected after all operations have been applied.[PAR]",
"Periodicity can be removed in a crude manner.",
"It is important that the box vectors at the bottom of your input file",
"are correct when the periodicity is to be removed.",
"[PAR]",
"When writing [TT].pdb[tt] files, B-factors can be",
"added with the [TT]-bf[tt] option. B-factors are read",
"from a file with with following format: first line states number of",
"entries in the file, next lines state an index",
"followed by a B-factor. The B-factors will be attached per residue",
"unless an index is larger than the number of residues or unless the",
"[TT]-atom[tt] option is set. Obviously, any type of numeric data can",
"be added instead of B-factors. [TT]-legend[tt] will produce",
"a row of CA atoms with B-factors ranging from the minimum to the",
"maximum value found, effectively making a legend for viewing.",
"[PAR]",
"With the option [TT]-mead[tt] a special [TT].pdb[tt] ([TT].pqr[tt])",
"file for the MEAD electrostatics",
"program (Poisson-Boltzmann solver) can be made. A further prerequisite",
"is that the input file is a run input file.",
"The B-factor field is then filled with the Van der Waals radius",
"of the atoms while the occupancy field will hold the charge.",
"[PAR]",
"The option [TT]-grasp[tt] is similar, but it puts the charges in the B-factor",
"and the radius in the occupancy.",
"[PAR]",
"Option [TT]-align[tt] allows alignment",
"of the principal axis of a specified group against the given vector, ",
"with an optional center of rotation specified by [TT]-aligncenter[tt].",
"[PAR]",
"Finally, with option [TT]-label[tt], [TT]editconf[tt] can add a chain identifier",
"to a [TT].pdb[tt] file, which can be useful for analysis with e.g. Rasmol.",
"[PAR]",
"To convert a truncated octrahedron file produced by a package which uses",
"a cubic box with the corners cut off (such as GROMOS), use:[BR]",
"[TT]editconf -f in -rotate 0 45 35.264 -bt o -box veclen -o out[tt][BR]",
"where [TT]veclen[tt] is the size of the cubic box times [SQRT]3[sqrt]/2."
};
const char *bugs[] =
{
"For complex molecules, the periodicity removal routine may break down, "
"in that case you can use [TT]trjconv[tt]."
};
static real dist = 0.0, rbox = 0.0, to_diam = 0.0;
static gmx_bool bNDEF = FALSE, bRMPBC = FALSE, bCenter = FALSE, bReadVDW =
FALSE, bCONECT = FALSE;
static gmx_bool peratom = FALSE, bLegend = FALSE, bOrient = FALSE, bMead =
FALSE, bGrasp = FALSE, bSig56 = FALSE;
static rvec scale =
{ 1, 1, 1 }, newbox =
{ 0, 0, 0 }, newang =
{ 90, 90, 90 };
static real rho = 1000.0, rvdw = 0.12;
static rvec center =
{ 0, 0, 0 }, translation =
{ 0, 0, 0 }, rotangles =
{ 0, 0, 0 }, aligncenter =
{ 0, 0, 0 }, targetvec =
{ 0, 0, 0 };
static const char *btype[] =
{ NULL, "triclinic", "cubic", "dodecahedron", "octahedron", NULL },
*label = "A";
static rvec visbox =
{ 0, 0, 0 };
static int resnr_start = -1;
t_pargs
pa[] =
{
{ "-ndef", FALSE, etBOOL,
{ &bNDEF }, "Choose output from default index groups" },
{ "-visbox", FALSE, etRVEC,
{ visbox },
"HIDDENVisualize a grid of boxes, -1 visualizes the 14 box images" },
{ "-bt", FALSE, etENUM,
{ btype }, "Box type for [TT]-box[tt] and [TT]-d[tt]" },
{ "-box", FALSE, etRVEC,
{ newbox }, "Box vector lengths (a,b,c)" },
{ "-angles", FALSE, etRVEC,
{ newang }, "Angles between the box vectors (bc,ac,ab)" },
{ "-d", FALSE, etREAL,
{ &dist }, "Distance between the solute and the box" },
{ "-c", FALSE, etBOOL,
{ &bCenter },
"Center molecule in box (implied by [TT]-box[tt] and [TT]-d[tt])" },
{ "-center", FALSE, etRVEC,
{ center }, "Coordinates of geometrical center" },
{ "-aligncenter", FALSE, etRVEC,
{ aligncenter }, "Center of rotation for alignment" },
{ "-align", FALSE, etRVEC,
{ targetvec },
"Align to target vector" },
{ "-translate", FALSE, etRVEC,
{ translation }, "Translation" },
{ "-rotate", FALSE, etRVEC,
{ rotangles },
"Rotation around the X, Y and Z axes in degrees" },
{ "-princ", FALSE, etBOOL,
{ &bOrient },
"Orient molecule(s) along their principal axes" },
{ "-scale", FALSE, etRVEC,
{ scale }, "Scaling factor" },
{ "-density", FALSE, etREAL,
{ &rho },
"Density (g/L) of the output box achieved by scaling" },
{ "-pbc", FALSE, etBOOL,
{ &bRMPBC },
"Remove the periodicity (make molecule whole again)" },
{ "-resnr", FALSE, etINT,
{ &resnr_start },
" Renumber residues starting from resnr" },
{ "-grasp", FALSE, etBOOL,
{ &bGrasp },
"Store the charge of the atom in the B-factor field and the radius of the atom in the occupancy field" },
{
"-rvdw", FALSE, etREAL,
{ &rvdw },
"Default Van der Waals radius (in nm) if one can not be found in the database or if no parameters are present in the topology file"
},
{ "-sig56", FALSE, etBOOL,
{ &bSig56 },
"Use rmin/2 (minimum in the Van der Waals potential) rather than [GRK]sigma[grk]/2 " },
{
"-vdwread", FALSE, etBOOL,
{ &bReadVDW },
"Read the Van der Waals radii from the file [TT]vdwradii.dat[tt] rather than computing the radii based on the force field"
},
{ "-atom", FALSE, etBOOL,
{ &peratom }, "Force B-factor attachment per atom" },
{ "-legend", FALSE, etBOOL,
{ &bLegend }, "Make B-factor legend" },
{ "-label", FALSE, etSTR,
{ &label }, "Add chain label for all residues" },
{
"-conect", FALSE, etBOOL,
{ &bCONECT },
"Add CONECT records to a [TT].pdb[tt] file when written. Can only be done when a topology is present"
}
};
#define NPA asize(pa)
FILE *out;
const char *infile, *outfile;
char title[STRLEN];
int outftp, inftp, natom, i, j, n_bfac, itype, ntype;
double *bfac = NULL, c6, c12;
int *bfac_nr = NULL;
t_topology *top = NULL;
t_atoms atoms;
char *grpname, *sgrpname, *agrpname;
int isize, ssize, tsize, asize;
atom_id *index, *sindex, *tindex, *aindex;
rvec *x, *v, gc, min, max, size;
int ePBC;
matrix box, rotmatrix, trans;
rvec princd, tmpvec;
gmx_bool bIndex, bSetSize, bSetAng, bCubic, bDist, bSetCenter, bAlign;
gmx_bool bHaveV, bScale, bRho, bTranslate, bRotate, bCalcGeom, bCalcDiam;
real xs, ys, zs, xcent, ycent, zcent, diam = 0, mass = 0, d, vdw;
gmx_atomprop_t aps;
gmx_conect conect;
output_env_t oenv;
t_filenm fnm[] =
{
{ efSTX, "-f", NULL, ffREAD },
{ efNDX, "-n", NULL, ffOPTRD },
{ efSTO, NULL, NULL, ffOPTWR },
{ efPQR, "-mead", "mead", ffOPTWR },
{ efDAT, "-bf", "bfact", ffOPTRD }
};
#define NFILE asize(fnm)
CopyRight(stderr, argv[0]);
parse_common_args(&argc, argv, PCA_CAN_VIEW, NFILE, fnm, NPA, pa,
asize(desc), desc, asize(bugs), bugs, &oenv);
bIndex = opt2bSet("-n", NFILE, fnm) || bNDEF;
bMead = opt2bSet("-mead", NFILE, fnm);
bSetSize = opt2parg_bSet("-box", NPA, pa);
bSetAng = opt2parg_bSet("-angles", NPA, pa);
bSetCenter = opt2parg_bSet("-center", NPA, pa);
bDist = opt2parg_bSet("-d", NPA, pa);
bAlign = opt2parg_bSet("-align", NPA, pa);
/* Only automatically turn on centering without -noc */
if ((bDist || bSetSize || bSetCenter) && !opt2parg_bSet("-c", NPA, pa))
{
bCenter = TRUE;
}
bScale = opt2parg_bSet("-scale", NPA, pa);
bRho = opt2parg_bSet("-density", NPA, pa);
bTranslate = opt2parg_bSet("-translate", NPA, pa);
bRotate = opt2parg_bSet("-rotate", NPA, pa);
if (bScale && bRho)
{
fprintf(stderr, "WARNING: setting -density overrides -scale\n");
}
bScale = bScale || bRho;
bCalcGeom = bCenter || bRotate || bOrient || bScale;
bCalcDiam = btype[0][0] == 'c' || btype[0][0] == 'd' || btype[0][0] == 'o';
infile = ftp2fn(efSTX, NFILE, fnm);
if (bMead)
{
outfile = ftp2fn(efPQR, NFILE, fnm);
}
else
{
outfile = ftp2fn(efSTO, NFILE, fnm);
}
outftp = fn2ftp(outfile);
inftp = fn2ftp(infile);
aps = gmx_atomprop_init();
if (bMead && bGrasp)
{
printf("Incompatible options -mead and -grasp. Turning off -grasp\n");
bGrasp = FALSE;
}
if (bGrasp && (outftp != efPDB))
{
gmx_fatal(FARGS, "Output file should be a .pdb file"
" when using the -grasp option\n");
}
if ((bMead || bGrasp) && !((fn2ftp(infile) == efTPR) ||
(fn2ftp(infile) == efTPA) ||
(fn2ftp(infile) == efTPB)))
{
gmx_fatal(FARGS, "Input file should be a .tp[abr] file"
" when using the -mead option\n");
}
get_stx_coordnum(infile, &natom);
init_t_atoms(&atoms, natom, TRUE);
snew(x, natom);
snew(v, natom);
read_stx_conf(infile, title, &atoms, x, v, &ePBC, box);
if (fn2ftp(infile) == efPDB)
{
get_pdb_atomnumber(&atoms, aps);
}
printf("Read %d atoms\n", atoms.nr);
/* Get the element numbers if available in a pdb file */
if (fn2ftp(infile) == efPDB)
{
get_pdb_atomnumber(&atoms, aps);
}
if (ePBC != epbcNONE)
{
real vol = det(box);
printf("Volume: %g nm^3, corresponds to roughly %d electrons\n",
vol, 100*((int)(vol*4.5)));
}
if (bMead || bGrasp || bCONECT)
{
top = read_top(infile, NULL);
}
if (bMead || bGrasp)
{
if (atoms.nr != top->atoms.nr)
{
gmx_fatal(FARGS, "Atom numbers don't match (%d vs. %d)", atoms.nr, top->atoms.nr);
}
snew(atoms.pdbinfo, top->atoms.nr);
ntype = top->idef.atnr;
for (i = 0; (i < atoms.nr); i++)
{
/* Determine the Van der Waals radius from the force field */
if (bReadVDW)
{
if (!gmx_atomprop_query(aps, epropVDW,
*top->atoms.resinfo[top->atoms.atom[i].resind].name,
*top->atoms.atomname[i], &vdw))
{
vdw = rvdw;
}
}
else
{
itype = top->atoms.atom[i].type;
c12 = top->idef.iparams[itype*ntype+itype].lj.c12;
c6 = top->idef.iparams[itype*ntype+itype].lj.c6;
if ((c6 != 0) && (c12 != 0))
{
real sig6;
if (bSig56)
{
sig6 = 2*c12/c6;
}
else
{
sig6 = c12/c6;
}
vdw = 0.5*pow(sig6, 1.0/6.0);
}
else
{
vdw = rvdw;
}
}
/* Factor of 10 for nm -> Angstroms */
vdw *= 10;
if (bMead)
{
atoms.pdbinfo[i].occup = top->atoms.atom[i].q;
atoms.pdbinfo[i].bfac = vdw;
}
else
{
atoms.pdbinfo[i].occup = vdw;
atoms.pdbinfo[i].bfac = top->atoms.atom[i].q;
}
}
}
bHaveV = FALSE;
for (i = 0; (i < natom) && !bHaveV; i++)
{
for (j = 0; (j < DIM) && !bHaveV; j++)
{
bHaveV = bHaveV || (v[i][j] != 0);
}
}
printf("%selocities found\n", bHaveV ? "V" : "No v");
if (visbox[0] > 0)
{
if (bIndex)
{
gmx_fatal(FARGS, "Sorry, can not visualize box with index groups");
}
if (outftp != efPDB)
{
gmx_fatal(FARGS, "Sorry, can only visualize box with a pdb file");
}
}
else if (visbox[0] == -1)
{
visualize_images("images.pdb", ePBC, box);
}
/* remove pbc */
if (bRMPBC)
{
rm_gropbc(&atoms, x, box);
}
if (bCalcGeom)
{
if (bIndex)
{
fprintf(stderr, "\nSelect a group for determining the system size:\n");
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm),
1, &ssize, &sindex, &sgrpname);
}
else
{
ssize = atoms.nr;
sindex = NULL;
}
diam = calc_geom(ssize, sindex, x, gc, min, max, bCalcDiam);
rvec_sub(max, min, size);
printf(" system size :%7.3f%7.3f%7.3f (nm)\n",
size[XX], size[YY], size[ZZ]);
if (bCalcDiam)
{
printf(" diameter :%7.3f (nm)\n", diam);
}
printf(" center :%7.3f%7.3f%7.3f (nm)\n", gc[XX], gc[YY], gc[ZZ]);
printf(" box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf(" box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ]) == 0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[YY], box[ZZ])),
norm2(box[ZZ]) == 0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX], box[ZZ])),
norm2(box[YY]) == 0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX], box[YY])));
printf(" box volume :%7.2f (nm^3)\n", det(box));
}
if (bRho || bOrient || bAlign)
{
mass = calc_mass(&atoms, !fn2bTPX(infile), aps);
}
if (bOrient)
{
atom_id *index;
char *grpnames;
/* Get a group for principal component analysis */
fprintf(stderr, "\nSelect group for the determining the orientation\n");
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &isize, &index, &grpnames);
/* Orient the principal axes along the coordinate axes */
orient_princ(&atoms, isize, index, natom, x, bHaveV ? v : NULL, NULL);
sfree(index);
sfree(grpnames);
}
if (bScale)
{
/* scale coordinates and box */
if (bRho)
{
/* Compute scaling constant */
real vol, dens;
vol = det(box);
dens = (mass*AMU)/(vol*NANO*NANO*NANO);
fprintf(stderr, "Volume of input %g (nm^3)\n", vol);
fprintf(stderr, "Mass of input %g (a.m.u.)\n", mass);
fprintf(stderr, "Density of input %g (g/l)\n", dens);
if (vol == 0 || mass == 0)
{
gmx_fatal(FARGS, "Cannot scale density with "
"zero mass (%g) or volume (%g)\n", mass, vol);
}
scale[XX] = scale[YY] = scale[ZZ] = pow(dens/rho, 1.0/3.0);
fprintf(stderr, "Scaling all box vectors by %g\n", scale[XX]);
}
scale_conf(atoms.nr, x, box, scale);
}
if (bAlign)
{
if (bIndex)
{
fprintf(stderr, "\nSelect a group that you want to align:\n");
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm),
1, &asize, &aindex, &agrpname);
}
else
{
asize = atoms.nr;
snew(aindex, asize);
for (i = 0; i < asize; i++)
{
aindex[i] = i;
}
}
printf("Aligning %d atoms (out of %d) to %g %g %g, center of rotation %g %g %g\n", asize, natom,
targetvec[XX], targetvec[YY], targetvec[ZZ],
aligncenter[XX], aligncenter[YY], aligncenter[ZZ]);
/*subtract out pivot point*/
for (i = 0; i < asize; i++)
{
rvec_dec(x[aindex[i]], aligncenter);
}
/*now determine transform and rotate*/
/*will this work?*/
principal_comp(asize, aindex, atoms.atom, x, trans, princd);
unitv(targetvec, targetvec);
printf("Using %g %g %g as principal axis\n", trans[0][2], trans[1][2], trans[2][2]);
tmpvec[XX] = trans[0][2]; tmpvec[YY] = trans[1][2]; tmpvec[ZZ] = trans[2][2];
calc_rotmatrix(tmpvec, targetvec, rotmatrix);
/* rotmatrix finished */
for (i = 0; i < asize; ++i)
{
mvmul(rotmatrix, x[aindex[i]], tmpvec);
copy_rvec(tmpvec, x[aindex[i]]);
}
/*add pivot point back*/
for (i = 0; i < asize; i++)
{
rvec_inc(x[aindex[i]], aligncenter);
}
if (!bIndex)
{
sfree(aindex);
}
}
if (bTranslate)
{
if (bIndex)
{
fprintf(stderr, "\nSelect a group that you want to translate:\n");
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm),
1, &ssize, &sindex, &sgrpname);
}
else
{
ssize = atoms.nr;
sindex = NULL;
}
printf("Translating %d atoms (out of %d) by %g %g %g nm\n", ssize, natom,
translation[XX], translation[YY], translation[ZZ]);
if (sindex)
{
for (i = 0; i < ssize; i++)
{
rvec_inc(x[sindex[i]], translation);
}
}
else
{
for (i = 0; i < natom; i++)
{
rvec_inc(x[i], translation);
}
}
}
if (bRotate)
{
/* Rotate */
printf("Rotating %g, %g, %g degrees around the X, Y and Z axis respectively\n", rotangles[XX], rotangles[YY], rotangles[ZZ]);
for (i = 0; i < DIM; i++)
{
rotangles[i] *= DEG2RAD;
}
rotate_conf(natom, x, v, rotangles[XX], rotangles[YY], rotangles[ZZ]);
}
if (bCalcGeom)
{
/* recalc geometrical center and max and min coordinates and size */
calc_geom(ssize, sindex, x, gc, min, max, FALSE);
rvec_sub(max, min, size);
if (bScale || bOrient || bRotate)
{
printf("new system size : %6.3f %6.3f %6.3f\n",
size[XX], size[YY], size[ZZ]);
}
}
if (bSetSize || bDist || (btype[0][0] == 't' && bSetAng))
{
ePBC = epbcXYZ;
if (!(bSetSize || bDist))
{
for (i = 0; i < DIM; i++)
{
newbox[i] = norm(box[i]);
}
}
clear_mat(box);
/* calculate new boxsize */
switch (btype[0][0])
{
case 't':
if (bDist)
{
for (i = 0; i < DIM; i++)
{
newbox[i] = size[i]+2*dist;
}
}
if (!bSetAng)
{
box[XX][XX] = newbox[XX];
box[YY][YY] = newbox[YY];
box[ZZ][ZZ] = newbox[ZZ];
}
else
{
matrix_convert(box, newbox, newang);
}
break;
case 'c':
case 'd':
case 'o':
if (bSetSize)
{
d = newbox[0];
}
else
{
d = diam+2*dist;
}
if (btype[0][0] == 'c')
{
for (i = 0; i < DIM; i++)
{
box[i][i] = d;
}
}
else if (btype[0][0] == 'd')
{
box[XX][XX] = d;
box[YY][YY] = d;
box[ZZ][XX] = d/2;
box[ZZ][YY] = d/2;
box[ZZ][ZZ] = d*sqrt(2)/2;
}
else
{
box[XX][XX] = d;
box[YY][XX] = d/3;
box[YY][YY] = d*sqrt(2)*2/3;
box[ZZ][XX] = -d/3;
box[ZZ][YY] = d*sqrt(2)/3;
box[ZZ][ZZ] = d*sqrt(6)/3;
}
break;
}
}
/* calculate new coords for geometrical center */
if (!bSetCenter)
{
calc_box_center(ecenterDEF, box, center);
}
/* center molecule on 'center' */
if (bCenter)
{
center_conf(natom, x, center, gc);
}
/* print some */
if (bCalcGeom)
{
calc_geom(ssize, sindex, x, gc, min, max, FALSE);
printf("new center :%7.3f%7.3f%7.3f (nm)\n", gc[XX], gc[YY], gc[ZZ]);
}
if (bOrient || bScale || bDist || bSetSize)
{
printf("new box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf("new box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ]) == 0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[YY], box[ZZ])),
norm2(box[ZZ]) == 0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX], box[ZZ])),
norm2(box[YY]) == 0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX], box[YY])));
printf("new box volume :%7.2f (nm^3)\n", det(box));
}
if (check_box(epbcXYZ, box))
{
printf("\nWARNING: %s\n"
"See the GROMACS manual for a description of the requirements that\n"
"must be satisfied by descriptions of simulation cells.\n",
check_box(epbcXYZ, box));
}
if (bDist && btype[0][0] == 't')
{
if (TRICLINIC(box))
{
printf("\nWARNING: Your box is triclinic with non-orthogonal axes. In this case, the\n"
"distance from the solute to a box surface along the corresponding normal\n"
"vector might be somewhat smaller than your specified value %f.\n"
"You can check the actual value with g_mindist -pi\n", dist);
}
else if (!opt2parg_bSet("-bt", NPA, pa))
{
printf("\nWARNING: No boxtype specified - distance condition applied in each dimension.\n"
"If the molecule rotates the actual distance will be smaller. You might want\n"
"to use a cubic box instead, or why not try a dodecahedron today?\n");
}
}
if (bCONECT && (outftp == efPDB) && (inftp == efTPR))
{
conect = gmx_conect_generate(top);
}
else
{
conect = NULL;
}
if (bIndex)
{
fprintf(stderr, "\nSelect a group for output:\n");
get_index(&atoms, opt2fn_null("-n", NFILE, fnm),
1, &isize, &index, &grpname);
if (resnr_start >= 0)
{
renum_resnr(&atoms, isize, index, resnr_start);
}
if (opt2parg_bSet("-label", NPA, pa))
{
for (i = 0; (i < atoms.nr); i++)
{
atoms.resinfo[atoms.atom[i].resind].chainid = label[0];
}
}
if (opt2bSet("-bf", NFILE, fnm) || bLegend)
{
gmx_fatal(FARGS, "Sorry, cannot do bfactors with an index group.");
}
if (outftp == efPDB)
{
out = ffopen(outfile, "w");
write_pdbfile_indexed(out, title, &atoms, x, ePBC, box, ' ', 1, isize, index, conect, TRUE);
ffclose(out);
}
else
{
write_sto_conf_indexed(outfile, title, &atoms, x, bHaveV ? v : NULL, ePBC, box, isize, index);
}
}
else
{
if (resnr_start >= 0)
{
renum_resnr(&atoms, atoms.nr, NULL, resnr_start);
}
if ((outftp == efPDB) || (outftp == efPQR))
{
out = ffopen(outfile, "w");
if (bMead)
{
set_pdb_wide_format(TRUE);
fprintf(out, "REMARK "
"The B-factors in this file hold atomic radii\n");
fprintf(out, "REMARK "
"The occupancy in this file hold atomic charges\n");
}
else if (bGrasp)
{
fprintf(out, "GRASP PDB FILE\nFORMAT NUMBER=1\n");
fprintf(out, "REMARK "
"The B-factors in this file hold atomic charges\n");
fprintf(out, "REMARK "
"The occupancy in this file hold atomic radii\n");
}
else if (opt2bSet("-bf", NFILE, fnm))
{
read_bfac(opt2fn("-bf", NFILE, fnm), &n_bfac, &bfac, &bfac_nr);
set_pdb_conf_bfac(atoms.nr, atoms.nres, &atoms,
n_bfac, bfac, bfac_nr, peratom);
}
if (opt2parg_bSet("-label", NPA, pa))
{
for (i = 0; (i < atoms.nr); i++)
{
atoms.resinfo[atoms.atom[i].resind].chainid = label[0];
}
}
write_pdbfile(out, title, &atoms, x, ePBC, box, ' ', -1, conect, TRUE);
if (bLegend)
{
pdb_legend(out, atoms.nr, atoms.nres, &atoms, x);
}
if (visbox[0] > 0)
{
visualize_box(out, bLegend ? atoms.nr+12 : atoms.nr,
bLegend ? atoms.nres = 12 : atoms.nres, box, visbox);
}
ffclose(out);
}
else
{
write_sto_conf(outfile, title, &atoms, x, bHaveV ? v : NULL, ePBC, box);
}
}
gmx_atomprop_destroy(aps);
do_view(oenv, outfile, NULL);
thanx(stderr);
return 0;
}
int gmx_order(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes the order parameter per atom for carbon tails. For atom i the",
"vector i-1, i+1 is used together with an axis. ",
"The index file should contain only the groups to be used for calculations,",
"with each group of equivalent carbons along the relevant acyl chain in its own",
"group. There should not be any generic groups (like System, Protein) in the index",
"file to avoid confusing the program (this is not relevant to tetrahedral order",
"parameters however, which only work for water anyway).[PAR]",
"[THISMODULE] can also give all",
"diagonal elements of the order tensor and even calculate the deuterium",
"order parameter Scd (default). If the option [TT]-szonly[tt] is given, only one",
"order tensor component (specified by the [TT]-d[tt] option) is given and the",
"order parameter per slice is calculated as well. If [TT]-szonly[tt] is not",
"selected, all diagonal elements and the deuterium order parameter is",
"given.[PAR]"
"The tetrahedrality order parameters can be determined",
"around an atom. Both angle an distance order parameters are calculated. See",
"P.-L. Chau and A.J. Hardwick, Mol. Phys., 93, (1998), 511-518.",
"for more details."
};
static int nslices = 1; /* nr of slices defined */
static gmx_bool bSzonly = FALSE; /* True if only Sz is wanted */
static gmx_bool bUnsat = FALSE; /* True if carbons are unsat. */
static const char *normal_axis[] = { NULL, "z", "x", "y", NULL };
static gmx_bool permolecule = FALSE; /*compute on a per-molecule basis */
static gmx_bool radial = FALSE; /*compute a radial membrane normal */
static gmx_bool distcalc = FALSE; /*calculate distance from a reference group */
t_pargs pa[] = {
{ "-d", FALSE, etENUM, {normal_axis},
"Direction of the normal on the membrane" },
{ "-sl", FALSE, etINT, {&nslices},
"Calculate order parameter as function of box length, dividing the box"
" into this number of slices." },
{ "-szonly", FALSE, etBOOL, {&bSzonly},
"Only give Sz element of order tensor. (axis can be specified with [TT]-d[tt])" },
{ "-unsat", FALSE, etBOOL, {&bUnsat},
"Calculate order parameters for unsaturated carbons. Note that this can"
"not be mixed with normal order parameters." },
{ "-permolecule", FALSE, etBOOL, {&permolecule},
"Compute per-molecule Scd order parameters" },
{ "-radial", FALSE, etBOOL, {&radial},
"Compute a radial membrane normal" },
{ "-calcdist", FALSE, etBOOL, {&distcalc},
"Compute distance from a reference" },
};
rvec *order; /* order par. for each atom */
real **slOrder; /* same, per slice */
real slWidth = 0.0; /* width of a slice */
char **grpname; /* groupnames */
int ngrps, /* nr. of groups */
i,
axis = 0; /* normal axis */
t_topology *top; /* topology */
int ePBC;
atom_id *index, /* indices for a */
*a; /* atom numbers in each group */
t_blocka *block; /* data from index file */
t_filenm fnm[] = { /* files for g_order */
{ efTRX, "-f", NULL, ffREAD }, /* trajectory file */
{ efNDX, "-n", NULL, ffREAD }, /* index file */
{ efNDX, "-nr", NULL, ffREAD }, /* index for radial axis calculation */
{ efTPR, NULL, NULL, ffREAD }, /* topology file */
{ efXVG, "-o", "order", ffWRITE }, /* xvgr output file */
{ efXVG, "-od", "deuter", ffWRITE }, /* xvgr output file */
{ efPDB, "-ob", NULL, ffWRITE }, /* write Scd as B factors to PDB if permolecule */
{ efXVG, "-os", "sliced", ffWRITE }, /* xvgr output file */
{ efXVG, "-Sg", "sg-ang", ffOPTWR }, /* xvgr output file */
{ efXVG, "-Sk", "sk-dist", ffOPTWR }, /* xvgr output file */
{ efXVG, "-Sgsl", "sg-ang-slice", ffOPTWR }, /* xvgr output file */
{ efXVG, "-Sksl", "sk-dist-slice", ffOPTWR }, /* xvgr output file */
};
gmx_bool bSliced = FALSE; /* True if box is sliced */
#define NFILE asize(fnm)
real **distvals = NULL;
const char *sgfnm, *skfnm, *ndxfnm, *tpsfnm, *trxfnm;
gmx_output_env_t *oenv;
if (!parse_common_args(&argc, argv, PCA_CAN_VIEW | PCA_CAN_TIME,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
if (nslices < 1)
{
gmx_fatal(FARGS, "Can not have nslices < 1");
}
sgfnm = opt2fn_null("-Sg", NFILE, fnm);
skfnm = opt2fn_null("-Sk", NFILE, fnm);
ndxfnm = opt2fn_null("-n", NFILE, fnm);
tpsfnm = ftp2fn(efTPR, NFILE, fnm);
trxfnm = ftp2fn(efTRX, NFILE, fnm);
/* Calculate axis */
GMX_RELEASE_ASSERT(normal_axis[0] != NULL, "Options inconsistency; normal_axis[0] is NULL");
if (std::strcmp(normal_axis[0], "x") == 0)
{
axis = XX;
}
else if (std::strcmp(normal_axis[0], "y") == 0)
{
axis = YY;
}
else if (std::strcmp(normal_axis[0], "z") == 0)
{
axis = ZZ;
}
else
{
gmx_fatal(FARGS, "Invalid axis, use x, y or z");
}
switch (axis)
{
case 0:
fprintf(stderr, "Taking x axis as normal to the membrane\n");
break;
case 1:
fprintf(stderr, "Taking y axis as normal to the membrane\n");
break;
case 2:
fprintf(stderr, "Taking z axis as normal to the membrane\n");
break;
}
/* tetraheder order parameter */
if (skfnm || sgfnm)
{
/* If either of theoptions is set we compute both */
sgfnm = opt2fn("-Sg", NFILE, fnm);
skfnm = opt2fn("-Sk", NFILE, fnm);
calc_tetra_order_parm(ndxfnm, tpsfnm, trxfnm, sgfnm, skfnm, nslices, axis,
opt2fn("-Sgsl", NFILE, fnm), opt2fn("-Sksl", NFILE, fnm),
oenv);
/* view xvgr files */
do_view(oenv, opt2fn("-Sg", NFILE, fnm), NULL);
do_view(oenv, opt2fn("-Sk", NFILE, fnm), NULL);
if (nslices > 1)
{
do_view(oenv, opt2fn("-Sgsl", NFILE, fnm), NULL);
do_view(oenv, opt2fn("-Sksl", NFILE, fnm), NULL);
}
}
else
{
/* tail order parameter */
if (nslices > 1)
{
bSliced = TRUE;
fprintf(stderr, "Dividing box in %d slices.\n\n", nslices);
}
if (bSzonly)
{
fprintf(stderr, "Only calculating Sz\n");
}
if (bUnsat)
{
fprintf(stderr, "Taking carbons as unsaturated!\n");
}
top = read_top(ftp2fn(efTPR, NFILE, fnm), &ePBC); /* read topology file */
block = init_index(ftp2fn(efNDX, NFILE, fnm), &grpname);
index = block->index; /* get indices from t_block block */
a = block->a; /* see block.h */
ngrps = block->nr;
if (permolecule)
{
nslices = index[1] - index[0]; /*I think this assumes contiguous lipids in topology*/
fprintf(stderr, "Calculating Scd order parameters for each of %d molecules\n", nslices);
}
if (radial)
{
fprintf(stderr, "Calculating radial distances\n");
if (!permolecule)
{
gmx_fatal(FARGS, "Cannot yet output radial distances without permolecule\n");
}
}
/* show atomtypes, to check if index file is correct */
print_types(index, a, ngrps, grpname, top);
calc_order(ftp2fn(efTRX, NFILE, fnm), index, a, &order,
&slOrder, &slWidth, nslices, bSliced, bUnsat,
top, ePBC, ngrps, axis, permolecule, radial, distcalc, opt2fn_null("-nr", NFILE, fnm), &distvals, oenv);
if (radial)
{
ngrps--; /*don't print the last group--was used for
center-of-mass determination*/
}
order_plot(order, slOrder, opt2fn("-o", NFILE, fnm), opt2fn("-os", NFILE, fnm),
opt2fn("-od", NFILE, fnm), ngrps, nslices, slWidth, bSzonly, permolecule, distvals, oenv);
if (opt2bSet("-ob", NFILE, fnm))
{
if (!permolecule)
{
fprintf(stderr,
"Won't write B-factors with averaged order parameters; use -permolecule\n");
}
else
{
write_bfactors(fnm, NFILE, index, a, nslices, ngrps, slOrder, top, distvals, oenv);
}
}
do_view(oenv, opt2fn("-o", NFILE, fnm), NULL); /* view xvgr file */
do_view(oenv, opt2fn("-os", NFILE, fnm), NULL); /* view xvgr file */
do_view(oenv, opt2fn("-od", NFILE, fnm), NULL); /* view xvgr file */
}
if (distvals != NULL)
{
for (i = 0; i < nslices; ++i)
{
sfree(distvals[i]);
}
sfree(distvals);
}
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",
"[TT].xpm[tt] 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 [TT].xpm[tt] 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);
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);
}
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] / (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_check(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] reads a trajectory ([REF].tng[ref], [REF].trr[ref] or ",
"[REF].xtc[ref]), an energy file ([REF].edr[ref])",
"or an index file ([REF].ndx[ref])",
"and prints out useful information about them.[PAR]",
"Option [TT]-c[tt] checks for presence of coordinates,",
"velocities and box in the file, for close contacts (smaller than",
"[TT]-vdwfac[tt] and not bonded, i.e. not between [TT]-bonlo[tt]",
"and [TT]-bonhi[tt], all relative to the sum of both Van der Waals",
"radii) and atoms outside the box (these may occur often and are",
"no problem). If velocities are present, an estimated temperature",
"will be calculated from them.[PAR]",
"If an index file, is given its contents will be summarized.[PAR]",
"If both a trajectory and a [REF].tpr[ref] file are given (with [TT]-s1[tt])",
"the program will check whether the bond lengths defined in the tpr",
"file are indeed correct in the trajectory. If not you may have",
"non-matching files due to e.g. deshuffling or due to problems with",
"virtual sites. With these flags, [TT]gmx check[tt] provides a quick check for such problems.[PAR]",
"The program can compare two run input ([REF].tpr[ref])",
"files",
"when both [TT]-s1[tt] and [TT]-s2[tt] are supplied.",
"Similarly a pair of trajectory files can be compared (using the [TT]-f2[tt]",
"option), or a pair of energy files (using the [TT]-e2[tt] option).[PAR]",
"For free energy simulations the A and B state topology from one",
"run input file can be compared with options [TT]-s1[tt] and [TT]-ab[tt].[PAR]",
"In case the [TT]-m[tt] flag is given a LaTeX file will be written",
"consisting of a rough outline for a methods section for a paper."
};
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffOPTRD },
{ efTRX, "-f2", NULL, ffOPTRD },
{ efTPR, "-s1", "top1", ffOPTRD },
{ efTPR, "-s2", "top2", ffOPTRD },
{ efTPS, "-c", NULL, ffOPTRD },
{ efEDR, "-e", NULL, ffOPTRD },
{ efEDR, "-e2", "ener2", ffOPTRD },
{ efNDX, "-n", NULL, ffOPTRD },
{ efTEX, "-m", NULL, ffOPTWR }
};
#define NFILE asize(fnm)
const char *fn1 = NULL, *fn2 = NULL, *tex = NULL;
gmx_output_env_t *oenv;
static real vdw_fac = 0.8;
static real bon_lo = 0.4;
static real bon_hi = 0.7;
static gmx_bool bRMSD = FALSE;
static real ftol = 0.001;
static real abstol = 0.001;
static gmx_bool bCompAB = FALSE;
static char *lastener = NULL;
static t_pargs pa[] = {
{ "-vdwfac", FALSE, etREAL, {&vdw_fac},
"Fraction of sum of VdW radii used as warning cutoff" },
{ "-bonlo", FALSE, etREAL, {&bon_lo},
"Min. fract. of sum of VdW radii for bonded atoms" },
{ "-bonhi", FALSE, etREAL, {&bon_hi},
"Max. fract. of sum of VdW radii for bonded atoms" },
{ "-rmsd", FALSE, etBOOL, {&bRMSD},
"Print RMSD for x, v and f" },
{ "-tol", FALSE, etREAL, {&ftol},
"Relative tolerance for comparing real values defined as [MATH]2*(a-b)/([MAG]a[mag]+[MAG]b[mag])[math]" },
{ "-abstol", FALSE, etREAL, {&abstol},
"Absolute tolerance, useful when sums are close to zero." },
{ "-ab", FALSE, etBOOL, {&bCompAB},
"Compare the A and B topology from one file" },
{ "-lastener", FALSE, etSTR, {&lastener},
"Last energy term to compare (if not given all are tested). It makes sense to go up until the Pressure." }
};
if (!parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
fn1 = opt2fn_null("-f", NFILE, fnm);
fn2 = opt2fn_null("-f2", NFILE, fnm);
tex = opt2fn_null("-m", NFILE, fnm);
if (fn1 && fn2)
{
comp_trx(oenv, fn1, fn2, bRMSD, ftol, abstol);
}
else if (fn1)
{
chk_trj(oenv, fn1, opt2fn_null("-s1", NFILE, fnm), ftol);
}
else if (fn2)
{
fprintf(stderr, "Please give me TWO trajectory (.xtc/.trr/.tng) files!\n");
}
fn1 = opt2fn_null("-s1", NFILE, fnm);
fn2 = opt2fn_null("-s2", NFILE, fnm);
if ((fn1 && fn2) || bCompAB)
{
if (bCompAB)
{
if (fn1 == NULL)
{
gmx_fatal(FARGS, "With -ab you need to set the -s1 option");
}
fn2 = NULL;
}
comp_tpx(fn1, fn2, bRMSD, ftol, abstol);
}
else if (fn1 && tex)
{
tpx2methods(fn1, tex);
}
else if ((fn1 && !opt2fn_null("-f", NFILE, fnm)) || (!fn1 && fn2))
{
fprintf(stderr, "Please give me TWO run input (.tpr) files\n"
"or specify the -m flag to generate a methods.tex file\n");
}
fn1 = opt2fn_null("-e", NFILE, fnm);
fn2 = opt2fn_null("-e2", NFILE, fnm);
if (fn1 && fn2)
{
comp_enx(fn1, fn2, ftol, abstol, lastener);
}
else if (fn1)
{
chk_enx(ftp2fn(efEDR, NFILE, fnm));
}
else if (fn2)
{
fprintf(stderr, "Please give me TWO energy (.edr/.ene) files!\n");
}
if (ftp2bSet(efTPS, NFILE, fnm))
{
chk_tps(ftp2fn(efTPS, NFILE, fnm), vdw_fac, bon_lo, bon_hi);
}
if (ftp2bSet(efNDX, NFILE, fnm))
{
chk_ndx(ftp2fn(efNDX, NFILE, fnm));
}
return 0;
}
int gmx_msd(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes the mean square displacement (MSD) of atoms from",
"a set of initial positions. This provides an easy way to compute",
"the diffusion constant using the Einstein relation.",
"The time between the reference points for the MSD calculation",
"is set with [TT]-trestart[tt].",
"The diffusion constant is calculated by least squares fitting a",
"straight line (D*t + c) through the MSD(t) from [TT]-beginfit[tt] to",
"[TT]-endfit[tt] (note that t is time from the reference positions,",
"not simulation time). An error estimate given, which is the difference",
"of the diffusion coefficients obtained from fits over the two halves",
"of the fit interval.[PAR]",
"There are three, mutually exclusive, options to determine different",
"types of mean square displacement: [TT]-type[tt], [TT]-lateral[tt]",
"and [TT]-ten[tt]. Option [TT]-ten[tt] writes the full MSD tensor for",
"each group, the order in the output is: trace xx yy zz yx zx zy.[PAR]",
"If [TT]-mol[tt] is set, [THISMODULE] plots the MSD for individual molecules",
"(including making molecules whole across periodic boundaries): ",
"for each individual molecule a diffusion constant is computed for ",
"its center of mass. The chosen index group will be split into ",
"molecules.[PAR]",
"The default way to calculate a MSD is by using mass-weighted averages.",
"This can be turned off with [TT]-nomw[tt].[PAR]",
"With the option [TT]-rmcomm[tt], the center of mass motion of a ",
"specific group can be removed. For trajectories produced with ",
"GROMACS this is usually not necessary, ",
"as [gmx-mdrun] usually already removes the center of mass motion.",
"When you use this option be sure that the whole system is stored",
"in the trajectory file.[PAR]",
"The diffusion coefficient is determined by linear regression of the MSD,",
"where, unlike for the normal output of D, the times are weighted",
"according to the number of reference points, i.e. short times have",
"a higher weight. Also when [TT]-beginfit[tt]=-1,fitting starts at 10%",
"and when [TT]-endfit[tt]=-1, fitting goes to 90%.",
"Using this option one also gets an accurate error estimate",
"based on the statistics between individual molecules.",
"Note that this diffusion coefficient and error estimate are only",
"accurate when the MSD is completely linear between",
"[TT]-beginfit[tt] and [TT]-endfit[tt].[PAR]",
"Option [TT]-pdb[tt] writes a [REF].pdb[ref] file with the coordinates of the frame",
"at time [TT]-tpdb[tt] with in the B-factor field the square root of",
"the diffusion coefficient of the molecule.",
"This option implies option [TT]-mol[tt]."
};
static const char *normtype[] = { NULL, "no", "x", "y", "z", NULL };
static const char *axtitle[] = { NULL, "no", "x", "y", "z", NULL };
static int ngroup = 1;
static real dt = 10;
static real t_pdb = 0;
static real beginfit = -1;
static real endfit = -1;
static gmx_bool bTen = FALSE;
static gmx_bool bMW = TRUE;
static gmx_bool bRmCOMM = FALSE;
t_pargs pa[] = {
{ "-type", FALSE, etENUM, {normtype},
"Compute diffusion coefficient in one direction" },
{ "-lateral", FALSE, etENUM, {axtitle},
"Calculate the lateral diffusion in a plane perpendicular to" },
{ "-ten", FALSE, etBOOL, {&bTen},
"Calculate the full tensor" },
{ "-ngroup", FALSE, etINT, {&ngroup},
"Number of groups to calculate MSD for" },
{ "-mw", FALSE, etBOOL, {&bMW},
"Mass weighted MSD" },
{ "-rmcomm", FALSE, etBOOL, {&bRmCOMM},
"Remove center of mass motion" },
{ "-tpdb", FALSE, etTIME, {&t_pdb},
"The frame to use for option [TT]-pdb[tt] (%t)" },
{ "-trestart", FALSE, etTIME, {&dt},
"Time between restarting points in trajectory (%t)" },
{ "-beginfit", FALSE, etTIME, {&beginfit},
"Start time for fitting the MSD (%t), -1 is 10%" },
{ "-endfit", FALSE, etTIME, {&endfit},
"End time for fitting the MSD (%t), -1 is 90%" }
};
t_filenm fnm[] = {
{ efTRX, NULL, NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "msd", ffWRITE },
{ efXVG, "-mol", "diff_mol", ffOPTWR },
{ efPDB, "-pdb", "diff_mol", ffOPTWR }
};
#define NFILE asize(fnm)
t_topology top;
int ePBC;
matrix box;
char title[256];
const char *trx_file, *tps_file, *ndx_file, *msd_file, *mol_file, *pdb_file;
rvec *xdum;
gmx_bool bTop;
int axis, type;
real dim_factor;
output_env_t oenv;
if (!parse_common_args(&argc, argv,
PCA_CAN_VIEW | PCA_CAN_BEGIN | PCA_CAN_END | PCA_TIME_UNIT,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
trx_file = ftp2fn_null(efTRX, NFILE, fnm);
tps_file = ftp2fn_null(efTPS, NFILE, fnm);
ndx_file = ftp2fn_null(efNDX, NFILE, fnm);
msd_file = ftp2fn_null(efXVG, NFILE, fnm);
pdb_file = opt2fn_null("-pdb", NFILE, fnm);
if (pdb_file)
{
mol_file = opt2fn("-mol", NFILE, fnm);
}
else
{
mol_file = opt2fn_null("-mol", NFILE, fnm);
}
if (ngroup < 1)
{
gmx_fatal(FARGS, "Must have at least 1 group (now %d)", ngroup);
}
if (mol_file && ngroup > 1)
{
gmx_fatal(FARGS, "With molecular msd can only have 1 group (now %d)",
ngroup);
}
if (mol_file)
{
bMW = TRUE;
fprintf(stderr, "Calculating diffusion coefficients for molecules.\n");
}
GMX_RELEASE_ASSERT(normtype[0] != 0, "Options inconsistency; normtype[0]Â is NULL");
GMX_RELEASE_ASSERT(axtitle[0] != 0, "Options inconsistency; axtitle[0]Â is NULL");
if (normtype[0][0] != 'n')
{
type = normtype[0][0] - 'x' + X; /* See defines above */
dim_factor = 2.0;
}
else
{
type = NORMAL;
dim_factor = 6.0;
}
if ((type == NORMAL) && (axtitle[0][0] != 'n'))
{
type = LATERAL;
dim_factor = 4.0;
axis = (axtitle[0][0] - 'x'); /* See defines above */
}
else
{
axis = 0;
}
if (bTen && type != NORMAL)
{
gmx_fatal(FARGS, "Can only calculate the full tensor for 3D msd");
}
bTop = read_tps_conf(tps_file, title, &top, &ePBC, &xdum, NULL, box, bMW || bRmCOMM);
if (mol_file && !bTop)
{
gmx_fatal(FARGS,
"Could not read a topology from %s. Try a tpr file instead.",
tps_file);
}
do_corr(trx_file, ndx_file, msd_file, mol_file, pdb_file, t_pdb, ngroup,
&top, ePBC, bTen, bMW, bRmCOMM, type, dim_factor, axis, dt, beginfit, endfit,
oenv);
view_all(oenv, NFILE, fnm);
return 0;
}
int gmx_sham(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] makes multi-dimensional free-energy, enthalpy and entropy plots.",
"[THISMODULE] reads one or more [TT].xvg[tt] files and analyzes data sets.",
"The basic purpose of [THISMODULE] is to plot Gibbs free energy landscapes",
"(option [TT]-ls[tt])",
"by Bolzmann inverting multi-dimensional histograms (option [TT]-lp[tt]),",
"but it can also",
"make enthalpy (option [TT]-lsh[tt]) and entropy (option [TT]-lss[tt])",
"plots. The histograms can be made for any quantities the user supplies.",
"A line in the input file may start with a time",
"(see option [TT]-time[tt]) and any number of [IT]y[it]-values may follow.",
"Multiple sets can also be",
"read when they are separated by & (option [TT]-n[tt]),",
"in this case only one [IT]y[it]-value is read from each line.",
"All lines starting with # and @ are skipped.",
"[PAR]",
"Option [TT]-ge[tt] can be used to supply a file with free energies",
"when the ensemble is not a Boltzmann ensemble, but needs to be biased",
"by this free energy. One free energy value is required for each",
"(multi-dimensional) data point in the [TT]-f[tt] input.",
"[PAR]",
"Option [TT]-ene[tt] can be used to supply a file with energies.",
"These energies are used as a weighting function in the single",
"histogram analysis method by Kumar et al. When temperatures",
"are supplied (as a second column in the file), an experimental",
"weighting scheme is applied. In addition the vales",
"are used for making enthalpy and entropy plots.",
"[PAR]",
"With option [TT]-dim[tt], dimensions can be gives for distances.",
"When a distance is 2- or 3-dimensional, the circumference or surface",
"sampled by two particles increases with increasing distance.",
"Depending on what one would like to show, one can choose to correct",
"the histogram and free-energy for this volume effect.",
"The probability is normalized by r and r^2 for dimensions of 2 and 3, ",
"respectively.",
"A value of -1 is used to indicate an angle in degrees between two",
"vectors: a sin(angle) normalization will be applied.",
"[BB]Note[bb] that for angles between vectors the inner-product or cosine",
"is the natural quantity to use, as it will produce bins of the same",
"volume."
};
static real tb = -1, te = -1, frac = 0.5, filtlen = 0;
static gmx_bool bHaveT = TRUE, bDer = FALSE, bSubAv = TRUE, bAverCorr = FALSE, bXYdy = FALSE;
static gmx_bool bEESEF = FALSE, bEENLC = FALSE, bEeFitAc = FALSE, bPower = FALSE;
static gmx_bool bShamEner = TRUE, bSham = TRUE;
static real Tref = 298.15, pmin = 0, ttol = 0, pmax = 0, gmax = 0, emin = 0, emax = 0;
static rvec nrdim = {1, 1, 1};
static rvec nrbox = {32, 32, 32};
static rvec xmin = {0, 0, 0}, xmax = {1, 1, 1};
static int nsets_in = 1, nb_min = 4, resol = 10, nlevels = 25;
t_pargs pa[] = {
{ "-time", FALSE, etBOOL, {&bHaveT},
"Expect a time in the input" },
{ "-b", FALSE, etREAL, {&tb},
"First time to read from set" },
{ "-e", FALSE, etREAL, {&te},
"Last time to read from set" },
{ "-ttol", FALSE, etREAL, {&ttol},
"Tolerance on time in appropriate units (usually ps)" },
{ "-n", FALSE, etINT, {&nsets_in},
"Read this number of sets separated by lines containing only an ampersand" },
{ "-d", FALSE, etBOOL, {&bDer},
"Use the derivative" },
{ "-sham", FALSE, etBOOL, {&bSham},
"Turn off energy weighting even if energies are given" },
{ "-tsham", FALSE, etREAL, {&Tref},
"Temperature for single histogram analysis" },
{ "-pmin", FALSE, etREAL, {&pmin},
"Minimum probability. Anything lower than this will be set to zero" },
{ "-dim", FALSE, etRVEC, {nrdim},
"Dimensions for distances, used for volume correction (max 3 values, dimensions > 3 will get the same value as the last)" },
{ "-ngrid", FALSE, etRVEC, {nrbox},
"Number of bins for energy landscapes (max 3 values, dimensions > 3 will get the same value as the last)" },
{ "-xmin", FALSE, etRVEC, {xmin},
"Minimum for the axes in energy landscape (see above for > 3 dimensions)" },
{ "-xmax", FALSE, etRVEC, {xmax},
"Maximum for the axes in energy landscape (see above for > 3 dimensions)" },
{ "-pmax", FALSE, etREAL, {&pmax},
"Maximum probability in output, default is calculate" },
{ "-gmax", FALSE, etREAL, {&gmax},
"Maximum free energy in output, default is calculate" },
{ "-emin", FALSE, etREAL, {&emin},
"Minimum enthalpy in output, default is calculate" },
{ "-emax", FALSE, etREAL, {&emax},
"Maximum enthalpy in output, default is calculate" },
{ "-nlevels", FALSE, etINT, {&nlevels},
"Number of levels for energy landscape" },
};
#define NPA asize(pa)
FILE *out;
int n, e_n, nlast, s, nset, e_nset, d_nset, i, j = 0, *idim, *ibox;
real **val, **et_val, *t, *e_t, e_dt, d_dt, dt, tot, error;
real *rmin, *rmax;
double *av, *sig, cum1, cum2, cum3, cum4, db;
const char *fn_ge, *fn_ene;
output_env_t oenv;
gmx_int64_t num_grid_points;
t_filenm fnm[] = {
{ efXVG, "-f", "graph", ffREAD },
{ efXVG, "-ge", "gibbs", ffOPTRD },
{ efXVG, "-ene", "esham", ffOPTRD },
{ efXVG, "-dist", "ener", ffOPTWR },
{ efXVG, "-histo", "edist", ffOPTWR },
{ efNDX, "-bin", "bindex", ffOPTWR },
{ efXPM, "-lp", "prob", ffOPTWR },
{ efXPM, "-ls", "gibbs", ffOPTWR },
{ efXPM, "-lsh", "enthalpy", ffOPTWR },
{ efXPM, "-lss", "entropy", ffOPTWR },
{ efPDB, "-ls3", "gibbs3", ffOPTWR },
{ efLOG, "-g", "shamlog", ffOPTWR }
};
#define NFILE asize(fnm)
int npargs;
npargs = asize(pa);
if (!parse_common_args(&argc, argv, PCA_CAN_VIEW,
NFILE, fnm, npargs, pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
val = read_xvg_time(opt2fn("-f", NFILE, fnm), bHaveT,
opt2parg_bSet("-b", npargs, pa), tb-ttol,
opt2parg_bSet("-e", npargs, pa), te+ttol,
nsets_in, &nset, &n, &dt, &t);
printf("Read %d sets of %d points, dt = %g\n\n", nset, n, dt);
fn_ge = opt2fn_null("-ge", NFILE, fnm);
fn_ene = opt2fn_null("-ene", NFILE, fnm);
if (fn_ge && fn_ene)
{
gmx_fatal(FARGS, "Can not do free energy and energy corrections at the same time");
}
if (fn_ge || fn_ene)
{
et_val = read_xvg_time(fn_ge ? fn_ge : fn_ene, bHaveT,
opt2parg_bSet("-b", npargs, pa), tb-ttol,
opt2parg_bSet("-e", npargs, pa), te+ttol,
1, &e_nset, &e_n, &e_dt, &e_t);
if (fn_ge)
{
if (e_nset != 1)
{
gmx_fatal(FARGS, "Can only handle one free energy component in %s",
fn_ge);
}
}
else
{
if (e_nset != 1 && e_nset != 2)
{
gmx_fatal(FARGS, "Can only handle one energy component or one energy and one T in %s",
fn_ene);
}
}
if (e_n != n)
{
gmx_fatal(FARGS, "Number of energies (%d) does not match number of entries (%d) in %s", e_n, n, opt2fn("-f", NFILE, fnm));
}
}
else
{
et_val = NULL;
}
if (fn_ene && et_val)
{
ehisto(opt2fn("-histo", NFILE, fnm), e_n, et_val, oenv);
}
snew(idim, max(3, nset));
snew(ibox, max(3, nset));
snew(rmin, max(3, nset));
snew(rmax, max(3, nset));
for (i = 0; (i < min(3, nset)); i++)
{
idim[i] = nrdim[i];
ibox[i] = nrbox[i];
rmin[i] = xmin[i];
rmax[i] = xmax[i];
}
for (; (i < nset); i++)
{
idim[i] = nrdim[2];
ibox[i] = nrbox[2];
rmin[i] = xmin[2];
rmax[i] = xmax[2];
}
/* Check that the grid size is manageable. */
num_grid_points = ibox[0];
for (i = 1; i < nset; i++)
{
gmx_int64_t result;
if (!check_int_multiply_for_overflow(num_grid_points, ibox[i], &result))
{
gmx_fatal(FARGS,
"The number of dimensions and grid points is too large for this tool.\n");
}
num_grid_points = result;
}
/* The number of grid points fits in a gmx_int64_t. */
do_sham(opt2fn("-dist", NFILE, fnm), opt2fn("-bin", NFILE, fnm),
opt2fn("-lp", NFILE, fnm),
opt2fn("-ls", NFILE, fnm), opt2fn("-lsh", NFILE, fnm),
opt2fn("-lss", NFILE, fnm),
opt2fn("-ls3", NFILE, fnm), opt2fn("-g", NFILE, fnm),
n, nset, val, fn_ge != NULL, e_nset, et_val, Tref,
pmax, gmax,
opt2parg_bSet("-emin", NPA, pa) ? &emin : NULL,
opt2parg_bSet("-emax", NPA, pa) ? &emax : NULL,
nlevels, pmin,
idim, ibox,
opt2parg_bSet("-xmin", NPA, pa), rmin,
opt2parg_bSet("-xmax", NPA, pa), rmax);
return 0;
}
int gmx_genpr(int argc,char *argv[])
{
const char *desc[] = {
"[TT]genrestr[tt] produces an include file for a topology containing",
"a list of atom numbers and three force constants for the",
"[IT]x[it]-, [IT]y[it]-, and [IT]z[it]-direction. A single isotropic force constant may",
"be given on the command line instead of three components.[PAR]",
"WARNING: position restraints only work for the one molecule at a time.",
"Position restraints are interactions within molecules, therefore",
"they should be included within the correct [TT][ moleculetype ][tt]",
"block in the topology. Since the atom numbers in every moleculetype",
"in the topology start at 1 and the numbers in the input file for",
"[TT]genrestr[tt] number consecutively from 1, [TT]genrestr[tt] will only",
"produce a useful file for the first molecule.[PAR]",
"The [TT]-of[tt] option produces an index file that can be used for",
"freezing atoms. In this case, the input file must be a [TT].pdb[tt] file.[PAR]",
"With the [TT]-disre[tt] option, half a matrix of distance restraints",
"is generated instead of position restraints. With this matrix, that",
"one typically would apply to C[GRK]alpha[grk] atoms in a protein, one can",
"maintain the overall conformation of a protein without tieing it to",
"a specific position (as with position restraints)."
};
static rvec fc={1000.0,1000.0,1000.0};
static real freeze_level = 0.0;
static real disre_dist = 0.1;
static real disre_frac = 0.0;
static real disre_up2 = 1.0;
static gmx_bool bDisre=FALSE;
static gmx_bool bConstr=FALSE;
static real cutoff = -1.0;
t_pargs pa[] = {
{ "-fc", FALSE, etRVEC, {fc},
"force constants (kJ/mol nm^2)" },
{ "-freeze", FALSE, etREAL, {&freeze_level},
"if the [TT]-of[tt] option or this one is given an index file will be written containing atom numbers of all atoms that have a B-factor less than the level given here" },
{ "-disre", FALSE, etBOOL, {&bDisre},
"Generate a distance restraint matrix for all the atoms in index" },
{ "-disre_dist", FALSE, etREAL, {&disre_dist},
"Distance range around the actual distance for generating distance restraints" },
{ "-disre_frac", FALSE, etREAL, {&disre_frac},
"Fraction of distance to be used as interval rather than a fixed distance. If the fraction of the distance that you specify here is less than the distance given in the previous option, that one is used instead." },
{ "-disre_up2", FALSE, etREAL, {&disre_up2},
"Distance between upper bound for distance restraints, and the distance at which the force becomes constant (see manual)" },
{ "-cutoff", FALSE, etREAL, {&cutoff},
"Only generate distance restraints for atoms pairs within cutoff (nm)" },
{ "-constr", FALSE, etBOOL, {&bConstr},
"Generate a constraint matrix rather than distance restraints. Constraints of type 2 will be generated that do generate exclusions." }
};
#define npargs asize(pa)
output_env_t oenv;
t_atoms *atoms=NULL;
int i,j,k;
FILE *out;
int igrp;
real d,dd,lo,hi;
atom_id *ind_grp;
const char *xfn,*nfn;
char *gn_grp;
char title[STRLEN];
matrix box;
gmx_bool bFreeze;
rvec dx,*x=NULL,*v=NULL;
t_filenm fnm[] = {
{ efSTX, "-f", NULL, ffREAD },
{ efNDX, "-n", NULL, ffOPTRD },
{ efITP, "-o", "posre", ffWRITE },
{ efNDX, "-of", "freeze", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,0,NFILE,fnm,npargs,pa,
asize(desc),desc,0,NULL,&oenv);
bFreeze = opt2bSet("-of",NFILE,fnm) || opt2parg_bSet("-freeze",asize(pa),pa);
bDisre = bDisre || opt2parg_bSet("-disre_dist",npargs,pa);
xfn = opt2fn_null("-f",NFILE,fnm);
nfn = opt2fn_null("-n",NFILE,fnm);
if (( nfn == NULL ) && ( xfn == NULL))
gmx_fatal(FARGS,"no index file and no structure file suplied");
if ((disre_frac < 0) || (disre_frac >= 1))
gmx_fatal(FARGS,"disre_frac should be between 0 and 1");
if (disre_dist < 0)
gmx_fatal(FARGS,"disre_dist should be >= 0");
if (xfn != NULL) {
snew(atoms,1);
get_stx_coordnum(xfn,&(atoms->nr));
init_t_atoms(atoms,atoms->nr,TRUE);
snew(x,atoms->nr);
snew(v,atoms->nr);
fprintf(stderr,"\nReading structure file\n");
read_stx_conf(xfn,title,atoms,x,v,NULL,box);
}
if (bFreeze) {
if (atoms && atoms->pdbinfo)
gmx_fatal(FARGS,"No B-factors in input file %s, use a pdb file next time.",
xfn);
out=opt2FILE("-of",NFILE,fnm,"w");
fprintf(out,"[ freeze ]\n");
for(i=0; (i<atoms->nr); i++) {
if (atoms->pdbinfo[i].bfac <= freeze_level)
fprintf(out,"%d\n",i+1);
}
ffclose(out);
}
else if ((bDisre || bConstr) && x) {
printf("Select group to generate %s matrix from\n",
bConstr ? "constraint" : "distance restraint");
get_index(atoms,nfn,1,&igrp,&ind_grp,&gn_grp);
out=ftp2FILE(efITP,NFILE,fnm,"w");
if (bConstr) {
fprintf(out,"; constraints for %s of %s\n\n",gn_grp,title);
fprintf(out,"[ constraints ]\n");
fprintf(out,";%4s %5s %1s %10s\n","i","j","tp","dist");
}
else {
fprintf(out,"; distance restraints for %s of %s\n\n",gn_grp,title);
fprintf(out,"[ distance_restraints ]\n");
fprintf(out,";%4s %5s %1s %5s %10s %10s %10s %10s %10s\n","i","j","?",
"label","funct","lo","up1","up2","weight");
}
for(i=k=0; i<igrp; i++)
for(j=i+1; j<igrp; j++,k++) {
rvec_sub(x[ind_grp[i]],x[ind_grp[j]],dx);
d = norm(dx);
if (bConstr)
fprintf(out,"%5d %5d %1d %10g\n",ind_grp[i]+1,ind_grp[j]+1,2,d);
else {
if (cutoff < 0 || d < cutoff)
{
if (disre_frac > 0)
dd = min(disre_dist,disre_frac*d);
else
dd = disre_dist;
lo = max(0,d-dd);
hi = d+dd;
fprintf(out,"%5d %5d %1d %5d %10d %10g %10g %10g %10g\n",
ind_grp[i]+1,ind_grp[j]+1,1,k,1,
lo,hi,hi+1,1.0);
}
}
}
ffclose(out);
}
else {
printf("Select group to position restrain\n");
get_index(atoms,nfn,1,&igrp,&ind_grp,&gn_grp);
out=ftp2FILE(efITP,NFILE,fnm,"w");
fprintf(out,"; position restraints for %s of %s\n\n",gn_grp,title);
fprintf(out,"[ position_restraints ]\n");
fprintf(out,";%3s %5s %9s %10s %10s\n","i","funct","fcx","fcy","fcz");
for(i=0; i<igrp; i++)
fprintf(out,"%4d %4d %10g %10g %10g\n",
ind_grp[i]+1,1,fc[XX],fc[YY],fc[ZZ]);
ffclose(out);
}
if (xfn) {
sfree(x);
sfree(v);
}
thanx(stderr);
return 0;
}
int gmx_sans(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes SANS spectra using Debye formula.",
"It currently uses topology file (since it need to assigne element for each atom).",
"[PAR]",
"Parameters:[PAR]"
"[TT]-pr[tt] Computes normalized g(r) function averaged over trajectory[PAR]",
"[TT]-prframe[tt] Computes normalized g(r) function for each frame[PAR]",
"[TT]-sq[tt] Computes SANS intensity curve averaged over trajectory[PAR]",
"[TT]-sqframe[tt] Computes SANS intensity curve for each frame[PAR]",
"[TT]-startq[tt] Starting q value in nm[PAR]",
"[TT]-endq[tt] Ending q value in nm[PAR]",
"[TT]-qstep[tt] Stepping in q space[PAR]",
"Note: When using Debye direct method computational cost increases as",
"1/2 * N * (N - 1) where N is atom number in group of interest.",
"[PAR]",
"WARNING: If sq or pr specified this tool can produce large number of files! Up to two times larger than number of frames!"
};
static gmx_bool bPBC = TRUE;
static gmx_bool bNORM = FALSE;
static real binwidth = 0.2, grid = 0.05; /* bins shouldnt be smaller then smallest bond (~0.1nm) length */
static real start_q = 0.0, end_q = 2.0, q_step = 0.01;
static real mcover = -1;
static unsigned int seed = 0;
static int nthreads = -1;
static const char *emode[] = { NULL, "direct", "mc", NULL };
static const char *emethod[] = { NULL, "debye", "fft", NULL };
gmx_neutron_atomic_structurefactors_t *gnsf;
gmx_sans_t *gsans;
#define NPA asize(pa)
t_pargs pa[] = {
{ "-bin", FALSE, etREAL, {&binwidth},
"[HIDDEN]Binwidth (nm)" },
{ "-mode", FALSE, etENUM, {emode},
"Mode for sans spectra calculation" },
{ "-mcover", FALSE, etREAL, {&mcover},
"Monte-Carlo coverage should be -1(default) or (0,1]"},
{ "-method", FALSE, etENUM, {emethod},
"[HIDDEN]Method for sans spectra calculation" },
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Use periodic boundary conditions for computing distances" },
{ "-grid", FALSE, etREAL, {&grid},
"[HIDDEN]Grid spacing (in nm) for FFTs" },
{"-startq", FALSE, etREAL, {&start_q},
"Starting q (1/nm) "},
{"-endq", FALSE, etREAL, {&end_q},
"Ending q (1/nm)"},
{ "-qstep", FALSE, etREAL, {&q_step},
"Stepping in q (1/nm)"},
{ "-seed", FALSE, etINT, {&seed},
"Random seed for Monte-Carlo"},
#ifdef GMX_OPENMP
{ "-nt", FALSE, etINT, {&nthreads},
"Number of threads to start"},
#endif
};
FILE *fp;
const char *fnTPX, *fnTRX, *fnDAT = NULL;
t_trxstatus *status;
t_topology *top = NULL;
gmx_rmpbc_t gpbc = NULL;
gmx_bool bFFT = FALSE, bDEBYE = FALSE;
gmx_bool bMC = FALSE;
int ePBC = -1;
matrix box;
rvec *x;
int natoms;
real t;
char **grpname = NULL;
atom_id *index = NULL;
int isize;
int i;
char *hdr = NULL;
char *suffix = NULL;
t_filenm *fnmdup = NULL;
gmx_radial_distribution_histogram_t *prframecurrent = NULL, *pr = NULL;
gmx_static_structurefactor_t *sqframecurrent = NULL, *sq = NULL;
gmx_output_env_t *oenv;
#define NFILE asize(fnm)
t_filenm fnm[] = {
{ efTPR, "-s", NULL, ffREAD },
{ efTRX, "-f", NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efDAT, "-d", "nsfactor", ffOPTRD },
{ efXVG, "-pr", "pr", ffWRITE },
{ efXVG, "-sq", "sq", ffWRITE },
{ efXVG, "-prframe", "prframe", ffOPTWR },
{ efXVG, "-sqframe", "sqframe", ffOPTWR }
};
nthreads = gmx_omp_get_max_threads();
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;
}
/* check that binwidth not smaller than smallers distance */
check_binwidth(binwidth);
check_mcover(mcover);
/* setting number of omp threads globaly */
gmx_omp_set_num_threads(nthreads);
/* Now try to parse opts for modes */
GMX_RELEASE_ASSERT(emethod[0] != NULL, "Options inconsistency; emethod[0]Â is NULL");
switch (emethod[0][0])
{
case 'd':
bDEBYE = TRUE;
switch (emode[0][0])
{
case 'd':
bMC = FALSE;
break;
case 'm':
bMC = TRUE;
break;
default:
break;
}
break;
case 'f':
bFFT = TRUE;
break;
default:
break;
}
if (bDEBYE)
{
if (bMC)
{
fprintf(stderr, "Using Monte Carlo Debye method to calculate spectrum\n");
}
else
{
fprintf(stderr, "Using direct Debye method to calculate spectrum\n");
}
}
else if (bFFT)
{
gmx_fatal(FARGS, "FFT method not implemented!");
}
else
{
gmx_fatal(FARGS, "Unknown combination for mode and method!");
}
/* Try to read files */
fnDAT = ftp2fn(efDAT, NFILE, fnm);
fnTPX = ftp2fn(efTPR, NFILE, fnm);
fnTRX = ftp2fn(efTRX, NFILE, fnm);
gnsf = gmx_neutronstructurefactors_init(fnDAT);
fprintf(stderr, "Read %d atom names from %s with neutron scattering parameters\n\n", gnsf->nratoms, fnDAT);
snew(top, 1);
snew(grpname, 1);
snew(index, 1);
read_tps_conf(fnTPX, top, &ePBC, &x, NULL, box, TRUE);
printf("\nPlease select group for SANS spectra calculation:\n");
get_index(&(top->atoms), ftp2fn_null(efNDX, NFILE, fnm), 1, &isize, &index, grpname);
gsans = gmx_sans_init(top, gnsf);
/* Prepare reference frame */
if (bPBC)
{
gpbc = gmx_rmpbc_init(&top->idef, ePBC, top->atoms.nr);
gmx_rmpbc(gpbc, top->atoms.nr, box, x);
}
natoms = read_first_x(oenv, &status, fnTRX, &t, &x, box);
if (natoms != top->atoms.nr)
{
fprintf(stderr, "\nWARNING: number of atoms in tpx (%d) and trajectory (%d) do not match\n", natoms, top->atoms.nr);
}
do
{
if (bPBC)
{
gmx_rmpbc(gpbc, top->atoms.nr, box, x);
}
/* allocate memory for pr */
if (pr == NULL)
{
/* in case its first frame to read */
snew(pr, 1);
}
/* realy calc p(r) */
prframecurrent = calc_radial_distribution_histogram(gsans, x, box, index, isize, binwidth, bMC, bNORM, mcover, seed);
/* copy prframecurrent -> pr and summ up pr->gr[i] */
/* allocate and/or resize memory for pr->gr[i] and pr->r[i] */
if (pr->gr == NULL)
{
/* check if we use pr->gr first time */
snew(pr->gr, prframecurrent->grn);
snew(pr->r, prframecurrent->grn);
}
else
{
/* resize pr->gr and pr->r if needed to preven overruns */
if (prframecurrent->grn > pr->grn)
{
srenew(pr->gr, prframecurrent->grn);
srenew(pr->r, prframecurrent->grn);
}
}
pr->grn = prframecurrent->grn;
pr->binwidth = prframecurrent->binwidth;
/* summ up gr and fill r */
for (i = 0; i < prframecurrent->grn; i++)
{
pr->gr[i] += prframecurrent->gr[i];
pr->r[i] = prframecurrent->r[i];
}
/* normalize histo */
normalize_probability(prframecurrent->grn, prframecurrent->gr);
/* convert p(r) to sq */
sqframecurrent = convert_histogram_to_intensity_curve(prframecurrent, start_q, end_q, q_step);
/* print frame data if needed */
if (opt2fn_null("-prframe", NFILE, fnm))
{
snew(hdr, 25);
snew(suffix, GMX_PATH_MAX);
/* prepare header */
sprintf(hdr, "g(r), t = %f", t);
/* prepare output filename */
fnmdup = dup_tfn(NFILE, fnm);
sprintf(suffix, "-t%.2f", t);
add_suffix_to_output_names(fnmdup, NFILE, suffix);
fp = xvgropen(opt2fn_null("-prframe", NFILE, fnmdup), hdr, "Distance (nm)", "Probability", oenv);
for (i = 0; i < prframecurrent->grn; i++)
{
fprintf(fp, "%10.6f%10.6f\n", prframecurrent->r[i], prframecurrent->gr[i]);
}
done_filenms(NFILE, fnmdup);
xvgrclose(fp);
sfree(hdr);
sfree(suffix);
sfree(fnmdup);
}
if (opt2fn_null("-sqframe", NFILE, fnm))
{
snew(hdr, 25);
snew(suffix, GMX_PATH_MAX);
/* prepare header */
sprintf(hdr, "I(q), t = %f", t);
/* prepare output filename */
fnmdup = dup_tfn(NFILE, fnm);
sprintf(suffix, "-t%.2f", t);
add_suffix_to_output_names(fnmdup, NFILE, suffix);
fp = xvgropen(opt2fn_null("-sqframe", NFILE, fnmdup), hdr, "q (nm^-1)", "s(q)/s(0)", oenv);
for (i = 0; i < sqframecurrent->qn; i++)
{
fprintf(fp, "%10.6f%10.6f\n", sqframecurrent->q[i], sqframecurrent->s[i]);
}
done_filenms(NFILE, fnmdup);
xvgrclose(fp);
sfree(hdr);
sfree(suffix);
sfree(fnmdup);
}
/* free pr structure */
sfree(prframecurrent->gr);
sfree(prframecurrent->r);
sfree(prframecurrent);
/* free sq structure */
sfree(sqframecurrent->q);
sfree(sqframecurrent->s);
sfree(sqframecurrent);
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
/* normalize histo */
normalize_probability(pr->grn, pr->gr);
sq = convert_histogram_to_intensity_curve(pr, start_q, end_q, q_step);
/* prepare pr.xvg */
fp = xvgropen(opt2fn_null("-pr", NFILE, fnm), "G(r)", "Distance (nm)", "Probability", oenv);
for (i = 0; i < pr->grn; i++)
{
fprintf(fp, "%10.6f%10.6f\n", pr->r[i], pr->gr[i]);
}
xvgrclose(fp);
/* prepare sq.xvg */
fp = xvgropen(opt2fn_null("-sq", NFILE, fnm), "I(q)", "q (nm^-1)", "s(q)/s(0)", oenv);
for (i = 0; i < sq->qn; i++)
{
fprintf(fp, "%10.6f%10.6f\n", sq->q[i], sq->s[i]);
}
xvgrclose(fp);
/*
* Clean up memory
*/
sfree(pr->gr);
sfree(pr->r);
sfree(pr);
sfree(sq->q);
sfree(sq->s);
sfree(sq);
please_cite(stdout, "Garmay2012");
return 0;
}
int main(int argc,char *argv[])
{
const char *desc[] = {
"[TT]do_multiprot[tt] ",
"reads a trajectory file and aligns it to a reference structure ",
"each time frame",
"calling the multiprot program. This allows you to use a reference",
"structure whose sequence is different than that of the protein in the ",
"trajectory, since the alignment is based on the geometry, not sequence.",
"The output of [TT]do_multiprot[tt] includes the rmsd and the number of residues",
"on which it was calculated.",
"[PAR]",
"An aligned trajectory file is generated with the [TT]-ox[tt] option.[PAR]",
"With the [TT]-cr[tt] option, the number of hits in the alignment is given",
"per residue. This number can be between 0 and the number of frames, and",
"indicates the structural conservation of this residue.[PAR]",
"If you do not have the [TT]multiprot[tt] program, get it. [TT]do_multiprot[tt] assumes",
"that the [TT]multiprot[tt] executable is [TT]/usr/local/bin/multiprot[tt]. If this is ",
"not the case, then you should set an environment variable [BB]MULTIPROT[bb]",
"pointing to the [TT]multiprot[tt] executable, e.g.: [PAR]",
"[TT]setenv MULTIPROT /usr/MultiProtInstall/multiprot.Linux[tt][PAR]",
"Note that at the current implementation only binary alignment (your",
"molecule to a reference) is supported. In addition, note that the ",
"by default [TT]multiprot[tt] aligns the two proteins on their C-alpha carbons.",
"and that this depends on the [TT]multiprot[tt] parameters which are not dealt ",
"with here. Thus, the C-alpha carbons is expected to give the same "
"results as choosing the whole protein and will be slightly faster.[PAR]",
"For information about [TT]multiprot[tt], see:",
"http://bioinfo3d.cs.tau.ac.il/MultiProt/.[PAR]"
};
static bool bVerbose;
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"HIDDENGenerate miles of useless information"
}
};
const char *bugs[] = {
"The program is very slow, since multiprot is run externally"
};
t_trxstatus *status;
t_trxstatus *trxout=NULL;
FILE *tapein,*fo,*frc,*tmpf,*out=NULL,*fres=NULL;
const char *fnRef;
const char *fn="2_sol.res";
t_topology top;
int ePBC;
t_atoms *atoms,ratoms,useatoms;
t_trxframe fr;
t_pdbinfo p;
int nres,nres2,nr0;
real t;
int i,j,natoms,nratoms,nframe=0,model_nr=-1;
int cur_res,prev_res;
int nout;
t_countres *countres=NULL;
matrix box,rbox;
int gnx;
char *grpnm,*ss_str;
atom_id *index;
rvec *xp,*x,*xr;
char pdbfile[32],refpdb[256],title[256],rtitle[256],filemode[5];
char out_title[256];
char multiprot[256],*mptr;
int ftp;
int outftp=-1;
real rmsd;
bool bTrjout,bCountres;
const char *TrjoutFile=NULL;
output_env_t oenv;
static rvec translation= {0,0,0},rotangles= {0,0,0};
gmx_rmpbc_t gpbc=NULL;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efSTX, "-r", NULL , ffREAD },
{ efXVG, "-o", "rmss", ffWRITE },
{ efXVG, "-rc", "rescount", ffWRITE},
{ efXVG, "-cr", "countres", ffOPTWR},
{ efTRX, "-ox", "aligned", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_TIME_UNIT | PCA_BE_NICE ,
NFILE,fnm, asize(pa),pa, asize(desc),desc,
asize(bugs),bugs,&oenv
);
fnRef=opt2fn("-r",NFILE,fnm);
bTrjout = opt2bSet("-ox",NFILE,fnm);
bCountres= opt2bSet("-cr",NFILE,fnm);
if (bTrjout) {
TrjoutFile = opt2fn_null("-ox",NFILE,fnm);
}
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xp,NULL,box,FALSE);
gpbc = gmx_rmpbc_init(&top.idef,ePBC,top.atoms.nr,box);
atoms=&(top.atoms);
ftp=fn2ftp(fnRef);
get_stx_coordnum(fnRef,&nratoms);
init_t_atoms(&ratoms,nratoms,TRUE);
snew(xr,nratoms);
read_stx_conf(fnRef,rtitle,&ratoms,xr,NULL,&ePBC,rbox);
if (bVerbose) {
fprintf(stderr,"Read %d atoms\n",atoms->nr);
fprintf(stderr,"Read %d reference atoms\n",ratoms.nr);
}
if (bCountres) {
snew(countres,ratoms.nres);
j=0;
cur_res=0;
for (i=0; i<ratoms.nr; i++) {
prev_res=cur_res;
cur_res=ratoms.atom[i].resind;
if (cur_res != prev_res) {
countres[j].resnr=cur_res;
countres[j].count=0;
j++;
}
}
}
get_index(atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&gnx,&index,&grpnm);
nres=0;
nr0=-1;
for(i=0; (i<gnx); i++) {
if (atoms->atom[index[i]].resind != nr0) {
nr0=atoms->atom[index[i]].resind;
nres++;
}
}
fprintf(stderr,"There are %d residues in your selected group\n",nres);
strcpy(pdbfile,"ddXXXXXX");
gmx_tmpnam(pdbfile);
if ((tmpf = fopen(pdbfile,"w")) == NULL) {
sprintf(pdbfile,"%ctmp%cfilterXXXXXX",DIR_SEPARATOR,DIR_SEPARATOR);
gmx_tmpnam(pdbfile);
if ((tmpf = fopen(pdbfile,"w")) == NULL) {
gmx_fatal(FARGS,"Can not open tmp file %s",pdbfile);
}
}
else {
ffclose(tmpf);
}
if (ftp != efPDB) {
strcpy(refpdb,"ddXXXXXX");
gmx_tmpnam(refpdb);
strcat(refpdb,".pdb");
write_sto_conf(refpdb,rtitle,&ratoms,xr,NULL,ePBC,rbox);
}
else {
strcpy(refpdb,fnRef);
}
if ((mptr=getenv("MULTIPROT")) == NULL) {
mptr="/usr/local/bin/multiprot";
}
if (!gmx_fexist(mptr)) {
gmx_fatal(FARGS,"MULTIPROT executable (%s) does not exist (use setenv MULTIPROT)",
mptr);
}
sprintf (multiprot,"%s %s %s > /dev/null %s",
mptr, refpdb, pdbfile, "2> /dev/null");
if (bVerbose)
fprintf(stderr,"multiprot cmd='%s'\n",multiprot);
if (!read_first_frame(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&fr,TRX_READ_X))
gmx_fatal(FARGS,"Could not read a frame from %s",ftp2fn(efTRX,NFILE,fnm));
natoms = fr.natoms;
if (bTrjout) {
nout=natoms;
/* open file now */
outftp=fn2ftp(TrjoutFile);
if (bVerbose)
fprintf(stderr,"Will write %s: %s\n",ftp2ext(ftp),ftp2desc(outftp));
strcpy(filemode,"w");
switch (outftp) {
case efXTC:
case efG87:
case efTRR:
case efTRJ:
out=NULL;
trxout = open_trx(TrjoutFile,filemode);
break;
case efGRO:
case efG96:
case efPDB:
/* Make atoms struct for output in GRO or PDB files */
/* get memory for stuff to go in pdb file */
init_t_atoms(&useatoms,nout,FALSE);
sfree(useatoms.resinfo);
useatoms.resinfo=atoms->resinfo;
for(i=0; (i<nout); i++) {
useatoms.atomname[i]=atoms->atomname[i];
useatoms.atom[i]=atoms->atom[i];
useatoms.nres=max(useatoms.nres,useatoms.atom[i].resind+1);
}
useatoms.nr=nout;
out=ffopen(TrjoutFile,filemode);
break;
}
if (outftp == efG87)
fprintf(gmx_fio_getfp(trx_get_fileio(trxout)),"Generated by %s. #atoms=%d, a BOX is"
" stored in this file.\n",Program(),nout);
}
if (natoms > atoms->nr) {
gmx_fatal(FARGS,"\nTrajectory does not match topology!");
}
if (gnx > natoms) {
gmx_fatal(FARGS,"\nTrajectory does not match selected group!");
}
fo = xvgropen(opt2fn("-o",NFILE,fnm),"RMSD","Time (ps)","RMSD (nm)",oenv);
frc = xvgropen(opt2fn("-rc",NFILE,fnm),"Number of Residues in the alignment","Time (ps)","Residues",oenv);
do {
t = output_env_conv_time(oenv,fr.time);
gmx_rmpbc(gpbc,natoms,fr.box,fr.x);
tapein=ffopen(pdbfile,"w");
write_pdbfile_indexed(tapein,NULL,atoms,fr.x,ePBC,fr.box,' ',-1,gnx,index,NULL,TRUE);
ffclose(tapein);
system(multiprot);
remove(pdbfile);
process_multiprot_output(fn, &rmsd, &nres2,rotangles,translation,bCountres,countres);
fprintf(fo,"%12.7f",t);
fprintf(fo," %12.7f\n",rmsd);
fprintf(frc,"%12.7f",t);
fprintf(frc,"%12d\n",nres2);
if (bTrjout) {
rotate_conf(natoms,fr.x,NULL,rotangles[XX],rotangles[YY],rotangles[ZZ]);
for(i=0; i<natoms; i++) {
rvec_inc(fr.x[i],translation);
}
switch(outftp) {
case efTRJ:
case efTRR:
case efG87:
case efXTC:
write_trxframe(trxout,&fr,NULL);
break;
case efGRO:
case efG96:
case efPDB:
sprintf(out_title,"Generated by do_multiprot : %s t= %g %s",
title,output_env_conv_time(oenv,fr.time),output_env_get_time_unit(oenv));
switch(outftp) {
case efGRO:
write_hconf_p(out,out_title,&useatoms,prec2ndec(fr.prec),
fr.x,NULL,fr.box);
break;
case efPDB:
fprintf(out,"REMARK GENERATED BY DO_MULTIPROT\n");
sprintf(out_title,"%s t= %g %s",title,output_env_conv_time(oenv,fr.time),output_env_get_time_unit(oenv));
/* if reading from pdb, we want to keep the original
model numbering else we write the output frame
number plus one, because model 0 is not allowed in pdb */
if (ftp==efPDB && fr.step > model_nr) {
model_nr = fr.step;
}
else {
model_nr++;
}
write_pdbfile(out,out_title,&useatoms,fr.x,ePBC,fr.box,' ',model_nr,NULL,TRUE);
break;
case efG96:
fr.title = out_title;
fr.bTitle = (nframe == 0);
fr.bAtoms = FALSE;
fr.bStep = TRUE;
fr.bTime = TRUE;
write_g96_conf(out,&fr,-1,NULL);
}
break;
}
}
nframe++;
} while(read_next_frame(oenv,status,&fr));
if (bCountres) {
fres= xvgropen(opt2fn("-cr",NFILE,fnm),"Number of frames in which the residues are aligned to","Residue","Number",oenv);
for (i=0; i<ratoms.nres; i++) {
fprintf(fres,"%10d %12d\n",countres[i].resnr,countres[i].count);
}
ffclose(fres);
}
ffclose(fo);
ffclose(frc);
fprintf(stderr,"\n");
close_trj(status);
if (trxout != NULL) {
close_trx(trxout);
}
else if (out != NULL) {
ffclose(out);
}
view_all(oenv,NFILE, fnm);
sfree(xr);
if (bCountres) {
sfree(countres);
}
free_t_atoms(&ratoms,TRUE);
if (bTrjout) {
if (outftp==efPDB || outftp==efGRO || outftp==efG96) {
free_t_atoms(&useatoms,TRUE);
}
}
thanx(stderr);
return 0;
}
int gmx_energy2bfac (int argc, char *argv[]) {
const char *desc[] =
{ "It maps the binding energy contribution of each residue on the structure.",
"The energy will be written in the B-factor field of the output PDB file/s",
"This PDB file can be used with any molecular visualizer and ",
"residues can be viewed in color according to the energy of respective residue.",
"The molecular visualizer should support method to color residues by B-factor values."
};
t_filenm fnm[] =
{
{ efTPS, "-s", NULL, ffREAD },
{ efDAT, "-i", "decomp_energy", ffREAD },
{ efNDX, "-n", "index", ffOPTRD },
{ efPDB, "-c", "complex.pdb", ffOPTWR },
{ efPDB, "-s1", "subunit_1.pdb", ffOPTWR },
{ efPDB, "-s2", "subunit_2.pdb", ffOPTWR },
};
char title[STRLEN], buf[256];
t_topology top;
int ePBC;
rvec *xtop;
matrix box;
t_atoms *atoms;
char *atomtype, *resname, *atomname, **modresname = NULL;
output_env_t oenv;
//Variable for index file
int *isize; //Number of index group
atom_id **index;
char **grpnm;
int i=0,j=0,k=0;
gmx_bool *bAtomA, *bAtomB, *bAtomAB;
int nres = 0, prev_res, curr_res;
gmx_bool *bResA, *bResB;
real *energy;
char fnEnergy[256];
FILE *fComplex, *fS1, *fS2;
#define NFILE asize(fnm)
CopyRightMsg();
//To show the option on the screen and to take the all option
parse_common_args(&argc, argv,
PCA_CAN_TIME | PCA_CAN_VIEW | PCA_TIME_UNIT | PCA_BE_NICE, NFILE, fnm,
0, NULL, asize(desc), desc, 0, NULL, &oenv);
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC, &xtop, NULL, box, FALSE);
atoms = &(top.atoms);
if (opt2fn_null("-i", NFILE, fnm) == NULL )
gmx_fatal(FARGS, "Residue energy file is missing, use \"-i\" option\n");
else
sprintf(fnEnergy, "%s", opt2fn("-i", NFILE, fnm));
snew(isize, 2);
snew(index, 2);
snew(grpnm, 2);
printf(
"\n\n\nEnter the group number for Protein or first Protein or first group\n\n");
get_index(atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &isize[0], &index[0],
&grpnm[0]);
printf(
"\n\n\nEnter the group number of Ligand or second Protein or second group\n\n");
get_index(atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &isize[1], &index[1],
&grpnm[1]);
srenew(index, 3);
srenew(isize, 3);
isize[2] = isize[0] + isize[1];
snew(index[2], isize[0]+isize[1]);
for (i = 0; i < isize[0]; i++)
index[2][i] = index[0][i];
for (i = 0; i < isize[1]; i++)
index[2][i + isize[0]] = index[1][i];
snew(bResA,top.atoms.nres);
snew(bResB,top.atoms.nres);
for(i = 0; i<top.atoms.nres;i++)
{
bResA[i] = FALSE;
bResB[i] = FALSE;
}
nres = 1;
prev_res = atoms->atom[index[2][0]].resind;
bResA[atoms->atom[index[2][0]].resind] = TRUE;
for(i=0;i<isize[2];i++)
{
curr_res = atoms->atom[index[2][i]].resind;
if(curr_res != prev_res)
{
nres++;
if(i<isize[0])
bResA[atoms->atom[index[2][i]].resind] = TRUE;
else
bResB[atoms->atom[index[2][i]].resind] = TRUE;
prev_res = curr_res;
}
}
printf("\nTotal number of residues in topology: %d \n", nres);
snew(energy,nres);
get_energy( fnEnergy, nres, energy);
snew(atoms->pdbinfo, atoms->nr);
for(i = 0; i<isize[2];i++)
{
if((bResA[atoms->atom[index[2][i]].resind]) || (bResB[atoms->atom[index[2][i]].resind])) {
atoms->pdbinfo[index[2][i]].bfac = energy[atoms->atom[index[2][i]].resind];
atoms->pdbinfo[index[2][i]].occup = 1.00;
}
else{
atoms->pdbinfo[index[2][i]].bfac = 0.00;
atoms->pdbinfo[index[2][i]].occup = 1.00;
}
}
fComplex = gmx_ffopen(opt2fn("-c", NFILE, fnm),"w");
write_pdbfile_indexed(fComplex,NULL,atoms,xtop,ePBC,box,' ',-1,isize[2],index[2],NULL,TRUE);
fS1 = gmx_ffopen(opt2fn("-s1", NFILE, fnm),"w");
write_pdbfile_indexed(fS1,NULL,atoms,xtop,ePBC,box,' ',-1,isize[0],index[0],NULL,TRUE);
fS2 = gmx_ffopen(opt2fn("-s2", NFILE, fnm),"w");
write_pdbfile_indexed(fS2,NULL,atoms,xtop,ePBC,box,' ',-1,isize[1],index[1],NULL,TRUE);
return 0;
}
int gmx_kinetics(int argc, char *argv[])
{
const char *desc[] = {
"[TT]g_kinetics[tt] reads two [TT].xvg[tt] files, each one containing data for N replicas.",
"The first file contains the temperature of each replica at each timestep,",
"and the second contains real values that can be interpreted as",
"an indicator for folding. If the value in the file is larger than",
"the cutoff it is taken to be unfolded and the other way around.[PAR]",
"From these data an estimate of the forward and backward rate constants",
"for folding is made at a reference temperature. In addition,",
"a theoretical melting curve and free energy as a function of temperature",
"are printed in an [TT].xvg[tt] file.[PAR]",
"The user can give a max value to be regarded as intermediate",
"([TT]-ucut[tt]), which, when given will trigger the use of an intermediate state",
"in the algorithm to be defined as those structures that have",
"cutoff < DATA < ucut. Structures with DATA values larger than ucut will",
"not be regarded as potential folders. In this case 8 parameters are optimized.[PAR]",
"The average fraction foled is printed in an [TT].xvg[tt] file together with the fit to it.",
"If an intermediate is used a further file will show the build of the intermediate and the fit to that process.[PAR]",
"The program can also be used with continuous variables (by setting",
"[TT]-nodiscrete[tt]). In this case kinetics of other processes can be",
"studied. This is very much a work in progress and hence the manual",
"(this information) is lagging behind somewhat.[PAR]",
"In order to compile this program you need access to the GNU",
"scientific library."
};
static int nreplica = 1;
static real tref = 298.15;
static real cutoff = 0.2;
static real ucut = 0.0;
static real Euf = 10;
static real Efu = 30;
static real Ei = 10;
static gmx_bool bHaveT = TRUE;
static real t0 = -1;
static real t1 = -1;
static real tb = 0;
static real te = 0;
static real tol = 1e-3;
static int maxiter = 100;
static int skip = 0;
static int nmult = 1;
static gmx_bool bBack = TRUE;
static gmx_bool bSplit = TRUE;
static gmx_bool bSum = TRUE;
static gmx_bool bDiscrete = TRUE;
t_pargs pa[] = {
{ "-time", FALSE, etBOOL, {&bHaveT},
"Expect a time in the input" },
{ "-b", FALSE, etREAL, {&tb},
"First time to read from set" },
{ "-e", FALSE, etREAL, {&te},
"Last time to read from set" },
{ "-bfit", FALSE, etREAL, {&t0},
"Time to start the fit from" },
{ "-efit", FALSE, etREAL, {&t1},
"Time to end the fit" },
{ "-T", FALSE, etREAL, {&tref},
"Reference temperature for computing rate constants" },
{ "-n", FALSE, etINT, {&nreplica},
"Read data for this number of replicas. Only necessary when files are written in xmgrace format using @type and & as delimiters." },
{ "-cut", FALSE, etREAL, {&cutoff},
"Cut-off (max) value for regarding a structure as folded" },
{ "-ucut", FALSE, etREAL, {&ucut},
"Cut-off (max) value for regarding a structure as intermediate (if not folded)" },
{ "-euf", FALSE, etREAL, {&Euf},
"Initial guess for energy of activation for folding (kJ/mol)" },
{ "-efu", FALSE, etREAL, {&Efu},
"Initial guess for energy of activation for unfolding (kJ/mol)" },
{ "-ei", FALSE, etREAL, {&Ei},
"Initial guess for energy of activation for intermediates (kJ/mol)" },
{ "-maxiter", FALSE, etINT, {&maxiter},
"Max number of iterations" },
{ "-back", FALSE, etBOOL, {&bBack},
"Take the back reaction into account" },
{ "-tol", FALSE, etREAL, {&tol},
"Absolute tolerance for convergence of the Nelder and Mead simplex algorithm" },
{ "-skip", FALSE, etINT, {&skip},
"Skip points in the output [TT].xvg[tt] file" },
{ "-split", FALSE, etBOOL, {&bSplit},
"Estimate error by splitting the number of replicas in two and refitting" },
{ "-sum", FALSE, etBOOL, {&bSum},
"Average folding before computing [GRK]chi[grk]^2" },
{ "-discrete", FALSE, etBOOL, {&bDiscrete},
"Use a discrete folding criterion (F <-> U) or a continuous one" },
{ "-mult", FALSE, etINT, {&nmult},
"Factor to multiply the data with before discretization" }
};
#define NPA asize(pa)
FILE *fp;
real dt_t, dt_d, dt_d2;
int nset_t, nset_d, nset_d2, n_t, n_d, n_d2, i;
const char *tfile, *dfile, *dfile2;
t_remd_data remd;
output_env_t oenv;
t_filenm fnm[] = {
{ efXVG, "-f", "temp", ffREAD },
{ efXVG, "-d", "data", ffREAD },
{ efXVG, "-d2", "data2", ffOPTRD },
{ efXVG, "-o", "ft_all", ffWRITE },
{ efXVG, "-o2", "it_all", ffOPTWR },
{ efXVG, "-o3", "ft_repl", ffOPTWR },
{ efXVG, "-ee", "err_est", ffOPTWR },
{ efLOG, "-g", "remd", ffWRITE },
{ efXVG, "-m", "melt", ffWRITE }
};
#define NFILE asize(fnm)
parse_common_args(&argc, argv, PCA_CAN_VIEW | PCA_BE_NICE | PCA_TIME_UNIT,
NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv);
#ifdef HAVE_LIBGSL
please_cite(stdout, "Spoel2006d");
if (cutoff < 0)
{
gmx_fatal(FARGS, "cutoff should be >= 0 (rather than %f)", cutoff);
}
tfile = opt2fn("-f", NFILE, fnm);
dfile = opt2fn("-d", NFILE, fnm);
dfile2 = opt2fn_null("-d2", NFILE, fnm);
fp = ffopen(opt2fn("-g", NFILE, fnm), "w");
remd.temp = read_xvg_time(tfile, bHaveT,
opt2parg_bSet("-b", NPA, pa), tb,
opt2parg_bSet("-e", NPA, pa), te,
nreplica, &nset_t, &n_t, &dt_t, &remd.time);
printf("Read %d sets of %d points in %s, dt = %g\n\n", nset_t, n_t, tfile, dt_t);
sfree(remd.time);
remd.data = read_xvg_time(dfile, bHaveT,
opt2parg_bSet("-b", NPA, pa), tb,
opt2parg_bSet("-e", NPA, pa), te,
nreplica, &nset_d, &n_d, &dt_d, &remd.time);
printf("Read %d sets of %d points in %s, dt = %g\n\n", nset_d, n_d, dfile, dt_d);
if ((nset_t != nset_d) || (n_t != n_d) || (dt_t != dt_d))
{
gmx_fatal(FARGS, "Files %s and %s are inconsistent. Check log file",
tfile, dfile);
}
if (dfile2)
{
remd.data2 = read_xvg_time(dfile2, bHaveT,
opt2parg_bSet("-b", NPA, pa), tb,
opt2parg_bSet("-e", NPA, pa), te,
nreplica, &nset_d2, &n_d2, &dt_d2, &remd.time);
printf("Read %d sets of %d points in %s, dt = %g\n\n",
nset_d2, n_d2, dfile2, dt_d2);
if ((nset_d2 != nset_d) || (n_d != n_d2) || (dt_d != dt_d2))
{
gmx_fatal(FARGS, "Files %s and %s are inconsistent. Check log file",
dfile, dfile2);
}
}
else
{
remd.data2 = NULL;
}
remd.nreplica = nset_d;
remd.nframe = n_d;
remd.dt = 1;
preprocess_remd(fp, &remd, cutoff, tref, ucut, bBack, Euf, Efu, Ei, t0, t1,
bSum, bDiscrete, nmult);
optimize_remd_parameters(&remd, maxiter, tol);
dump_remd_parameters(fp, &remd, opt2fn("-o", NFILE, fnm),
opt2fn_null("-o2", NFILE, fnm),
opt2fn_null("-o3", NFILE, fnm),
opt2fn_null("-ee", NFILE, fnm),
opt2fn("-m", NFILE, fnm), skip, tref, oenv);
if (bSplit)
{
printf("Splitting set of replicas in two halves\n");
for (i = 0; (i < remd.nreplica); i++)
{
remd.bMask[i] = FALSE;
}
remd.nmask = 0;
for (i = 0; (i < remd.nreplica); i += 2)
{
remd.bMask[i] = TRUE;
remd.nmask++;
}
sum_ft(&remd);
optimize_remd_parameters(&remd, maxiter, tol);
dump_remd_parameters(fp, &remd, "test1.xvg", NULL, NULL, NULL, NULL, skip, tref, oenv);
for (i = 0; (i < remd.nreplica); i++)
{
remd.bMask[i] = !remd.bMask[i];
}
remd.nmask = remd.nreplica - remd.nmask;
sum_ft(&remd);
optimize_remd_parameters(&remd, maxiter, tol);
dump_remd_parameters(fp, &remd, "test2.xvg", NULL, NULL, NULL, NULL, skip, tref, oenv);
for (i = 0; (i < remd.nreplica); i++)
{
remd.bMask[i] = FALSE;
}
remd.nmask = 0;
for (i = 0; (i < remd.nreplica/2); i++)
{
remd.bMask[i] = TRUE;
remd.nmask++;
}
sum_ft(&remd);
optimize_remd_parameters(&remd, maxiter, tol);
dump_remd_parameters(fp, &remd, "test1.xvg", NULL, NULL, NULL, NULL, skip, tref, oenv);
for (i = 0; (i < remd.nreplica); i++)
{
remd.bMask[i] = FALSE;
}
remd.nmask = 0;
for (i = remd.nreplica/2; (i < remd.nreplica); i++)
{
remd.bMask[i] = TRUE;
remd.nmask++;
}
sum_ft(&remd);
optimize_remd_parameters(&remd, maxiter, tol);
dump_remd_parameters(fp, &remd, "test1.xvg", NULL, NULL, NULL, NULL, skip, tref, oenv);
}
ffclose(fp);
view_all(oenv, NFILE, fnm);
#else
fprintf(stderr, "This program should be compiled with the GNU scientific library. Please install the library and reinstall GROMACS.\n");
#endif /*HAVE_LIBGSL*/
return 0;
}
int main(int argc,char *argv[])
{
static char *desc[] = {
"do_dssp ",
"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. do_dssp assumes that the dssp executable is",
"/usr/local/bin/dssp. If this is not the case, then you should",
"set an environment variable [BB]DSSP[bb] pointing to the dssp",
"executable, e.g.: [PAR]",
"[TT]setenv DSSP /opt/dssp/bin/dssp[tt][PAR]",
"The structure assignment for each residue and time is written to an",
"[TT].xpm[tt] matrix file. This file can be visualized with for instance",
"[TT]xv[tt] and can be converted to postscript with [TT]xpm2ps[tt].",
"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 [TT]g_sas[tt] 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 [TT]g_chi[tt]. Together",
"these two programs can be used to analyze dihedral properties as a",
"function of secondary structure type."
};
static bool bVerbose;
static char *ss_string="HEBT";
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"HIDDENGenerate miles of useless information" },
{ "-sss", FALSE, etSTR, {&ss_string},
"Secondary structures for structure count"}
};
int status;
FILE *tapein;
FILE *ss,*acc,*fTArea,*tmpf;
char *fnSCount,*fnArea,*fnTArea,*fnAArea;
char *leg[] = { "Phobic", "Phylic" };
t_topology top;
int ePBC;
t_atoms *atoms;
t_matrix mat;
int nres,nr0,naccr;
bool *bPhbres,bDoAccSurf;
real t;
int i,j,natoms,nframe=0;
matrix box;
int gnx;
char *grpnm,*ss_str;
atom_id *index;
rvec *xp,*x;
int *average_area;
real **accr,*av_area, *norm_av_area;
char pdbfile[32],tmpfile[32],title[256];
char dssp[256],*dptr;
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)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_TIME_UNIT | PCA_BE_NICE ,
NFILE,fnm, asize(pa),pa, asize(desc),desc,0,NULL);
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]].resnr != nr0) {
nr0=atoms->atom[index[i]].resnr;
nres++;
}
}
fprintf(stderr,"There are %d residues in your selected group\n",nres);
strcpy(pdbfile,"ddXXXXXX");
gmx_tmpnam(pdbfile);
if ((tmpf = fopen(pdbfile,"w")) == NULL) {
sprintf(pdbfile,"%ctmp%cfilterXXXXXX",DIR_SEPARATOR,DIR_SEPARATOR);
gmx_tmpnam(pdbfile);
if ((tmpf = fopen(pdbfile,"w")) == NULL)
gmx_fatal(FARGS,"Can not open tmp file %s",pdbfile);
}
else
fclose(tmpf);
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 (!fexist(dptr))
gmx_fatal(FARGS,"DSSP executable (%s) does not exist (use setenv DSSP)",
dptr);
sprintf(dssp,"%s %s %s %s > /dev/null %s",
dptr,bDoAccSurf?"":"-na",pdbfile,tmpfile,bVerbose?"":"2> /dev/null");
if (bVerbose)
fprintf(stderr,"dssp cmd='%s'\n",dssp);
if (fnTArea) {
fTArea=xvgropen(fnTArea,"Solvent Accessible Surface Area",
xvgr_tlabel(),"Area (nm\\S2\\N)");
xvgr_legend(fTArea,2,leg);
} else
fTArea=NULL;
mat.map=NULL;
mat.nmap=getcmap(libopen(opt2fn("-map",NFILE,fnm)),
opt2fn("-map",NFILE,fnm),&(mat.map));
natoms=read_first_x(&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+10);
snew(av_area,atoms->nres+10);
snew(norm_av_area,atoms->nres+10);
accr=NULL;
naccr=0;
do {
t = convert_time(t);
if (nframe>=naccr) {
naccr+=10;
srenew(accr,naccr);
for(i=naccr-10; i<naccr; i++)
snew(accr[i],atoms->nres+10);
}
rm_pbc(&(top.idef),ePBC,natoms,box,x,x);
tapein=ffopen(pdbfile,"w");
write_pdbfile_indexed(tapein,NULL,atoms,x,ePBC,box,0,-1,gnx,index);
fclose(tapein);
#ifdef GMX_NO_SYSTEM
printf("Warning-- No calls to system(3) supported on this platform.");
printf("Warning-- Skipping execution of 'system(\"%s\")'.", dssp);
exit(1);
#else
if(0 != system(dssp))
{
gmx_fatal(FARGS,"Failed to execute command: %s",dssp);
}
#endif
strip_dssp(tmpfile,nres,bPhbres,t,
accr[nframe],fTArea,&mat,average_area);
remove(tmpfile);
remove(pdbfile);
nframe++;
} while(read_next_x(status,&t,natoms,x,box));
fprintf(stderr,"\n");
close_trj(status);
if (fTArea)
ffclose(fTArea);
prune_ss_legend(&mat);
ss=opt2FILE("-o",NFILE,fnm,"w");
write_xpm_m(ss,mat);
ffclose(ss);
if (opt2bSet("-ssdump",NFILE,fnm)) {
snew(ss_str,nres+1);
for(i=0; (i<nres); i++)
ss_str[i] = mat.map[mat.matrix[0][i]].code.c1;
ss_str[i] = '\0';
ss = opt2FILE("-ssdump",NFILE,fnm,"w");
fprintf(ss,"%d\n%s\n",nres,ss_str);
fclose(ss);
sfree(ss_str);
}
analyse_ss(fnSCount,&mat,ss_string);
if (bDoAccSurf) {
write_sas_mat(fnArea,accr,nframe,nres,&mat);
for(i=0; i<atoms->nres; i++)
av_area[i] = (average_area[i] / (real)nframe);
norm_acc(atoms, nres, av_area, norm_av_area);
if (fnAArea) {
acc=xvgropen(fnAArea,"Average Accessible Area",
"Residue","A\\S2");
for(i=0; (i<nres); i++)
fprintf(acc,"%5d %10g %10g\n",i+1,av_area[i], norm_av_area[i]);
ffclose(acc);
}
}
view_all(NFILE, fnm);
thanx(stderr);
return 0;
}
int gmx_analyze(int argc,char *argv[])
{
static char *desc[] = {
"g_analyze reads an ascii file and analyzes data sets.",
"A line in the input file may start with a time",
"(see option [TT]-time[tt]) and any number of y values may follow.",
"Multiple sets can also be",
"read when they are seperated by & (option [TT]-n[tt]),",
"in this case only one y value is read from each line.",
"All lines starting with # and @ are skipped.",
"All analyses can also be done for the derivative of a set",
"(option [TT]-d[tt]).[PAR]",
"All options, except for [TT]-av[tt] and [TT]-power[tt] assume that the",
"points are equidistant in time.[PAR]",
"g_analyze always shows the average and standard deviation of each",
"set. For each set it also shows the relative deviation of the third",
"and forth cumulant from those of a Gaussian distribution with the same",
"standard deviation.[PAR]",
"Option [TT]-ac[tt] produces the autocorrelation function(s).[PAR]",
"Option [TT]-cc[tt] plots the resemblance of set i with a cosine of",
"i/2 periods. The formula is:[BR]"
"2 (int0-T y(t) cos(i pi t) dt)^2 / int0-T y(t) y(t) dt[BR]",
"This is useful for principal components obtained from covariance",
"analysis, since the principal components of random diffusion are",
"pure cosines.[PAR]",
"Option [TT]-msd[tt] produces the mean square displacement(s).[PAR]",
"Option [TT]-dist[tt] produces distribution plot(s).[PAR]",
"Option [TT]-av[tt] produces the average over the sets.",
"Error bars can be added with the option [TT]-errbar[tt].",
"The errorbars can represent the standard deviation, the error",
"(assuming the points are independent) or the interval containing",
"90% of the points, by discarding 5% of the points at the top and",
"the bottom.[PAR]",
"Option [TT]-ee[tt] produces error estimates using block averaging.",
"A set is divided in a number of blocks and averages are calculated for",
"each block. The error for the total average is calculated from",
"the variance between averages of the m blocks B_i as follows:",
"error^2 = Sum (B_i - <B>)^2 / (m*(m-1)).",
"These errors are plotted as a function of the block size.",
"Also an analytical block average curve is plotted, assuming",
"that the autocorrelation is a sum of two exponentials.",
"The analytical curve for the block average is:[BR]",
"f(t) = sigma sqrt(2/T ( a (tau1 ((exp(-t/tau1) - 1) tau1/t + 1)) +[BR]",
" (1-a) (tau2 ((exp(-t/tau2) - 1) tau2/t + 1)))),[BR]"
"where T is the total time.",
"a, tau1 and tau2 are obtained by fitting f^2(t) to error^2.",
"When the actual block average is very close to the analytical curve,",
"the error is sigma*sqrt(2/T (a tau1 + (1-a) tau2)).",
"The complete derivation is given in",
"B. Hess, J. Chem. Phys. 116:209-217, 2002.[PAR]",
"Option [TT]-filter[tt] prints the RMS high-frequency fluctuation",
"of each set and over all sets with respect to a filtered average.",
"The filter is proportional to cos(pi t/len) where t goes from -len/2",
"to len/2. len is supplied with the option [TT]-filter[tt].",
"This filter reduces oscillations with period len/2 and len by a factor",
"of 0.79 and 0.33 respectively.[PAR]",
"Option [TT]-g[tt] fits the data to the function given with option",
"[TT]-fitfn[tt].[PAR]",
"Option [TT]-power[tt] fits the data to b t^a, which is accomplished",
"by fitting to a t + b on log-log scale. All points after the first",
"zero or negative value are ignored.[PAR]"
"Option [TT]-luzar[tt] performs a Luzar & Chandler kinetics analysis",
"on output from [TT]g_hbond[tt]. The input file can be taken directly",
"from [TT]g_hbond -ac[tt], and then the same result should be produced."
};
static real tb=-1,te=-1,frac=0.5,filtlen=0,binwidth=0.1,aver_start=0;
static bool bHaveT=TRUE,bDer=FALSE,bSubAv=TRUE,bAverCorr=FALSE,bXYdy=FALSE;
static bool bEESEF=FALSE,bEENLC=FALSE,bEeFitAc=FALSE,bPower=FALSE;
static bool bIntegrate=FALSE,bRegression=FALSE,bLuzar=FALSE,bLuzarError=FALSE;
static int nsets_in=1,d=1,nb_min=4,resol=10;
static real temp=298.15,fit_start=1,smooth_tail_start=-1;
/* must correspond to enum avbar* declared at beginning of file */
static char *avbar_opt[avbarNR+1] = {
NULL, "none", "stddev", "error", "90", NULL
};
t_pargs pa[] = {
{ "-time", FALSE, etBOOL, {&bHaveT},
"Expect a time in the input" },
{ "-b", FALSE, etREAL, {&tb},
"First time to read from set" },
{ "-e", FALSE, etREAL, {&te},
"Last time to read from set" },
{ "-n", FALSE, etINT, {&nsets_in},
"Read # sets seperated by &" },
{ "-d", FALSE, etBOOL, {&bDer},
"Use the derivative" },
{ "-dp", FALSE, etINT, {&d},
"HIDDENThe derivative is the difference over # points" },
{ "-bw", FALSE, etREAL, {&binwidth},
"Binwidth for the distribution" },
{ "-errbar", FALSE, etENUM, {avbar_opt},
"Error bars for -av" },
{ "-integrate",FALSE,etBOOL, {&bIntegrate},
"Integrate data function(s) numerically using trapezium rule" },
{ "-aver_start",FALSE, etREAL, {&aver_start},
"Start averaging the integral from here" },
{ "-xydy", FALSE, etBOOL, {&bXYdy},
"Interpret second data set as error in the y values for integrating" },
{ "-regression",FALSE,etBOOL,{&bRegression},
"Perform a linear regression analysis on the data" },
{ "-luzar", FALSE, etBOOL, {&bLuzar},
"Do a Luzar and Chandler analysis on a correlation function and related as produced by g_hbond. When in addition the -xydy flag is given the second and fourth column will be interpreted as errors in c(t) and n(t)." },
{ "-temp", FALSE, etREAL, {&temp},
"Temperature for the Luzar hydrogen bonding kinetics analysis" },
{ "-fitstart", FALSE, etREAL, {&fit_start},
"Time (ps) from which to start fitting the correlation functions in order to obtain the forward and backward rate constants for HB breaking and formation" },
{ "-smooth",FALSE, etREAL, {&smooth_tail_start},
"If >= 0, the tail of the ACF will be smoothed by fitting it to an exponential function: y = A exp(-x/tau)" },
{ "-nbmin", FALSE, etINT, {&nb_min},
"HIDDENMinimum number of blocks for block averaging" },
{ "-resol", FALSE, etINT, {&resol},
"HIDDENResolution for the block averaging, block size increases with"
" a factor 2^(1/#)" },
{ "-eeexpfit", FALSE, etBOOL, {&bEESEF},
"HIDDENAlways use a single exponential fit for the error estimate" },
{ "-eenlc", FALSE, etBOOL, {&bEENLC},
"HIDDENAllow a negative long-time correlation" },
{ "-eefitac", FALSE, etBOOL, {&bEeFitAc},
"HIDDENAlso plot analytical block average using a autocorrelation fit" },
{ "-filter", FALSE, etREAL, {&filtlen},
"Print the high-frequency fluctuation after filtering with a cosine filter of length #" },
{ "-power", FALSE, etBOOL, {&bPower},
"Fit data to: b t^a" },
{ "-subav", FALSE, etBOOL, {&bSubAv},
"Subtract the average before autocorrelating" },
{ "-oneacf", FALSE, etBOOL, {&bAverCorr},
"Calculate one ACF over all sets" }
};
#define NPA asize(pa)
FILE *out,*out_fit;
int n,nlast,s,nset,i,j=0;
real **val,*t,dt,tot,error;
double *av,*sig,cum1,cum2,cum3,cum4,db;
char *acfile,*msdfile,*ccfile,*distfile,*avfile,*eefile,*fitfile;
t_filenm fnm[] = {
{ efXVG, "-f", "graph", ffREAD },
{ efXVG, "-ac", "autocorr", ffOPTWR },
{ efXVG, "-msd", "msd", ffOPTWR },
{ efXVG, "-cc", "coscont", ffOPTWR },
{ efXVG, "-dist", "distr", ffOPTWR },
{ efXVG, "-av", "average", ffOPTWR },
{ efXVG, "-ee", "errest", ffOPTWR },
{ efLOG, "-g", "fitlog", ffOPTWR }
};
#define NFILE asize(fnm)
int npargs;
t_pargs *ppa;
npargs = asize(pa);
ppa = add_acf_pargs(&npargs,pa);
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_VIEW,
NFILE,fnm,npargs,ppa,asize(desc),desc,0,NULL);
acfile = opt2fn_null("-ac",NFILE,fnm);
msdfile = opt2fn_null("-msd",NFILE,fnm);
ccfile = opt2fn_null("-cc",NFILE,fnm);
distfile = opt2fn_null("-dist",NFILE,fnm);
avfile = opt2fn_null("-av",NFILE,fnm);
eefile = opt2fn_null("-ee",NFILE,fnm);
if (opt2parg_bSet("-fitfn",npargs,ppa))
fitfile = opt2fn("-g",NFILE,fnm);
else
fitfile = opt2fn_null("-g",NFILE,fnm);
val=read_xvg_time(opt2fn("-f",NFILE,fnm),bHaveT,
opt2parg_bSet("-b",npargs,ppa),tb,
opt2parg_bSet("-e",npargs,ppa),te,
nsets_in,&nset,&n,&dt,&t);
printf("Read %d sets of %d points, dt = %g\n\n",nset,n,dt);
if (bDer) {
printf("Calculating the derivative as (f[i+%d]-f[i])/(%d*dt)\n\n",
d,d);
n -= d;
for(s=0; s<nset; s++)
for(i=0; (i<n); i++)
val[s][i] = (val[s][i+d]-val[s][i])/(d*dt);
}
if (bIntegrate) {
real sum,stddev;
printf("Calculating the integral using the trapezium rule\n");
if (bXYdy) {
sum = evaluate_integral(n,t,val[0],val[1],aver_start,&stddev);
printf("Integral %10.3f +/- %10.5f\n",sum,stddev);
}
else {
for(s=0; s<nset; s++) {
sum = evaluate_integral(n,t,val[s],NULL,aver_start,&stddev);
printf("Integral %d %10.5f +/- %10.5f\n",s+1,sum,stddev);
}
}
}
if (fitfile) {
out_fit = ffopen(fitfile,"w");
if (bXYdy && nset>=2) {
do_fit(out_fit,0,TRUE,n,t,val,npargs,ppa);
} else {
for(s=0; s<nset; s++)
do_fit(out_fit,s,FALSE,n,t,val,npargs,ppa);
}
fclose(out_fit);
}
printf(" std. dev. relative deviation of\n");
printf(" standard --------- cumulants from those of\n");
printf("set average deviation sqrt(n-1) a Gaussian distribition\n");
printf(" cum. 3 cum. 4\n");
snew(av,nset);
snew(sig,nset);
for(s=0; (s<nset); s++) {
cum1 = 0;
cum2 = 0;
cum3 = 0;
cum4 = 0;
for(i=0; (i<n); i++)
cum1 += val[s][i];
cum1 /= n;
for(i=0; (i<n); i++) {
db = val[s][i]-cum1;
cum2 += db*db;
cum3 += db*db*db;
cum4 += db*db*db*db;
}
cum2 /= n;
cum3 /= n;
cum4 /= n;
av[s] = cum1;
sig[s] = sqrt(cum2);
if (n > 1)
error = sqrt(cum2/(n-1));
else
error = 0;
printf("SS%d %13.6e %12.6e %12.6e %6.3f %6.3f\n",
s+1,av[s],sig[s],error,
sig[s] ? cum3/(sig[s]*sig[s]*sig[s]*sqrt(8/M_PI)) : 0,
sig[s] ? cum4/(sig[s]*sig[s]*sig[s]*sig[s]*3)-1 : 0);
}
printf("\n");
if (filtlen)
filter(filtlen,n,nset,val,dt);
if (msdfile) {
out=xvgropen(msdfile,"Mean square displacement",
"time","MSD (nm\\S2\\N)");
nlast = (int)(n*frac);
for(s=0; s<nset; s++) {
for(j=0; j<=nlast; j++) {
if (j % 100 == 0)
fprintf(stderr,"\r%d",j);
tot=0;
for(i=0; i<n-j; i++)
tot += sqr(val[s][i]-val[s][i+j]);
tot /= (real)(n-j);
fprintf(out," %g %8g\n",dt*j,tot);
}
if (s<nset-1)
fprintf(out,"&\n");
}
fclose(out);
fprintf(stderr,"\r%d, time=%g\n",j-1,(j-1)*dt);
}
if (ccfile)
plot_coscont(ccfile,n,nset,val);
if (distfile)
histogram(distfile,binwidth,n,nset,val);
if (avfile)
average(avfile,nenum(avbar_opt),n,nset,val,t);
if (eefile)
estimate_error(eefile,nb_min,resol,n,nset,av,sig,val,dt,
bEeFitAc,bEESEF,bEENLC);
if (bPower)
power_fit(n,nset,val,t);
if (acfile) {
if (bSubAv)
for(s=0; s<nset; s++)
for(i=0; i<n; i++)
val[s][i] -= av[s];
do_autocorr(acfile,"Autocorrelation",n,nset,val,dt,
eacNormal,bAverCorr);
}
if (bRegression)
regression_analysis(n,bXYdy,t,val);
if (bLuzar)
luzar_correl(n,t,nset,val,temp,bXYdy,fit_start,smooth_tail_start);
view_all(NFILE, fnm);
thanx(stderr);
return 0;
}
int gmx_confrms(int argc, char *argv[])
{
const char *desc[] = {
"[TT]g_confrms[tt] 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 [TT].pdb[tt] file",
"the two structures will be written as separate models",
"(use [TT]rasmol -nmrpdb[tt]). Also in a [TT].pdb[tt] 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.ndx", ffOPTRD },
{ efNDX, "-n2", "fit2.ndx", ffOPTRD },
{ efNDX, "-no", "match.ndx", ffOPTWR }
};
#define NFILE asize(fnm)
/* the two structure files */
const char *conf1file, *conf2file, *matchndxfile, *outfile;
FILE *fp;
char title1[STRLEN], title2[STRLEN], *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, j, m;
/* center of mass calculation */
real tmas1, tmas2;
rvec xcm1, xcm2;
/* variables for fit */
char *groupnames1, *groupnames2;
int isize1, isize2;
atom_id *index1, *index2;
real rms, msd, minmsd, maxmsd;
real *msds;
parse_common_args(&argc, argv, PCA_BE_NICE | PCA_CAN_VIEW,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv);
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, title1, top1, &ePBC1, &x1, &v1, box1, TRUE);
atoms1 = &(top1->atoms);
fprintf(stderr, "%s\nContaining %d atoms in %d residues\n",
title1, 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, title2, top2, &ePBC2, &x2, &v2, box2, TRUE);
atoms2 = &(top2->atoms);
fprintf(stderr, "%s\nContaining %d atoms in %d residues\n",
title2, 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 = 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, "%4u%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, "%4u%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 (strcmp(name1, name2))
{
if (warn < 20)
{
fprintf(stderr,
"Warning: atomnames at index %d don't match: %u %s, %u %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 = max(maxmsd, msds[at]);
minmsd = min(minmsd, msds[at]);
totmass += mass;
}
rms = 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 = ffopen(outfile, "w");
if (!bOne)
{
write_pdbfile(fp, title1, atoms1, x1, ePBC1, box1, ' ', 1, NULL, TRUE);
}
write_pdbfile(fp, title2, atoms2, x2, ePBC2, box2, ' ', bOne ? -1 : 2, NULL, TRUE);
ffclose(fp);
break;
case efGRO:
if (bBfac)
{
fprintf(stderr, "WARNING: cannot write B-factor values to gro file\n");
}
fp = ffopen(outfile, "w");
if (!bOne)
{
write_hconf_p(fp, title1, atoms1, 3, x1, v1, box1);
}
write_hconf_p(fp, title2, atoms2, 3, x2, v2, box2);
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, title2, atoms2, x2, v2, ePBC2, box2);
break;
}
view_all(oenv, NFILE, fnm);
thanx(stderr);
return 0;
}
int gmx_bond(int argc,char *argv[])
{
static char *desc[] = {
"g_bond makes a distribution of bond lengths. If all is well a",
"gaussian distribution should be made when using a harmonic potential.",
"bonds are read from a single group in the index file in order i1-j1",
"i2-j2 thru in-jn.[PAR]",
"[TT]-tol[tt] gives the half-width of the distribution as a fraction",
"of the bondlength ([TT]-blen[tt]). That means, for a bond of 0.2",
"a tol of 0.1 gives a distribution from 0.18 to 0.22.[PAR]",
"Option [TT]-d[tt] plots all the distances as a function of time.",
"This requires a structure file for the atom and residue names in",
"the output. If however the option [TT]-averdist[tt] is given (as well",
"or separately) the average bond length is plotted instead."
};
static char *bugs[] = {
"It should be possible to get bond information from the topology."
};
static real blen=-1.0,tol=0.1;
static bool bAver=TRUE,bAverDist=TRUE;
t_pargs pa[] = {
{ "-blen", FALSE, etREAL, {&blen},
"Bond length. By default length of first bond" },
{ "-tol", FALSE, etREAL, {&tol},
"Half width of distribution as fraction of blen" },
{ "-aver", FALSE, etBOOL, {&bAver},
"Average bond length distributions" },
{ "-averdist", FALSE, etBOOL, {&bAverDist},
"Average distances (turns on -d)" }
};
FILE *fp;
char *grpname,*fdist;
int gnx;
atom_id *index;
char title[STRLEN];
t_topology top;
int ePBC=-1;
rvec *x;
matrix box;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efNDX, NULL, NULL, ffREAD },
{ efTPS, NULL, NULL, ffOPTRD },
{ efXVG, "-o", "bonds", ffWRITE },
{ efLOG, NULL, "bonds", ffOPTWR },
{ efXVG, "-d", "distance", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_VIEW | PCA_CAN_TIME | PCA_BE_NICE ,
NFILE,fnm,asize(pa),pa,asize(desc),desc,asize(bugs),bugs);
if (bAverDist)
fdist = opt2fn("-d",NFILE,fnm);
else {
fdist = opt2fn_null("-d",NFILE,fnm);
if (fdist)
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&x,NULL,box,
FALSE);
}
rd_index(ftp2fn(efNDX,NFILE,fnm),1,&gnx,&index,&grpname);
if ( !even(gnx) )
fprintf(stderr,"WARNING: odd number of atoms (%d) in group!\n",gnx);
fprintf(stderr,"Will gather information on %d bonds\n",gnx/2);
if (!bAver)
fp = ftp2FILE(efLOG,NFILE,fnm,"w");
else
fp = NULL;
do_bonds(fp,ftp2fn(efTRX,NFILE,fnm),opt2fn("-o",NFILE,fnm),fdist,gnx,index,
blen,tol,bAver,&top,ePBC,bAverDist);
do_view(opt2fn("-o",NFILE,fnm),"-nxy");
do_view(opt2fn_null("-d",NFILE,fnm),"-nxy");
thanx(stderr);
return 0;
}
int gmx_vanhove(int argc,char *argv[])
{
const char *desc[] = {
"g_vanhove computes the Van Hove correlation function.",
"The Van Hove G(r,t) is the probability that a particle that is at r0",
"at time zero can be found at position r0+r at time t.",
"g_vanhove determines G not for a vector r, but for the length of r.",
"Thus it gives the probability that a particle moves a distance of r",
"in time t.",
"Jumps across the periodic boundaries are removed.",
"Corrections are made for scaling due to isotropic",
"or anisotropic pressure coupling.",
"[PAR]",
"With option [TT]-om[tt] the whole matrix can be written as a function",
"of t and r or as a function of sqrt(t) and r (option [TT]-sqrt[tt]).",
"[PAR]",
"With option [TT]-or[tt] the Van Hove function is plotted for one",
"or more values of t. Option [TT]-nr[tt] sets the number of times,",
"option [TT]-fr[tt] the number spacing between the times.",
"The binwidth is set with option [TT]-rbin[tt]. The number of bins",
"is determined automatically.",
"[PAR]",
"With option [TT]-ot[tt] the integral up to a certain distance",
"(option [TT]-rt[tt]) is plotted as a function of time.",
"[PAR]",
"For all frames that are read the coordinates of the selected particles",
"are stored in memory. Therefore the program may use a lot of memory.",
"For options [TT]-om[tt] and [TT]-ot[tt] the program may be slow.",
"This is because the calculation scales as the number of frames times",
"[TT]-fm[tt] or [TT]-ft[tt].",
"Note that with the [TT]-dt[tt] option the memory usage and calculation",
"time can be reduced."
};
static int fmmax=0,ftmax=0,nlev=81,nr=1,fshift=0;
static real sbin=0,rmax=2,rbin=0.01,mmax=0,rint=0;
t_pargs pa[] = {
{ "-sqrt", FALSE, etREAL,{&sbin},
"Use sqrt(t) on the matrix axis which binspacing # in sqrt(ps)" },
{ "-fm", FALSE, etINT, {&fmmax},
"Number of frames in the matrix, 0 is plot all" },
{ "-rmax", FALSE, etREAL, {&rmax},
"Maximum r in the matrix (nm)" },
{ "-rbin", FALSE, etREAL, {&rbin},
"Binwidth in the matrix and for -or (nm)" },
{ "-mmax", FALSE, etREAL, {&mmax},
"Maximum density in the matrix, 0 is calculate (1/nm)" },
{ "-nlevels" ,FALSE, etINT, {&nlev},
"Number of levels in the matrix" },
{ "-nr", FALSE, etINT, {&nr},
"Number of curves for the -or output" },
{ "-fr", FALSE, etINT, {&fshift},
"Frame spacing for the -or output" },
{ "-rt", FALSE, etREAL, {&rint},
"Integration limit for the -ot output (nm)" },
{ "-ft", FALSE, etINT, {&ftmax},
"Number of frames in the -ot output, 0 is plot all" }
};
#define NPA asize(pa)
t_filenm fnm[] = {
{ efTRX, NULL, NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXPM, "-om", "vanhove", ffOPTWR },
{ efXVG, "-or", "vanhove_r", ffOPTWR },
{ efXVG, "-ot", "vanhove_t", ffOPTWR }
};
#define NFILE asize(fnm)
output_env_t oenv;
const char *matfile,*otfile,*orfile;
char title[256];
t_topology top;
int ePBC;
matrix boxtop,box,*sbox,avbox,corr;
rvec *xtop,*x,**sx;
int isize,nalloc,nallocn,natom;
t_trxstatus *status;
atom_id *index;
char *grpname;
int nfr,f,ff,i,m,mat_nx=0,nbin=0,bin,mbin,fbin;
real *time,t,invbin=0,rmax2=0,rint2=0,d2;
real invsbin=0,matmax,normfac,dt,*tickx,*ticky;
char buf[STRLEN],**legend;
real **mat=NULL;
int *pt=NULL,**pr=NULL,*mcount=NULL,*tcount=NULL,*rcount=NULL;
FILE *fp;
t_rgb rlo={1,1,1}, rhi={0,0,0};
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_VIEW | PCA_CAN_TIME | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL,&oenv);
matfile = opt2fn_null("-om",NFILE,fnm);
if (opt2parg_bSet("-fr",NPA,pa))
orfile = opt2fn("-or",NFILE,fnm);
else
orfile = opt2fn_null("-or",NFILE,fnm);
if (opt2parg_bSet("-rt",NPA,pa))
otfile = opt2fn("-ot",NFILE,fnm);
else
otfile = opt2fn_null("-ot",NFILE,fnm);
if (!matfile && !otfile && !orfile) {
fprintf(stderr,
"For output set one (or more) of the output file options\n");
exit(0);
}
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xtop,NULL,boxtop,
FALSE);
get_index(&top.atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&isize,&index,&grpname);
nalloc = 0;
time = NULL;
sbox = NULL;
sx = NULL;
clear_mat(avbox);
natom=read_first_x(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
nfr = 0;
do {
if (nfr >= nalloc) {
nalloc += 100;
srenew(time,nalloc);
srenew(sbox,nalloc);
srenew(sx,nalloc);
}
time[nfr] = t;
copy_mat(box,sbox[nfr]);
/* This assumes that the off-diagonal box elements
* are not affected by jumps across the periodic boundaries.
*/
m_add(avbox,box,avbox);
snew(sx[nfr],isize);
for(i=0; i<isize; i++)
copy_rvec(x[index[i]],sx[nfr][i]);
nfr++;
} while (read_next_x(oenv,status,&t,natom,x,box));
/* clean up */
sfree(x);
close_trj(status);
fprintf(stderr,"Read %d frames\n",nfr);
dt = (time[nfr-1] - time[0])/(nfr - 1);
/* Some ugly rounding to get nice nice times in the output */
dt = (int)(10000.0*dt + 0.5)/10000.0;
invbin = 1.0/rbin;
if (matfile) {
if (fmmax <= 0 || fmmax >= nfr)
fmmax = nfr - 1;
snew(mcount,fmmax);
nbin = (int)(rmax*invbin + 0.5);
if (sbin == 0) {
mat_nx = fmmax + 1;
} else {
invsbin = 1.0/sbin;
mat_nx = sqrt(fmmax*dt)*invsbin + 1;
}
snew(mat,mat_nx);
for(f=0; f<mat_nx; f++)
snew(mat[f],nbin);
rmax2 = sqr(nbin*rbin);
/* Initialize time zero */
mat[0][0] = nfr*isize;
mcount[0] += nfr;
} else {
fmmax = 0;
}
if (orfile) {
snew(pr,nr);
nalloc = 0;
snew(rcount,nr);
}
if (otfile) {
if (ftmax <= 0)
ftmax = nfr - 1;
snew(tcount,ftmax);
snew(pt,nfr);
rint2 = rint*rint;
/* Initialize time zero */
pt[0] = nfr*isize;
tcount[0] += nfr;
} else {
ftmax = 0;
}
msmul(avbox,1.0/nfr,avbox);
for(f=0; f<nfr; f++) {
if (f % 100 == 0)
fprintf(stderr,"\rProcessing frame %d",f);
/* Scale all the configuration to the average box */
m_inv_ur0(sbox[f],corr);
mmul_ur0(avbox,corr,corr);
for(i=0; i<isize; i++) {
mvmul_ur0(corr,sx[f][i],sx[f][i]);
if (f > 0) {
/* Correct for periodic jumps */
for(m=DIM-1; m>=0; m--) {
while(sx[f][i][m] - sx[f-1][i][m] > 0.5*avbox[m][m])
rvec_dec(sx[f][i],avbox[m]);
while(sx[f][i][m] - sx[f-1][i][m] <= -0.5*avbox[m][m])
rvec_inc(sx[f][i],avbox[m]);
}
}
}
for(ff=0; ff<f; ff++) {
fbin = f - ff;
if (fbin <= fmmax || fbin <= ftmax) {
if (sbin == 0)
mbin = fbin;
else
mbin = (int)(sqrt(fbin*dt)*invsbin + 0.5);
for(i=0; i<isize; i++) {
d2 = distance2(sx[f][i],sx[ff][i]);
if (mbin < mat_nx && d2 < rmax2) {
bin = (int)(sqrt(d2)*invbin + 0.5);
if (bin < nbin) {
mat[mbin][bin] += 1;
}
}
if (fbin <= ftmax && d2 <= rint2)
pt[fbin]++;
}
if (matfile)
mcount[mbin]++;
if (otfile)
tcount[fbin]++;
}
}
if (orfile) {
for(fbin=0; fbin<nr; fbin++) {
ff = f - (fbin + 1)*fshift;
if (ff >= 0) {
for(i=0; i<isize; i++) {
d2 = distance2(sx[f][i],sx[ff][i]);
bin = (int)(sqrt(d2)*invbin);
if (bin >= nalloc) {
nallocn = 10*(bin/10) + 11;
for(m=0; m<nr; m++) {
srenew(pr[m],nallocn);
for(i=nalloc; i<nallocn; i++)
pr[m][i] = 0;
}
nalloc = nallocn;
}
pr[fbin][bin]++;
}
rcount[fbin]++;
}
}
}
}
fprintf(stderr,"\n");
if (matfile) {
matmax = 0;
for(f=0; f<mat_nx; f++) {
normfac = 1.0/(mcount[f]*isize*rbin);
for(i=0; i<nbin; i++) {
mat[f][i] *= normfac;
if (mat[f][i] > matmax && (f!=0 || i!=0))
matmax = mat[f][i];
}
}
fprintf(stdout,"Value at (0,0): %.3f, maximum of the rest %.3f\n",
mat[0][0],matmax);
if (mmax > 0)
matmax = mmax;
snew(tickx,mat_nx);
for(f=0; f<mat_nx; f++) {
if (sbin == 0)
tickx[f] = f*dt;
else
tickx[f] = f*sbin;
}
snew(ticky,nbin+1);
for(i=0; i<=nbin; i++)
ticky[i] = i*rbin;
fp = ffopen(matfile,"w");
write_xpm(fp,MAT_SPATIAL_Y,"Van Hove function","G (1/nm)",
sbin==0 ? "time (ps)" : "sqrt(time) (ps^1/2)","r (nm)",
mat_nx,nbin,tickx,ticky,mat,0,matmax,rlo,rhi,&nlev);
ffclose(fp);
}
if (orfile) {
fp = xvgropen(orfile,"Van Hove function","r (nm)","G (nm\\S-1\\N)",oenv);
fprintf(fp,"@ subtitle \"for particles in group %s\"\n",grpname);
snew(legend,nr);
for(fbin=0; fbin<nr; fbin++) {
sprintf(buf,"%g ps",(fbin + 1)*fshift*dt);
legend[fbin] = strdup(buf);
}
xvgr_legend(fp,nr,(const char**)legend,oenv);
for(i=0; i<nalloc; i++) {
fprintf(fp,"%g",i*rbin);
for(fbin=0; fbin<nr; fbin++)
fprintf(fp," %g",
(real)pr[fbin][i]/(rcount[fbin]*isize*rbin*(i==0 ? 0.5 : 1)));
fprintf(fp,"\n");
}
ffclose(fp);
}
if (otfile) {
sprintf(buf,"Probability of moving less than %g nm",rint);
fp = xvgropen(otfile,buf,"t (ps)","",oenv);
fprintf(fp,"@ subtitle \"for particles in group %s\"\n",grpname);
for(f=0; f<=ftmax; f++)
fprintf(fp,"%g %g\n",f*dt,(real)pt[f]/(tcount[f]*isize));
ffclose(fp);
}
do_view(oenv, matfile,NULL);
do_view(oenv, orfile,NULL);
do_view(oenv, otfile,NULL);
thanx(stderr);
return 0;
}
int gmx_morph(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] does a linear interpolation of conformations in order to",
"create intermediates. Of course these are completely unphysical, but",
"that you may try to justify yourself. Output is in the form of a ",
"generic trajectory. The number of intermediates can be controlled with",
"the [TT]-ninterm[tt] flag. The first and last flag correspond to the way of",
"interpolating: 0 corresponds to input structure 1 while",
"1 corresponds to input structure 2.",
"If you specify [TT]-first[tt] < 0 or [TT]-last[tt] > 1 extrapolation will be",
"on the path from input structure x[SUB]1[sub] to x[SUB]2[sub]. In general, the coordinates",
"of the intermediate x(i) out of N total intermediates correspond to:[PAR]",
"x(i) = x[SUB]1[sub] + (first+(i/(N-1))*(last-first))*(x[SUB]2[sub]-x[SUB]1[sub])[PAR]",
"Finally the RMSD with respect to both input structures can be computed",
"if explicitly selected ([TT]-or[tt] option). In that case, an index file may be",
"read to select the group from which the RMS is computed."
};
t_filenm fnm[] = {
{ efSTX, "-f1", "conf1", ffREAD },
{ efSTX, "-f2", "conf2", ffREAD },
{ efTRX, "-o", "interm", ffWRITE },
{ efXVG, "-or", "rms-interm", ffOPTWR },
{ efNDX, "-n", "index", ffOPTRD }
};
#define NFILE asize(fnm)
static int ninterm = 11;
static real first = 0.0;
static real last = 1.0;
static gmx_bool bFit = TRUE;
t_pargs pa [] = {
{ "-ninterm", FALSE, etINT, {&ninterm},
"Number of intermediates" },
{ "-first", FALSE, etREAL, {&first},
"Corresponds to first generated structure (0 is input x[SUB]1[sub], see above)" },
{ "-last", FALSE, etREAL, {&last},
"Corresponds to last generated structure (1 is input x[SUB]2[sub], see above)" },
{ "-fit", FALSE, etBOOL, {&bFit},
"Do a least squares fit of the second to the first structure before interpolating" }
};
const char *leg[] = { "Ref = 1\\Sst\\N conf", "Ref = 2\\Snd\\N conf" };
FILE *fp = NULL;
int i, isize, is_lsq, nat1, nat2;
t_trxstatus *status;
atom_id *index, *index_lsq, *index_all, *dummy;
t_atoms atoms;
rvec *x1, *x2, *xx, *v;
matrix box;
real rms1, rms2, fac, *mass;
char title[STRLEN], *grpname;
gmx_bool bRMS;
output_env_t oenv;
if (!parse_common_args(&argc, argv, PCA_CAN_VIEW,
NFILE, fnm, asize(pa), pa, asize(desc), desc,
0, NULL, &oenv))
{
return 0;
}
get_stx_coordnum (opt2fn("-f1", NFILE, fnm), &nat1);
get_stx_coordnum (opt2fn("-f2", NFILE, fnm), &nat2);
if (nat1 != nat2)
{
gmx_fatal(FARGS, "Number of atoms in first structure is %d, in second %d",
nat1, nat2);
}
init_t_atoms(&atoms, nat1, TRUE);
snew(x1, nat1);
snew(x2, nat1);
snew(xx, nat1);
snew(v, nat1);
read_stx_conf(opt2fn("-f1", NFILE, fnm), title, &atoms, x1, v, NULL, box);
read_stx_conf(opt2fn("-f2", NFILE, fnm), title, &atoms, x2, v, NULL, box);
snew(mass, nat1);
snew(index_all, nat1);
for (i = 0; (i < nat1); i++)
{
mass[i] = 1;
index_all[i] = i;
}
if (bFit)
{
printf("Select group for LSQ superposition:\n");
get_index(&atoms, opt2fn_null("-n", NFILE, fnm), 1, &is_lsq, &index_lsq,
&grpname);
reset_x(is_lsq, index_lsq, nat1, index_all, x1, mass);
reset_x(is_lsq, index_lsq, nat1, index_all, x2, mass);
do_fit(nat1, mass, x1, x2);
}
bRMS = opt2bSet("-or", NFILE, fnm);
if (bRMS)
{
fp = xvgropen(opt2fn("-or", NFILE, fnm), "RMSD", "Conf", "(nm)", oenv);
xvgr_legend(fp, asize(leg), leg, oenv);
printf("Select group for RMSD calculation:\n");
get_index(&atoms, opt2fn_null("-n", NFILE, fnm), 1, &isize, &index, &grpname);
printf("You selected group %s, containing %d atoms\n", grpname, isize);
rms1 = rmsdev_ind(isize, index, mass, x1, x2);
fprintf(stderr, "RMSD between input conformations is %g nm\n", rms1);
}
snew(dummy, nat1);
for (i = 0; (i < nat1); i++)
{
dummy[i] = i;
}
status = open_trx(ftp2fn(efTRX, NFILE, fnm), "w");
for (i = 0; (i < ninterm); i++)
{
fac = dointerp(nat1, x1, x2, xx, i, ninterm, first, last);
write_trx(status, nat1, dummy, &atoms, i, fac, box, xx, NULL, NULL);
if (bRMS)
{
rms1 = rmsdev_ind(isize, index, mass, x1, xx);
rms2 = rmsdev_ind(isize, index, mass, x2, xx);
fprintf(fp, "%10g %10g %10g\n", fac, rms1, rms2);
}
}
close_trx(status);
if (bRMS)
{
gmx_ffclose(fp);
do_view(oenv, opt2fn("-or", NFILE, fnm), "-nxy");
}
return 0;
}
int gmx_analyze(int argc, char *argv[])
{
static const char *desc[] = {
"[THISMODULE] reads an ASCII file and analyzes data sets.",
"A line in the input file may start with a time",
"(see option [TT]-time[tt]) and any number of [IT]y[it]-values may follow.",
"Multiple sets can also be",
"read when they are separated by & (option [TT]-n[tt]);",
"in this case only one [IT]y[it]-value is read from each line.",
"All lines starting with # and @ are skipped.",
"All analyses can also be done for the derivative of a set",
"(option [TT]-d[tt]).[PAR]",
"All options, except for [TT]-av[tt] and [TT]-power[tt], assume that the",
"points are equidistant in time.[PAR]",
"[THISMODULE] always shows the average and standard deviation of each",
"set, as well as the relative deviation of the third",
"and fourth cumulant from those of a Gaussian distribution with the same",
"standard deviation.[PAR]",
"Option [TT]-ac[tt] produces the autocorrelation function(s).",
"Be sure that the time interval between data points is",
"much shorter than the time scale of the autocorrelation.[PAR]",
"Option [TT]-cc[tt] plots the resemblance of set i with a cosine of",
"i/2 periods. The formula is::",
"",
" [MATH]2 ([INT][FROM]0[from][TO]T[to][int] y(t) [COS]i [GRK]pi[grk] t[cos] dt)^2 / [INT][FROM]0[from][TO]T[to][int] y^2(t) dt[math]",
"",
"This is useful for principal components obtained from covariance",
"analysis, since the principal components of random diffusion are",
"pure cosines.[PAR]",
"Option [TT]-msd[tt] produces the mean square displacement(s).[PAR]",
"Option [TT]-dist[tt] produces distribution plot(s).[PAR]",
"Option [TT]-av[tt] produces the average over the sets.",
"Error bars can be added with the option [TT]-errbar[tt].",
"The errorbars can represent the standard deviation, the error",
"(assuming the points are independent) or the interval containing",
"90% of the points, by discarding 5% of the points at the top and",
"the bottom.[PAR]",
"Option [TT]-ee[tt] produces error estimates using block averaging.",
"A set is divided in a number of blocks and averages are calculated for",
"each block. The error for the total average is calculated from",
"the variance between averages of the m blocks B[SUB]i[sub] as follows:",
"error^2 = [SUM][sum] (B[SUB]i[sub] - [CHEVRON]B[chevron])^2 / (m*(m-1)).",
"These errors are plotted as a function of the block size.",
"Also an analytical block average curve is plotted, assuming",
"that the autocorrelation is a sum of two exponentials.",
"The analytical curve for the block average is::",
"",
" [MATH]f(t) = [GRK]sigma[grk][TT]*[tt][SQRT]2/T ( [GRK]alpha[grk] ([GRK]tau[grk][SUB]1[sub] (([EXP]-t/[GRK]tau[grk][SUB]1[sub][exp] - 1) [GRK]tau[grk][SUB]1[sub]/t + 1)) +",
" (1-[GRK]alpha[grk]) ([GRK]tau[grk][SUB]2[sub] (([EXP]-t/[GRK]tau[grk][SUB]2[sub][exp] - 1) [GRK]tau[grk][SUB]2[sub]/t + 1)))[sqrt][math],",
"",
"where T is the total time.",
"[GRK]alpha[grk], [GRK]tau[grk][SUB]1[sub] and [GRK]tau[grk][SUB]2[sub] are obtained by fitting f^2(t) to error^2.",
"When the actual block average is very close to the analytical curve,",
"the error is [MATH][GRK]sigma[grk][TT]*[tt][SQRT]2/T (a [GRK]tau[grk][SUB]1[sub] + (1-a) [GRK]tau[grk][SUB]2[sub])[sqrt][math].",
"The complete derivation is given in",
"B. Hess, J. Chem. Phys. 116:209-217, 2002.[PAR]",
"Option [TT]-filter[tt] prints the RMS high-frequency fluctuation",
"of each set and over all sets with respect to a filtered average.",
"The filter is proportional to cos([GRK]pi[grk] t/len) where t goes from -len/2",
"to len/2. len is supplied with the option [TT]-filter[tt].",
"This filter reduces oscillations with period len/2 and len by a factor",
"of 0.79 and 0.33 respectively.[PAR]",
"Option [TT]-g[tt] fits the data to the function given with option",
"[TT]-fitfn[tt].[PAR]",
"Option [TT]-power[tt] fits the data to [MATH]b t^a[math], which is accomplished",
"by fitting to [MATH]a t + b[math] on log-log scale. All points after the first",
"zero or with a negative value are ignored.[PAR]"
"Option [TT]-luzar[tt] performs a Luzar & Chandler kinetics analysis",
"on output from [gmx-hbond]. The input file can be taken directly",
"from [TT]gmx hbond -ac[tt], and then the same result should be produced.[PAR]",
"Option [TT]-fitfn[tt] performs curve fitting to a number of different",
"curves that make sense in the context of molecular dynamics, mainly",
"exponential curves. More information is in the manual. To check the output",
"of the fitting procedure the option [TT]-fitted[tt] will print both the",
"original data and the fitted function to a new data file. The fitting",
"parameters are stored as comment in the output file."
};
static real tb = -1, te = -1, frac = 0.5, filtlen = 0, binwidth = 0.1, aver_start = 0;
static gmx_bool bHaveT = TRUE, bDer = FALSE, bSubAv = TRUE, bAverCorr = FALSE, bXYdy = FALSE;
static gmx_bool bEESEF = FALSE, bEENLC = FALSE, bEeFitAc = FALSE, bPower = FALSE;
static gmx_bool bIntegrate = FALSE, bRegression = FALSE, bLuzar = FALSE;
static int nsets_in = 1, d = 1, nb_min = 4, resol = 10;
static real temp = 298.15, fit_start = 1, fit_end = 60;
/* must correspond to enum avbar* declared at beginning of file */
static const char *avbar_opt[avbarNR+1] = {
NULL, "none", "stddev", "error", "90", NULL
};
t_pargs pa[] = {
{ "-time", FALSE, etBOOL, {&bHaveT},
"Expect a time in the input" },
{ "-b", FALSE, etREAL, {&tb},
"First time to read from set" },
{ "-e", FALSE, etREAL, {&te},
"Last time to read from set" },
{ "-n", FALSE, etINT, {&nsets_in},
"Read this number of sets separated by &" },
{ "-d", FALSE, etBOOL, {&bDer},
"Use the derivative" },
{ "-dp", FALSE, etINT, {&d},
"HIDDENThe derivative is the difference over this number of points" },
{ "-bw", FALSE, etREAL, {&binwidth},
"Binwidth for the distribution" },
{ "-errbar", FALSE, etENUM, {avbar_opt},
"Error bars for [TT]-av[tt]" },
{ "-integrate", FALSE, etBOOL, {&bIntegrate},
"Integrate data function(s) numerically using trapezium rule" },
{ "-aver_start", FALSE, etREAL, {&aver_start},
"Start averaging the integral from here" },
{ "-xydy", FALSE, etBOOL, {&bXYdy},
"Interpret second data set as error in the y values for integrating" },
{ "-regression", FALSE, etBOOL, {&bRegression},
"Perform a linear regression analysis on the data. If [TT]-xydy[tt] is set a second set will be interpreted as the error bar in the Y value. Otherwise, if multiple data sets are present a multilinear regression will be performed yielding the constant A that minimize [MATH][GRK]chi[grk]^2 = (y - A[SUB]0[sub] x[SUB]0[sub] - A[SUB]1[sub] x[SUB]1[sub] - ... - A[SUB]N[sub] x[SUB]N[sub])^2[math] where now Y is the first data set in the input file and x[SUB]i[sub] the others. Do read the information at the option [TT]-time[tt]." },
{ "-luzar", FALSE, etBOOL, {&bLuzar},
"Do a Luzar and Chandler analysis on a correlation function and "
"related as produced by [gmx-hbond]. When in addition the "
"[TT]-xydy[tt] flag is given the second and fourth column will be "
"interpreted as errors in c(t) and n(t)." },
{ "-temp", FALSE, etREAL, {&temp},
"Temperature for the Luzar hydrogen bonding kinetics analysis (K)" },
{ "-fitstart", FALSE, etREAL, {&fit_start},
"Time (ps) from which to start fitting the correlation functions in order to obtain the forward and backward rate constants for HB breaking and formation" },
{ "-fitend", FALSE, etREAL, {&fit_end},
"Time (ps) where to stop fitting the correlation functions in order to obtain the forward and backward rate constants for HB breaking and formation. Only with [TT]-gem[tt]" },
{ "-nbmin", FALSE, etINT, {&nb_min},
"HIDDENMinimum number of blocks for block averaging" },
{ "-resol", FALSE, etINT, {&resol},
"HIDDENResolution for the block averaging, block size increases with"
" a factor 2^(1/resol)" },
{ "-eeexpfit", FALSE, etBOOL, {&bEESEF},
"HIDDENAlways use a single exponential fit for the error estimate" },
{ "-eenlc", FALSE, etBOOL, {&bEENLC},
"HIDDENAllow a negative long-time correlation" },
{ "-eefitac", FALSE, etBOOL, {&bEeFitAc},
"HIDDENAlso plot analytical block average using a autocorrelation fit" },
{ "-filter", FALSE, etREAL, {&filtlen},
"Print the high-frequency fluctuation after filtering with a cosine filter of this length" },
{ "-power", FALSE, etBOOL, {&bPower},
"Fit data to: b t^a" },
{ "-subav", FALSE, etBOOL, {&bSubAv},
"Subtract the average before autocorrelating" },
{ "-oneacf", FALSE, etBOOL, {&bAverCorr},
"Calculate one ACF over all sets" },
};
#define NPA asize(pa)
FILE *out;
int n, nlast, s, nset, i, j = 0;
real **val, *t, dt, tot, error;
double *av, *sig, cum1, cum2, cum3, cum4, db;
const char *acfile, *msdfile, *ccfile, *distfile, *avfile, *eefile, *fitfile;
gmx_output_env_t *oenv;
t_filenm fnm[] = {
{ efXVG, "-f", "graph", ffREAD },
{ efXVG, "-ac", "autocorr", ffOPTWR },
{ efXVG, "-msd", "msd", ffOPTWR },
{ efXVG, "-cc", "coscont", ffOPTWR },
{ efXVG, "-dist", "distr", ffOPTWR },
{ efXVG, "-av", "average", ffOPTWR },
{ efXVG, "-ee", "errest", ffOPTWR },
{ efXVG, "-fitted", "fitted", ffOPTWR },
{ efLOG, "-g", "fitlog", 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,
NFILE, fnm, npargs, ppa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
acfile = opt2fn_null("-ac", NFILE, fnm);
msdfile = opt2fn_null("-msd", NFILE, fnm);
ccfile = opt2fn_null("-cc", NFILE, fnm);
distfile = opt2fn_null("-dist", NFILE, fnm);
avfile = opt2fn_null("-av", NFILE, fnm);
eefile = opt2fn_null("-ee", NFILE, fnm);
if (opt2parg_bSet("-fitfn", npargs, ppa) && acfile == NULL)
{
fitfile = opt2fn("-g", NFILE, fnm);
}
else
{
fitfile = opt2fn_null("-g", NFILE, fnm);
}
val = read_xvg_time(opt2fn("-f", NFILE, fnm), bHaveT,
opt2parg_bSet("-b", npargs, ppa), tb,
opt2parg_bSet("-e", npargs, ppa), te,
nsets_in, &nset, &n, &dt, &t);
printf("Read %d sets of %d points, dt = %g\n\n", nset, n, dt);
if (bDer)
{
printf("Calculating the derivative as (f[i+%d]-f[i])/(%d*dt)\n\n",
d, d);
n -= d;
for (s = 0; s < nset; s++)
{
for (i = 0; (i < n); i++)
{
val[s][i] = (val[s][i+d]-val[s][i])/(d*dt);
}
}
}
if (bIntegrate)
{
real sum, stddev;
printf("Calculating the integral using the trapezium rule\n");
if (bXYdy)
{
sum = evaluate_integral(n, t, val[0], val[1], aver_start, &stddev);
printf("Integral %10.3f +/- %10.5f\n", sum, stddev);
}
else
{
for (s = 0; s < nset; s++)
{
sum = evaluate_integral(n, t, val[s], NULL, aver_start, &stddev);
printf("Integral %d %10.5f +/- %10.5f\n", s+1, sum, stddev);
}
}
}
if (fitfile != NULL)
{
print_fitted_function(fitfile,
opt2fn_null("-fitted", NFILE, fnm),
bXYdy, nset,
n, t, val,
npargs, ppa,
oenv);
}
printf(" std. dev. relative deviation of\n");
printf(" standard --------- cumulants from those of\n");
printf("set average deviation sqrt(n-1) a Gaussian distribition\n");
printf(" cum. 3 cum. 4\n");
snew(av, nset);
snew(sig, nset);
for (s = 0; (s < nset); s++)
{
cum1 = 0;
cum2 = 0;
cum3 = 0;
cum4 = 0;
for (i = 0; (i < n); i++)
{
cum1 += val[s][i];
}
cum1 /= n;
for (i = 0; (i < n); i++)
{
db = val[s][i]-cum1;
cum2 += db*db;
cum3 += db*db*db;
cum4 += db*db*db*db;
}
cum2 /= n;
cum3 /= n;
cum4 /= n;
av[s] = cum1;
sig[s] = std::sqrt(cum2);
if (n > 1)
{
error = std::sqrt(cum2/(n-1));
}
else
{
error = 0;
}
printf("SS%d %13.6e %12.6e %12.6e %6.3f %6.3f\n",
s+1, av[s], sig[s], error,
sig[s] ? cum3/(sig[s]*sig[s]*sig[s]*std::sqrt(8/M_PI)) : 0,
sig[s] ? cum4/(sig[s]*sig[s]*sig[s]*sig[s]*3)-1 : 0);
}
printf("\n");
if (filtlen)
{
filter(filtlen, n, nset, val, dt);
}
if (msdfile)
{
out = xvgropen(msdfile, "Mean square displacement",
"time", "MSD (nm\\S2\\N)", oenv);
nlast = static_cast<int>(n*frac);
for (s = 0; s < nset; s++)
{
for (j = 0; j <= nlast; j++)
{
if (j % 100 == 0)
{
fprintf(stderr, "\r%d", j);
}
tot = 0;
for (i = 0; i < n-j; i++)
{
tot += sqr(val[s][i]-val[s][i+j]);
}
tot /= (n-j);
fprintf(out, " %g %8g\n", dt*j, tot);
}
if (s < nset-1)
{
fprintf(out, "%s\n", output_env_get_print_xvgr_codes(oenv) ? "&" : "");
}
}
xvgrclose(out);
fprintf(stderr, "\r%d, time=%g\n", j-1, (j-1)*dt);
}
if (ccfile)
{
plot_coscont(ccfile, n, nset, val, oenv);
}
if (distfile)
{
histogram(distfile, binwidth, n, nset, val, oenv);
}
if (avfile)
{
average(avfile, nenum(avbar_opt), n, nset, val, t);
}
if (eefile)
{
estimate_error(eefile, nb_min, resol, n, nset, av, sig, val, dt,
bEeFitAc, bEESEF, bEENLC, oenv);
}
if (bPower)
{
power_fit(n, nset, val, t);
}
if (acfile != NULL)
{
if (bSubAv)
{
for (s = 0; s < nset; s++)
{
for (i = 0; i < n; i++)
{
val[s][i] -= av[s];
}
}
}
do_autocorr(acfile, oenv, "Autocorrelation", n, nset, val, dt,
eacNormal, bAverCorr);
}
if (bRegression)
{
regression_analysis(n, bXYdy, t, nset, val);
}
if (bLuzar)
{
luzar_correl(n, t, nset, val, temp, bXYdy, fit_start);
}
view_all(oenv, NFILE, fnm);
return 0;
}
int gmx_tcaf(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes tranverse current autocorrelations.",
"These are used to estimate the shear viscosity, [GRK]eta[grk].",
"For details see: Palmer, Phys. Rev. E 49 (1994) pp 359-366.[PAR]",
"Transverse currents are calculated using the",
"k-vectors (1,0,0) and (2,0,0) each also in the [IT]y[it]- and [IT]z[it]-direction,",
"(1,1,0) and (1,-1,0) each also in the 2 other planes (these vectors",
"are not independent) and (1,1,1) and the 3 other box diagonals (also",
"not independent). For each k-vector the sine and cosine are used, in",
"combination with the velocity in 2 perpendicular directions. This gives",
"a total of 16*2*2=64 transverse currents. One autocorrelation is",
"calculated fitted for each k-vector, which gives 16 TCAFs. Each of",
"these TCAFs is fitted to [MATH]f(t) = [EXP]-v[exp]([COSH]Wv[cosh] + 1/W [SINH]Wv[sinh])[math],",
"[MATH]v = -t/(2 [GRK]tau[grk])[math], [MATH]W = [SQRT]1 - 4 [GRK]tau[grk] [GRK]eta[grk]/[GRK]rho[grk] k^2[sqrt][math], which gives 16 values of [GRK]tau[grk]",
"and [GRK]eta[grk]. The fit weights decay exponentially with time constant [MATH]w[math] (given with [TT]-wt[tt]) as [MATH][EXP]-t/w[exp][math], and the TCAF and",
"fit are calculated up to time [MATH]5*w[math].",
"The [GRK]eta[grk] values should be fitted to [MATH]1 - a [GRK]eta[grk](k) k^2[math], from which",
"one can estimate the shear viscosity at k=0.[PAR]",
"When the box is cubic, one can use the option [TT]-oc[tt], which",
"averages the TCAFs over all k-vectors with the same length.",
"This results in more accurate TCAFs.",
"Both the cubic TCAFs and fits are written to [TT]-oc[tt]",
"The cubic [GRK]eta[grk] estimates are also written to [TT]-ov[tt].[PAR]",
"With option [TT]-mol[tt], the transverse current is determined of",
"molecules instead of atoms. In this case, the index group should",
"consist of molecule numbers instead of atom numbers.[PAR]",
"The k-dependent viscosities in the [TT]-ov[tt] file should be",
"fitted to [MATH][GRK]eta[grk](k) = [GRK]eta[grk][SUB]0[sub] (1 - a k^2)[math] to obtain the viscosity at",
"infinite wavelength.[PAR]",
"[BB]Note:[bb] make sure you write coordinates and velocities often enough.",
"The initial, non-exponential, part of the autocorrelation function",
"is very important for obtaining a good fit."
};
static gmx_bool bMol = FALSE, bK34 = FALSE;
static real wt = 5;
t_pargs pa[] = {
{ "-mol", FALSE, etBOOL, {&bMol},
"Calculate TCAF of molecules" },
{ "-k34", FALSE, etBOOL, {&bK34},
"Also use k=(3,0,0) and k=(4,0,0)" },
{ "-wt", FALSE, etREAL, {&wt},
"Exponential decay time for the TCAF fit weights" }
};
t_topology top;
int ePBC;
t_trxframe fr;
matrix box;
gmx_bool bTop;
int gnx;
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 **tc;
gmx_output_env_t *oenv;
#define NHISTO 360
t_filenm fnm[] = {
{ efTRN, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-ot", "transcur", ffOPTWR },
{ efXVG, "-oa", "tcaf_all", ffWRITE },
{ efXVG, "-o", "tcaf", ffWRITE },
{ efXVG, "-of", "tcaf_fit", ffWRITE },
{ efXVG, "-oc", "tcaf_cub", ffOPTWR },
{ efXVG, "-ov", "visc_k", ffWRITE }
};
#define NFILE asize(fnm)
int npargs;
t_pargs *ppa;
npargs = asize(pa);
ppa = add_acf_pargs(&npargs, pa);
if (!parse_common_args(&argc, argv, PCA_CAN_VIEW | PCA_CAN_TIME,
NFILE, fnm, npargs, ppa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, NULL, NULL, box,
TRUE);
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &gnx, &index, &grpname);
if (bMol)
{
if (!bTop)
{
gmx_fatal(FARGS, "Need a topology to determine the molecules");
}
atndx = top.mols.index;
}
if (bK34)
{
nkc = NKC;
}
else
{
nkc = NKC0;
}
nk = kset_c[nkc];
ntc = nk*NPK;
sprintf(title, "Velocity Autocorrelation Function for %s", grpname);
sysmass = 0;
for (i = 0; i < nk; i++)
{
if (iprod(v0[i], v1[i]) != 0)
{
gmx_fatal(FARGS, "DEATH HORROR: vectors not orthogonal");
}
if (iprod(v0[i], v2[i]) != 0)
{
gmx_fatal(FARGS, "DEATH HORROR: vectors not orthogonal");
}
if (iprod(v1[i], v2[i]) != 0)
{
gmx_fatal(FARGS, "DEATH HORROR: vectors not orthogonal");
}
unitv(v1[i], v1[i]);
unitv(v2[i], v2[i]);
}
snew(tc, ntc);
for (i = 0; i < top.atoms.nr; i++)
{
sysmass += top.atoms.atom[i].m;
}
read_first_frame(oenv, &status, ftp2fn(efTRN, NFILE, fnm), &fr,
TRX_NEED_X | TRX_NEED_V);
t0 = fr.time;
n_alloc = 0;
nframes = 0;
rho = 0;
do
{
if (nframes >= n_alloc)
{
n_alloc += 100;
for (i = 0; i < ntc; i++)
{
srenew(tc[i], n_alloc);
}
}
rho += 1/det(fr.box);
for (k = 0; k < nk; k++)
{
for (d = 0; d < DIM; d++)
{
kfac[k][d] = 2*M_PI*v0[k][d]/fr.box[d][d];
}
}
for (i = 0; i < ntc; i++)
{
tc[i][nframes] = 0;
}
for (i = 0; i < gnx; i++)
{
if (bMol)
{
clear_rvec(mv_mol);
clear_rvec(cm_mol);
mtot = 0;
for (j = 0; j < atndx[index[i]+1] - atndx[index[i]]; j++)
{
at = atndx[index[i]] + j;
m = top.atoms.atom[at].m;
mv_mol[XX] += m*fr.v[at][XX];
mv_mol[YY] += m*fr.v[at][YY];
mv_mol[ZZ] += m*fr.v[at][ZZ];
cm_mol[XX] += m*fr.x[at][XX];
cm_mol[YY] += m*fr.x[at][YY];
cm_mol[ZZ] += m*fr.x[at][ZZ];
mtot += m;
}
svmul(1.0/mtot, cm_mol, cm_mol);
}
else
{
svmul(top.atoms.atom[index[i]].m, fr.v[index[i]], mv_mol);
}
if (!bMol)
{
copy_rvec(fr.x[index[i]], cm_mol);
}
j = 0;
for (k = 0; k < nk; k++)
{
sx = std::sin(iprod(kfac[k], cm_mol));
cx = std::cos(iprod(kfac[k], cm_mol));
tc[j][nframes] += sx*iprod(v1[k], mv_mol);
j++;
tc[j][nframes] += cx*iprod(v1[k], mv_mol);
j++;
tc[j][nframes] += sx*iprod(v2[k], mv_mol);
j++;
tc[j][nframes] += cx*iprod(v2[k], mv_mol);
j++;
}
}
t1 = fr.time;
nframes++;
}
while (read_next_frame(oenv, status, &fr));
close_trj(status);
dt = (t1-t0)/(nframes-1);
rho *= sysmass/nframes*AMU/(NANO*NANO*NANO);
fprintf(stdout, "Density = %g (kg/m^3)\n", rho);
process_tcaf(nframes, dt, nkc, tc, kfac, rho, wt,
opt2fn_null("-ot", NFILE, fnm),
opt2fn("-oa", NFILE, fnm), opt2fn("-o", NFILE, fnm),
opt2fn("-of", NFILE, fnm), opt2fn_null("-oc", NFILE, fnm),
opt2fn("-ov", NFILE, fnm), oenv);
return 0;
}
int 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_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 natoms, nat, 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;
int d, dj, nfit;
atom_id *index, *ifit;
gmx_bool bDiffMass1, bDiffMass2;
char timebuf[STRLEN];
t_rgb rlo, rmi, rhi;
real *eigenvectors;
gmx_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, &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] = std::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;
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 (std::sqrt(static_cast<real>(GMX_INT64_MAX)) < static_cast<real>(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", static_cast<int>(ndim), static_cast<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);
std::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 (std::abs(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(stderr, "\nWARNING: there are fewer frames in your trajectory than there are\n");
fprintf(stderr, "degrees of freedom in your system. Only generating the first\n");
fprintf(stderr, "%d out of %d eigenvectors and eigenvalues.\n", end, static_cast<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", static_cast<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", static_cast<int>(ndim), static_cast<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", static_cast<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_make_edi(int argc, char *argv[])
{
static const char *desc[] = {
"[THISMODULE] generates an essential dynamics (ED) sampling input file to be used with [TT]mdrun[tt]",
"based on eigenvectors of a covariance matrix ([gmx-covar]) or from a",
"normal modes analysis ([gmx-nmeig]).",
"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 radstep = 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, {&radstep},
"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;
if (!parse_common_args(&argc, argv, 0,
NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
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)
{
snew(evStepList[ev_class], nvecs);
for (i = 0; i < nvecs; i++)
{
evStepList[ev_class][i] = radstep;
}
}
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(gmx_ffopen(EdiFile, "w"), &edi_params, eigvec1, nvec1, listen, evStepList);
return 0;
}
int gmx_disre(int argc,char *argv[])
{
const char *desc[] = {
"g_disre computes violations of distance restraints.",
"If necessary all protons can be added to a protein molecule ",
"using the protonate program.[PAR]",
"The program always",
"computes the instantaneous violations rather than time-averaged,",
"because this analysis is done from a trajectory file afterwards",
"it does not make sense to use time averaging. However,",
"the time averaged values per restraint are given in the log file.[PAR]",
"An index file may be used to select specific restraints for",
"printing.[PAR]",
"When the optional[TT]-q[tt] flag is given a pdb file coloured by the",
"amount of average violations.[PAR]",
"When the [TT]-c[tt] option is given, an index file will be read",
"containing the frames in your trajectory corresponding to the clusters",
"(defined in another manner) that you want to analyze. For these clusters",
"the program will compute average violations using the third power",
"averaging algorithm and print them in the log file."
};
static int ntop = 0;
static int nlevels = 20;
static real max_dr = 0;
static gmx_bool bThird = TRUE;
t_pargs pa[] = {
{ "-ntop", FALSE, etINT, {&ntop},
"Number of large violations that are stored in the log file every step" },
{ "-maxdr", FALSE, etREAL, {&max_dr},
"Maximum distance violation in matrix output. If less than or equal to 0 the maximum will be determined by the data." },
{ "-nlevels", FALSE, etINT, {&nlevels},
"Number of levels in the matrix output" },
{ "-third", FALSE, etBOOL, {&bThird},
"Use inverse third power averaging or linear for matrix output" }
};
FILE *out=NULL,*aver=NULL,*numv=NULL,*maxxv=NULL,*xvg=NULL;
t_tpxheader header;
t_inputrec ir;
gmx_mtop_t mtop;
rvec *xtop;
gmx_localtop_t *top;
t_atoms *atoms=NULL;
t_forcerec *fr;
t_fcdata fcd;
t_nrnb nrnb;
t_commrec *cr;
t_graph *g;
int ntopatoms,natoms,i,j,kkk;
t_trxstatus *status;
real t;
rvec *x,*f,*xav=NULL;
matrix box;
gmx_bool bPDB;
int isize;
atom_id *index=NULL,*ind_fit=NULL;
char *grpname;
t_cluster_ndx *clust=NULL;
t_dr_result dr,*dr_clust=NULL;
char **leg;
real *vvindex=NULL,*w_rls=NULL;
t_mdatoms *mdatoms;
t_pbc pbc,*pbc_null;
int my_clust;
FILE *fplog;
output_env_t oenv;
gmx_rmpbc_t gpbc=NULL;
t_filenm fnm[] = {
{ efTPX, NULL, NULL, ffREAD },
{ efTRX, "-f", NULL, ffREAD },
{ efXVG, "-ds", "drsum", ffWRITE },
{ efXVG, "-da", "draver", ffWRITE },
{ efXVG, "-dn", "drnum", ffWRITE },
{ efXVG, "-dm", "drmax", ffWRITE },
{ efXVG, "-dr", "restr", ffWRITE },
{ efLOG, "-l", "disres", ffWRITE },
{ efNDX, NULL, "viol", ffOPTRD },
{ efPDB, "-q", "viol", ffOPTWR },
{ efNDX, "-c", "clust", ffOPTRD },
{ efXPM, "-x", "matrix", ffOPTWR }
};
#define NFILE asize(fnm)
cr = init_par(&argc,&argv);
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,&oenv);
gmx_log_open(ftp2fn(efLOG,NFILE,fnm),cr,FALSE,0,&fplog);
if (ntop)
init5(ntop);
read_tpxheader(ftp2fn(efTPX,NFILE,fnm),&header,FALSE,NULL,NULL);
snew(xtop,header.natoms);
read_tpx(ftp2fn(efTPX,NFILE,fnm),&ir,box,&ntopatoms,xtop,NULL,NULL,&mtop);
bPDB = opt2bSet("-q",NFILE,fnm);
if (bPDB) {
snew(xav,ntopatoms);
snew(ind_fit,ntopatoms);
snew(w_rls,ntopatoms);
for(kkk=0; (kkk<ntopatoms); kkk++) {
w_rls[kkk] = 1;
ind_fit[kkk] = kkk;
}
snew(atoms,1);
*atoms = gmx_mtop_global_atoms(&mtop);
if (atoms->pdbinfo == NULL) {
snew(atoms->pdbinfo,atoms->nr);
}
}
top = gmx_mtop_generate_local_top(&mtop,&ir);
g = NULL;
pbc_null = NULL;
if (ir.ePBC != epbcNONE) {
if (ir.bPeriodicMols)
pbc_null = &pbc;
else
g = mk_graph(fplog,&top->idef,0,mtop.natoms,FALSE,FALSE);
}
if (ftp2bSet(efNDX,NFILE,fnm)) {
rd_index(ftp2fn(efNDX,NFILE,fnm),1,&isize,&index,&grpname);
xvg=xvgropen(opt2fn("-dr",NFILE,fnm),"Inidividual Restraints","Time (ps)",
"nm",oenv);
snew(vvindex,isize);
snew(leg,isize);
for(i=0; (i<isize); i++) {
index[i]++;
snew(leg[i],12);
sprintf(leg[i],"index %d",index[i]);
}
xvgr_legend(xvg,isize,(const char**)leg,oenv);
}
else
isize=0;
ir.dr_tau=0.0;
init_disres(fplog,&mtop,&ir,NULL,FALSE,&fcd,NULL);
natoms=read_first_x(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
snew(f,5*natoms);
init_dr_res(&dr,fcd.disres.nres);
if (opt2bSet("-c",NFILE,fnm)) {
clust = cluster_index(fplog,opt2fn("-c",NFILE,fnm));
snew(dr_clust,clust->clust->nr+1);
for(i=0; (i<=clust->clust->nr); i++)
init_dr_res(&dr_clust[i],fcd.disres.nres);
}
else {
out =xvgropen(opt2fn("-ds",NFILE,fnm),
"Sum of Violations","Time (ps)","nm",oenv);
aver=xvgropen(opt2fn("-da",NFILE,fnm),
"Average Violation","Time (ps)","nm",oenv);
numv=xvgropen(opt2fn("-dn",NFILE,fnm),
"# Violations","Time (ps)","#",oenv);
maxxv=xvgropen(opt2fn("-dm",NFILE,fnm),
"Largest Violation","Time (ps)","nm",oenv);
}
mdatoms = init_mdatoms(fplog,&mtop,ir.efep!=efepNO);
atoms2md(&mtop,&ir,0,NULL,0,mtop.natoms,mdatoms);
update_mdatoms(mdatoms,ir.init_lambda);
fr = mk_forcerec();
fprintf(fplog,"Made forcerec\n");
init_forcerec(fplog,oenv,fr,NULL,&ir,&mtop,cr,box,FALSE,NULL,NULL,NULL,
FALSE,-1);
init_nrnb(&nrnb);
if (ir.ePBC != epbcNONE)
gpbc = gmx_rmpbc_init(&top->idef,ir.ePBC,natoms,box);
j=0;
do {
if (ir.ePBC != epbcNONE) {
if (ir.bPeriodicMols)
set_pbc(&pbc,ir.ePBC,box);
else
gmx_rmpbc(gpbc,natoms,box,x);
}
if (clust) {
if (j > clust->maxframe)
gmx_fatal(FARGS,"There are more frames in the trajectory than in the cluster index file. t = %8f\n",t);
my_clust = clust->inv_clust[j];
range_check(my_clust,0,clust->clust->nr);
check_viol(fplog,cr,&(top->idef.il[F_DISRES]),
top->idef.iparams,top->idef.functype,
x,f,fr,pbc_null,g,dr_clust,my_clust,isize,index,vvindex,&fcd);
}
else
check_viol(fplog,cr,&(top->idef.il[F_DISRES]),
top->idef.iparams,top->idef.functype,
x,f,fr,pbc_null,g,&dr,0,isize,index,vvindex,&fcd);
if (bPDB) {
reset_x(atoms->nr,ind_fit,atoms->nr,NULL,x,w_rls);
do_fit(atoms->nr,w_rls,x,x);
if (j == 0) {
/* Store the first frame of the trajectory as 'characteristic'
* for colouring with violations.
*/
for(kkk=0; (kkk<atoms->nr); kkk++)
copy_rvec(x[kkk],xav[kkk]);
}
}
if (!clust) {
if (isize > 0) {
fprintf(xvg,"%10g",t);
for(i=0; (i<isize); i++)
fprintf(xvg," %10g",vvindex[i]);
fprintf(xvg,"\n");
}
fprintf(out, "%10g %10g\n",t,dr.sumv);
fprintf(aver, "%10g %10g\n",t,dr.averv);
fprintf(maxxv,"%10g %10g\n",t,dr.maxv);
fprintf(numv, "%10g %10d\n",t,dr.nv);
}
j++;
} while (read_next_x(oenv,status,&t,natoms,x,box));
close_trj(status);
if (ir.ePBC != epbcNONE)
gmx_rmpbc_done(gpbc);
if (clust) {
dump_clust_stats(fplog,fcd.disres.nres,&(top->idef.il[F_DISRES]),
top->idef.iparams,clust->clust,dr_clust,
clust->grpname,isize,index);
}
else {
dump_stats(fplog,j,fcd.disres.nres,&(top->idef.il[F_DISRES]),
top->idef.iparams,&dr,isize,index,
bPDB ? atoms : NULL);
if (bPDB) {
write_sto_conf(opt2fn("-q",NFILE,fnm),
"Coloured by average violation in Angstrom",
atoms,xav,NULL,ir.ePBC,box);
}
dump_disre_matrix(opt2fn_null("-x",NFILE,fnm),&dr,fcd.disres.nres,
j,&top->idef,&mtop,max_dr,nlevels,bThird);
ffclose(out);
ffclose(aver);
ffclose(numv);
ffclose(maxxv);
if (isize > 0) {
ffclose(xvg);
do_view(oenv,opt2fn("-dr",NFILE,fnm),"-nxy");
}
do_view(oenv,opt2fn("-dn",NFILE,fnm),"-nxy");
do_view(oenv,opt2fn("-da",NFILE,fnm),"-nxy");
do_view(oenv,opt2fn("-ds",NFILE,fnm),"-nxy");
do_view(oenv,opt2fn("-dm",NFILE,fnm),"-nxy");
}
thanx(stderr);
if (gmx_parallel_env_initialized())
gmx_finalize();
gmx_log_close(fplog);
return 0;
}
void sas_plot(int nfile,t_filenm fnm[],real solsize,int ndots,
real qcut,gmx_bool bSave,real minarea,gmx_bool bPBC,
real dgs_default,gmx_bool bFindex, const output_env_t oenv)
{
FILE *fp,*fp2,*fp3=NULL,*vp;
const char *flegend[] = { "Hydrophobic", "Hydrophilic",
"Total", "D Gsolv" };
const char *vlegend[] = { "Volume (nm\\S3\\N)", "Density (g/l)" };
const char *or_and_oa_legend[] = { "Average (nm\\S2\\N)", "Standard deviation (nm\\S2\\N)" };
const char *vfile;
real t;
gmx_atomprop_t aps=NULL;
gmx_rmpbc_t gpbc=NULL;
t_trxstatus *status;
int ndefault;
int i,j,ii,nfr,natoms,flag,nsurfacedots,res;
rvec *xtop,*x;
matrix topbox,box;
t_topology top;
char title[STRLEN];
int ePBC;
gmx_bool bTop;
t_atoms *atoms;
gmx_bool *bOut,*bPhobic;
gmx_bool bConnelly;
gmx_bool bResAt,bITP,bDGsol;
real *radius,*dgs_factor=NULL,*area=NULL,*surfacedots=NULL;
real at_area,*atom_area=NULL,*atom_area2=NULL;
real *res_a=NULL,*res_area=NULL,*res_area2=NULL;
real totarea,totvolume,totmass=0,density,harea,tarea,fluc2;
atom_id **index,*findex;
int *nx,nphobic,npcheck,retval;
char **grpname,*fgrpname;
real dgsolv;
bITP = opt2bSet("-i",nfile,fnm);
bResAt = opt2bSet("-or",nfile,fnm) || opt2bSet("-oa",nfile,fnm) || bITP;
bTop = read_tps_conf(ftp2fn(efTPS,nfile,fnm),title,&top,&ePBC,
&xtop,NULL,topbox,FALSE);
atoms = &(top.atoms);
if (!bTop) {
fprintf(stderr,"No tpr file, will not compute Delta G of solvation\n");
bDGsol = FALSE;
} else {
bDGsol = strcmp(*(atoms->atomtype[0]),"?") != 0;
if (!bDGsol) {
fprintf(stderr,"Warning: your tpr file is too old, will not compute "
"Delta G of solvation\n");
} else {
printf("In case you use free energy of solvation predictions:\n");
please_cite(stdout,"Eisenberg86a");
}
}
aps = gmx_atomprop_init();
if ((natoms=read_first_x(oenv,&status,ftp2fn(efTRX,nfile,fnm),
&t,&x,box))==0)
gmx_fatal(FARGS,"Could not read coordinates from statusfile\n");
if ((ePBC != epbcXYZ) || (TRICLINIC(box))) {
fprintf(stderr,"\n\nWARNING: non-rectangular boxes may give erroneous results or crashes.\n"
"Analysis based on vacuum simulations (with the possibility of evaporation)\n"
"will certainly crash the analysis.\n\n");
}
snew(nx,2);
snew(index,2);
snew(grpname,2);
fprintf(stderr,"Select a group for calculation of surface and a group for output:\n");
get_index(atoms,ftp2fn_null(efNDX,nfile,fnm),2,nx,index,grpname);
if (bFindex) {
fprintf(stderr,"Select a group of hydrophobic atoms:\n");
get_index(atoms,ftp2fn_null(efNDX,nfile,fnm),1,&nphobic,&findex,&fgrpname);
}
snew(bOut,natoms);
for(i=0; i<nx[1]; i++)
bOut[index[1][i]] = TRUE;
/* Now compute atomic readii including solvent probe size */
snew(radius,natoms);
snew(bPhobic,nx[0]);
if (bResAt) {
snew(atom_area,nx[0]);
snew(atom_area2,nx[0]);
snew(res_a,atoms->nres);
snew(res_area,atoms->nres);
snew(res_area2,atoms->nres);
}
if (bDGsol)
snew(dgs_factor,nx[0]);
/* Get a Van der Waals radius for each atom */
ndefault = 0;
for(i=0; (i<natoms); i++) {
if (!gmx_atomprop_query(aps,epropVDW,
*(atoms->resinfo[atoms->atom[i].resind].name),
*(atoms->atomname[i]),&radius[i]))
ndefault++;
/* radius[i] = calc_radius(*(top->atoms.atomname[i])); */
radius[i] += solsize;
}
if (ndefault > 0)
fprintf(stderr,"WARNING: could not find a Van der Waals radius for %d atoms\n",ndefault);
/* Determine which atom is counted as hydrophobic */
if (bFindex) {
npcheck = 0;
for(i=0; (i<nx[0]); i++) {
ii = index[0][i];
for(j=0; (j<nphobic); j++) {
if (findex[j] == ii) {
bPhobic[i] = TRUE;
if (bOut[ii])
npcheck++;
}
}
}
if (npcheck != nphobic)
gmx_fatal(FARGS,"Consistency check failed: not all %d atoms in the hydrophobic index\n"
"found in the normal index selection (%d atoms)",nphobic,npcheck);
}
else
nphobic = 0;
for(i=0; (i<nx[0]); i++) {
ii = index[0][i];
if (!bFindex) {
bPhobic[i] = fabs(atoms->atom[ii].q) <= qcut;
if (bPhobic[i] && bOut[ii])
nphobic++;
}
if (bDGsol)
if (!gmx_atomprop_query(aps,epropDGsol,
*(atoms->resinfo[atoms->atom[ii].resind].name),
*(atoms->atomtype[ii]),&(dgs_factor[i])))
dgs_factor[i] = dgs_default;
if (debug)
fprintf(debug,"Atom %5d %5s-%5s: q= %6.3f, r= %6.3f, dgsol= %6.3f, hydrophobic= %s\n",
ii+1,*(atoms->resinfo[atoms->atom[ii].resind].name),
*(atoms->atomname[ii]),
atoms->atom[ii].q,radius[ii]-solsize,dgs_factor[i],
BOOL(bPhobic[i]));
}
fprintf(stderr,"%d out of %d atoms were classified as hydrophobic\n",
nphobic,nx[1]);
fp=xvgropen(opt2fn("-o",nfile,fnm),"Solvent Accessible Surface","Time (ps)",
"Area (nm\\S2\\N)",oenv);
xvgr_legend(fp,asize(flegend) - (bDGsol ? 0 : 1),flegend,oenv);
vfile = opt2fn_null("-tv",nfile,fnm);
if (vfile) {
if (!bTop) {
gmx_fatal(FARGS,"Need a tpr file for option -tv");
}
vp=xvgropen(vfile,"Volume and Density","Time (ps)","",oenv);
xvgr_legend(vp,asize(vlegend),vlegend,oenv);
totmass = 0;
ndefault = 0;
for(i=0; (i<nx[0]); i++) {
real mm;
ii = index[0][i];
/*
if (!query_atomprop(atomprop,epropMass,
*(top->atoms.resname[top->atoms.atom[ii].resnr]),
*(top->atoms.atomname[ii]),&mm))
ndefault++;
totmass += mm;
*/
totmass += atoms->atom[ii].m;
}
if (ndefault)
fprintf(stderr,"WARNING: Using %d default masses for density calculation, which most likely are inaccurate\n",ndefault);
}
else
vp = NULL;
gmx_atomprop_destroy(aps);
if (bPBC)
gpbc = gmx_rmpbc_init(&top.idef,ePBC,natoms,box);
nfr=0;
do {
if (bPBC)
gmx_rmpbc(gpbc,natoms,box,x);
bConnelly = (nfr==0 && opt2bSet("-q",nfile,fnm));
if (bConnelly) {
if (!bTop)
gmx_fatal(FARGS,"Need a tpr file for Connelly plot");
flag = FLAG_ATOM_AREA | FLAG_DOTS;
} else {
flag = FLAG_ATOM_AREA;
}
if (vp) {
flag = flag | FLAG_VOLUME;
}
if (debug)
write_sto_conf("check.pdb","pbc check",atoms,x,NULL,ePBC,box);
retval = nsc_dclm_pbc(x,radius,nx[0],ndots,flag,&totarea,
&area,&totvolume,&surfacedots,&nsurfacedots,
index[0],ePBC,bPBC ? box : NULL);
if (retval)
gmx_fatal(FARGS,"Something wrong in nsc_dclm_pbc");
if (bConnelly)
connelly_plot(ftp2fn(efPDB,nfile,fnm),
nsurfacedots,surfacedots,x,atoms,
&(top.symtab),ePBC,box,bSave);
harea = 0;
tarea = 0;
dgsolv = 0;
if (bResAt)
for(i=0; i<atoms->nres; i++)
res_a[i] = 0;
for(i=0; (i<nx[0]); i++) {
ii = index[0][i];
if (bOut[ii]) {
at_area = area[i];
if (bResAt) {
atom_area[i] += at_area;
atom_area2[i] += sqr(at_area);
res_a[atoms->atom[ii].resind] += at_area;
}
tarea += at_area;
if (bDGsol)
dgsolv += at_area*dgs_factor[i];
if (bPhobic[i])
harea += at_area;
}
}
if (bResAt)
for(i=0; i<atoms->nres; i++) {
res_area[i] += res_a[i];
res_area2[i] += sqr(res_a[i]);
}
fprintf(fp,"%10g %10g %10g %10g",t,harea,tarea-harea,tarea);
if (bDGsol)
fprintf(fp," %10g\n",dgsolv);
else
fprintf(fp,"\n");
/* Print volume */
if (vp) {
density = totmass*AMU/(totvolume*NANO*NANO*NANO);
fprintf(vp,"%12.5e %12.5e %12.5e\n",t,totvolume,density);
}
if (area) {
sfree(area);
area = NULL;
}
if (surfacedots) {
sfree(surfacedots);
surfacedots = NULL;
}
nfr++;
} while (read_next_x(oenv,status,&t,natoms,x,box));
if (bPBC)
gmx_rmpbc_done(gpbc);
fprintf(stderr,"\n");
close_trj(status);
ffclose(fp);
if (vp)
ffclose(vp);
/* if necessary, print areas per atom to file too: */
if (bResAt) {
for(i=0; i<atoms->nres; i++) {
res_area[i] /= nfr;
res_area2[i] /= nfr;
}
for(i=0; i<nx[0]; i++) {
atom_area[i] /= nfr;
atom_area2[i] /= nfr;
}
fprintf(stderr,"Printing out areas per atom\n");
fp = xvgropen(opt2fn("-or",nfile,fnm),"Area per residue over the trajectory","Residue",
"Area (nm\\S2\\N)",oenv);
xvgr_legend(fp, asize(or_and_oa_legend),or_and_oa_legend,oenv);
fp2 = xvgropen(opt2fn("-oa",nfile,fnm),"Area per atom over the trajectory","Atom #",
"Area (nm\\S2\\N)",oenv);
xvgr_legend(fp2, asize(or_and_oa_legend),or_and_oa_legend,oenv);
if (bITP) {
fp3 = ftp2FILE(efITP,nfile,fnm,"w");
fprintf(fp3,"[ position_restraints ]\n"
"#define FCX 1000\n"
"#define FCY 1000\n"
"#define FCZ 1000\n"
"; Atom Type fx fy fz\n");
}
for(i=0; i<nx[0]; i++) {
ii = index[0][i];
res = atoms->atom[ii].resind;
if (i==nx[0]-1 || res!=atoms->atom[index[0][i+1]].resind) {
fluc2 = res_area2[res]-sqr(res_area[res]);
if (fluc2 < 0)
fluc2 = 0;
fprintf(fp,"%10d %10g %10g\n",
atoms->resinfo[res].nr,res_area[res],sqrt(fluc2));
}
fluc2 = atom_area2[i]-sqr(atom_area[i]);
if (fluc2 < 0)
fluc2 = 0;
fprintf(fp2,"%d %g %g\n",index[0][i]+1,atom_area[i],sqrt(fluc2));
if (bITP && (atom_area[i] > minarea))
fprintf(fp3,"%5d 1 FCX FCX FCZ\n",ii+1);
}
if (bITP)
ffclose(fp3);
ffclose(fp);
}
/* Be a good citizen, keep our memory free! */
sfree(x);
sfree(nx);
for(i=0;i<2;i++)
{
sfree(index[i]);
sfree(grpname[i]);
}
sfree(bOut);
sfree(radius);
sfree(bPhobic);
if(bResAt)
{
sfree(atom_area);
sfree(atom_area2);
sfree(res_a);
sfree(res_area);
sfree(res_area2);
}
if(bDGsol)
{
sfree(dgs_factor);
}
}
int main(int argc,char *argv[])
{
const char *desc[] = {
"g_zcoord can output the z(t) coordinates of atoms which are located in a "
"cylindrical region. "
"This region is defined by its radius R, the axis, and a point on this axis."
"It takes an index file with atom, ",
"and generates an output file with the ",
"z coordinates for each entry in the index file. Coordinates of particles "
"that are NOT in the cylinder are set to a special value, which is set "
"with the [TT]-nan[TT] option.",
"[PAR]For quicker visualisation the [TT]-mat[tt] option is useful. It creates ",
"an xpm matrix file. The boundaries of the graph in z are taken from "
"z1 and z2; the spacing can be set with the hidden option "
"[TT]-matspacing[TT]. Its default is " xstr(XPM_Z_SPACING) " nm.",
"[PAR]Due to the huge amount of diskspace that the .dat and .xvg file can "
"take up these options have been all made optional. YOU NEED TO SET AT LEAST "
"ONE OF [TT]-dat[TT], [TT]-o[TT], or [TT]-mat[TT] to generate any output."
};
t_cavity cavity = { /* define volume to count mols in */
{0, 0, 1}, /* axis */
{0, 0, 0}, /* cpoint */
-1, /* radius */
-1, /* z1 < z2 */
-1,
0 /* volume - calculate later */
};
real spacing = XPM_Z_SPACING; /* spacing in nm (!) for conversion to xpm */
int ngroups = 1; /* not used yet >1 */
real invalid = 9999.0; /* mark coordinates of particles not in cylinder */
t_pargs pa[] = {
{ "-axis", FALSE, etRVEC, {&(cavity.axis)},
"Vector pointing parallel to the pore axis"},
{ "-cpoint", FALSE, etRVEC, {&(cavity.cpoint)},
"Point on the pore axis"},
{ "-R", FALSE, etREAL, {&(cavity.radius)},
"Radius of the cylindrical pore cavity"},
{ "-z1", FALSE, etREAL, {&(cavity.z1)},
"Confine waters to have a z coordinate larger than z1, and"},
{ "-z2", FALSE, etREAL, {&(cavity.z2)},
"smaller than z2 (in nm). Also the z-boundaries for the xpm matrix."},
{ "-nan", FALSE, etREAL, {&invalid},
"number that is used in output files for coordinates when the particle "
"is not in the cylinder"},
{ "-matspacing", FALSE, etREAL, {&spacing},
"HIDDENz spacing (in nm) for the xpm matrix"},
{ "-ng", FALSE, etINT, {&ngroups},
"HIDDENNumber of groups to consider" },
};
FILE *out = NULL; /* xmgr file with coordinates */
FILE *fData= NULL; /* simple data file: t z */
t_topology top; /* topology */
rvec *xtop;
int ePBC;
char title[STRLEN];
gmx_bool bTop;
rvec *x,*x_s; /* coord, with and without pbc*/
rvec xcm; /* center of mass of molecule */
matrix box; /* box matrix (3x3) */
real t,tm; /* time, total mass molecule */
int natoms; /* number of atoms in system */
t_trxstatus *status;
int i,j; /* loopcounters */
int k_frame; /* counts frames */
const char *indexfn;
char **grpname; /* groupnames for all groups */
int *isize;
atom_id **index; /* molecule numbers in index for each group */
atom_id *atndx = NULL; /* indices from block. */
t_block *mols= NULL; /* all molecules in system */
char *ggrpname; /* name of the FIRST group */
int gnx = 0; /* number of atoms in FIRST group*/
atom_id *gindex = NULL; /* index of FIRST group */
real maxzval = MINZVAL_DEFAULT; /* max z in nm (!) for conversion to xpm */
real minzval = MAXZVAL_DEFAULT; /* min z in nm (!) for conversion to xpm */
int nbins = 0; /* number of bins for conv to xpm */
real **zbins = NULL; /* bins for conversion to xpm */
FILE *xpmOut = NULL; /* xpm matrix file */
t_rgb rlo, rhi; /* low and high colors for matrix */
int nlevels = 2;
int max_frames = XPM_INITIAL_FRAMES;
/* current max number of frames in xpm matrix */
real *x_axis = NULL;/* x-axis labels */
real *y_axis = NULL;/* y-axis labels */
gmx_bool bXPM = FALSE; /* produce XPM matrix ?*/
gmx_bool bXVG = FALSE; /* no output generated by default */
gmx_bool bDAT = FALSE;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efXVG, "-o", "zcoord", ffOPTWR },
{ efXPM, "-mat", "zcoord", ffOPTWR }, /* this is for xpm output */
{ efDAT, "-dat", "zcoord", ffOPTWR },
{ efNDX, NULL, NULL, ffOPTRD }
};
output_env_t oenv;
#define NFILE asize(fnm)
#define NPA asize(pa)
#define NDFILES 2
FILE *dfiles[NDFILES+1]; /* output files to dump data to
terminate with NULL */
const char *bugs[] = {
"Even if the cylinder axis is not (0,0,1), the top and bottom of the cylinder are"
"still determined by the z-coordinates z1 and z2.",
"ATTENTION: no data is generated by default !!!",
"xpm graph: If no proper (i.e. |z| < " xstr(Z_SANITY) "nm) z-limits are "
"given they are set to "
"the arbitrary values z_min=" xstr(MINZVAL_DEFAULT) " and "
"z_max=" xstr(MAXZVAL_DEFAULT),
};
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW,
NFILE,fnm,asize(pa),pa,asize(desc),desc,asize(bugs),bugs,
&oenv);
bDAT = (opt2fn_null("-dat", NFILE, fnm)) ? TRUE : FALSE;
bXVG = (opt2fn_null("-o", NFILE, fnm)) ? TRUE : FALSE;
bXPM = (opt2fn_null("-mat", NFILE, fnm)) ? TRUE : FALSE;
if (! (bXPM || bXVG || bDAT)) {
/* check if this is a pointless run */
msg("No output selected. I stop here.\n");
return (1);
}
bTop = read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xtop,NULL,box,TRUE);
sfree(xtop);
if (!bTop) {
gmx_fatal(FARGS, "Need a run input file");
}
indexfn = ftp2fn_null(efNDX,NFILE,fnm);
if (ngroups != 1) {
gmx_fatal(FARGS, "Sorry, only a single group currently allowed.");
}
snew(grpname,ngroups);
snew(isize,ngroups);
snew(index,ngroups);
get_index(&(top.atoms),indexfn,ngroups,isize,index,grpname);
/* ngroups == 1 at moment */
gnx = isize[0];
gindex = index[0];
ggrpname = grpname[0];
mols = &(top.mols);
atndx = mols->index;
natoms=read_first_x(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
snew(x_s,natoms);
/* look at cavity */
if (cavity.z1 >= cavity.z2) {
gmx_fatal(FARGS, "z-boundaries have worng values: They must be z1 < z2.");
}
/* look at cavity
set defaults from the simulation box size
*/
msg("\n");
autoset_cavity(&cavity,box,NPA,pa);
cavity.vol = sqr(cavity.radius) * PI * (cavity.z2 - cavity.z1); // not needed, just for completeness
if (bXPM) {
/* for xpm output: set limits to z1 and z2 */
/* mild sanity check */
minzval = cavity.z1 < -Z_SANITY ? MINZVAL_DEFAULT : cavity.z1;
maxzval = cavity.z2 > Z_SANITY ? MAXZVAL_DEFAULT : cavity.z2;
/* xpm graphics: initialize bins */
nbins = (int)ceill((maxzval - minzval) / spacing);
snew(zbins,max_frames);
snew(x_axis,max_frames);
msg("Limits for xpm matrix: %g nm < z < %g nm\n", minzval, maxzval);
}
/* initialize dfiles: use it to dump data to different files simultanously */
for (i = 0; i < NDFILES+1; i++) dfiles[i] = NULL;
i = 0; /* use to count how many output files are open */
if (bXVG) {
out = xmgropen(opt2fn("-o",NFILE,fnm),
"z coordinate",
"Coordinate",
"Time (ps)","z (nm)");
dfiles[i++] = out;
}
if (bDAT) {
fData = ffopen (opt2fn("-dat", NFILE, fnm), "w");
dfiles[i++] = fData;
}
k_frame = 0; /*! counts the frames */
do {
dump_data (dfiles, "%10g", t);
if (bXPM) {
// new timeframe
// check if we need more memory
if (k_frame >= max_frames) {
max_frames += XPM_INITIAL_FRAMES;
if (!(srenew(zbins,max_frames)) ||
!(srenew(x_axis,max_frames)) ) {
msg("Out of memory for xpm graph: I abort and try to process what "
"I have got so far (frame = %g).\n", k_frame);
break;
}
}
snew(zbins[k_frame],nbins);
x_axis[k_frame]=t/1000; // in ns
// initialize bins to zero
for (i=0; i<nbins; i++)
zbins[k_frame][i] = 0.0;
}
/* We are not interested in molecules, just in the z-coordinates
of atoms */
for(i=0; i<gnx; i++) {
if ( bInCavity (x[gindex[i]], &cavity) ) { // only look at cylinder
if (bXPM) {
if ( (x[gindex[i]][ZZ] >= minzval) && (x[gindex[i]][ZZ] <= maxzval))
zbins[k_frame][(int)floorl((x[gindex[i]][ZZ] - minzval) / spacing)]=1.0;
}
}
else {
/* particle OUTSIDE cylinder: mark coordinates as 'invalid'
but keep them in the output file */
for(j=0; j<3; j++) {
x[gindex[i]][j] = invalid;
}
}
dump_data (dfiles,"\t%10g", x[gindex[i]][ZZ]);
}
/* some printout for debugging/development - MB
for (i=0; i<nbins; i++)
for (i=0; i<10; i++)
printf("%1d",(int)zbins[k_frame][i]);
printf("\n");
*/
dump_data (dfiles, "\n");
k_frame++;
} while(read_next_x(oenv,status,&t,natoms,x,box));
close_trj(status);
if (bXPM) {
/* colors for matrix */
rlo.r = 1.0, rlo.g = 1.0, rlo.b = 1.0; // no water color
rhi.r = 0.4, rhi.g = 0.4, rhi.b = 1.0; // water color
/* create labels */
snew(y_axis,nbins+1);
for(i=0; i<=nbins; i++) { // n+1 labels with MAT_SPATIAL_Y
y_axis[i]=10 * (minzval + (i * spacing)); // Yes, I WANT Angstroms !!!
}
/* write xpm matrix */
xpmOut = fopen(opt2fn("-mat", NFILE, fnm),"w");
write_xpm(xpmOut,
MAT_SPATIAL_Y,
"g_zcoord matrix", // title
"existence", // label for the continuous legend
"timeframe / ns", // label for the x-axis
"z coordinate / A", // label for the y-axis - where the F**k is the
// bloody Angstrom
k_frame, nbins, // size of the matrix
x_axis, // the x-ticklabels
// would be nice to have the times here
y_axis, // the y-ticklabels
// would be nice to have the zcoordinate label in nm or A
zbins, // element x,y is matrix[x][y]
0.0, // output lower than lo is set to lo
1.0, // output higher than hi is set to hi
rlo, // rgb value for level lo
rhi, // rgb value for level hi
&nlevels); // number of color levels for the output
fclose(xpmOut);
};
/* clean up a bit */
fprintf(stderr,"\n");
if (bDAT) fclose(fData);
if (bXVG) fclose(out);
if (bXPM) {
// free memory from xpm matrix data
for (i=0; i<k_frame; i++)
sfree(zbins[i]);
sfree(zbins);
sfree(x_axis);
}
thanx(stdout);
return 0;
}
int gmx_sas(int argc,char *argv[])
{
const char *desc[] = {
"[TT]g_sas[tt] computes hydrophobic, hydrophilic and total solvent",
"accessible surface area. See Eisenhaber F, Lijnzaad P, Argos P,",
"Sander C, & Scharf M (1995) J. Comput. Chem. 16, 273-284.",
"As a side effect, the Connolly surface can be generated as well in",
"a [TT].pdb[tt] file where the nodes are represented as atoms and the",
"vertice connecting the nearest nodes as CONECT records.",
"The program will ask for a group for the surface calculation",
"and a group for the output. The calculation group should always",
"consists of all the non-solvent atoms in the system.",
"The output group can be the whole or part of the calculation group.",
"The average and standard deviation of the area over the trajectory can be plotted",
"per residue and atom as well (options [TT]-or[tt] and [TT]-oa[tt]).",
"In combination with the latter option an [TT].itp[tt] file can be",
"generated (option [TT]-i[tt])",
"which can be used to restrain surface atoms.[PAR]",
"By default, periodic boundary conditions are taken into account,",
"this can be turned off using the [TT]-nopbc[tt] option.[PAR]",
"With the [TT]-tv[tt] option the total volume and density of the",
"molecule can be computed.",
"Please consider whether the normal probe radius is appropriate",
"in this case or whether you would rather use e.g. 0. It is good",
"to keep in mind that the results for volume and density are very",
"approximate. For example, in ice Ih, one can easily fit water molecules in the",
"pores which would yield a volume that is too low, and surface area and density",
"that are both too high."
};
output_env_t oenv;
static real solsize = 0.14;
static int ndots = 24;
static real qcut = 0.2;
static real minarea = 0.5, dgs_default=0;
static gmx_bool bSave = TRUE,bPBC=TRUE,bFindex=FALSE;
t_pargs pa[] = {
{ "-probe", FALSE, etREAL, {&solsize},
"Radius of the solvent probe (nm)" },
{ "-ndots", FALSE, etINT, {&ndots},
"Number of dots per sphere, more dots means more accuracy" },
{ "-qmax", FALSE, etREAL, {&qcut},
"The maximum charge (e, absolute value) of a hydrophobic atom" },
{ "-f_index", FALSE, etBOOL, {&bFindex},
"Determine from a group in the index file what are the hydrophobic atoms rather than from the charge" },
{ "-minarea", FALSE, etREAL, {&minarea},
"The minimum area (nm^2) to count an atom as a surface atom when writing a position restraint file (see help)" },
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Take periodicity into account" },
{ "-prot", FALSE, etBOOL, {&bSave},
"Output the protein to the Connelly [TT].pdb[tt] file too" },
{ "-dgs", FALSE, etREAL, {&dgs_default},
"Default value for solvation free energy per area (kJ/mol/nm^2)" }
};
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, "-s", NULL, ffREAD },
{ efXVG, "-o", "area", ffWRITE },
{ efXVG, "-or", "resarea", ffOPTWR },
{ efXVG, "-oa", "atomarea", ffOPTWR },
{ efXVG, "-tv", "volume", ffOPTWR },
{ efPDB, "-q", "connelly", ffOPTWR },
{ efNDX, "-n", "index", ffOPTRD },
{ efITP, "-i", "surfat", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_VIEW | PCA_CAN_TIME | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL,&oenv);
if (solsize < 0) {
solsize=1e-3;
fprintf(stderr,"Probe size too small, setting it to %g\n",solsize);
}
if (ndots < 20) {
ndots = 20;
fprintf(stderr,"Ndots too small, setting it to %d\n",ndots);
}
please_cite(stderr,"Eisenhaber95");
sas_plot(NFILE,fnm,solsize,ndots,qcut,bSave,minarea,bPBC,dgs_default,bFindex,
oenv);
do_view(oenv,opt2fn("-o",NFILE,fnm),"-nxy");
do_view(oenv,opt2fn_null("-or",NFILE,fnm),"-nxy");
do_view(oenv,opt2fn_null("-oa",NFILE,fnm),"-nxy");
thanx(stderr);
return 0;
}
int gmx_rms(int argc, char *argv[])
{
const char *desc[] =
{
"[THISMODULE] compares two structures by computing the root mean square",
"deviation (RMSD), the size-independent [GRK]rho[grk] similarity parameter",
"([TT]rho[tt]) or the scaled [GRK]rho[grk] ([TT]rhosc[tt]), ",
"see Maiorov & Crippen, Proteins [BB]22[bb], 273 (1995).",
"This is selected by [TT]-what[tt].[PAR]"
"Each structure from a trajectory ([TT]-f[tt]) is compared to a",
"reference structure. The reference structure",
"is taken from the structure file ([TT]-s[tt]).[PAR]",
"With option [TT]-mir[tt] also a comparison with the mirror image of",
"the reference structure is calculated.",
"This is useful as a reference for 'significant' values, see",
"Maiorov & Crippen, Proteins [BB]22[bb], 273 (1995).[PAR]",
"Option [TT]-prev[tt] produces the comparison with a previous frame",
"the specified number of frames ago.[PAR]",
"Option [TT]-m[tt] produces a matrix in [TT].xpm[tt] format of",
"comparison values of each structure in the trajectory with respect to",
"each other structure. This file can be visualized with for instance",
"[TT]xv[tt] and can be converted to postscript with [gmx-xpm2ps].[PAR]",
"Option [TT]-fit[tt] controls the least-squares fitting of",
"the structures on top of each other: complete fit (rotation and",
"translation), translation only, or no fitting at all.[PAR]",
"Option [TT]-mw[tt] controls whether mass weighting is done or not.",
"If you select the option (default) and ",
"supply a valid [TT].tpr[tt] file masses will be taken from there, ",
"otherwise the masses will be deduced from the [TT]atommass.dat[tt] file in",
"[TT]GMXLIB[tt]. This is fine for proteins, but not",
"necessarily for other molecules. A default mass of 12.011 amu (carbon)",
"is assigned to unknown atoms. You can check whether this happend by",
"turning on the [TT]-debug[tt] flag and inspecting the log file.[PAR]",
"With [TT]-f2[tt], the 'other structures' are taken from a second",
"trajectory, this generates a comparison matrix of one trajectory",
"versus the other.[PAR]",
"Option [TT]-bin[tt] does a binary dump of the comparison matrix.[PAR]",
"Option [TT]-bm[tt] produces a matrix of average bond angle deviations",
"analogously to the [TT]-m[tt] option. Only bonds between atoms in the",
"comparison group are considered."
};
static gmx_bool bPBC = TRUE, bFitAll = TRUE, bSplit = FALSE;
static gmx_bool bDeltaLog = FALSE;
static int prev = 0, freq = 1, freq2 = 1, nlevels = 80, avl = 0;
static real rmsd_user_max = -1, rmsd_user_min = -1, bond_user_max = -1,
bond_user_min = -1, delta_maxy = 0.0;
/* strings and things for selecting difference method */
enum
{
ewSel, ewRMSD, ewRho, ewRhoSc, ewNR
};
int ewhat;
const char *what[ewNR + 1] =
{ NULL, "rmsd", "rho", "rhosc", NULL };
const char *whatname[ewNR] =
{ NULL, "RMSD", "Rho", "Rho sc" };
const char *whatlabel[ewNR] =
{ NULL, "RMSD (nm)", "Rho", "Rho sc" };
const char *whatxvgname[ewNR] =
{ NULL, "RMSD", "\\8r\\4", "\\8r\\4\\ssc\\N" };
const char *whatxvglabel[ewNR] =
{ NULL, "RMSD (nm)", "\\8r\\4", "\\8r\\4\\ssc\\N" };
/* strings and things for fitting methods */
enum
{
efSel, efFit, efReset, efNone, efNR
};
int efit;
const char *fit[efNR + 1] =
{ NULL, "rot+trans", "translation", "none", NULL };
const char *fitgraphlabel[efNR + 1] =
{ NULL, "lsq fit", "translational fit", "no fit" };
static int nrms = 1;
static gmx_bool bMassWeighted = TRUE;
t_pargs pa[] =
{
{ "-what", FALSE, etENUM,
{ what }, "Structural difference measure" },
{ "-pbc", FALSE, etBOOL,
{ &bPBC }, "PBC check" },
{ "-fit", FALSE, etENUM,
{ fit }, "Fit to reference structure" },
{ "-prev", FALSE, etINT,
{ &prev }, "Compare with previous frame" },
{ "-split", FALSE, etBOOL,
{ &bSplit }, "Split graph where time is zero" },
{ "-fitall", FALSE, etBOOL,
{ &bFitAll }, "HIDDENFit all pairs of structures in matrix" },
{ "-skip", FALSE, etINT,
{ &freq }, "Only write every nr-th frame to matrix" },
{ "-skip2", FALSE, etINT,
{ &freq2 }, "Only write every nr-th frame to matrix" },
{ "-max", FALSE, etREAL,
{ &rmsd_user_max }, "Maximum level in comparison matrix" },
{ "-min", FALSE, etREAL,
{ &rmsd_user_min }, "Minimum level in comparison matrix" },
{ "-bmax", FALSE, etREAL,
{ &bond_user_max }, "Maximum level in bond angle matrix" },
{ "-bmin", FALSE, etREAL,
{ &bond_user_min }, "Minimum level in bond angle matrix" },
{ "-mw", FALSE, etBOOL,
{ &bMassWeighted }, "Use mass weighting for superposition" },
{ "-nlevels", FALSE, etINT,
{ &nlevels }, "Number of levels in the matrices" },
{ "-ng", FALSE, etINT,
{ &nrms }, "Number of groups to compute RMS between" },
{ "-dlog", FALSE, etBOOL,
{ &bDeltaLog },
"HIDDENUse a log x-axis in the delta t matrix" },
{ "-dmax", FALSE, etREAL,
{ &delta_maxy }, "HIDDENMaximum level in delta matrix" },
{ "-aver", FALSE, etINT,
{ &avl },
"HIDDENAverage over this distance in the RMSD matrix" }
};
int natoms_trx, natoms_trx2, natoms;
int i, j, k, m, teller, teller2, tel_mat, tel_mat2;
#define NFRAME 5000
int maxframe = NFRAME, maxframe2 = NFRAME;
real t, *w_rls, *w_rms, *w_rls_m = NULL, *w_rms_m = NULL;
gmx_bool bNorm, bAv, bFreq2, bFile2, bMat, bBond, bDelta, bMirror, bMass;
gmx_bool bFit, bReset;
t_topology top;
int ePBC;
t_iatom *iatom = NULL;
matrix box;
rvec *x, *xp, *xm = NULL, **mat_x = NULL, **mat_x2, *mat_x2_j = NULL, vec1,
vec2;
t_trxstatus *status;
char buf[256], buf2[256];
int ncons = 0;
FILE *fp;
real rlstot = 0, **rls, **rlsm = NULL, *time, *time2, *rlsnorm = NULL,
**rmsd_mat = NULL, **bond_mat = NULL, *axis, *axis2, *del_xaxis,
*del_yaxis, rmsd_max, rmsd_min, rmsd_avg, bond_max, bond_min, ang;
real **rmsdav_mat = NULL, av_tot, weight, weight_tot;
real **delta = NULL, delta_max, delta_scalex = 0, delta_scaley = 0,
*delta_tot;
int delta_xsize = 0, del_lev = 100, mx, my, abs_my;
gmx_bool bA1, bA2, bPrev, bTop, *bInMat = NULL;
int ifit, *irms, ibond = 0, *ind_bond1 = NULL, *ind_bond2 = NULL, n_ind_m =
0;
atom_id *ind_fit, **ind_rms, *ind_m = NULL, *rev_ind_m = NULL, *ind_rms_m =
NULL;
char *gn_fit, **gn_rms;
t_rgb rlo, rhi;
output_env_t oenv;
gmx_rmpbc_t gpbc = NULL;
t_filenm fnm[] =
{
{ efTPS, NULL, NULL, ffREAD },
{ efTRX, "-f", NULL, ffREAD },
{ efTRX, "-f2", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "rmsd", ffWRITE },
{ efXVG, "-mir", "rmsdmir", ffOPTWR },
{ efXVG, "-a", "avgrp", ffOPTWR },
{ efXVG, "-dist", "rmsd-dist", ffOPTWR },
{ efXPM, "-m", "rmsd", ffOPTWR },
{ efDAT, "-bin", "rmsd", ffOPTWR },
{ efXPM, "-bm", "bond", 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;
}
/* parse enumerated options: */
ewhat = nenum(what);
if (ewhat == ewRho || ewhat == ewRhoSc)
{
please_cite(stdout, "Maiorov95");
}
efit = nenum(fit);
bFit = efit == efFit;
bReset = efit == efReset;
if (bFit)
{
bReset = TRUE; /* for fit, reset *must* be set */
}
else
{
bFitAll = FALSE;
}
/* mark active cmdline options */
bMirror = opt2bSet("-mir", NFILE, fnm); /* calc RMSD vs mirror of ref. */
bFile2 = opt2bSet("-f2", NFILE, fnm);
bMat = opt2bSet("-m", NFILE, fnm);
bBond = opt2bSet("-bm", NFILE, fnm);
bDelta = (delta_maxy > 0); /* calculate rmsd vs delta t matrix from *
* your RMSD matrix (hidden option */
bNorm = opt2bSet("-a", NFILE, fnm);
bFreq2 = opt2parg_bSet("-skip2", asize(pa), pa);
if (freq <= 0)
{
fprintf(stderr, "The number of frames to skip is <= 0. "
"Writing out all frames.\n\n");
freq = 1;
}
if (!bFreq2)
{
freq2 = freq;
}
else if (bFile2 && freq2 <= 0)
{
fprintf(stderr,
"The number of frames to skip in second trajectory is <= 0.\n"
" Writing out all frames.\n\n");
freq2 = 1;
}
bPrev = (prev > 0);
if (bPrev)
{
prev = abs(prev);
if (freq != 1)
{
fprintf(stderr, "WARNING: option -skip also applies to -prev\n");
}
}
if (bFile2 && !bMat && !bBond)
{
fprintf(
stderr,
"WARNING: second trajectory (-f2) useless when not calculating matrix (-m/-bm),\n"
" will not read from %s\n", opt2fn("-f2", NFILE,
fnm));
bFile2 = FALSE;
}
if (bDelta)
{
bMat = TRUE;
if (bFile2)
{
fprintf(stderr,
"WARNING: second trajectory (-f2) useless when making delta matrix,\n"
" will not read from %s\n", opt2fn("-f2",
NFILE, fnm));
bFile2 = FALSE;
}
}
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm), buf, &top, &ePBC, &xp,
NULL, box, TRUE);
snew(w_rls, top.atoms.nr);
snew(w_rms, top.atoms.nr);
if (!bTop && bBond)
{
fprintf(stderr,
"WARNING: Need a run input file for bond angle matrix,\n"
" will not calculate bond angle matrix.\n");
bBond = FALSE;
}
if (bReset)
{
fprintf(stderr, "Select group for %s fit\n", bFit ? "least squares"
: "translational");
get_index(&(top.atoms), ftp2fn_null(efNDX, NFILE, fnm), 1, &ifit,
&ind_fit, &gn_fit);
}
else
{
ifit = 0;
}
if (bReset)
{
if (bFit && ifit < 3)
{
gmx_fatal(FARGS, "Need >= 3 points to fit!\n" );
}
bMass = FALSE;
for (i = 0; i < ifit; i++)
{
if (bMassWeighted)
{
w_rls[ind_fit[i]] = top.atoms.atom[ind_fit[i]].m;
}
else
{
w_rls[ind_fit[i]] = 1;
}
bMass = bMass || (top.atoms.atom[ind_fit[i]].m != 0);
}
if (!bMass)
{
fprintf(stderr, "All masses in the fit group are 0, using masses of 1\n");
for (i = 0; i < ifit; i++)
{
w_rls[ind_fit[i]] = 1;
}
}
}
if (bMat || bBond)
{
nrms = 1;
}
snew(gn_rms, nrms);
snew(ind_rms, nrms);
snew(irms, nrms);
fprintf(stderr, "Select group%s for %s calculation\n",
(nrms > 1) ? "s" : "", whatname[ewhat]);
get_index(&(top.atoms), ftp2fn_null(efNDX, NFILE, fnm),
nrms, irms, ind_rms, gn_rms);
if (bNorm)
{
snew(rlsnorm, irms[0]);
}
snew(rls, nrms);
for (j = 0; j < nrms; j++)
{
snew(rls[j], maxframe);
}
if (bMirror)
{
snew(rlsm, nrms);
for (j = 0; j < nrms; j++)
{
snew(rlsm[j], maxframe);
}
}
snew(time, maxframe);
for (j = 0; j < nrms; j++)
{
bMass = FALSE;
for (i = 0; i < irms[j]; i++)
{
if (bMassWeighted)
{
w_rms[ind_rms[j][i]] = top.atoms.atom[ind_rms[j][i]].m;
}
else
{
w_rms[ind_rms[j][i]] = 1.0;
}
bMass = bMass || (top.atoms.atom[ind_rms[j][i]].m != 0);
}
if (!bMass)
{
fprintf(stderr, "All masses in group %d are 0, using masses of 1\n", j);
for (i = 0; i < irms[j]; i++)
{
w_rms[ind_rms[j][i]] = 1;
}
}
}
/* Prepare reference frame */
if (bPBC)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr);
gmx_rmpbc(gpbc, top.atoms.nr, box, xp);
}
if (bReset)
{
reset_x(ifit, ind_fit, top.atoms.nr, NULL, xp, w_rls);
}
if (bMirror)
{
/* generate reference structure mirror image: */
snew(xm, top.atoms.nr);
for (i = 0; i < top.atoms.nr; i++)
{
copy_rvec(xp[i], xm[i]);
xm[i][XX] = -xm[i][XX];
}
}
if (ewhat == ewRhoSc)
{
norm_princ(&top.atoms, ifit, ind_fit, top.atoms.nr, xp);
}
/* read first frame */
natoms_trx = read_first_x(oenv, &status, opt2fn("-f", NFILE, fnm), &t, &x, box);
if (natoms_trx != top.atoms.nr)
{
fprintf(stderr,
"\nWARNING: topology has %d atoms, whereas trajectory has %d\n",
top.atoms.nr, natoms_trx);
}
natoms = min(top.atoms.nr, natoms_trx);
if (bMat || bBond || bPrev)
{
snew(mat_x, NFRAME);
if (bPrev)
{
/* With -prev we use all atoms for simplicity */
n_ind_m = natoms;
}
else
{
/* Check which atoms we need (fit/rms) */
snew(bInMat, natoms);
for (i = 0; i < ifit; i++)
{
bInMat[ind_fit[i]] = TRUE;
}
n_ind_m = ifit;
for (i = 0; i < irms[0]; i++)
{
if (!bInMat[ind_rms[0][i]])
{
bInMat[ind_rms[0][i]] = TRUE;
n_ind_m++;
}
}
}
/* Make an index of needed atoms */
snew(ind_m, n_ind_m);
snew(rev_ind_m, natoms);
j = 0;
for (i = 0; i < natoms; i++)
{
if (bPrev || bInMat[i])
{
ind_m[j] = i;
rev_ind_m[i] = j;
j++;
}
}
snew(w_rls_m, n_ind_m);
snew(ind_rms_m, irms[0]);
snew(w_rms_m, n_ind_m);
for (i = 0; i < ifit; i++)
{
w_rls_m[rev_ind_m[ind_fit[i]]] = w_rls[ind_fit[i]];
}
for (i = 0; i < irms[0]; i++)
{
ind_rms_m[i] = rev_ind_m[ind_rms[0][i]];
w_rms_m[ind_rms_m[i]] = w_rms[ind_rms[0][i]];
}
sfree(bInMat);
}
if (bBond)
{
ncons = 0;
for (k = 0; k < F_NRE; k++)
{
if (IS_CHEMBOND(k))
{
iatom = top.idef.il[k].iatoms;
ncons += top.idef.il[k].nr/3;
}
}
fprintf(stderr, "Found %d bonds in topology\n", ncons);
snew(ind_bond1, ncons);
snew(ind_bond2, ncons);
ibond = 0;
for (k = 0; k < F_NRE; k++)
{
if (IS_CHEMBOND(k))
{
iatom = top.idef.il[k].iatoms;
ncons = top.idef.il[k].nr/3;
for (i = 0; i < ncons; i++)
{
bA1 = FALSE;
bA2 = FALSE;
for (j = 0; j < irms[0]; j++)
{
if (iatom[3*i+1] == ind_rms[0][j])
{
bA1 = TRUE;
}
if (iatom[3*i+2] == ind_rms[0][j])
{
bA2 = TRUE;
}
}
if (bA1 && bA2)
{
ind_bond1[ibond] = rev_ind_m[iatom[3*i+1]];
ind_bond2[ibond] = rev_ind_m[iatom[3*i+2]];
ibond++;
}
}
}
}
fprintf(stderr, "Using %d bonds for bond angle matrix\n", ibond);
if (ibond == 0)
{
gmx_fatal(FARGS, "0 bonds found");
}
}
/* start looping over frames: */
tel_mat = 0;
teller = 0;
do
{
if (bPBC)
{
gmx_rmpbc(gpbc, natoms, box, x);
}
if (bReset)
{
reset_x(ifit, ind_fit, natoms, NULL, x, w_rls);
}
if (ewhat == ewRhoSc)
{
norm_princ(&top.atoms, ifit, ind_fit, natoms, x);
}
if (bFit)
{
/*do the least squares fit to original structure*/
do_fit(natoms, w_rls, xp, x);
}
if (teller % freq == 0)
{
/* keep frame for matrix calculation */
if (bMat || bBond || bPrev)
{
if (tel_mat >= NFRAME)
{
srenew(mat_x, tel_mat+1);
}
snew(mat_x[tel_mat], n_ind_m);
for (i = 0; i < n_ind_m; i++)
{
copy_rvec(x[ind_m[i]], mat_x[tel_mat][i]);
}
}
tel_mat++;
}
/*calculate energy of root_least_squares*/
if (bPrev)
{
j = tel_mat-prev-1;
if (j < 0)
{
j = 0;
}
for (i = 0; i < n_ind_m; i++)
{
copy_rvec(mat_x[j][i], xp[ind_m[i]]);
}
if (bReset)
{
reset_x(ifit, ind_fit, natoms, NULL, xp, w_rls);
}
if (bFit)
{
do_fit(natoms, w_rls, x, xp);
}
}
for (j = 0; (j < nrms); j++)
{
rls[j][teller] =
calc_similar_ind(ewhat != ewRMSD, irms[j], ind_rms[j], w_rms, x, xp);
}
if (bNorm)
{
for (j = 0; (j < irms[0]); j++)
{
rlsnorm[j] +=
calc_similar_ind(ewhat != ewRMSD, 1, &(ind_rms[0][j]), w_rms, x, xp);
}
}
if (bMirror)
{
if (bFit)
{
/*do the least squares fit to mirror of original structure*/
do_fit(natoms, w_rls, xm, x);
}
for (j = 0; j < nrms; j++)
{
rlsm[j][teller] =
calc_similar_ind(ewhat != ewRMSD, irms[j], ind_rms[j], w_rms, x, xm);
}
}
time[teller] = output_env_conv_time(oenv, t);
teller++;
if (teller >= maxframe)
{
maxframe += NFRAME;
srenew(time, maxframe);
for (j = 0; (j < nrms); j++)
{
srenew(rls[j], maxframe);
}
if (bMirror)
{
for (j = 0; (j < nrms); j++)
{
srenew(rlsm[j], maxframe);
}
}
}
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (bFile2)
{
snew(time2, maxframe2);
fprintf(stderr, "\nWill read second trajectory file\n");
snew(mat_x2, NFRAME);
natoms_trx2 =
read_first_x(oenv, &status, opt2fn("-f2", NFILE, fnm), &t, &x, box);
if (natoms_trx2 != natoms_trx)
{
gmx_fatal(FARGS,
"Second trajectory (%d atoms) does not match the first one"
" (%d atoms)", natoms_trx2, natoms_trx);
}
tel_mat2 = 0;
teller2 = 0;
do
{
if (bPBC)
{
gmx_rmpbc(gpbc, natoms, box, x);
}
if (bReset)
{
reset_x(ifit, ind_fit, natoms, NULL, x, w_rls);
}
if (ewhat == ewRhoSc)
{
norm_princ(&top.atoms, ifit, ind_fit, natoms, x);
}
if (bFit)
{
/*do the least squares fit to original structure*/
do_fit(natoms, w_rls, xp, x);
}
if (teller2 % freq2 == 0)
{
/* keep frame for matrix calculation */
if (bMat)
{
if (tel_mat2 >= NFRAME)
{
srenew(mat_x2, tel_mat2+1);
}
snew(mat_x2[tel_mat2], n_ind_m);
for (i = 0; i < n_ind_m; i++)
{
copy_rvec(x[ind_m[i]], mat_x2[tel_mat2][i]);
}
}
tel_mat2++;
}
time2[teller2] = output_env_conv_time(oenv, t);
teller2++;
if (teller2 >= maxframe2)
{
maxframe2 += NFRAME;
srenew(time2, maxframe2);
}
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
}
else
{
mat_x2 = mat_x;
time2 = time;
tel_mat2 = tel_mat;
freq2 = freq;
}
gmx_rmpbc_done(gpbc);
if (bMat || bBond)
{
/* calculate RMS matrix */
fprintf(stderr, "\n");
if (bMat)
{
fprintf(stderr, "Building %s matrix, %dx%d elements\n",
whatname[ewhat], tel_mat, tel_mat2);
snew(rmsd_mat, tel_mat);
}
if (bBond)
{
fprintf(stderr, "Building bond angle matrix, %dx%d elements\n",
tel_mat, tel_mat2);
snew(bond_mat, tel_mat);
}
snew(axis, tel_mat);
snew(axis2, tel_mat2);
rmsd_max = 0;
if (bFile2)
{
rmsd_min = 1e10;
}
else
{
rmsd_min = 0;
}
rmsd_avg = 0;
bond_max = 0;
bond_min = 1e10;
for (j = 0; j < tel_mat2; j++)
{
axis2[j] = time2[freq2*j];
}
if (bDelta)
{
if (bDeltaLog)
{
delta_scalex = 8.0/log(2.0);
delta_xsize = (int)(log(tel_mat/2)*delta_scalex+0.5)+1;
}
else
{
delta_xsize = tel_mat/2;
}
delta_scaley = 1.0/delta_maxy;
snew(delta, delta_xsize);
for (j = 0; j < delta_xsize; j++)
{
snew(delta[j], del_lev+1);
}
if (avl > 0)
{
snew(rmsdav_mat, tel_mat);
for (j = 0; j < tel_mat; j++)
{
snew(rmsdav_mat[j], tel_mat);
}
}
}
if (bFitAll)
{
snew(mat_x2_j, natoms);
}
for (i = 0; i < tel_mat; i++)
{
axis[i] = time[freq*i];
fprintf(stderr, "\r element %5d; time %5.2f ", i, axis[i]);
if (bMat)
{
snew(rmsd_mat[i], tel_mat2);
}
if (bBond)
{
snew(bond_mat[i], tel_mat2);
}
for (j = 0; j < tel_mat2; j++)
{
if (bFitAll)
{
for (k = 0; k < n_ind_m; k++)
{
copy_rvec(mat_x2[j][k], mat_x2_j[k]);
}
do_fit(n_ind_m, w_rls_m, mat_x[i], mat_x2_j);
}
else
{
mat_x2_j = mat_x2[j];
}
if (bMat)
{
if (bFile2 || (i < j))
{
rmsd_mat[i][j] =
calc_similar_ind(ewhat != ewRMSD, irms[0], ind_rms_m,
w_rms_m, mat_x[i], mat_x2_j);
if (rmsd_mat[i][j] > rmsd_max)
{
rmsd_max = rmsd_mat[i][j];
}
if (rmsd_mat[i][j] < rmsd_min)
{
rmsd_min = rmsd_mat[i][j];
}
rmsd_avg += rmsd_mat[i][j];
}
else
{
rmsd_mat[i][j] = rmsd_mat[j][i];
}
}
if (bBond)
{
if (bFile2 || (i <= j))
{
ang = 0.0;
for (m = 0; m < ibond; m++)
{
rvec_sub(mat_x[i][ind_bond1[m]], mat_x[i][ind_bond2[m]], vec1);
rvec_sub(mat_x2_j[ind_bond1[m]], mat_x2_j[ind_bond2[m]], vec2);
ang += acos(cos_angle(vec1, vec2));
}
bond_mat[i][j] = ang*180.0/(M_PI*ibond);
if (bond_mat[i][j] > bond_max)
{
bond_max = bond_mat[i][j];
}
if (bond_mat[i][j] < bond_min)
{
bond_min = bond_mat[i][j];
}
}
else
{
bond_mat[i][j] = bond_mat[j][i];
}
}
}
}
if (bFile2)
{
rmsd_avg /= tel_mat*tel_mat2;
}
else
{
rmsd_avg /= tel_mat*(tel_mat - 1)/2;
}
if (bMat && (avl > 0))
{
rmsd_max = 0.0;
rmsd_min = 0.0;
rmsd_avg = 0.0;
for (j = 0; j < tel_mat-1; j++)
{
for (i = j+1; i < tel_mat; i++)
{
av_tot = 0;
weight_tot = 0;
for (my = -avl; my <= avl; my++)
{
if ((j+my >= 0) && (j+my < tel_mat))
{
abs_my = abs(my);
for (mx = -avl; mx <= avl; mx++)
{
if ((i+mx >= 0) && (i+mx < tel_mat))
{
weight = (real)(avl+1-max(abs(mx), abs_my));
av_tot += weight*rmsd_mat[i+mx][j+my];
weight_tot += weight;
}
}
}
}
rmsdav_mat[i][j] = av_tot/weight_tot;
rmsdav_mat[j][i] = rmsdav_mat[i][j];
if (rmsdav_mat[i][j] > rmsd_max)
{
rmsd_max = rmsdav_mat[i][j];
}
}
}
rmsd_mat = rmsdav_mat;
}
if (bMat)
{
fprintf(stderr, "\n%s: Min %f, Max %f, Avg %f\n",
whatname[ewhat], rmsd_min, rmsd_max, rmsd_avg);
rlo.r = 1; rlo.g = 1; rlo.b = 1;
rhi.r = 0; rhi.g = 0; rhi.b = 0;
if (rmsd_user_max != -1)
{
rmsd_max = rmsd_user_max;
}
if (rmsd_user_min != -1)
{
rmsd_min = rmsd_user_min;
}
if ((rmsd_user_max != -1) || (rmsd_user_min != -1))
{
fprintf(stderr, "Min and Max value set to resp. %f and %f\n",
rmsd_min, rmsd_max);
}
sprintf(buf, "%s %s matrix", gn_rms[0], whatname[ewhat]);
write_xpm(opt2FILE("-m", NFILE, fnm, "w"), 0, buf, whatlabel[ewhat],
output_env_get_time_label(oenv), output_env_get_time_label(oenv), tel_mat, tel_mat2,
axis, axis2, rmsd_mat, rmsd_min, rmsd_max, rlo, rhi, &nlevels);
/* Print the distribution of RMSD values */
if (opt2bSet("-dist", NFILE, fnm))
{
low_rmsd_dist(opt2fn("-dist", NFILE, fnm), rmsd_max, tel_mat, rmsd_mat, oenv);
}
if (bDelta)
{
snew(delta_tot, delta_xsize);
for (j = 0; j < tel_mat-1; j++)
{
for (i = j+1; i < tel_mat; i++)
{
mx = i-j;
if (mx < tel_mat/2)
{
if (bDeltaLog)
{
mx = (int)(log(mx)*delta_scalex+0.5);
}
my = (int)(rmsd_mat[i][j]*delta_scaley*del_lev+0.5);
delta_tot[mx] += 1.0;
if ((rmsd_mat[i][j] >= 0) && (rmsd_mat[i][j] <= delta_maxy))
{
delta[mx][my] += 1.0;
}
}
}
}
delta_max = 0;
for (i = 0; i < delta_xsize; i++)
{
if (delta_tot[i] > 0.0)
{
delta_tot[i] = 1.0/delta_tot[i];
for (j = 0; j <= del_lev; j++)
{
delta[i][j] *= delta_tot[i];
if (delta[i][j] > delta_max)
{
delta_max = delta[i][j];
}
}
}
}
fprintf(stderr, "Maximum in delta matrix: %f\n", delta_max);
snew(del_xaxis, delta_xsize);
snew(del_yaxis, del_lev+1);
for (i = 0; i < delta_xsize; i++)
{
del_xaxis[i] = axis[i]-axis[0];
}
for (i = 0; i < del_lev+1; i++)
{
del_yaxis[i] = delta_maxy*i/del_lev;
}
sprintf(buf, "%s %s vs. delta t", gn_rms[0], whatname[ewhat]);
fp = gmx_ffopen("delta.xpm", "w");
write_xpm(fp, 0, buf, "density", output_env_get_time_label(oenv), whatlabel[ewhat],
delta_xsize, del_lev+1, del_xaxis, del_yaxis,
delta, 0.0, delta_max, rlo, rhi, &nlevels);
gmx_ffclose(fp);
}
if (opt2bSet("-bin", NFILE, fnm))
{
/* NB: File must be binary if we use fwrite */
fp = ftp2FILE(efDAT, NFILE, fnm, "wb");
for (i = 0; i < tel_mat; i++)
{
if (fwrite(rmsd_mat[i], sizeof(**rmsd_mat), tel_mat2, fp) != tel_mat2)
{
gmx_fatal(FARGS, "Error writing to output file");
}
}
gmx_ffclose(fp);
}
}
if (bBond)
{
fprintf(stderr, "\nMin. angle: %f, Max. angle: %f\n", bond_min, bond_max);
if (bond_user_max != -1)
{
bond_max = bond_user_max;
}
if (bond_user_min != -1)
{
bond_min = bond_user_min;
}
if ((bond_user_max != -1) || (bond_user_min != -1))
{
fprintf(stderr, "Bond angle Min and Max set to:\n"
"Min. angle: %f, Max. angle: %f\n", bond_min, bond_max);
}
rlo.r = 1; rlo.g = 1; rlo.b = 1;
rhi.r = 0; rhi.g = 0; rhi.b = 0;
sprintf(buf, "%s av. bond angle deviation", gn_rms[0]);
write_xpm(opt2FILE("-bm", NFILE, fnm, "w"), 0, buf, "degrees",
output_env_get_time_label(oenv), output_env_get_time_label(oenv), tel_mat, tel_mat2,
axis, axis2, bond_mat, bond_min, bond_max, rlo, rhi, &nlevels);
}
}
bAv = opt2bSet("-a", NFILE, fnm);
/* Write the RMSD's to file */
if (!bPrev)
{
sprintf(buf, "%s", whatxvgname[ewhat]);
}
else
{
sprintf(buf, "%s with frame %g %s ago", whatxvgname[ewhat],
time[prev*freq]-time[0], output_env_get_time_label(oenv));
}
fp = xvgropen(opt2fn("-o", NFILE, fnm), buf, output_env_get_xvgr_tlabel(oenv),
whatxvglabel[ewhat], oenv);
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"%s%s after %s%s%s\"\n",
(nrms == 1) ? "" : "of ", gn_rms[0], fitgraphlabel[efit],
bFit ? " to " : "", bFit ? gn_fit : "");
}
if (nrms != 1)
{
xvgr_legend(fp, nrms, (const char**)gn_rms, oenv);
}
for (i = 0; (i < teller); i++)
{
if (bSplit && i > 0 &&
abs(time[bPrev ? freq*i : i]/output_env_get_time_factor(oenv)) < 1e-5)
{
fprintf(fp, "&\n");
}
fprintf(fp, "%12.7f", time[bPrev ? freq*i : i]);
for (j = 0; (j < nrms); j++)
{
fprintf(fp, " %12.7f", rls[j][i]);
if (bAv)
{
rlstot += rls[j][i];
}
}
fprintf(fp, "\n");
}
gmx_ffclose(fp);
if (bMirror)
{
/* Write the mirror RMSD's to file */
sprintf(buf, "%s with Mirror", whatxvgname[ewhat]);
sprintf(buf2, "Mirror %s", whatxvglabel[ewhat]);
fp = xvgropen(opt2fn("-mir", NFILE, fnm), buf, output_env_get_xvgr_tlabel(oenv),
buf2, oenv);
if (nrms == 1)
{
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"of %s after lsq fit to mirror of %s\"\n",
gn_rms[0], gn_fit);
}
}
else
{
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"after lsq fit to mirror %s\"\n", gn_fit);
}
xvgr_legend(fp, nrms, (const char**)gn_rms, oenv);
}
for (i = 0; (i < teller); i++)
{
if (bSplit && i > 0 && abs(time[i]) < 1e-5)
{
fprintf(fp, "&\n");
}
fprintf(fp, "%12.7f", time[i]);
for (j = 0; (j < nrms); j++)
{
fprintf(fp, " %12.7f", rlsm[j][i]);
}
fprintf(fp, "\n");
}
gmx_ffclose(fp);
}
if (bAv)
{
sprintf(buf, "Average %s", whatxvgname[ewhat]);
sprintf(buf2, "Average %s", whatxvglabel[ewhat]);
fp = xvgropen(opt2fn("-a", NFILE, fnm), buf, "Residue", buf2, oenv);
for (j = 0; (j < nrms); j++)
{
fprintf(fp, "%10d %10g\n", j, rlstot/teller);
}
gmx_ffclose(fp);
}
if (bNorm)
{
fp = xvgropen("aver.xvg", gn_rms[0], "Residue", whatxvglabel[ewhat], oenv);
for (j = 0; (j < irms[0]); j++)
{
fprintf(fp, "%10d %10g\n", j, rlsnorm[j]/teller);
}
gmx_ffclose(fp);
}
do_view(oenv, opt2fn_null("-a", NFILE, fnm), "-graphtype bar");
do_view(oenv, opt2fn("-o", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-mir", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-m", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-bm", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-dist", NFILE, fnm), NULL);
return 0;
}
int gmx_rmsf(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes the root mean square fluctuation (RMSF, i.e. standard ",
"deviation) of atomic positions in the trajectory (supplied with [TT]-f[tt])",
"after (optionally) fitting to a reference frame (supplied with [TT]-s[tt]).[PAR]",
"With option [TT]-oq[tt] the RMSF values are converted to B-factor",
"values, which are written to a [TT].pdb[tt] file with the coordinates, of the",
"structure file, or of a [TT].pdb[tt] file when [TT]-q[tt] is specified.",
"Option [TT]-ox[tt] writes the B-factors to a file with the average",
"coordinates.[PAR]",
"With the option [TT]-od[tt] the root mean square deviation with",
"respect to the reference structure is calculated.[PAR]",
"With the option [TT]-aniso[tt], [THISMODULE] will compute anisotropic",
"temperature factors and then it will also output average coordinates",
"and a [TT].pdb[tt] 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 [TT].pdb[tt] 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 [TT].pdb[tt] file.[PAR]",
"With option [TT]-dir[tt] the average MSF (3x3) matrix is diagonalized.",
"This shows the directions in which the atoms fluctuate the most and",
"the least."
};
static gmx_bool bRes = FALSE, bAniso = FALSE, 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 natom;
int step, nre, 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;
gmx_bool bCont;
matrix box, pdbbox;
rvec *x, *pdbx, *xref;
t_trxstatus *status;
int npdbatoms, res0;
char buf[256];
const char *label;
char title[STRLEN];
FILE *fp; /* the graphics file */
const char *devfn, *dirfn;
int resind;
gmx_bool bReadPDB;
atom_id *index;
int isize;
char *grpnames;
real bfac, pdb_bfac, *Uaver;
double **U, *xav;
atom_id aid;
rvec *rmsd_x = NULL;
double *rmsf, invcount, totmass;
int d;
real count = 0;
rvec xcm;
gmx_rmpbc_t gpbc = NULL;
output_env_t oenv;
const 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)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_CAN_VIEW | PCA_BE_NICE,
NFILE, fnm, asize(pargs), pargs, asize(desc), desc, 0, NULL,
&oenv))
{
return 0;
}
bReadPDB = ftp2bSet(efPDB, NFILE, fnm);
devfn = opt2fn_null("-od", NFILE, fnm);
dirfn = opt2fn_null("-dir", NFILE, fnm);
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), 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(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
if (bFit)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, natom);
}
/* Now read the trj again to compute fluctuations */
teller = 0;
do
{
if (bFit)
{
/* Remove periodic boundary */
gmx_rmpbc(gpbc, natom, box, x);
/* Set center of mass to zero */
sub_xcm(x, isize, index, top.atoms.atom, xcm, FALSE);
/* Fit to reference structure */
do_fit(natom, w_rls, xref, x);
}
/* Calculate Anisotropic U Tensor */
for (i = 0; i < isize; i++)
{
aid = index[i];
for (d = 0; d < DIM; d++)
{
xav[i*DIM + d] += x[aid][d];
for (m = 0; m < DIM; m++)
{
U[i][d*DIM + m] += x[aid][d]*x[aid][m];
}
}
}
if (devfn)
{
/* Calculate RMS Deviation */
for (i = 0; (i < isize); i++)
{
aid = index[i];
for (d = 0; (d < DIM); d++)
{
rmsd_x[i][d] += sqr(x[aid][d]-xref[aid][d]);
}
}
}
count += 1.0;
teller++;
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (bFit)
{
gmx_rmpbc_done(gpbc);
}
invcount = 1.0/count;
snew(Uaver, DIM*DIM);
totmass = 0;
for (i = 0; i < isize; i++)
{
for (d = 0; d < DIM; d++)
{
xav[i*DIM + d] *= invcount;
}
for (d = 0; d < DIM; d++)
{
for (m = 0; m < DIM; m++)
{
U[i][d*DIM + m] = U[i][d*DIM + m]*invcount
- xav[i*DIM + d]*xav[i*DIM + m];
Uaver[3*d+m] += top.atoms.atom[index[i]].m*U[i][d*DIM + m];
}
}
totmass += top.atoms.atom[index[i]].m;
}
for (d = 0; d < DIM*DIM; d++)
{
Uaver[d] /= totmass;
}
if (bRes)
{
for (d = 0; d < DIM*DIM; d++)
{
average_residues(NULL, U, d, isize, index, w_rls, &top.atoms);
}
}
if (bAniso)
{
for (i = 0; i < isize; i++)
{
aid = index[i];
pdbatoms->pdbinfo[aid].bAnisotropic = TRUE;
pdbatoms->pdbinfo[aid].uij[U11] = 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)
{
label = "Residue";
}
else
{
label = "Atom";
}
for (i = 0; i < isize; i++)
{
rmsf[i] = U[i][XX*DIM + XX] + U[i][YY*DIM + YY] + U[i][ZZ*DIM + ZZ];
}
if (dirfn)
{
fprintf(stdout, "\n");
print_dir(stdout, Uaver);
fp = gmx_ffopen(dirfn, "w");
print_dir(fp, Uaver);
gmx_ffclose(fp);
}
for (i = 0; i < isize; i++)
{
sfree(U[i]);
}
sfree(U);
/* Write RMSF output */
if (bReadPDB)
{
bfac = 8.0*M_PI*M_PI/3.0*100;
fp = xvgropen(ftp2fn(efXVG, NFILE, fnm), "B-Factors",
label, "(A\\b\\S\\So\\N\\S2\\N)", oenv);
xvgr_legend(fp, 2, leg, oenv);
for (i = 0; (i < isize); i++)
{
if (!bRes || i+1 == isize ||
top.atoms.atom[index[i]].resind != top.atoms.atom[index[i+1]].resind)
{
resind = top.atoms.atom[index[i]].resind;
pdb_bfac = find_pdb_bfac(pdbatoms, &top.atoms.resinfo[resind],
*(top.atoms.atomname[index[i]]));
fprintf(fp, "%5d %10.5f %10.5f\n",
bRes ? top.atoms.resinfo[top.atoms.atom[index[i]].resind].nr : index[i]+1, rmsf[i]*bfac,
pdb_bfac);
}
}
gmx_ffclose(fp);
}
else
{
fp = xvgropen(ftp2fn(efXVG, NFILE, fnm), "RMS fluctuation", label, "(nm)", oenv);
for (i = 0; i < isize; i++)
{
if (!bRes || i+1 == isize ||
top.atoms.atom[index[i]].resind != top.atoms.atom[index[i+1]].resind)
{
fprintf(fp, "%5d %8.4f\n",
bRes ? top.atoms.resinfo[top.atoms.atom[index[i]].resind].nr : index[i]+1, sqrt(rmsf[i]));
}
}
gmx_ffclose(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, NULL, 0, isize, index, w_rls, &top.atoms);
}
/* Write RMSD output */
fp = xvgropen(devfn, "RMS Deviation", label, "(nm)", oenv);
for (i = 0; i < isize; i++)
{
if (!bRes || i+1 == isize ||
top.atoms.atom[index[i]].resind != top.atoms.atom[index[i+1]].resind)
{
fprintf(fp, "%5d %8.4f\n",
bRes ? top.atoms.resinfo[top.atoms.atom[index[i]].resind].nr : index[i]+1, sqrt(rmsf[i]));
}
}
gmx_ffclose(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, oenv);
do_view(oenv, opt2fn("-oc", NFILE, fnm), "-nxy");
}
do_view(oenv, opt2fn("-o", NFILE, fnm), "-nxy");
if (devfn)
{
do_view(oenv, opt2fn("-od", NFILE, fnm), "-nxy");
}
return 0;
}