*
* Copyright (c) 1991-2000, University of Groningen, The Netherlands.
* Copyright (c) 2001-2004, The GROMACS development team.
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
* and including many others, as listed in the AUTHORS file in the
* top-level source directory and at http://www.gromacs.org.
int gmx_anadock(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_anadock[tt] analyses the results of an Autodock run and clusters the",
+ "[THISMODULE] analyses the results of an Autodock run and clusters the",
"structures together, based on distance or RMSD. The docked energy",
"and free energy estimates are analysed, and for each cluster the",
"energy statistics are printed.[PAR]",
"An alternative approach to this is to cluster the structures first",
- "using [TT]g_cluster[tt] and then sort the clusters on either lowest",
+ "using [gmx-cluster] and then sort the clusters on either lowest",
"energy or average energy."
};
t_filenm fnm[] = {
int gmx_anaeig(int argc, char *argv[])
{
static const char *desc[] = {
- "[TT]g_anaeig[tt] analyzes eigenvectors. The eigenvectors can be of a",
- "covariance matrix ([TT]g_covar[tt]) or of a Normal Modes analysis",
- "([TT]g_nmeig[tt]).[PAR]",
+ "[THISMODULE] analyzes eigenvectors. The eigenvectors can be of a",
+ "covariance matrix ([gmx-covar]) or of a Normal Modes analysis",
+ "([gmx-nmeig]).[PAR]",
"When a trajectory is projected on eigenvectors, all structures are",
"fitted to the structure in the eigenvector file, if present, otherwise",
"since the pc's of random diffusion are cosines with the number",
"of periods equal to half the pc index.",
"The cosine content of the pc's can be calculated with the program",
- "[TT]g_analyze[tt].[PAR]",
+ "[gmx-analyze].[PAR]",
"[TT]-2d[tt]: calculate a 2d projection of a trajectory on eigenvectors",
"[TT]-first[tt] and [TT]-last[tt].[PAR]",
int gmx_analyze(int argc, char *argv[])
{
static const char *desc[] = {
- "[TT]g_analyze[tt] reads an ASCII file and analyzes data sets.",
+ "[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",
"All options, except for [TT]-av[tt] and [TT]-power[tt], assume that the",
"points are equidistant in time.[PAR]",
- "[TT]g_analyze[tt] always shows the average and standard deviation of each",
+ "[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]",
"zero or with a 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."
+ "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."
};
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;
{ "-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 [TT]g_hbond[tt]. 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)." },
+ "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},
int gmx_g_angle(int argc, char *argv[])
{
static const char *desc[] = {
- "[TT]g_angle[tt] computes the angle distribution for a number of angles",
+ "[THISMODULE] computes the angle distribution for a number of angles",
"or dihedrals.[PAR]",
"With option [TT]-ov[tt], you can plot the average angle of",
"a group of angles as a function of time. With the [TT]-all[tt] option,",
"the first graph is the average and the rest are the individual angles.[PAR]",
- "With the [TT]-of[tt] option, [TT]g_angle[tt] also calculates the fraction of trans",
+ "With the [TT]-of[tt] option, [THISMODULE] also calculates the fraction of trans",
"dihedrals (only for dihedrals) as function of time, but this is",
"probably only fun for a select few.[PAR]",
"With option [TT]-oc[tt], a dihedral correlation function is calculated.[PAR]",
"If this is not the case, the program will crash.[PAR]",
"With option [TT]-or[tt], a trajectory file is dumped containing cos and",
"sin of selected dihedral angles, which subsequently can be used as",
- "input for a principal components analysis using [TT]g_covar[tt].[PAR]",
+ "input for a principal components analysis using [gmx-covar].[PAR]",
"Option [TT]-ot[tt] plots when transitions occur between",
"dihedral rotamers of multiplicity 3 and [TT]-oh[tt]",
"records a histogram of the times between such transitions,",
{
if (*temp <= 0)
{
- gmx_fatal(FARGS, "Did not find a temperature in the subtitle in file '%s', use the -temp option of [TT]g_bar[tt]", fn);
+ gmx_fatal(FARGS, "Did not find a temperature in the subtitle in file '%s', use the -temp option of [TT]gmx bar[tt]", fn);
}
ba->temp = *temp;
}
int gmx_bar(int argc, char *argv[])
{
static const char *desc[] = {
- "[TT]g_bar[tt] calculates free energy difference estimates through ",
+ "[THISMODULE] calculates free energy difference estimates through ",
"Bennett's acceptance ratio method (BAR). It also automatically",
"adds series of individual free energies obtained with BAR into",
"a combined free energy estimate.[PAR]",
"over 5 blocks. A range of block numbers for error estimation can ",
"be provided with the options [TT]-nbmin[tt] and [TT]-nbmax[tt].[PAR]",
- "[TT]g_bar[tt] tries to aggregate samples with the same 'native' and ",
+ "[THISMODULE] tries to aggregate samples with the same 'native' and ",
"'foreign' [GRK]lambda[grk] values, but always assumes independent ",
"samples. [BB]Note[bb] that when aggregating energy ",
"differences/derivatives with different sampling intervals, this is ",
int gmx_bundle(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_bundle[tt] analyzes bundles of axes. The axes can be for instance",
+ "[THISMODULE] analyzes bundles of axes. The axes can be for instance",
"helix axes. The program reads two index groups and divides both",
"of them in [TT]-na[tt] parts. The centers of mass of these parts",
"define the tops and bottoms of the axes.",
int gmx_chi(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_chi[tt] computes [GRK]phi[grk], [GRK]psi[grk], [GRK]omega[grk], and [GRK]chi[grk] dihedrals for all your ",
+ "[THISMODULE] computes [GRK]phi[grk], [GRK]psi[grk], [GRK]omega[grk],",
+ "and [GRK]chi[grk] dihedrals for all your",
"amino acid backbone and sidechains.",
"It can compute dihedral angle as a function of time, and as",
"histogram distributions.",
const char *bugs[] = {
"Produces MANY output files (up to about 4 times the number of residues in the protein, twice that if autocorrelation functions are calculated). Typically several hundred files are output.",
- "[GRK]phi[grk] and [GRK]psi[grk] dihedrals are calculated in a non-standard way, using H-N-CA-C for [GRK]phi[grk] instead of C(-)-N-CA-C, and N-CA-C-O for [GRK]psi[grk] instead of N-CA-C-N(+). This causes (usually small) discrepancies with the output of other tools like [TT]g_rama[tt].",
+ "[GRK]phi[grk] and [GRK]psi[grk] dihedrals are calculated in a "
+ "non-standard way, using H-N-CA-C for [GRK]phi[grk] instead of "
+ "C(-)-N-CA-C, and N-CA-C-O for [GRK]psi[grk] instead of N-CA-C-N(+). "
+ "This causes (usually small) discrepancies with the output of other "
+ "tools like [gmx-rama].",
"[TT]-r0[tt] option does not work properly",
"Rotamers with multiplicity 2 are printed in [TT]chi.log[tt] as if they had multiplicity 3, with the 3rd (g(+)) always having probability 0"
};
int gmx_cluster(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_cluster[tt] can cluster structures using several different methods.",
+ "[THISMODULE] can cluster structures using several different methods.",
"Distances between structures can be determined from a trajectory",
"or read from an [TT].xpm[tt] matrix file with the [TT]-dm[tt] option.",
"RMS deviation after fitting or RMS deviation of atom-pair distances",
set_mat_entry(rms, i1, i2, rmsd);
}
nrms -= (gmx_large_int_t) (nf-i1-1);
- fprintf(stderr, "\r# RMSD calculations left: "gmx_large_int_pfmt" ", nrms);
+ fprintf(stderr, "\r# RMSD calculations left: " gmx_large_int_pfmt " ", nrms);
}
sfree(x1);
}
snew(d1[i], isize);
snew(d2[i], isize);
}
- for (i1 = 0; i1 < nf ; i1++)
+ for (i1 = 0; i1 < nf; i1++)
{
calc_dist(isize, xx[i1], d1);
for (i2 = i1+1; (i2 < nf); i2++)
set_mat_entry(rms, i1, i2, rms_dist(isize, d1, d2));
}
nrms -= (nf-i1-1);
- fprintf(stderr, "\r# RMSD calculations left: "gmx_large_int_pfmt" ", nrms);
+ fprintf(stderr, "\r# RMSD calculations left: " gmx_large_int_pfmt " ", nrms);
}
/* Clean up work arrays */
for (i = 0; (i < isize); i++)
int gmx_clustsize(int argc, char *argv[])
{
const char *desc[] = {
- "This program computes the size distributions of molecular/atomic clusters in",
+ "[THISMODULE] computes the size distributions of molecular/atomic clusters in",
"the gas phase. The output is given in the form of an [TT].xpm[tt] file.",
"The total number of clusters is written to an [TT].xvg[tt] file.[PAR]",
"When the [TT]-mol[tt] option is given clusters will be made out of",
int gmx_confrms(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_confrms[tt] computes the root mean square deviation (RMSD) of two",
+ "[THISMODULE] computes the root mean square deviation (RMSD) of two",
"structures after least-squares fitting the second structure on the first one.",
"The two structures do NOT need to have the same number of atoms,",
"only the two index groups used for the fit need to be identical.",
int gmx_covar(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_covar[tt] calculates and diagonalizes the (mass-weighted)",
+ "[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",
"written with t=0, the eigenvectors",
"are written as frames with the eigenvector number as timestamp.",
"[PAR]",
- "The eigenvectors can be analyzed with [TT]g_anaeig[tt].",
+ "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, ...",
const char *desc[] = {
- "[TT]g_current[tt] is a tool for calculating the current autocorrelation function, the correlation",
+ "[THISMODULE] is a tool for calculating the current autocorrelation function, the correlation",
"of the rotational and translational dipole moment of the system, and the resulting static",
"dielectric constant. To obtain a reasonable result, the index group has to be neutral.",
"Furthermore, the routine is capable of extracting the static conductivity from the current ",
int gmx_density(int argc, char *argv[])
{
const char *desc[] = {
- "Compute partial densities across the box, using an index file.[PAR]",
- "For the total density of NPT simulations, use [TT]g_energy[tt] instead.",
+ "[THISMODULE] computes partial densities across the box, using an index file.[PAR]",
+ "For the total density of NPT simulations, use [gmx-energy] instead.",
"[PAR]",
"Densities are in kg/m^3, and number densities or electron densities can also be",
"calculated. For electron densities, a file describing the number of",
int gmx_densmap(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_densmap[tt] computes 2D number-density maps.",
+ "[THISMODULE] computes 2D number-density maps.",
"It can make planar and axial-radial density maps.",
"The output [TT].xpm[tt] file can be visualized with for instance xv",
"and can be converted to postscript with [TT]xpm2ps[tt].",
int gmx_densorder(int argc, char *argv[])
{
static const char *desc[] = {
- "A small program to reduce a two-phase density distribution",
- "along an axis, computed over a MD trajectory",
+ "[THISMODULE] reduces a two-phase density distribution",
+ "along an axis, computed over a MD trajectory,",
"to 2D surfaces fluctuating in time, by a fit to",
- "a functional profile for interfacial densities",
+ "a functional profile for interfacial densities.",
"A time-averaged spatial representation of the",
- "interfaces can be output with the option -tavg"
+ "interfaces can be output with the option [TT]-tavg[tt]."
};
/* Extra arguments - but note how you always get the begin/end
int gmx_dielectric(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_dielectric[tt] calculates frequency dependent dielectric constants",
+ "[THISMODULE] calculates frequency dependent dielectric constants",
"from the autocorrelation function of the total dipole moment in",
- "your simulation. This ACF can be generated by [TT]g_dipoles[tt].",
+ "your simulation. This ACF can be generated by [gmx-dipoles].",
"The functional forms of the available functions are:[PAR]",
"One parameter: y = [EXP]-a[SUB]1[sub] x[exp],[BR]",
"Two parameters: y = a[SUB]2[sub] [EXP]-a[SUB]1[sub] x[exp],[BR]",
int gmx_dipoles(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_dipoles[tt] computes the total dipole plus fluctuations of a simulation",
+ "[THISMODULE] computes the total dipole plus fluctuations of a simulation",
"system. From this you can compute e.g. the dielectric constant for",
"low-dielectric media.",
"For molecules with a net charge, the net charge is subtracted at",
"the dipoles divided by the distance to the third power.[PAR]",
"[PAR]",
"EXAMPLES[PAR]",
- "[TT]g_dipoles -corr mol -P 1 -o dip_sqr -mu 2.273 -mumax 5.0[tt][PAR]",
+ "[TT]gmx dipoles -corr mol -P 1 -o dip_sqr -mu 2.273 -mumax 5.0[tt][PAR]",
"This will calculate the autocorrelation function of the molecular",
"dipoles using a first order Legendre polynomial of the angle of the",
"dipole vector and itself a time t later. For this calculation 1001",
int gmx_disre(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_disre[tt] computes violations of distance restraints.",
+ "[THISMODULE] computes violations of distance restraints.",
"If necessary, all protons can be added to a protein molecule ",
- "using the [TT]g_protonate[tt] program.[PAR]",
+ "using the [gmx-protonate] program.[PAR]",
"The program always",
"computes the instantaneous violations rather than time-averaged,",
"because this analysis is done from a trajectory file afterwards",
*
* Copyright (c) 1991-2000, University of Groningen, The Netherlands.
* Copyright (c) 2001-2004, The GROMACS development team.
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
* and including many others, as listed in the AUTHORS file in the
* top-level source directory and at http://www.gromacs.org.
int gmx_do_dssp(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]do_dssp[tt] ",
+ "[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. [TT]do_dssp[tt] assumes ",
+ "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",
"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",
+ "[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 [TT]g_chi[tt]. Together",
+ "[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."
};
int gmx_dos(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_dos[tt] computes the Density of States from a simulations.",
+ "[THISMODULE] computes the Density of States from a simulations.",
"In order for this to be meaningful the velocities must be saved",
"in the trajecotry with sufficiently high frequency such as to cover",
"all vibrations. For flexible systems that would be around a few fs",
{
const char *desc[] =
{
- "This tool extracts dye dynamics from trajectory files.",
+ "[THISMODULE] extracts dye dynamics from trajectory files.",
"Currently, R and kappa^2 between dyes is extracted for (F)RET",
"simulations with assumed dipolar coupling as in the Foerster equation.",
"It further allows the calculation of R(t) and kappa^2(t), R and",
int gmx_dyndom(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_dyndom[tt] reads a [TT].pdb[tt] file output from DynDom",
+ "[THISMODULE] reads a [TT].pdb[tt] file output from DynDom",
"(http://www.cmp.uea.ac.uk/dyndom/).",
"It reads the coordinates, the coordinates of the rotation axis,",
"and an index file containing the domains.",
"determined by DynDom is given, one should be able to recover the",
"second structure used for generating the DynDom output.",
"Because of limited numerical accuracy this should be verified by",
- "computing an all-atom RMSD (using [TT]g_confrms[tt]) rather than by file",
+ "computing an all-atom RMSD (using [gmx-confrms]) rather than by file",
"comparison (using diff).[PAR]",
"The purpose of this program is to interpolate and extrapolate the",
"rotation as found by DynDom. As a result unphysical structures with",
int gmx_editconf(int argc, char *argv[])
{
- const char
- *desc[] =
+ const char *desc[] =
{
- "[TT]editconf[tt] converts generic structure format to [TT].gro[tt], [TT].g96[tt]",
+ "[THISMODULE] 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",
"[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]",
+ "[TT]gmx 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]."
+ "in that case you can use [gmx-trjconv]."
};
static real dist = 0.0, rbox = 0.0, to_diam = 0.0;
static gmx_bool bNDEF = FALSE, bRMPBC = FALSE, bCenter = FALSE, bReadVDW =
"in the later file is used. By specifying [TT]-settime[tt] you will be",
"asked for the start time of each file. The input files are taken",
"from the command line,",
- "such that the command [TT]eneconv -f *.edr -o fixed.edr[tt] should do",
+ "such that the command [TT]gmx eneconv -f *.edr -o fixed.edr[tt] should do",
"the trick. [PAR]",
"With [IT]one file[it] specified for [TT]-f[tt]:[BR]",
"Reads one energy file and writes another, applying the [TT]-dt[tt],",
int gmx_enemat(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_enemat[tt] extracts an energy matrix from the energy file ([TT]-f[tt]).",
+ "[THISMODULE] extracts an energy matrix from the energy file ([TT]-f[tt]).",
"With [TT]-groups[tt] a file must be supplied with on each",
"line a group of atoms to be used. For these groups matrix of",
"interaction energies will be extracted from the energy file",
"[TT]SOL[tt][BR]",
"then energy groups with names like 'Coul-SR:Protein-SOL' and ",
"'LJ:Protein-SOL' are expected in the energy file (although",
- "[TT]g_enemat[tt] is most useful if many groups are analyzed",
+ "[THISMODULE] is most useful if many groups are analyzed",
"simultaneously). Matrices for different energy types are written",
"out separately, as controlled by the",
"[TT]-[no]coul[tt], [TT]-[no]coulr[tt], [TT]-[no]coul14[tt], ",
int gmx_energy(int argc, char *argv[])
{
const char *desc[] = {
-
- "[TT]g_energy[tt] extracts energy components or distance restraint",
+ "[THISMODULE] extracts energy components or distance restraint",
"data from an energy file. The user is prompted to interactively",
"select the desired energy terms.[PAR]",
"[TT]-nbmin[tt] and [TT]-nbmax[tt].",
"[BB]Note[bb] that in most cases the energy files contains averages over all",
"MD steps, or over many more points than the number of frames in",
- "energy file. This makes the [TT]g_energy[tt] statistics output more accurate",
+ "energy file. This makes the [THISMODULE] statistics output more accurate",
"than the [TT].xvg[tt] output. When exact averages are not present in the energy",
"file, the statistics mentioned above are simply over the single, per-frame",
"energy values.[PAR]",
"---------------------------------------------------[BR]",
"You always need to set the number of molecules [TT]-nmol[tt].",
"The C[SUB]p[sub]/C[SUB]v[sub] computations do [BB]not[bb] include any corrections",
- "for quantum effects. Use the [TT]g_dos[tt] program if you need that (and you do).[PAR]"
+ "for quantum effects. Use the [gmx-dos] program if you need that (and you do).[PAR]"
"When the [TT]-viol[tt] option is set, the time averaged",
"violations are plotted and the running time-averaged and",
"instantaneous sum of violations are recalculated. Additionally",
int gmx_filter(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_filter[tt] performs frequency filtering on a trajectory.",
+ "[THISMODULE] performs frequency filtering on a trajectory.",
"The filter shape is cos([GRK]pi[grk] t/A) + 1 from -A to +A, where A is given",
"by the option [TT]-nf[tt] times the time step in the input trajectory.",
"This filter reduces fluctuations with period A by 85%, with period",
int gmx_genbox(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]genbox[tt] can do one of 4 things:[PAR]",
+ "[THISMODULE] can do one of 4 things:[PAR]",
"1) Generate a box of solvent. Specify [TT]-cs[tt] and [TT]-box[tt]. Or specify [TT]-cs[tt] and",
"[TT]-cp[tt] with a structure file with a box, but without atoms.[PAR]",
"[PAR]",
"If you need to do more than one of the above operations, it can be",
- "best to call [TT]genbox[tt] separately for each operation, so that",
+ "best to call [THISMODULE] separately for each operation, so that",
"you are sure of the order in which the operations occur.[PAR]",
"The default solvent is Simple Point Charge water (SPC), with coordinates ",
"Setting [TT]-shell[tt] larger than zero will place a layer of water of",
"the specified thickness (nm) around the solute. Hint: it is a good",
- "idea to put the protein in the center of a box first (using [TT]editconf[tt]).",
+ "idea to put the protein in the center of a box first (using [gmx-editconf]).",
"[PAR]",
- "Finally, [TT]genbox[tt] will optionally remove lines from your topology file in ",
+ "Finally, [THISMODULE] will optionally remove lines from your topology file in ",
"which a number of solvent molecules is already added, and adds a ",
"line with the total number of solvent molecules in your coordinate file."
};
int gmx_genconf(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]genconf[tt] multiplies a given coordinate file by simply stacking them",
+ "[THISMODULE] multiplies a given coordinate file by simply stacking them",
"on top of each other, like a small child playing with wooden blocks.",
"The program makes a grid of [IT]user-defined[it]",
"proportions ([TT]-nbox[tt]), ",
int gmx_genion(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]genion[tt] randomly replaces solvent molecules with monoatomic ions.",
+ "[THISMODULE] randomly replaces solvent molecules with monoatomic ions.",
"The group of solvent molecules should be continuous and all molecules",
"should have the same number of atoms.",
"The user should add the ion molecules to the topology file or use",
"either by hand or with [TT]-p[tt]. Do not use an atom name instead!",
"[PAR]Ions which can have multiple charge states get the multiplicity",
"added, without sign, for the uncommon states only.[PAR]",
- "For larger ions, e.g. sulfate we recommended using [TT]genbox[tt]."
+ "For larger ions, e.g. sulfate we recommended using [gmx-genbox]."
};
const char *bugs[] = {
"If you specify a salt concentration existing ions are not taken into "
int gmx_genpr(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]genrestr[tt] produces an include file for a topology containing",
+ "[THISMODULE] 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]",
"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",
+ "[THISMODULE] number consecutively from 1, [THISMODULE] 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]",
int gmx_gyrate(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_gyrate[tt] computes the radius of gyration of a molecule",
+ "[THISMODULE] computes the radius of gyration of a molecule",
"and the radii of gyration about the [IT]x[it]-, [IT]y[it]- and [IT]z[it]-axes,",
"as a function of time. The atoms are explicitly mass weighted.[PAR]",
"With the [TT]-nmol[tt] option the radius of gyration will be calculated",
int gmx_h2order(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_h2order[tt] computes the orientation of water molecules with respect to the normal",
+ "[THISMODULE] computes the orientation of water molecules with respect to the normal",
"of the box. The program determines the average cosine of the angle",
"between the dipole moment of water and an axis of the box. The box is",
"divided in slices and the average orientation per slice is printed.",
int gmx_hbond(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_hbond[tt] computes and analyzes hydrogen bonds. Hydrogen bonds are",
+ "[THISMODULE] computes and analyzes hydrogen bonds. Hydrogen bonds are",
"determined based on cutoffs for the angle Hydrogen - Donor - Acceptor",
"(zero is extended) and the distance Donor - Acceptor",
"(or Hydrogen - Acceptor using [TT]-noda[tt]).",
int gmx_helix(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_helix[tt] computes all kinds of helix properties. First, the peptide",
+ "[THISMODULE] computes all kinds of helix properties. First, the peptide",
"is checked to find the longest helical part, as determined by",
"hydrogen bonds and [GRK]phi[grk]/[GRK]psi[grk] angles.",
"That bit is fitted",
int gmx_helixorient(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_helixorient[tt] calculates the coordinates and direction of the average",
+ "[THISMODULE] calculates the coordinates and direction of the average",
"axis inside an alpha helix, and the direction/vectors of both the",
"C[GRK]alpha[grk] and (optionally) a sidechain atom relative to the axis.[PAR]",
"As input, you need to specify an index group with C[GRK]alpha[grk] atoms",
int gmx_hydorder(int argc, char *argv[])
{
static const char *desc[] = {
- "g_hydorder computes the tetrahedrality order parameters around a ",
+ "[THISMODULE] computes the tetrahedrality order parameters around a ",
"given 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.[BR]"
- "This application calculates the orderparameter in a 3d-mesh in the box, and",
+ "for more details.[PAR]"
+ "[THISMODULE] calculates the order parameter in a 3d-mesh in the box, and",
"with 2 phases in the box gives the user the option to define a 2D interface in time",
- "separating the faces by specifying parameters -sgang1 and -sgang2 (It is important",
- "to select these judiciously)"
+ "separating the faces by specifying parameters [TT]-sgang1[tt] and",
+ "[TT]-sgang2[tt] (it is important to select these judiciously)."
};
int axis = 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.",
+ "[THISMODULE] 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",
"[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",
+ "In order to run [THISMODULE], GROMACS must be compiled with the GNU",
"scientific library."
};
static int nreplica = 1;
int gmx_lie(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_lie[tt] computes a free energy estimate based on an energy analysis",
+ "[THISMODULE] computes a free energy estimate based on an energy analysis",
"from. One needs an energy file with the following components:",
"Coul (A-B) LJ-SR (A-B) etc."
};
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
* and including many others, as listed in the AUTHORS file in the
* top-level source directory and at http://www.gromacs.org.
{
static const char *desc[] = {
- "[TT]make_edi[tt] generates an essential dynamics (ED) sampling input file to be used with [TT]mdrun[tt]",
- "based on eigenvectors of a covariance matrix ([TT]g_covar[tt]) or from a",
- "normal modes analysis ([TT]g_nmeig[tt]).",
+ "[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",
*
* Copyright (c) 1991-2000, University of Groningen, The Netherlands.
* Copyright (c) 2001-2004, The GROMACS development team.
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
* and including many others, as listed in the AUTHORS file in the
* top-level source directory and at http://www.gromacs.org.
int gmx_make_ndx(int argc, char *argv[])
{
const char *desc[] = {
- "Index groups are necessary for almost every gromacs program.",
+ "Index groups are necessary for almost every GROMACS program.",
"All these programs can generate default index groups. You ONLY",
- "have to use [TT]make_ndx[tt] when you need SPECIAL index groups.",
+ "have to use [THISMODULE] when you need SPECIAL index groups.",
"There is a default index group for the whole system, 9 default",
"index groups for proteins, and a default index group",
"is generated for every other residue name.[PAR]",
- "When no index file is supplied, also [TT]make_ndx[tt] will generate the",
+ "When no index file is supplied, also [THISMODULE] will generate the",
"default groups.",
"With the index editor you can select on atom, residue and chain names",
"and numbers.",
int gmx_mdmat(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_mdmat[tt] makes distance matrices consisting of the smallest distance",
+ "[THISMODULE] makes distance matrices consisting of the smallest distance",
"between residue pairs. With [TT]-frames[tt], these distance matrices can be",
"stored in order to see differences in tertiary structure as a",
"function of time. If you choose your options unwisely, this may generate",
"trajectory is output.",
"Also a count of the number of different atomic contacts between",
"residues over the whole trajectory can be made.",
- "The output can be processed with [TT]xpm2ps[tt] to make a PostScript (tm) plot."
+ "The output can be processed with [gmx-xpm2ps] to make a PostScript (tm) plot."
};
static real truncate = 1.5;
static gmx_bool bAtom = FALSE;
*
* Copyright (c) 1991-2000, University of Groningen, The Netherlands.
* Copyright (c) 2001-2004, The GROMACS development team.
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
* and including many others, as listed in the AUTHORS file in the
* top-level source directory and at http://www.gromacs.org.
int gmx_mk_angndx(int argc, char *argv[])
{
static const char *desc[] = {
- "[TT]mk_angndx[tt] makes an index file for calculation of",
+ "[THISMODULE] makes an index file for calculation of",
"angle distributions etc. It uses a run input file ([TT].tpx[tt]) for the",
"definitions of the angles, dihedrals etc."
};
int gmx_morph(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_morph[tt] does a linear interpolation of conformations in order to",
+ "[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",
int gmx_msd(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_msd[tt] computes the mean square displacement (MSD) of atoms from",
+ "[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",
"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, [TT]g_msd[tt] plots the MSD for individual molecules",
+ "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 ",
"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 [TT]mdrun[tt] usually already removes the center of mass motion.",
+ "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,",
int gmx_nmeig(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_nmeig[tt] calculates the eigenvectors/values of a (Hessian) matrix,",
- "which can be calculated with [TT]mdrun[tt].",
+ "[THISMODULE] calculates the eigenvectors/values of a (Hessian) matrix,",
+ "which can be calculated with [gmx-mdrun].",
"The eigenvectors are written to a trajectory file ([TT]-v[tt]).",
"The structure is written first with t=0. The eigenvectors",
"are written as frames with the eigenvector number as timestamp.",
- "The eigenvectors can be analyzed with [TT]g_anaeig[tt].",
+ "The eigenvectors can be analyzed with [gmx-anaeig].",
"An ensemble of structures can be generated from the eigenvectors with",
- "[TT]g_nmens[tt]. When mass weighting is used, the generated eigenvectors",
+ "[gmx-nmens]. When mass weighting is used, the generated eigenvectors",
"will be scaled back to plain Cartesian coordinates before generating the",
"output. In this case, they will no longer be exactly orthogonal in the",
"standard Cartesian norm, but in the mass-weighted norm they would be.[PAR]",
"degree of freedom at the given temperature.",
"The total correction is printed on the terminal screen.",
"The recommended way of getting the corrections out is:[PAR]",
- "[TT]g_nmeig -s topol.tpr -f nm.mtx -first 7 -last 10000 -T 300 -qc [-constr][tt][PAR]",
+ "[TT]gmx nmeig -s topol.tpr -f nm.mtx -first 7 -last 10000 -T 300 -qc [-constr][tt][PAR]",
"The [TT]-constr[tt] option should be used when bond constraints were used during the",
"simulation [BB]for all the covalent bonds[bb]. If this is not the case, ",
"you need to analyze the [TT]quant_corr.xvg[tt] file yourself.[PAR]",
int gmx_nmens(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_nmens[tt] generates an ensemble around an average structure",
+ "[THISMODULE] generates an ensemble around an average structure",
"in a subspace that is defined by a set of normal modes (eigenvectors).",
"The eigenvectors are assumed to be mass-weighted.",
"The position along each eigenvector is randomly taken from a Gaussian",
{
const char *desc[] =
{
- "[TT]g_nmtraj[tt] generates an virtual trajectory from an eigenvector, ",
+ "[THISMODULE] generates an virtual trajectory from an eigenvector, ",
"corresponding to a harmonic Cartesian oscillation around the average ",
"structure. The eigenvectors should normally be mass-weighted, but you can ",
"use non-weighted eigenvectors to generate orthogonal motions. ",
int gmx_order(int argc, char *argv[])
{
const char *desc[] = {
- "Compute the order parameter per atom for carbon tails. For atom i the",
+ "[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]",
- "The program can also give all",
+ "[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",
int gmx_pme_error(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_pme_error[tt] estimates the error of the electrostatic forces",
+ "[THISMODULE] estimates the error of the electrostatic forces",
"if using the sPME algorithm. The flag [TT]-tune[tt] will determine",
"the splitting parameter such that the error is equally",
"distributed over the real and reciprocal space part.",
int gmx_polystat(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_polystat[tt] plots static properties of polymers as a function of time",
+ "[THISMODULE] plots static properties of polymers as a function of time",
"and prints the average.[PAR]",
"By default it determines the average end-to-end distance and radii",
"of gyration of polymers. It asks for an index group and split this",
int gmx_potential(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_potential[tt] computes the electrostatical potential across the box. The potential is",
+ "[THISMODULE] computes the electrostatical potential across the box. The potential is",
"calculated by first summing the charges per slice and then integrating",
"twice of this charge distribution. Periodic boundaries are not taken",
"into account. Reference of potential is taken to be the left side of",
int gmx_principal(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_principal[tt] calculates the three principal axes of inertia for a group",
+ "[THISMODULE] calculates the three principal axes of inertia for a group",
"of atoms.",
};
static gmx_bool foo = FALSE;
int gmx_rama(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_rama[tt] selects the [GRK]phi[grk]/[GRK]psi[grk] dihedral combinations from your topology file",
+ "[THISMODULE] selects the [GRK]phi[grk]/[GRK]psi[grk] dihedral combinations from your topology file",
"and computes these as a function of time.",
"Using simple Unix tools such as [IT]grep[it] you can select out",
"specific residues."
"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]",
- "[TT]g_rdf[tt] calculates radial distribution functions in different ways.",
+ "[THISMODULE] calculates radial distribution functions in different ways.",
"The normal method is around a (set of) particle(s), the other methods",
"are around the center of mass of a set of particles ([TT]-com[tt])",
"or to the closest particle in a set ([TT]-surf[tt]).",
int gmx_rms(int argc, char *argv[])
{
- const char
- *desc[] =
+ const char *desc[] =
{
- "[TT]g_rms[tt] compares two structures by computing the root mean square",
+ "[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).",
"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 [TT]xpm2ps[tt].[PAR]",
+ "[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",
return sqrt(r2);
}
-int gmx_rmsdist (int argc, char *argv[])
+int gmx_rmsdist(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_rmsdist[tt] computes the root mean square deviation of atom distances,",
+ "[THISMODULE] computes the root mean square deviation of atom distances,",
"which has the advantage that no fit is needed like in standard RMS",
- "deviation as computed by [TT]g_rms[tt].",
+ "deviation as computed by [gmx-rms].",
"The reference structure is taken from the structure file.",
"The RMSD at time t is calculated as the RMS",
"of the differences in distance between atom-pairs in the reference",
"structure and the structure at time t.[PAR]",
- "[TT]g_rmsdist[tt] can also produce matrices of the rms distances, rms distances",
+ "[THISMODULE] can also produce matrices of the rms distances, rms distances",
"scaled with the mean distance and the mean distances and matrices with",
"NMR averaged distances (1/r^3 and 1/r^6 averaging). Finally, lists",
"of atom pairs with 1/r^3 and 1/r^6 averaged distance below the",
int gmx_rmsf(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_rmsf[tt] computes the root mean square fluctuation (RMSF, i.e. standard ",
+ "[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",
"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], [TT]g_rmsf[tt] will compute anisotropic",
+ "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",
int gmx_rotacf(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_rotacf[tt] calculates the rotational correlation function",
+ "[THISMODULE] calculates the rotational correlation function",
"for molecules. Atom triplets (i,j,k) must be given in the index",
"file, defining two vectors ij and jk. The rotational ACF",
"is calculated as the autocorrelation function of the vector",
"by specifying atom pairs (i,j) in the index file.",
"[PAR]",
"EXAMPLES[PAR]",
- "[TT]g_rotacf -P 1 -nparm 2 -fft -n index -o rotacf-x-P1",
+ "[TT]gmx rotacf -P 1 -nparm 2 -fft -n index -o rotacf-x-P1",
"-fa expfit-x-P1 -beginfit 2.5 -endfit 20.0[tt][PAR]",
"This will calculate the rotational correlation function using a first",
"order Legendre polynomial of the angle of a vector defined by the index",
int gmx_rotmat(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_rotmat[tt] plots the rotation matrix required for least squares fitting",
+ "[THISMODULE] plots the rotation matrix required for least squares fitting",
"a conformation onto the reference conformation provided with",
"[TT]-s[tt]. Translation is removed before fitting.",
"The output are the three vectors that give the new directions",
"This tool is useful for, for instance,",
"determining the orientation of a molecule",
"at an interface, possibly on a trajectory produced with",
- "[TT]trjconv -fit rotxy+transxy[tt] to remove the rotation",
+ "[TT]gmx trjconv -fit rotxy+transxy[tt] to remove the rotation",
"in the [IT]x-y[it] plane.",
"[PAR]",
"Option [TT]-ref[tt] determines a reference structure for fitting,",
int gmx_saltbr(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_saltbr[tt] plots the distance between all combination of charged groups",
+ "[THISMODULE] plots the distance between all combination of charged groups",
"as a function of time. The groups are combined in different ways.",
"A minimum distance can be given (i.e. a cut-off), such that groups",
"that are never closer than that distance will not be plotted.[PAR]",
int gmx_sans(int argc, char *argv[])
{
const char *desc[] = {
- "This is simple tool to compute SANS spectra using Debye formula",
- "It currently uses topology file (since it need to assigne element for each atom)",
+ "[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]-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",
+ "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!"
};
int gmx_sas(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_sas[tt] computes hydrophobic, hydrophilic and total solvent",
+ "[THISMODULE] 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",
int gmx_saxs(int argc, char *argv[])
{
const char *desc[] = {
- "g_saxs calculates SAXS structure factors for given index groups based on Cromer's method.",
+ "[THISMODULE] calculates SAXS structure factors for given index",
+ "groups based on Cromer's method.",
"Both topology and trajectory files are required."
};
int gmx_sham(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_sham[tt] makes multi-dimensional free-energy, enthalpy and entropy plots.",
- "[TT]g_sham[tt] reads one or more [TT].xvg[tt] files and analyzes data sets.",
- "The basic purpose of [TT]g_sham[tt] is to plot Gibbs free energy landscapes",
+ "[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",
*
* Copyright (c) 1991-2000, University of Groningen, The Netherlands.
* Copyright (c) 2001-2004, The GROMACS development team.
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
* and including many others, as listed in the AUTHORS file in the
* top-level source directory and at http://www.gromacs.org.
int gmx_sigeps(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_sigeps[tt] is a simple utility that converts C6/C12 or C6/Cn combinations",
+ "[THISMODULE] is a simple utility that converts C6/C12 or C6/Cn combinations",
"to [GRK]sigma[grk] and [GRK]epsilon[grk], or vice versa. It can also plot the potential",
"in file. In addition, it makes an approximation of a Buckingham potential",
"to a Lennard-Jones potential."
};
const char *desc[] = {
- "[TT]g_sorient[tt] analyzes solvent orientation around solutes.",
+ "[THISMODULE] analyzes solvent orientation around solutes.",
"It calculates two angles between the vector from one or more",
"reference positions to the first atom of each solvent molecule:[PAR]",
"[GRK]theta[grk][SUB]1[sub]: the angle with the vector from the first atom of the solvent",
int gmx_spatial(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_spatial[tt] calculates the spatial distribution function and ",
+ "[THISMODULE] calculates the spatial distribution function and ",
"outputs it in a form that can be read by VMD as Gaussian98 cube format. ",
- "This was developed from template.c (GROMACS-3.3). ",
"For a system of 32,000 atoms and a 50 ns trajectory, the SDF can be generated ",
"in about 30 minutes, with most of the time dedicated to the two runs through ",
"[TT]trjconv[tt] that are required to center everything properly. ",
"well, or select the protein backbone in a stable folded structure to get the SDF ",
"of solvent and look at the time-averaged solvation shell. ",
"It is also possible using this program to generate the SDF based on some arbitrary ",
- "Cartesian coordinate. To do that, simply omit the preliminary [TT]trjconv[tt] steps. \n",
+ "Cartesian coordinate. To do that, simply omit the preliminary [gmx-trjconv] steps. \n",
"USAGE: \n",
- "1. Use [TT]make_ndx[tt] to create a group containing the atoms around which you want the SDF \n",
- "2. [TT]trjconv -s a.tpr -f a.xtc -o b.xtc -boxcenter tric -ur compact -pbc none[tt] \n",
- "3. [TT]trjconv -s a.tpr -f b.xtc -o c.xtc -fit rot+trans[tt] \n",
- "4. run [TT]g_spatial[tt] on the [TT].xtc[tt] output of step #3. \n",
+ "1. Use [gmx-make_ndx] to create a group containing the atoms around which you want the SDF \n",
+ "2. [TT]gmx trjconv -s a.tpr -f a.xtc -o b.xtc -boxcenter tric -ur compact -pbc none[tt] \n",
+ "3. [TT]gmx trjconv -s a.tpr -f b.xtc -o c.xtc -fit rot+trans[tt] \n",
+ "4. run [THISMODULE] on the [TT].xtc[tt] output of step #3. \n",
"5. Load [TT]grid.cube[tt] into VMD and view as an isosurface. \n",
- "[BB]Note[bb] that systems such as micelles will require [TT]trjconv -pbc cluster[tt] between steps 1 and 2\n",
+ "[BB]Note[bb] that systems such as micelles will require [TT]gmx trjconv -pbc cluster[tt] between steps 1 and 2\n",
"WARNINGS:[BR]",
"The SDF will be generated for a cube that contains all bins that have some non-zero occupancy. ",
- "However, the preparatory [TT]-fit rot+trans[tt] option to [TT]trjconv[tt] implies that your system will be rotating ",
+ "However, the preparatory [TT]-fit rot+trans[tt] option to [gmx-trjconv] implies that your system will be rotating ",
"and translating in space (in order that the selected group does not). Therefore the values that are ",
"returned will only be valid for some region around your central group/coordinate that has full overlap ",
"with system volume throughout the entire translated/rotated system over the course of the trajectory. ",
"with an increased [TT]-nab[tt] value. \n",
"RISKY OPTIONS:[BR]",
"To reduce the amount of space and time required, you can output only the coords ",
- "that are going to be used in the first and subsequent run through [TT]trjconv[tt]. ",
+ "that are going to be used in the first and subsequent run through [gmx-trjconv]. ",
"However, be sure to set the [TT]-nab[tt] option to a sufficiently high value since ",
"memory is allocated for cube bins based on the initial coordinates and the [TT]-nab[tt] ",
"option value. \n"
const char *desc[] = {
- "[TT]g_spol[tt] analyzes dipoles around a solute; it is especially useful",
+ "[THISMODULE] analyzes dipoles around a solute; it is especially useful",
"for polarizable water. A group of reference atoms, or a center",
"of mass reference (option [TT]-com[tt]) and a group of solvent",
"atoms is required. The program splits the group of solvent atoms",
int gmx_tcaf(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_tcaf[tt] computes tranverse current autocorrelations.",
+ "[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",
int gmx_traj(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_traj[tt] plots coordinates, velocities, forces and/or the box.",
+ "[THISMODULE] plots coordinates, velocities, forces and/or the box.",
"With [TT]-com[tt] the coordinates, velocities and forces are",
"calculated for the center of mass of each group.",
"When [TT]-mol[tt] is set, the numbers in the index file are",
int gmx_trjcat(int argc, char *argv[])
{
- const char
- *desc[] =
+ const char *desc[] =
{
- "[TT]trjcat[tt] concatenates several input trajectory files in sorted order. ",
+ "[THISMODULE] concatenates several input trajectory files in sorted order. ",
"In case of double time frames the one in the later file is used. ",
"By specifying [TT]-settime[tt] you will be asked for the start time ",
"of each file. The input files are taken from the command line, ",
- "such that a command like [TT]trjcat -f *.trr -o fixed.trr[tt] should do ",
+ "such that a command like [TT]gmx trjcat -f *.trr -o fixed.trr[tt] should do ",
"the trick. Using [TT]-cat[tt], you can simply paste several files ",
"together without removal of frames with identical time stamps.[PAR]",
"One important option is inferred when the output file is amongst the",
int gmx_trjconv(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]trjconv[tt] can convert trajectory files in many ways:[BR]",
+ "[THISMODULE] can convert trajectory files in many ways:[BR]",
"[BB]1.[bb] from one format to another[BR]",
"[BB]2.[bb] select a subset of atoms[BR]",
"[BB]3.[bb] change the periodicity representation[BR]",
"[BB]10.[bb] select frames within a certain range of a quantity given",
"in an [TT].xvg[tt] file.[PAR]",
- "The program [TT]trjcat[tt] is better suited for concatenating multiple trajectory files.",
+ "[gmx-trjcat] is better suited for concatenating multiple trajectory files.",
"[PAR]",
"Currently seven formats are supported for input and output:",
"is always taken from [TT]-ndec[tt], when this option is set.",
"All other formats have fixed precision. [TT].trr[tt] and [TT].trj[tt]",
"output can be single or double precision, depending on the precision",
- "of the [TT]trjconv[tt] binary.",
+ "of the [THISMODULE] binary.",
"Note that velocities are only supported in",
"[TT].trr[tt], [TT].trj[tt], [TT].gro[tt] and [TT].g96[tt] files.[PAR]",
"It is not always possible to use combinations of [TT]-pbc[tt],",
"[TT]-fit[tt], [TT]-ur[tt] and [TT]-center[tt] to do exactly what",
- "you want in one call to [TT]trjconv[tt]. Consider using multiple",
+ "you want in one call to [THISMODULE]. Consider using multiple",
"calls, and check out the GROMACS website for suggestions.[PAR]",
"With [TT]-dt[tt], it is possible to reduce the number of ",
"frames in the output. This option relies on the accuracy of the times",
"in your input trajectory, so if these are inaccurate use the",
"[TT]-timestep[tt] option to modify the time (this can be done",
- "simultaneously). For making smooth movies, the program [TT]g_filter[tt]",
+ "simultaneously). For making smooth movies, the program [gmx-filter]",
"can reduce the number of frames while using low-pass frequency",
"filtering, this reduces aliasing of high frequency motions.[PAR]",
- "Using [TT]-trunc[tt] [TT]trjconv[tt] can truncate [TT].trj[tt] in place, i.e.",
+ "Using [TT]-trunc[tt] [THISMODULE] can truncate [TT].trj[tt] in place, i.e.",
"without copying the file. This is useful when a run has crashed",
"during disk I/O (i.e. full disk), or when two contiguous",
"trajectories must be concatenated without having double frames.[PAR]",
int gmx_trjorder(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]trjorder[tt] orders molecules according to the smallest distance",
+ "[THISMODULE] orders molecules according to the smallest distance",
"to atoms in a reference group",
"or on z-coordinate (with option [TT]-z[tt]).",
"With distance ordering, it will ask for a group of reference",
"be used instead of a reference atom by setting [TT]-da[tt] to 0.",
"All atoms in the trajectory are written",
"to the output trajectory.[PAR]",
- "[TT]trjorder[tt] can be useful for e.g. analyzing the n waters closest to a",
+ "[THISMODULE] can be useful for e.g. analyzing the n waters closest to a",
"protein.",
"In that case the reference group would be the protein and the group",
"of molecules would consist of all the water atoms. When an index group",
int gmx_tune_pme(int argc, char *argv[])
{
const char *desc[] = {
- "For a given number [TT]-np[tt] or [TT]-ntmpi[tt] of processors/threads, this program systematically",
- "times [TT]mdrun[tt] with various numbers of PME-only nodes and determines",
+ "For a given number [TT]-np[tt] or [TT]-ntmpi[tt] of processors/threads, [THISMODULE] systematically",
+ "times [gmx-mdrun] with various numbers of PME-only nodes and determines",
"which setting is fastest. It will also test whether performance can",
"be enhanced by shifting load from the reciprocal to the real space",
"part of the Ewald sum. ",
- "Simply pass your [TT].tpr[tt] file to [TT]g_tune_pme[tt] together with other options",
- "for [TT]mdrun[tt] as needed.[PAR]",
+ "Simply pass your [TT].tpr[tt] file to [THISMODULE] together with other options",
+ "for [gmx-mdrun] as needed.[PAR]",
"Which executables are used can be set in the environment variables",
"MPIRUN and MDRUN. If these are not present, 'mpirun' and 'mdrun'",
"will be used as defaults. Note that for certain MPI frameworks you",
"need to provide a machine- or hostfile. This can also be passed",
"via the MPIRUN variable, e.g.[PAR]",
"[TT]export MPIRUN=\"/usr/local/mpirun -machinefile hosts\"[tt][PAR]",
- "Please call [TT]g_tune_pme[tt] with the normal options you would pass to",
- "[TT]mdrun[tt] and add [TT]-np[tt] for the number of processors to perform the",
+ "Please call [THISMODULE] with the normal options you would pass to",
+ "[gmx-mdrun] and add [TT]-np[tt] for the number of processors to perform the",
"tests on, or [TT]-ntmpi[tt] for the number of threads. You can also add [TT]-r[tt]",
"to repeat each test several times to get better statistics. [PAR]",
- "[TT]g_tune_pme[tt] can test various real space / reciprocal space workloads",
+ "[THISMODULE] can test various real space / reciprocal space workloads",
"for you. With [TT]-ntpr[tt] you control how many extra [TT].tpr[tt] files will be",
"written with enlarged cutoffs and smaller Fourier grids respectively.",
"Typically, the first test (number 0) will be with the settings from the input",
"for a higher accuarcy of the measurements, you should set [TT]-resetstep[tt] to a higher value.",
"From the 'DD' load imbalance entries in the md.log output file you",
"can tell after how many steps the load is sufficiently balanced. Example call:[PAR]"
- "[TT]g_tune_pme -np 64 -s protein.tpr -launch[tt][PAR]",
- "After calling [TT]mdrun[tt] several times, detailed performance information",
- "is available in the output file [TT]perf.out.[tt] ",
+ "[TT]gmx tune_pme -np 64 -s protein.tpr -launch[tt][PAR]",
+ "After calling [gmx-mdrun] several times, detailed performance information",
+ "is available in the output file [TT]perf.out[tt].",
"[BB]Note[bb] that during the benchmarks, a couple of temporary files are written",
"(options [TT]-b[tt]*), these will be automatically deleted after each test.[PAR]",
"If you want the simulation to be started automatically with the",
int gmx_vanhove(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_vanhove[tt] computes the Van Hove correlation function.",
+ "[THISMODULE] computes the Van Hove correlation function.",
"The Van Hove G(r,t) is the probability that a particle that is at r[SUB]0[sub]",
"at time zero can be found at position r[SUB]0[sub]+r at time t.",
- "[TT]g_vanhove[tt] determines G not for a vector r, but for the length of r.",
+ "[THISMODULE] 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.",
int gmx_velacc(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_velacc[tt] computes the velocity autocorrelation function.",
+ "[THISMODULE] computes the velocity autocorrelation function.",
"When the [TT]-m[tt] option is used, the momentum autocorrelation",
"function is calculated.[PAR]",
"With option [TT]-mol[tt] the velocity autocorrelation function of",
int gmx_wham(int argc, char *argv[])
{
const char *desc[] = {
- "This is an analysis program that implements the Weighted",
+ "[THISMODULE] is an analysis program that implements the Weighted",
"Histogram Analysis Method (WHAM). It is intended to analyze",
"output files generated by umbrella sampling simulations to ",
"compute a potential of mean force (PMF). [PAR] ",
"[TT]*[tt] With option [TT]-ip[tt], the user provides file names of (gzipped) [TT].pdo[tt] files, i.e.",
" the GROMACS 3.3 umbrella output files. If you have some unusual"
" reaction coordinate you may also generate your own [TT].pdo[tt] files and",
- " feed them with the [TT]-ip[tt] option into to [TT]g_wham[tt]. The [TT].pdo[tt] file header",
+ " feed them with the [TT]-ip[tt] option into to [THISMODULE]. The [TT].pdo[tt] file header",
" must be similar to the following:[PAR]",
"[TT]# UMBRELLA 3.0[BR]",
"# Component selection: 0 0 1[BR]",
"If you want the free energy at a different ",
"position to be zero, set [TT]-zprof0[tt] (useful with bootstrapping, see below).[PAR]",
"For cyclic or periodic reaction coordinates (dihedral angle, channel PMF",
- "without osmotic gradient), the option [TT]-cycl[tt] is useful. [TT]g_wham[tt] will make use of the ",
+ "without osmotic gradient), the option [TT]-cycl[tt] is useful.",
+ "[THISMODULE] will make use of the",
"periodicity of the system and generate a periodic PMF. The first and the last bin of the",
"reaction coordinate will assumed be be neighbors.[PAR]",
"Option [TT]-sym[tt] symmetrizes the profile around z=0 before output, ",
"which may be useful for, e.g. membranes.[PAR]",
"AUTOCORRELATIONS[BR]----------------[BR]",
- "With [TT]-ac[tt], [TT]g_wham[tt] estimates the integrated autocorrelation ",
+ "With [TT]-ac[tt], [THISMODULE] estimates the integrated autocorrelation ",
"time (IACT) [GRK]tau[grk] for each umbrella window and weights the respective ",
"window with 1/[1+2*[GRK]tau[grk]/dt]. The IACTs are written ",
"to the file defined with [TT]-oiact[tt]. In verbose mode, all ",
"integration of the ACFs while the ACFs are larger 0.05.",
"If you prefer to compute the IACTs by a more sophisticated (but possibly ",
"less robust) method such as fitting to a double exponential, you can ",
- "compute the IACTs with [TT]g_analyze[tt] and provide them to [TT]g_wham[tt] with the file ",
+ "compute the IACTs with [gmx-analyze] and provide them to [THISMODULE] with the file ",
"[TT]iact-in.dat[tt] (option [TT]-iiact[tt]), which should contain one line per ",
"input file ([TT].pdo[tt] or pullx/f file) and one column per pull group in the respective file.[PAR]",
"ERROR ANALYSIS[BR]--------------[BR]",
int gmx_wheel(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_wheel[tt] plots a helical wheel representation of your sequence.",
+ "[THISMODULE] plots a helical wheel representation of your sequence.",
"The input sequence is in the [TT].dat[tt] file where the first line contains",
"the number of residues and each consecutive line contains a residue "
"name."
int gmx_xpm2ps(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]xpm2ps[tt] makes a beautiful color plot of an XPixelMap file.",
+ "[THISMODULE] makes a beautiful color plot of an XPixelMap file.",
"Labels and axis can be displayed, when they are supplied",
"in the correct matrix format.",
- "Matrix data may be generated by programs such as [TT]do_dssp[tt], [TT]g_rms[tt] or",
- "[TT]g_mdmat[tt].[PAR]",
+ "Matrix data may be generated by programs such as [gmx-do_dssp], [gmx-rms] or",
+ "[gmx-mdmat].[PAR]",
"Parameters are set in the [TT].m2p[tt] file optionally supplied with",
"[TT]-di[tt]. Reasonable defaults are provided. Settings for the [IT]y[it]-axis",
"default to those for the [IT]x[it]-axis. Font names have a defaulting hierarchy:",
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2009,2010,2011,2012, by the GROMACS development team, led by
+ * Copyright (c) 2009,2010,2011,2012,2013, by the GROMACS development team, led by
* Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
* and including many others, as listed in the AUTHORS file in the
* top-level source directory and at http://www.gromacs.org.
"Selection limitations";
const char *const LimitationsHelpText::text[] = {
"Some analysis programs may require a special structure for the input",
- "selections (e.g., [TT]g_angle[tt] requires the index group to be made",
+ "selections (e.g., [TT]gmx angle[tt] requires the index group to be made",
"of groups of three or four atoms).",
"For such programs, it is up to the user to provide a proper selection",
"expression that always returns such positions.",
Angle::initOptions(Options *options, TrajectoryAnalysisSettings * /*settings*/)
{
static const char *const desc[] = {
- "[TT]gmx gangle[tt] computes different types of angles between vectors.",
+ "[THISMODULE] computes different types of angles between vectors.",
"It supports both vectors defined by two positions and normals of",
"planes defined by three positions.",
"The z axis or the local normal of a sphere can also be used as",
Distance::initOptions(Options *options, TrajectoryAnalysisSettings * /*settings*/)
{
static const char *const desc[] = {
- "[TT]gmx distance[tt] calculates distances between pairs of positions",
+ "[THISMODULE] calculates distances between pairs of positions",
"as a function of time. Each selection specifies an independent set",
"of distances to calculate. Each selection should consist of pairs",
"of positions, and the distances are computed between positions 1-2,",
TrajectoryAnalysisSettings *settings)
{
static const char *const desc[] = {
- "g_freevol can calculate the free volume in a box as",
+ "[THISMODULE] can calculate the free volume in a box as",
"a function of time. The free volume is",
"plotted as a fraction of the total volume.",
"The program tries to insert a probe with a given radius,",
Select::initOptions(Options *options, TrajectoryAnalysisSettings * /*settings*/)
{
static const char *const desc[] = {
- "[TT]g_select[tt] writes out basic data about dynamic selections.",
+ "[THISMODULE] writes out basic data about dynamic selections.",
"It can be used for some simple analyses, or the output can",
"be combined with output from other programs and/or external",
"analysis programs to calculate more complex things.",
int gmx_protonate(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_protonate[tt] reads (a) conformation(s) and adds all missing",
+ "[THISMODULE] reads (a) conformation(s) and adds all missing",
"hydrogens as defined in [TT]gmx2.ff/aminoacids.hdb[tt]. If only [TT]-s[tt] is",
"specified, this conformation will be protonated, if also [TT]-f[tt]",
"is specified, the conformation(s) will be read from this file, ",
int gmx_x2top(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]g_x2top[tt] generates a primitive topology from a coordinate file.",
+ "[THISMODULE] generates a primitive topology from a coordinate file.",
"The program assumes all hydrogens are present when defining",
"the hybridization from the atom name and the number of bonds.",
"The program can also make an [TT].rtp[tt] entry, which you can then add",
"information about file formats. By default, the force field selection",
"is interactive, but you can use the [TT]-ff[tt] option to specify",
"one of the short names above on the command line instead. In that",
- "case [TT]g_x2top[tt] just looks for the corresponding file.[PAR]",
+ "case [THISMODULE] just looks for the corresponding file.[PAR]",
};
const char *bugs[] = {
"The atom type selection is primitive. Virtually no chemical knowledge is used",
int gmx_gmxcheck(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]gmx check[tt] reads a trajectory ([TT].trj[tt], [TT].trr[tt] or ",
+ "[THISMODULE] reads a trajectory ([TT].trj[tt], [TT].trr[tt] or ",
"[TT].xtc[tt]), an energy file ([TT].ene[tt] or [TT].edr[tt])",
"or an index file ([TT].ndx[tt])",
"and prints out useful information about them.[PAR]",
int gmx_gmxdump(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]gmx dump[tt] reads a run input file ([TT].tpa[tt]/[TT].tpr[tt]/[TT].tpb[tt]),",
+ "[THISMODULE] reads a run input file ([TT].tpa[tt]/[TT].tpr[tt]/[TT].tpb[tt]),",
"a trajectory ([TT].trj[tt]/[TT].trr[tt]/[TT].xtc[tt]), an energy",
"file ([TT].ene[tt]/[TT].edr[tt]), or a checkpoint file ([TT].cpt[tt])",
"and prints that to standard output in a readable format.",
int gmx_grompp(int argc, char *argv[])
{
static const char *desc[] = {
- "The gromacs preprocessor",
+ "[THISMODULE] (the gromacs preprocessor)",
"reads a molecular topology file, checks the validity of the",
"file, expands the topology from a molecular description to an atomic",
"description. The topology file contains information about",
"for hydrogens and heavy atoms.",
"Then a coordinate file is read and velocities can be generated",
"from a Maxwellian distribution if requested.",
- "[TT]grompp[tt] also reads parameters for the [TT]mdrun[tt] ",
+ "[THISMODULE] also reads parameters for [gmx-mdrun] ",
"(eg. number of MD steps, time step, cut-off), and others such as",
"NEMD parameters, which are corrected so that the net acceleration",
"is zero.",
"Eventually a binary file is produced that can serve as the sole input",
"file for the MD program.[PAR]",
- "[TT]grompp[tt] uses the atom names from the topology file. The atom names",
+ "[THISMODULE] uses the atom names from the topology file. The atom names",
"in the coordinate file (option [TT]-c[tt]) are only read to generate",
"warnings when they do not match the atom names in the topology.",
"Note that the atom names are irrelevant for the simulation as",
"only the atom types are used for generating interaction parameters.[PAR]",
- "[TT]grompp[tt] uses a built-in preprocessor to resolve includes, macros, ",
+ "[THISMODULE] uses a built-in preprocessor to resolve includes, macros, ",
"etc. The preprocessor supports the following keywords:[PAR]",
"#ifdef VARIABLE[BR]",
"#ifndef VARIABLE[BR]",
"[TT]-e[tt] to read Nose-Hoover and/or Parrinello-Rahman coupling",
"variables.[PAR]",
- "[TT]grompp[tt] can be used to restart simulations (preserving",
+ "[THISMODULE] can be used to restart simulations (preserving",
"continuity) by supplying just a checkpoint file with [TT]-t[tt].",
"However, for simply changing the number of run steps to extend",
- "a run, using [TT]tpbconv[tt] is more convenient than [TT]grompp[tt].",
- "You then supply the old checkpoint file directly to [TT]mdrun[tt]",
+ "a run, using [gmx-tpbconv] is more convenient than [THISMODULE].",
+ "You then supply the old checkpoint file directly to [gmx-mdrun]",
"with [TT]-cpi[tt]. If you wish to change the ensemble or things",
"like output frequency, then supplying the checkpoint file to",
- "[TT]grompp[tt] with [TT]-t[tt] along with a new [TT].mdp[tt] file",
+ "[THISMODULE] with [TT]-t[tt] along with a new [TT].mdp[tt] file",
"with [TT]-f[tt] is the recommended procedure.[PAR]",
"By default, all bonded interactions which have constant energy due to",
"To verify your run input file, please take note of all warnings",
"on the screen, and correct where necessary. Do also look at the contents",
"of the [TT]mdout.mdp[tt] file; this contains comment lines, as well as",
- "the input that [TT]grompp[tt] has read. If in doubt, you can start [TT]grompp[tt]",
+ "the input that [THISMODULE] has read. If in doubt, you can start [THISMODULE]",
"with the [TT]-debug[tt] option which will give you more information",
"in a file called [TT]grompp.log[tt] (along with real debug info). You",
- "can see the contents of the run input file with the [TT]gmxdump[tt]",
- "program. [TT]gmxcheck[tt] can be used to compare the contents of two",
+ "can see the contents of the run input file with the [gmx-dump]",
+ "program. [gmx-check] can be used to compare the contents of two",
"run input files.[PAR]"
"The [TT]-maxwarn[tt] option can be used to override warnings printed",
- "by [TT]grompp[tt] that otherwise halt output. In some cases, warnings are",
+ "by [THISMODULE] that otherwise halt output. In some cases, warnings are",
"harmless, but usually they are not. The user is advised to carefully",
"interpret the output messages before attempting to bypass them with",
"this option."
int gmx_pdb2gmx(int argc, char *argv[])
{
const char *desc[] = {
- "This program reads a [TT].pdb[tt] (or [TT].gro[tt]) file, reads",
+ "[THISMODULE] reads a [TT].pdb[tt] (or [TT].gro[tt]) file, reads",
"some database files, adds hydrogens to the molecules and generates",
"coordinates in GROMACS (GROMOS), or optionally [TT].pdb[tt], format",
"and a topology in GROMACS format.",
"These files can subsequently be processed to generate a run input file.",
"[PAR]",
- "[TT]pdb2gmx[tt] will search for force fields by looking for",
+ "[THISMODULE] will search for force fields by looking for",
"a [TT]forcefield.itp[tt] file in subdirectories [TT]<forcefield>.ff[tt]",
"of the current working directory and of the GROMACS library directory",
"as inferred from the path of the binary or the [TT]GMXLIB[tt] environment",
"variable.",
"By default the forcefield selection is interactive,",
"but you can use the [TT]-ff[tt] option to specify one of the short names",
- "in the list on the command line instead. In that case [TT]pdb2gmx[tt] just looks",
+ "in the list on the command line instead. In that case [THISMODULE] just looks",
"for the corresponding [TT]<forcefield>.ff[tt] directory.",
"[PAR]",
"After choosing a force field, all files will be read only from",
"two protein chains or if you have a HEME group bound to a protein.",
"In such cases multiple chains should be contained in a single",
"[TT]moleculetype[tt] definition.",
- "To handle this, [TT]pdb2gmx[tt] uses two separate options.",
+ "To handle this, [THISMODULE] uses two separate options.",
"First, [TT]-chainsep[tt] allows you to choose when a new chemical chain should",
"start, and termini added when applicable. This can be done based on the",
"existence of TER records, when the chain id changes, or combinations of either",
"This can be turned off (no merging), all non-water chains can be merged into a",
"single molecule, or the selection can be done interactively.[PAR]",
- "[TT]pdb2gmx[tt] will also check the occupancy field of the [TT].pdb[tt] file.",
+ "[THISMODULE] will also check the occupancy field of the [TT].pdb[tt] file.",
"If any of the occupancies are not one, indicating that the atom is",
"not resolved well in the structure, a warning message is issued.",
"When a [TT].pdb[tt] file does not originate from an X-ray structure determination",
int gmx_tpbconv(int argc, char *argv[])
{
const char *desc[] = {
- "tpbconv can edit run input files in four ways.[PAR]",
+ "[THISMODULE] can edit run input files in four ways.[PAR]",
"[BB]1.[bb] by modifying the number of steps in a run input file",
"with options [TT]-extend[tt], [TT]-until[tt] or [TT]-nsteps[tt]",
"(nsteps=-1 means unlimited number of steps)[PAR]",
int gmx_mdrun(int argc, char *argv[])
{
const char *desc[] = {
- "The [TT]mdrun[tt] program is the main computational chemistry engine",
+ "[THISMODULE] is the main computational chemistry engine",
"within GROMACS. Obviously, it performs Molecular Dynamics simulations,",
"but it can also perform Stochastic Dynamics, Energy Minimization,",
"test particle insertion or (re)calculation of energies.",
"builds a Hessian matrix from single conformation.",
"For usual Normal Modes-like calculations, make sure that",
"the structure provided is properly energy-minimized.",
- "The generated matrix can be diagonalized by [TT]g_nmeig[tt].[PAR]",
+ "The generated matrix can be diagonalized by [gmx-nmeig].[PAR]",
"The [TT]mdrun[tt] program reads the run input file ([TT]-s[tt])",
"and distributes the topology over nodes if needed.",
"[TT]mdrun[tt] produces at least four output files.",
"The MPI parallelization uses multiple processes when [TT]mdrun[tt] is",
"compiled with a normal MPI library or threads when [TT]mdrun[tt] is",
"compiled with the GROMACS built-in thread-MPI library. OpenMP threads",
- "are supported when mdrun is compiled with OpenMP. Full OpenMP support",
+ "are supported when [TT]mdrun[tt] is compiled with OpenMP. Full OpenMP support",
"is only available with the Verlet cut-off scheme, with the (older)",
"group scheme only PME-only processes can use OpenMP parallelization.",
"In all cases [TT]mdrun[tt] will by default try to use all the available",
"With Intel Hyper-Threading 2 is best when using half or less of the",
"logical cores, 1 otherwise. The default value of 0 do exactly that:",
"it minimizes the threads per logical core, to optimize performance.",
- "If you want to run multiple mdrun jobs on the same physical node,"
+ "If you want to run multiple [TT]mdrun[tt] jobs on the same physical node,"
"you should set [TT]-pinstride[tt] to 1 when using all logical cores.",
- "When running multiple mdrun (or other) simulations on the same physical",
+ "When running multiple [TT]mdrun[tt] (or other) simulations on the same physical",
"node, some simulations need to start pinning from a non-zero core",
"to avoid overloading cores; with [TT]-pinoffset[tt] you can specify",
"the offset in logical cores for pinning.",
* But unfortunately we are not allowed to call a function here,
* since declarations follow below.
*/
- gmx_hw_opt_t hw_opt = { 0, 0, 0, 0, threadaffSEL, 0, 0,
- { NULL, FALSE, 0, NULL } };
+ gmx_hw_opt_t hw_opt = {
+ 0, 0, 0, 0, threadaffSEL, 0, 0,
+ { NULL, FALSE, 0, NULL }
+ };
t_pargs pa[] = {
int gmx_view(int argc, char *argv[])
{
const char *desc[] = {
- "[TT]view[tt] is the GROMACS trajectory viewer. This program reads a",
+ "[THISMODULE] is the GROMACS trajectory viewer. This program reads a",
"trajectory file, a run input file and an index file and plots a",
"3D structure of your molecule on your standard X Window",
"screen. No need for a high end graphics workstation, it even",
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff