GMX_TEST_CFLAG(CXXFLAGS_WARN "/wd4273" GMXC_CXXFLAGS)
endif()
+ if (CMAKE_C_COMPILER_ID MATCHES "Clang")
+ if(NOT GMX_OPENMP)
+ GMX_TEST_CFLAG(CFLAGS_PRAGMA "-Wno-unknown-pragmas" GMXC_CFLAGS)
+ endif()
+ GMX_TEST_CFLAG(CFLAGS_WARN "-Wall -Wno-unused" GMXC_CFLAGS)
+ endif()
+
+ if (CMAKE_C_COMPILER_ID MATCHES "Clang")
+ if(NOT GMX_OPENMP)
+ GMX_TEST_CFLAG(CXXFLAGS_PRAGMA "-Wno-unknown-pragmas" GMXC_CXXFLAGS)
+ endif()
+ GMX_TEST_CXXFLAG(CXXFLAGS_WARN "-Wall -Wno-unused" GMXC_CXXFLAGS)
+ endif()
# now actually set the flags:
# C
To avoid spurious contibrutions to the virial and pressure due to large
forces between completely frozen atoms you need to use
<A HREF="#egexcl">energy group exclusions</A>, this also saves computing time.
-Note that frozen coordinates are not subject to pressure scaling.</dd>
+Note that coordinates of frozen atoms are not scaled by pressure-coupling
+algorithms.</dd>
<dt><b>freezedim: </b></dt>
<dd>dimensions for which groups in <b>freezegrps</b> should be frozen,
specify <tt>Y</tt> or <tt>N</tt> for X, Y and Z and for each group
static void cp_error()
{
- gmx_fatal(FARGS,"Checkpoint file corrupted/truncated, or maybe you are out of quota?");
+ gmx_fatal(FARGS,"Checkpoint file corrupted/truncated, or maybe you are out of disk space?");
}
static void do_cpt_string_err(XDR *xd,gmx_bool bRead,const char *desc,char **s,FILE *list)
res = xdr_int(xd,&magic);
if (res == 0)
{
- gmx_fatal(FARGS,"The checkpoint file is empty/corrupted, or maybe you are out of quota?");
+ gmx_fatal(FARGS,"The checkpoint file is empty/corrupted, or maybe you are out of disk space?");
}
if (magic != CPT_MAGIC1)
{
(do_cpt_files(gmx_fio_getxdr(fp),FALSE,&outputfiles,&noutputfiles,NULL,
file_version) < 0))
{
- gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of quota?");
+ gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?");
}
do_cpt_footer(gmx_fio_getxdr(fp),FALSE,file_version);
{
char buf[STRLEN];
sprintf(buf,
- "Cannot fsync '%s'; maybe you are out of disk space or quota?",
+ "Cannot fsync '%s'; maybe you are out of disk space?",
gmx_fio_getname(ret));
if (getenv(GMX_IGNORE_FSYNC_FAILURE_ENV)==NULL)
if( gmx_fio_close(fp) != 0)
{
- gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of quota?");
+ gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?");
}
/* we don't move the checkpoint if the user specified they didn't want it,
}
if (gmx_file_rename(fntemp, fn) != 0)
{
- gmx_file("Cannot rename checkpoint file; maybe you are out of quota?");
+ gmx_file("Cannot rename checkpoint file; maybe you are out of disk space?");
}
}
}
if( gmx_fio_close(fp) != 0)
{
- gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of quota?");
+ gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?");
}
sfree(fprog);
read_checkpoint_data(fp,simulation_part,step,t,state,FALSE,NULL,NULL);
if( gmx_fio_close(fp) != 0)
{
- gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of quota?");
+ gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?");
}
}
}
if( gmx_fio_close(fp) != 0)
{
- gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of quota?");
+ gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?");
}
done_state(&state);
&nfiles,&outputfiles);
if( gmx_fio_close(fp) != 0)
{
- gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of quota?");
+ gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?");
}
done_state(&state);
}
if(!xdr_string(xdr,&(nm->name),STRLEN))
{
- gmx_file("Cannot write energy names to file; maybe you are out of quota?");
+ gmx_file("Cannot write energy names to file; maybe you are out of disk space?");
}
if (file_version >= 2)
{
if(!xdr_string(xdr,&(nm->unit),STRLEN))
{
- gmx_file("Cannot write energy names to file; maybe you are out of quota?");
+ gmx_file("Cannot write energy names to file; maybe you are out of disk space?");
}
}
else
{
if(!bRead)
{
- gmx_file("Cannot write energy names to file; maybe you are out of quota?");
+ gmx_file("Cannot write energy names to file; maybe you are out of disk space?");
}
*nre=0;
return;
{
if(gmx_fio_close(ef->fio) != 0)
{
- gmx_file("Cannot close energy file; it might be corrupt, or maybe you are out of quota?");
+ gmx_file("Cannot close energy file; it might be corrupt, or maybe you are out of disk space?");
}
}
do_eheader(ef,&file_version,fr,nre,&bWrongPrecision,&bOK);
if(!bOK)
{
- gmx_file("Cannot write energy file header; maybe you are out of quota?");
+ gmx_file("Cannot write energy file header; maybe you are out of disk space?");
}
if (((fr->e_size && (fr->nre == nre) &&
}
else
{
- gmx_file("Cannot write energy file header; maybe you are out of quota?");
+ gmx_file("Cannot write energy file header; maybe you are out of disk space?");
}
return FALSE;
}
{
if( gmx_fio_flush(ef->fio) != 0)
{
- gmx_file("Cannot write energy file; maybe you are out of quota?");
+ gmx_file("Cannot write energy file; maybe you are out of disk space?");
}
}
char buf[STRLEN];
sprintf(
buf,
- "Cannot write file '%s'; maybe you are out of disk space or quota?",
+ "Cannot write file '%s'; maybe you are out of disk space?",
fio->fn);
gmx_file(buf);
}
gmx_bool bSelDump = FALSE;
t_pargs sel_pa[] = {
{"-select", FALSE, etSTR, {&selection},
- "Selection string (use 'help' for help)"},
+ "Selection string (use 'help' for help). Note that the "
+ "whole selection string will need to be quoted so that "
+ "your shell will pass it in as a string. Example: "
+ "[TT]g_select -select '\"Nearby water\" resname SOL "
+ "and within 0.25 of group Protein'[tt]"},
{"-seldebug", FALSE, etBOOL, {&bSelDump},
"HIDDENPrint out the parsed and compiled selection trees"},
};
{
if( do_trn(fio,FALSE,&step,&t,&lambda,box,&natoms,x,v,f) == FALSE)
{
- gmx_file("Cannot write trajectory frame; maybe you are out of quota?");
+ gmx_file("Cannot write trajectory frame; maybe you are out of disk space?");
}
}
char *search,*replace;
} t_sandr;
+/* The order of these arrays is significant. Text search and replace
+ * for each element occurs in order, so earlier changes can induce
+ * subsequent changes even though the original text might not appear
+ * to invoke the latter changes. */
+
const t_sandr_const sandrTeX[] = {
{ "[TT]", "{\\tt " },
{ "[tt]", "}" },
{ "&", "\\&" },
/* The next couple of lines allow true Greek symbols to be written to the
manual, which makes it look pretty */
- { "[GRK]", "$\\" },
- { "[grk]", "$" },
- /* The next two lines used to substitute "|" and "||" to "or", but only
- * g_angle used that functionality, so that was changed to a textual
- * "or" there, so that other places could use those symbols to indicate
- * magnitudes. */
- { "||", "\\textbar{}\\textbar" },
- { "|", "\\textbar{}" }
+ { "[GRK]", "\\ensuremath{\\" },
+ { "[grk]", "}" },
+ { "[MATH]","\\ensuremath{" },
+ { "[math]","}" },
+ { "[CHEVRON]", "\\ensuremath{<}" },
+ { "[chevron]", "\\ensuremath{>}" },
+ { "[MAG]", "\\ensuremath{|}" },
+ { "[mag]", "\\ensuremath{|}" },
+ { "[INT]","\\ensuremath{\\int" },
+ { "[FROM]","_" },
+ { "[from]","" },
+ { "[TO]", "^" },
+ { "[to]", "" },
+ { "[int]","}" },
+ { "[SUM]","\\ensuremath{\\sum" },
+ { "[sum]","}" },
+ { "[SUB]","\\ensuremath{_{" },
+ { "[sub]","}}" },
+ { "[SQRT]","\\ensuremath{\\sqrt{" },
+ { "[sqrt]","}}" },
+ { "[EXP]","\\ensuremath{\\exp{(" },
+ { "[exp]",")}}" },
+ { "[LN]","\\ensuremath{\\ln{(" },
+ { "[ln]",")}}" },
+ { "[LOG]","\\ensuremath{\\log{(" },
+ { "[log]",")}}" },
+ { "[COS]","\\ensuremath{\\cos{(" },
+ { "[cos]",")}}" },
+ { "[SIN]","\\ensuremath{\\sin{(" },
+ { "[sin]",")}}" },
+ { "[TAN]","\\ensuremath{\\tan{(" },
+ { "[tan]",")}}" },
+ { "[COSH]","\\ensuremath{\\cosh{(" },
+ { "[cosh]",")}}" },
+ { "[SINH]","\\ensuremath{\\sinh{(" },
+ { "[sinh]",")}}" },
+ { "[TANH]","\\ensuremath{\\tanh{(" },
+ { "[tanh]",")}}" }
};
#define NSRTEX asize(sandrTeX)
{ "[bb]", "" },
{ "[IT]", "" },
{ "[it]", "" },
+ { "[MATH]","" },
+ { "[math]","" },
+ { "[CHEVRON]","<" },
+ { "[chevron]",">" },
+ { "[MAG]", "|" },
+ { "[mag]", "|" },
+ { "[INT]","integral" },
+ { "[FROM]"," from " },
+ { "[from]","" },
+ { "[TO]", " to " },
+ { "[to]", " of" },
+ { "[int]","" },
+ { "[SUM]","sum" },
+ { "[sum]","" },
+ { "[SUB]","_" },
+ { "[sub]","" },
+ { "[SQRT]","sqrt(" },
+ { "[sqrt]",")" },
+ { "[EXP]","exp(" },
+ { "[exp]",")" },
+ { "[LN]","ln(" },
+ { "[ln]",")" },
+ { "[LOG]","log(" },
+ { "[log]",")" },
+ { "[COS]","cos(" },
+ { "[cos]",")" },
+ { "[SIN]","sin(" },
+ { "[sin]",")" },
+ { "[TAN]","tan(" },
+ { "[tan]",")" },
+ { "[COSH]","cosh(" },
+ { "[cosh]",")" },
+ { "[SINH]","sinh(" },
+ { "[sinh]",")" },
+ { "[TANH]","tanh(" },
+ { "[tanh]",")" },
{ "[PAR]","\n\n" },
{ "[BR]", "\n"},
{ "[GRK]", "" },
{ "[bb]", "'''" },
{ "[IT]", "''" },
{ "[it]", "''" },
+ { "[MATH]","" },
+ { "[math]","" },
+ { "[CHEVRON]","<" },
+ { "[chevron]",">" },
+ { "[MAG]", "|" },
+ { "[mag]", "|" },
+ { "[INT]","integral" },
+ { "[FROM]"," from " },
+ { "[from]","" },
+ { "[TO]", " to " },
+ { "[to]", " of" },
+ { "[int]","" },
+ { "[SUM]","sum" },
+ { "[sum]","" },
+ { "[SUB]","_" },
+ { "[sub]","" },
+ { "[SQRT]","sqrt(" },
+ { "[sqrt]",")", },
+ { "[EXP]","exp(" },
+ { "[exp]",")" },
+ { "[LN]","ln(" },
+ { "[ln]",")" },
+ { "[LOG]","log(" },
+ { "[log]",")" },
+ { "[COS]","cos(" },
+ { "[cos]",")" },
+ { "[SIN]","sin(" },
+ { "[sin]",")" },
+ { "[TAN]","tan(" },
+ { "[tan]",")" },
+ { "[COSH]","cosh(" },
+ { "[cosh]",")" },
+ { "[SINH]","sinh(" },
+ { "[sinh]",")" },
+ { "[TANH]","tanh(" },
+ { "[tanh]",")" },
{ "[PAR]","\n\n" },
{ "[BR]", "\n" },
{ "[GRK]", "&" },
{ "[bb]", "\\fR" },
{ "[IT]", "\\fI " },
{ "[it]", "\\fR" },
+ { "[MATH]","" },
+ { "[math]","" },
+ { "[CHEVRON]","<" },
+ { "[chevron]",">" },
+ { "[MAG]", "|" },
+ { "[mag]", "|" },
+ { "[INT]","integral" },
+ { "[FROM]"," from " },
+ { "[from]","" },
+ { "[TO]", " to " },
+ { "[to]", " of" },
+ { "[int]","" },
+ { "[SUM]","sum" },
+ { "[sum]","" },
+ { "[SUB]","_" },
+ { "[sub]","" },
+ { "[SQRT]","sqrt(" },
+ { "[sqrt]",")", },
+ { "[EXP]","exp(" },
+ { "[exp]",")" },
+ { "[LN]","ln(" },
+ { "[ln]",")" },
+ { "[LOG]","log(" },
+ { "[log]",")" },
+ { "[COS]","cos(" },
+ { "[cos]",")" },
+ { "[SIN]","sin(" },
+ { "[sin]",")" },
+ { "[TAN]","tan(" },
+ { "[tan]",")" },
+ { "[COSH]","cosh(" },
+ { "[cosh]",")" },
+ { "[SINH]","sinh(" },
+ { "[sinh]",")" },
+ { "[TANH]","tanh(" },
+ { "[tanh]",")" },
{ "[PAR]","\n\n" },
{ "\n ", "\n" },
{ "<", "" },
{ "[bb]", "</b>" },
{ "[IT]", "<it>" },
{ "[it]", "</it>" },
+ { "[MATH]","" },
+ { "[math]","" },
+ { "[CHEVRON]","<" },
+ { "[chevron]",">" },
+ { "[MAG]", "|" },
+ { "[mag]", "|" },
+ { "[INT]","integral" },
+ { "[FROM]"," from " },
+ { "[from]","" },
+ { "[TO]", " to " },
+ { "[to]", " of" },
+ { "[int]","" },
+ { "[SUM]","sum" },
+ { "[sum]","" },
+ { "[SUB]","_" },
+ { "[sub]","" },
+ { "[SQRT]","sqrt(" },
+ { "[sqrt]",")", },
+ { "[EXP]","exp(" },
+ { "[exp]",")" },
+ { "[LN]","ln(" },
+ { "[ln]",")" },
+ { "[LOG]","log(" },
+ { "[log]",")" },
+ { "[COS]","cos(" },
+ { "[cos]",")" },
+ { "[SIN]","sin(" },
+ { "[sin]",")" },
+ { "[TAN]","tan(" },
+ { "[tan]",")" },
+ { "[COSH]","cosh(" },
+ { "[cosh]",")" },
+ { "[SINH]","sinh(" },
+ { "[sinh]",")" },
+ { "[TANH]","tanh(" },
+ { "[tanh]",")" },
{ "[PAR]","<p>" },
{ "[BR]", "<br>" },
{ "[GRK]", "&" },
{ "[bb]", "</emp>" },
{ "[IT]", "<it>" },
{ "[it]", "</it>" },
+ { "[MATH]","" },
+ { "[math]","" },
+ { "[CHEVRON]","<" },
+ { "[chevron]",">" },
+ { "[MAG]", "|" },
+ { "[mag]", "|" },
+ { "[INT]","integral" },
+ { "[FROM]"," from " },
+ { "[from]","" },
+ { "[TO]", " to " },
+ { "[to]", " of" },
+ { "[int]","" },
+ { "[SUM]","sum" },
+ { "[sum]","" },
+ { "[SUB]","_" },
+ { "[sub]","" },
+ { "[SQRT]","sqrt(" },
+ { "[sqrt]",")", },
+ { "[EXP]","exp(" },
+ { "[exp]",")" },
+ { "[LN]","ln(" },
+ { "[ln]",")" },
+ { "[LOG]","log(" },
+ { "[log]",")" },
+ { "[COS]","cos(" },
+ { "[cos]",")" },
+ { "[SIN]","sin(" },
+ { "[sin]",")" },
+ { "[TAN]","tan(" },
+ { "[tan]",")" },
+ { "[COSH]","cosh(" },
+ { "[cosh]",")" },
+ { "[SINH]","sinh(" },
+ { "[sinh]",")" },
+ { "[TANH]","tanh(" },
+ { "[tanh]",")" },
{ "[PAR]","</par>\n<par>" },
{ "[BR]", "<br />" },
{ "[GRK]", "" },
{ "-rmsd", FALSE, etBOOL, {&bRMSD},
"Print RMSD for x, v and f" },
{ "-tol", FALSE, etREAL, {&ftol},
- "Relative tolerance for comparing real values defined as 2*(a-b)/(|a|+|b|)" },
+ "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},
{
if(fflush(fplog) != 0)
{
- gmx_fatal(FARGS,"Cannot flush logfile - maybe you are out of quota?");
+ gmx_fatal(FARGS,"Cannot flush logfile - maybe you are out of disk space?");
}
}
}
if (MASTER(cr))
{
char tbuf[20];
- fprintf(fplog,"Initial temperature: %g K\n",enerd->term[F_TEMP]);
fprintf(stderr,"starting mdrun '%s'\n",
*(top_global->name));
if (ir->nsteps >= 0)
{
if (fflush(fplog) != 0)
{
- gmx_fatal(FARGS,"Cannot flush logfile - maybe you are out of quota?");
+ gmx_fatal(FARGS,"Cannot flush logfile - maybe you are out of disk space?");
}
}
{ "-multi", FALSE, etINT,{&nmultisim},
"Do multiple simulations in parallel" },
{ "-replex", FALSE, etINT, {&repl_ex_nst},
- "Attempt replica exchange every # steps" },
+ "Attempt replica exchange periodically with this period (steps)" },
{ "-reseed", FALSE, etINT, {&repl_ex_seed},
"Seed for replica exchange, -1 is generate a seed" },
{ "-rerunvsite", FALSE, etBOOL, {&bRerunVSite},
else if (ir->bPeriodicMols)
{
/* Can not easily determine the required cut-off */
- dd_warning(cr,fplog,"NOTE: Periodic molecules: can not easily determine the required minimum bonded cut-off, using half the non-bonded cut-off\n");
+ dd_warning(cr,fplog,"NOTE: Periodic molecules are present in this system. Because of this, the domain decomposition algorithm cannot easily determine the minimum cell size that it requires for treating bonded interactions. Instead, domain decomposition will assume that half the non-bonded cut-off will be a suitable lower bound.\n");
comm->cutoff_mbody = comm->cutoff/2;
r_bonded_limit = comm->cutoff_mbody;
}
}
if (rc < 0)
{
- gmx_fatal(FARGS,"Cannot write to logfile; maybe you are out of quota?");
+ gmx_fatal(FARGS,"Cannot write to logfile; maybe you are out of disk space?");
}
}
(mdof_flags & MDOF_F) ? f_global : NULL);
if (gmx_fio_flush(of->fp_trn) != 0)
{
- gmx_file("Cannot write trajectory; maybe you are out of quota?");
+ gmx_file("Cannot write trajectory; maybe you are out of disk space?");
}
gmx_fio_check_file_position(of->fp_trn);
}
if (write_xtc(of->fp_xtc,*n_xtc,step,t,
state_local->box,xxtc,of->xtc_prec) == 0)
{
- gmx_fatal(FARGS,"XTC error - maybe you are out of quota?");
+ gmx_fatal(FARGS,"XTC error - maybe you are out of disk space?");
}
gmx_fio_check_file_position(of->fp_xtc);
}
{ "-fitfn", FALSE, etENUM, {s_ffn},
"Fit function" },
{ "-ncskip", FALSE, etINT, {&acf.nskip},
- "Skip N points in the output file of correlation functions" },
+ "Skip this many points in the output file of correlation functions" },
{ "-beginfit", FALSE, etREAL, {&acf.tbeginfit},
"Time where to begin the exponential fit of the correlation function" },
{ "-endfit", FALSE, etREAL, {&acf.tendfit},
static real Abh=1e5,Bbh=32,Cbh=1e-3;
static int npow=12;
t_pargs pa[] = {
- { "-c6", FALSE, etREAL, {&c6}, "c6" },
- { "-cn", FALSE, etREAL, {&cn}, "constant for repulsion" },
- { "-pow", FALSE, etINT, {&npow},"power of the repulsion term" },
- { "-sig", FALSE, etREAL, {&sig}, "sig" },
- { "-eps", FALSE, etREAL, {&eps}, "eps" },
+ { "-c6", FALSE, etREAL, {&c6}, "C6" },
+ { "-cn", FALSE, etREAL, {&cn}, "Constant for repulsion" },
+ { "-pow", FALSE, etINT, {&npow},"Power of the repulsion term" },
+ { "-sig", FALSE, etREAL, {&sig}, "[GRK]sigma[grk]" },
+ { "-eps", FALSE, etREAL, {&eps}, "[GRK]epsilon[grk]" },
{ "-A", FALSE, etREAL, {&Abh}, "Buckingham A" },
{ "-B", FALSE, etREAL, {&Bbh}, "Buckingham B" },
{ "-C", FALSE, etREAL, {&Cbh}, "Buckingham C" },
{ "-qi", FALSE, etREAL, {&qi}, "qi" },
{ "-qj", FALSE, etREAL, {&qj}, "qj" },
- { "-sigfac", FALSE, etREAL, {&sigfac}, "Factor in front of sigma for starting the plot" }
+ { "-sigfac", FALSE, etREAL, {&sigfac}, "Factor in front of [GRK]sigma[grk] for starting the plot" }
};
t_filenm fnm[] = {
{ efXVG, "-o", "potje", ffWRITE }
int nat,i,j,d,v,vec,nfr,nframes=0,snew_size,frame;
t_trxstatus *out=NULL;
t_trxstatus *status;
- int noutvec_extr,*imin,*imax;
+ int noutvec_extr,imin,imax;
+ real *pmin,*pmax;
atom_id *all_at;
matrix box;
rvec *xread,*x;
}
if (extremefile) {
+ snew(pmin,noutvec_extr);
+ snew(pmax,noutvec_extr);
if (extreme==0) {
fprintf(stderr,"%11s %17s %17s\n","eigenvector","Minimum","Maximum");
fprintf(stderr,
- "%11s %10s %10s %10s %10s\n","","value","time","value","time");
- snew(imin,noutvec_extr);
- snew(imax,noutvec_extr);
+ "%11s %10s %10s %10s %10s\n","","value","frame","value","frame");
+ imin = 0;
+ imax = 0;
for(v=0; v<noutvec_extr; v++) {
for(i=0; i<nframes; i++) {
- if (inprod[v][i]<inprod[v][imin[v]])
- imin[v]=i;
- if (inprod[v][i]>inprod[v][imax[v]])
- imax[v]=i;
+ if (inprod[v][i]<inprod[v][imin])
+ imin = i;
+ if (inprod[v][i]>inprod[v][imax])
+ imax = i;
}
- min=inprod[v][imin[v]];
- max=inprod[v][imax[v]];
- fprintf(stderr,"%7d %10.6f %10.1f %10.6f %10.1f\n",
+ pmin[v] = inprod[v][imin];
+ pmax[v] = inprod[v][imax];
+ fprintf(stderr,"%7d %10.6f %10d %10.6f %10d\n",
eignr[outvec[v]]+1,
- min,inprod[noutvec][imin[v]],max,inprod[noutvec][imax[v]]);
+ pmin[v],imin,pmax[v],imax);
}
}
else {
- min=-extreme;
- max=+extreme;
+ pmin[0] = -extreme;
+ pmax[0] = extreme;
}
/* build format string for filename: */
strcpy(str,extremefile);/* copy filename */
for(i=0; i<natoms; i++)
for(d=0; d<DIM; d++)
xread[index[i]][d] =
- (xav[i][d] + (min*(nextr-frame-1)+max*frame)/(nextr-1)
+ (xav[i][d] + (pmin[v]*(nextr-frame-1)+pmax[v]*frame)/(nextr-1)
*eigvec[outvec[v]][i][d]/sqrtm[i]);
write_trx(out,natoms,index,atoms,0,frame,topbox,xread,NULL,NULL);
}
close_trx(out);
}
+ sfree(pmin);
+ sfree(pmax);
}
fprintf(stderr,"\n");
}
}
if (bEntropy) {
+ if (bDMA1) {
+ gmx_fatal(FARGS,"Can not calculate entropies from mass-weighted eigenvalues, redo the analysis without mass-weighting");
+ }
calc_entropy_qh(stdout,neig1,eigval1,temp,nskip);
calc_entropy_schlitter(stdout,neig1,nskip,eigval1,temp);
}
"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 [GRK]pi[grk] t) dt)^2 / int0-T y(t) y(t) dt[BR]",
+ "[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][BR]",
"This is useful for principal components obtained from covariance",
"analysis, since the principal components of random diffusion are",
"pure cosines.[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)).",
+ "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:[BR]",
- "f(t) = [GRK]sigma[grk][TT]*[tt]sqrt(2/T ( [GRK]alpha[grk] ([GRK]tau[grk]1 ((exp(-t/[GRK]tau[grk]1) - 1) [GRK]tau[grk]1/t + 1)) +[BR]",
- " (1-[GRK]alpha[grk]) ([GRK]tau[grk]2 ((exp(-t/[GRK]tau[grk]2) - 1) [GRK]tau[grk]2/t + 1)))),[BR]"
+ "[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)) +[BR]",
+ " (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],[BR]"
"where T is the total time.",
- "[GRK]alpha[grk], [GRK]tau[grk]1 and [GRK]tau[grk]2 are obtained by fitting f^2(t) to error^2.",
+ "[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 [GRK]sigma[grk][TT]*[tt]sqrt(2/T (a [GRK]tau[grk]1 + (1-a) [GRK]tau[grk]2)).",
+ "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]-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",
+ "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",
{ "-e", FALSE, etREAL, {&te},
"Last time to read from set" },
{ "-n", FALSE, etINT, {&nsets_in},
- "Read # sets separated by &" },
+ "Read this number of sets separated by &" },
{ "-d", FALSE, etBOOL, {&bDer},
"Use the derivative" },
{ "-dp", FALSE, etINT, {&d},
- "HIDDENThe derivative is the difference over # points" },
+ "HIDDENThe derivative is the difference over this number of points" },
{ "-bw", FALSE, etREAL, {&binwidth},
"Binwidth for the distribution" },
{ "-errbar", FALSE, etENUM, {avbar_opt},
{ "-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 [GRK]chi[grk]^2 = (y - A0 x0 - A1 x1 - ... - AN xN)^2 where now Y is the first data set in the input file and xi the others. Do read the information at the option [TT]-time[tt]." },
+ "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)." },
{ "-temp", FALSE, etREAL, {&temp},
- "Temperature for the Luzar hydrogen bonding kinetics analysis" },
+ "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]" },
{ "-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/[GRK]tau[grk])" },
+ "If this value is >= 0, the tail of the ACF will be smoothed by fitting it to an exponential function: [MATH]y = A [EXP]-x/[GRK]tau[grk][exp][math]" },
{ "-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/#)" },
+ " a factor 2^(1/resol)" },
{ "-eeexpfit", FALSE, etBOOL, {&bEESEF},
"HIDDENAlways use a single exponential fit for the error estimate" },
{ "-eenlc", FALSE, etBOOL, {&bEENLC},
{ "-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 #" },
+ "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},
{ "-blen", FALSE, etREAL, {&blen},
"Bond length. By default length of first bond" },
{ "-tol", FALSE, etREAL, {&tol},
- "Half width of distribution as fraction of blen" },
+ "Half width of distribution as fraction of [TT]-blen[tt]" },
{ "-aver", FALSE, etBOOL, {&bAver},
"Average bond length distributions" },
{ "-averdist", FALSE, etBOOL, {&bAverDist},
"The distributions [TT](histo-(dihedral)(RESIDUE).xvg[tt]) are cumulative over all residues of each type.[PAR]",
"If option [TT]-corr[tt] is given, the program will",
"calculate dihedral autocorrelation functions. The function used",
- "is C(t) = < cos([GRK]chi[grk]([GRK]tau[grk])) cos([GRK]chi[grk]([GRK]tau[grk]+t)) >. The use of cosines",
+ "is C(t) = [CHEVRON][COS][GRK]chi[grk]([GRK]tau[grk])[cos] [COS][GRK]chi[grk]([GRK]tau[grk]+t)[cos][chevron]. The use of cosines",
"rather than angles themselves, resolves the problem of periodicity.",
"(Van der Spoel & Berendsen (1997), Biophys. J. 72, 2032-2041).",
"Separate files for each dihedral of each residue",
"rotamers per nanosecond, and the order parameter S^2 of each dihedral.[BR]",
"(d) a table for each residue of the rotamer occupancy.[PAR]",
"All rotamers are taken as 3-fold, except for [GRK]omega[grk] and [GRK]chi[grk] dihedrals",
- "to planar groups (i.e. [GRK]chi[grk]2 of aromatics, Asp and Asn; [GRK]chi[grk]3 of Glu",
- "and Gln; and [GRK]chi[grk]4 of Arg), which are 2-fold. \"rotamer 0\" means ",
+ "to planar groups (i.e. [GRK]chi[grk][SUB]2[sub] of aromatics, Asp and Asn; [GRK]chi[grk][SUB]3[sub] of Glu",
+ "and Gln; and [GRK]chi[grk][SUB]4[sub] of Arg), which are 2-fold. \"rotamer 0\" means ",
"that the dihedral was not in the core region of each rotamer. ",
"The width of the core region can be set with [TT]-core_rotamer[tt][PAR]",
"are equally spaced in time.[PAR]",
"If [TT]-chi_prod[tt] is set (and [TT]-maxchi[tt] > 0), cumulative rotamers, e.g.",
- "1+9([GRK]chi[grk]1-1)+3([GRK]chi[grk]2-1)+([GRK]chi[grk]3-1) (if the residue has three 3-fold ",
+ "1+9([GRK]chi[grk][SUB]1[sub]-1)+3([GRK]chi[grk][SUB]2[sub]-1)+([GRK]chi[grk][SUB]3[sub]-1) (if the residue has three 3-fold ",
"dihedrals and [TT]-maxchi[tt] >= 3)",
"are calculated. As before, if any dihedral is not in the core region,",
"the rotamer is taken to be 0. The occupancies of these cumulative ",
{ "-omega",FALSE, etBOOL, {&bOmega},
"Output for [GRK]omega[grk] dihedrals (peptide bonds)" },
{ "-rama", FALSE, etBOOL, {&bRama},
- "Generate [GRK]phi[grk]/[GRK]psi[grk] and [GRK]chi[grk]1/[GRK]chi[grk]2 Ramachandran plots" },
+ "Generate [GRK]phi[grk]/[GRK]psi[grk] and [GRK]chi[grk][SUB]1[sub]/[GRK]chi[grk][SUB]2[sub] Ramachandran plots" },
{ "-viol", FALSE, etBOOL, {&bViol},
"Write a file that gives 0 or 1 for violated Ramachandran angles" },
{ "-periodic", FALSE, etBOOL, {&bPBC},
{ "-normhisto", FALSE, etBOOL, {&bNormHisto},
"Normalize histograms" },
{ "-ramomega",FALSE,etBOOL, {&bRamOmega},
- "compute average omega as a function of phi/psi and plot it in an [TT].xpm[tt] plot" },
+ "compute average omega as a function of [GRK]phi[grk]/[GRK]psi[grk] and plot it in an [TT].xpm[tt] plot" },
{ "-bfact", FALSE, etREAL, {&bfac_init},
"B-factor value for [TT].pdb[tt] file for atoms with no calculated dihedral order parameter"},
{ "-chi_prod",FALSE,etBOOL, {&bChiProduct},
{ "-dista", FALSE, etBOOL, {&bRMSdist},
"Use RMSD of distances instead of RMS deviation" },
{ "-nlevels",FALSE,etINT, {&nlevels},
- "Discretize RMSD matrix in # levels" },
+ "Discretize RMSD matrix in this number of levels" },
{ "-cutoff",FALSE, etREAL, {&rmsdcut},
"RMSD cut-off (nm) for two structures to be neighbor" },
{ "-fit", FALSE, etBOOL, {&bFit},
{ "-av", FALSE, etBOOL, {&bAverage},
"Write average iso middle structure for each cluster" },
{ "-wcl", FALSE, etINT, {&write_ncl},
- "Write all structures for first # clusters to numbered files" },
+ "Write the structures for this number of clusters to numbered files" },
{ "-nst", FALSE, etINT, {&write_nst},
- "Only write all structures if more than # per cluster" },
+ "Only write all structures if more than this number of structures per cluster" },
{ "-rmsmin",FALSE, etREAL, {&rmsmin},
"minimum rms difference with rest of cluster for writing structures" },
{ "-method",FALSE, etENUM, {methodname},
* cluster cj and if so, put them in ci
*/
for(k=0; (k<nindex); k++) {
- if ((clust_index[k] == cj)) {
+ if (clust_index[k] == cj) {
if (clust_size[cj] <= 0)
gmx_fatal(FARGS,"negative cluster size %d for element %d",
clust_size[cj],cj);
{ "-nojump", FALSE, etBOOL, {&bNoJump},
"Removes jumps of atoms across the box."},
{ "-eps", FALSE, etREAL, {&eps_rf},
- "Dielectric constant of the surrounding medium. eps=0.0 corresponds to eps=infinity (tin-foil boundary conditions)."},
+ "Dielectric constant of the surrounding medium. The value zero corresponds to infinity (tin-foil boundary conditions)."},
{ "-bfit", FALSE, etREAL, {&bfit},
"Begin of the fit of the straight line to the MSD of the translational fraction of the dipole moment."},
{ "-efit", FALSE, etREAL, {&efit},
"Option [TT]-temp[tt] sets the temperature required for the computation of the static dielectric constant.",
"[PAR]",
"Option [TT]-eps[tt] controls the dielectric constant of the surrounding medium for simulations using",
- "a Reaction Field or dipole corrections of the Ewald summation (eps=0 corresponds to",
+ "a Reaction Field or dipole corrections of the Ewald summation ([TT]-eps[tt]=0 corresponds to",
"tin-foil boundary conditions).",
"[PAR]",
"[TT]-[no]nojump[tt] unfolds the coordinates to allow free diffusion. This is required to get a continuous",
{ "-d", FALSE, etSTR, {&axtitle},
"Take the normal on the membrane in direction X, Y or Z." },
{ "-sl", FALSE, etINT, {&nslices},
- "Divide the box in #nr slices." },
+ "Divide the box in this number of slices." },
{ "-dens", FALSE, etENUM, {dens_opt},
"Density"},
{ "-ng", FALSE, etINT, {&ngrps},
- "Number of groups to compute densities of" },
+ "Number of groups of which to compute densities." },
{ "-symm", FALSE, etBOOL, {&bSymmetrize},
"Symmetrize the density along the axis, with respect to the center. Useful for bilayers." },
{ "-center", FALSE, etBOOL, {&bCenter},
"from the autocorrelation function of the total dipole moment in",
"your simulation. This ACF can be generated by [TT]g_dipoles[tt].",
"The functional forms of the available functions are:[PAR]",
- "One parameter: y = Exp[-a1 x],[BR]",
- "Two parameters: y = a2 Exp[-a1 x],[BR]",
- "Three parameters: y = a2 Exp[-a1 x] + (1 - a2) Exp[-a3 x].[BR]",
+ "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]",
+ "Three parameters: y = a[SUB]2[sub] [EXP]-a[SUB]1[sub] x[exp] + (1 - a[SUB]2[sub]) [EXP]-a[SUB]3[sub] x[exp].[BR]",
"Start values for the fit procedure can be given on the command line.",
"It is also possible to fix parameters at their start value, use [TT]-fix[tt]",
"with the number of the parameter you want to fix.",
"center of mass of the molecule.[PAR]",
"The file [TT]Mtot.xvg[tt] contains the total dipole moment of a frame, the",
"components as well as the norm of the vector.",
- "The file [TT]aver.xvg[tt] contains < |Mu|^2 > and |< Mu >|^2 during the",
+ "The file [TT]aver.xvg[tt] contains [CHEVRON][MAG][GRK]mu[grk][mag]^2[chevron] and [MAG][CHEVRON][GRK]mu[grk][chevron][mag]^2 during the",
"simulation.",
"The file [TT]dipdist.xvg[tt] contains the distribution of dipole moments during",
"the simulation",
"dipoles using a first order Legendre polynomial of the angle of the",
"dipole vector and itself a time t later. For this calculation 1001",
"frames will be used. Further, the dielectric constant will be calculated",
- "using an [GRK]epsilon[grk]RF of infinity (default), temperature of 300 K (default) and",
+ "using an [TT]-epsilonRF[tt] of infinity (default), temperature of 300 K (default) and",
"an average dipole moment of the molecule of 2.273 (SPC). For the",
"distribution function a maximum of 5.0 will be used."
};
{ "-mumax", FALSE, etREAL, {&mu_max},
"max dipole in Debye (for histogram)" },
{ "-epsilonRF",FALSE, etREAL, {&epsilonRF},
- "epsilon of the reaction field used during the simulation, needed for dielectric constant calculation. WARNING: 0.0 means infinity (default)" },
+ "[GRK]epsilon[grk] of the reaction field used during the simulation, needed for dielectric constant calculation. WARNING: 0.0 means infinity (default)" },
{ "-skip", FALSE, etINT, {&skip},
"Skip steps in the output (but not in the computations)" },
{ "-temp", FALSE, etREAL, {&temp},
{ "-corr", FALSE, etENUM, {corrtype},
"Correlation function to calculate" },
{ "-pairs", FALSE, etBOOL, {&bPairs},
- "Calculate |cos [GRK]theta[grk]| between all pairs of molecules. May be slow" },
+ "Calculate [MAG][COS][GRK]theta[grk][cos][mag] between all pairs of molecules. May be slow" },
{ "-ncos", FALSE, etINT, {&ncos},
- "Must be 1 or 2. Determines whether the <cos> is computed between all molecules in one group, or between molecules in two different groups. This turns on the [TT]-gkr[tt] flag." },
+ "Must be 1 or 2. Determines whether the [CHEVRON][COS][GRK]theta[grk][cos][chevron] is computed between all molecules in one group, or between molecules in two different groups. This turns on the [TT]-g[tt] flag." },
{ "-axis", FALSE, etSTR, {&axtitle},
"Take the normal on the computational box in direction X, Y or Z." },
{ "-sl", FALSE, etINT, {&nslices},
- "Divide the box in #nr slices." },
+ "Divide the box into this number of slices." },
{ "-gkratom", FALSE, etINT, {&nFA},
"Use the n-th atom of a molecule (starting from 1) to calculate the distance between molecules rather than the center of charge (when 0) in the calculation of distance dependent Kirkwood factors" },
{ "-gkratom2", FALSE, etINT, {&nFB},
{ visbox },
"HIDDENVisualize a grid of boxes, -1 visualizes the 14 box images" },
{ "-bt", FALSE, etENUM,
- { btype }, "Box type for -box and -d" },
+ { btype }, "Box type for [TT]-box[tt] and [TT]-d[tt]" },
{ "-box", FALSE, etRVEC,
{ newbox }, "Box vector lengths (a,b,c)" },
{ "-angles", FALSE, etRVEC,
{ &dist }, "Distance between the solute and the box" },
{ "-c", FALSE, etBOOL,
{ &bCenter },
- "Center molecule in box (implied by -box and -d)" },
+ "Center molecule in box (implied by [TT]-box[tt] and [TT]-d[tt])" },
{ "-center", FALSE, etRVEC,
{ center }, "Coordinates of geometrical center" },
{ "-aligncenter", FALSE, etRVEC,
"Default Van der Waals radius (in nm) if one can not be found in the database or if no parameters are present in the topology file" },
{ "-sig56", FALSE, etREAL,
{ &bSig56 },
- "Use rmin/2 (minimum in the Van der Waals potential) rather than sigma/2 " },
+ "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 vdwradii.dat rather than computing the radii based on the force field" },
+ "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,
"calculated ([TT]-etot[tt]).[PAR]",
"An approximation of the free energy can be calculated using:",
- "E(free) = E0 + kT log( <exp((E-E0)/kT)> ), where '<>'",
+ "[MATH]E[SUB]free[sub] = E[SUB]0[sub] + kT [LOG][CHEVRON][EXP](E-E[SUB]0[sub])/kT[exp][chevron][log][math], where '[MATH][CHEVRON][chevron][math]'",
"stands for time-average. A file with reference free energies",
"can be supplied to calculate the free energy difference",
"with some reference state. Group names (e.g. residue names)",
"will be computed:[BR]",
"Property Energy terms needed[BR]",
"---------------------------------------------------[BR]",
- "Heat capacity Cp (NPT sims): Enthalpy, Temp [BR]",
- "Heat capacity Cv (NVT sims): Etot, Temp [BR]",
+ "Heat capacity C[SUB]p[sub] (NPT sims): Enthalpy, Temp [BR]",
+ "Heat capacity C[SUB]v[sub] (NVT sims): Etot, Temp [BR]",
"Thermal expansion coeff. (NPT): Enthalpy, Vol, Temp[BR]",
"Isothermal compressibility: Vol, Temp [BR]",
"Adiabatic bulk modulus: Vol, Temp [BR]",
"---------------------------------------------------[BR]",
"You always need to set the number of molecules [TT]-nmol[tt].",
- "The Cp/Cv computations do [BB]not[bb] include any corrections",
+ "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]"
"When the [TT]-viol[tt] option is set, the time averaged",
"violations are plotted and the running time-averaged and",
"With [TT]-fee[tt] an estimate is calculated for the free-energy",
"difference with an ideal gas state: [BR]",
- " [GRK]Delta[grk] A = A(N,V,T) - A_idgas(N,V,T) = kT ln < e^(Upot/kT) >[BR]",
- " [GRK]Delta[grk] G = G(N,p,T) - G_idgas(N,p,T) = kT ln < e^(Upot/kT) >[BR]",
+ " [GRK]Delta[grk] A = A(N,V,T) - A[SUB]idealgas[sub](N,V,T) = kT [LN][CHEVRON][EXP]U[SUB]pot[sub]/kT[exp][chevron][ln][BR]",
+ " [GRK]Delta[grk] G = G(N,p,T) - G[SUB]idealgas[sub](N,p,T) = kT [LN][CHEVRON][EXP]U[SUB]pot[sub]/kT[exp][chevron][ln][BR]",
"where k is Boltzmann's constant, T is set by [TT]-fetemp[tt] and",
"the average is over the ensemble (or time in a trajectory).",
"Note that this is in principle",
"only correct when averaging over the whole (Boltzmann) ensemble",
"and using the potential energy. This also allows for an entropy",
"estimate using:[BR]",
- " [GRK]Delta[grk] S(N,V,T) = S(N,V,T) - S_idgas(N,V,T) = (<Upot> - [GRK]Delta[grk] A)/T[BR]",
- " [GRK]Delta[grk] S(N,p,T) = S(N,p,T) - S_idgas(N,p,T) = (<Upot> + pV - [GRK]Delta[grk] G)/T",
+ " [GRK]Delta[grk] S(N,V,T) = S(N,V,T) - S[SUB]idealgas[sub](N,V,T) = ([CHEVRON]U[SUB]pot[sub][chevron] - [GRK]Delta[grk] A)/T[BR]",
+ " [GRK]Delta[grk] S(N,p,T) = S(N,p,T) - S[SUB]idealgas[sub](N,p,T) = ([CHEVRON]U[SUB]pot[sub][chevron] + pV - [GRK]Delta[grk] G)/T",
"[PAR]",
"When a second energy file is specified ([TT]-f2[tt]), a free energy",
- "difference is calculated dF = -kT ln < e ^ -(EB-EA)/kT >A ,",
- "where EA and EB are the energies from the first and second energy",
+ "difference is calculated [BR] dF = -kT [LN][CHEVRON][EXP]-(E[SUB]B[sub]-E[SUB]A[sub])/kT[exp][chevron][SUB]A[sub][ln] ,",
+ "where E[SUB]A[sub] and E[SUB]B[sub] are the energies from the first and second energy",
"files, and the average is over the ensemble A. The running average",
"of the free energy difference is printed to a file specified by [TT]-ravg[tt].",
"[BB]Note[bb] that the energies must both be calculated from the same trajectory."
output_env_t oenv;
t_pargs pa[] = {
{ "-box", FALSE, etRVEC, {new_box},
- "box size" },
+ "Box size" },
{ "-nmol", FALSE, etINT , {&nmol_ins},
- "no of extra molecules to insert" },
+ "Number of extra molecules to insert" },
{ "-try", FALSE, etINT , {&nmol_try},
- "try inserting [TT]-nmol[tt] times [TT]-try[tt] times" },
+ "Try inserting [TT]-nmol[tt] times [TT]-try[tt] times" },
{ "-seed", FALSE, etINT , {&seed},
- "random generator seed"},
+ "Random generator seed"},
{ "-vdwd", FALSE, etREAL, {&r_distance},
- "default vdwaals distance"},
+ "Default van der Waals distance"},
{ "-shell", FALSE, etREAL, {&r_shell},
- "thickness of optional water layer around solute" },
+ "Thickness of optional water layer around solute" },
{ "-maxsol", FALSE, etINT, {&max_sol},
- "maximum number of solvent molecules to add if they fit in the box. If zero (default) this is ignored" },
+ "Maximum number of solvent molecules to add if they fit in the box. If zero (default) this is ignored" },
{ "-vel", FALSE, etBOOL, {&bReadV},
- "keep velocities from input solute and solvent" }
+ "Keep velocities from input solute and solvent" }
};
CopyRight(stderr,argv[0]);
t_pargs pa[] = {
{ "-fc", FALSE, etRVEC, {fc},
- "force constants (kJ/mol nm^2)" },
+ "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" },
+ "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},
{ "-moi", FALSE, etBOOL, {&bMOI},
"Calculate the moments of inertia (defined by the principal axes)." },
{ "-nz", FALSE, etINT, {&nz},
- "Calculate the 2D radii of gyration of # slices along the z-axis" },
+ "Calculate the 2D radii of gyration of this number of slices along the z-axis" },
};
FILE *out;
t_trxstatus *status;
"Take the normal on the membrane in direction X, Y or Z." },
{ "-sl", FALSE, etINT, {&nslices},
"Calculate order parameter as function of boxlength, dividing the box"
- " in #nr slices."}
+ " in this number of slices."}
};
const char *bugs[] = {
"The program assigns whole water molecules to a slice, based on the first "
"Then the following properties are computed:[PAR]",
"[BB]1.[bb] Helix radius (file [TT]radius.xvg[tt]). This is merely the",
"RMS deviation in two dimensions for all C[GRK]alpha[grk] atoms.",
- "it is calced as sqrt((SUM i(x^2(i)+y^2(i)))/N), where N is the number",
+ "it is calculated as [SQRT]([SUM][sum][SUB]i[sub] (x^2(i)+y^2(i)))/N[sqrt] where N is the number",
"of backbone atoms. For an ideal helix the radius is 0.23 nm[BR]",
"[BB]2.[bb] Twist (file [TT]twist.xvg[tt]). The average helical angle per",
"residue is calculated. For an [GRK]alpha[grk]-helix it is 100 degrees,",
{ "-T", FALSE, etREAL, {&tref},
"Reference temperature for computing rate constants" },
{ "-n", FALSE, etINT, {&nreplica},
- "Read data for # replicas. Only necessary when files are written in xmgrace format using @type and & as delimiters." },
+ "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},
{ "-t", FALSE, etREAL, {&truncate},
"trunc distance" },
{ "-nlevels", FALSE, etINT, {&nlevels},
- "Discretize distance in # levels" }
+ "Discretize distance in this number of levels" }
};
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{
if(fflush(fplog) != 0)
{
- gmx_fatal(FARGS,"Cannot flush logfile - maybe you are out of quota?");
+ gmx_fatal(FARGS,"Cannot flush logfile - maybe you are out of disk space?");
}
}
}
{ "-multi", FALSE, etINT,{&nmultisim},
"HIDDENDo multiple simulations in parallel" },
{ "-replex", FALSE, etINT, {&repl_ex_nst},
- "HIDDENAttempt replica exchange every # steps" },
+ "HIDDENAttempt replica exchange periodically with this period (steps)" },
{ "-reseed", FALSE, etINT, {&repl_ex_seed},
"HIDDENSeed for replica exchange, -1 is generate a seed" },
{ "-rerunvsite", FALSE, etBOOL, {&bRerunVSite},
"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 x1 to x2. In general, the coordinates",
- "of the intermediate x(i) out of N total intermidates correspond to:[PAR]",
- "x(i) = x1 + (first+(i/(N-1))*(last-first))*(x2-x1)[PAR]",
+ "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."
{ "-ninterm", FALSE, etINT, {&ninterm},
"Number of intermediates" },
{ "-first", FALSE, etREAL, {&first},
- "Corresponds to first generated structure (0 is input x0, see above)" },
+ "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 x1, see above)" },
+ "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" }
};
{
{ "-eignr", FALSE, etSTR, {&eignrvec}, "String of eigenvectors to use (first is 1)" },
{ "-phases", FALSE, etSTR, {&phasevec}, "String of phases (default is 0.0)" },
- { "-temp", FALSE, etREAL, {&temp}, "Temperature in Kelvin" },
+ { "-temp", FALSE, etREAL, {&temp}, "Temperature (K)" },
{ "-amplitude", FALSE, etREAL, {&refamplitude}, "Amplitude for modes with eigenvalue<=0" },
{ "-nframes", FALSE, etINT, {&nframes}, "Number of frames to generate" }
};
"Direction of the normal on the membrane" },
{ "-sl", FALSE, etINT, {&nslices},
"Calculate order parameter as function of box length, dividing the box"
- " in #nr slices." },
+ " 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},
"Take the normal on the membrane in direction X, Y or Z." },
{ "-sl", FALSE, etINT, {&nslices},
"Calculate potential as function of boxlength, dividing the box"
- " in #nr slices." } ,
+ " in this number of slices." } ,
{ "-cb", FALSE, etINT, {&cb},
- "Discard first #nr slices of box for integration" },
+ "Discard this number of first slices of box for integration" },
{ "-ce", FALSE, etINT, {&ce},
- "Discard last #nr slices of box for integration" },
+ "Discard this number of last slices of box for integration" },
{ "-tz", FALSE, etREAL, {&fudge_z},
- "Translate all coordinates <distance> in the direction of the box" },
+ "Translate all coordinates by this distance in the direction of the box" },
{ "-spherical", FALSE, etBOOL, {&bSpherical},
"Calculate spherical thingie" },
{ "-ng", FALSE, etINT, {&ngrps},
t_pargs pa[] = {
{ "-nlevels", FALSE, etINT, {&nlevels},
- "Discretize rms in # levels" },
+ "Discretize RMS in this number of levels" },
{ "-max", FALSE, etREAL, {&scalemax},
"Maximum level in matrices" },
{ "-sumh", FALSE, etBOOL, {&bSumH},
- "average distance over equivalent hydrogens" },
+ "Average distance over equivalent hydrogens" },
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Use periodic boundary conditions when computing distances" }
};
static real truncate=1000.0;
t_pargs pa[] = {
{ "-t", FALSE, etREAL, {&truncate},
- "trunc distance" },
+ "Groups that are never closer than this distance are not plotted" },
{ "-sep", FALSE, etBOOL, {&bSep},
"Use separate files for each interaction (may be MANY)" }
};
{ "-ttol", FALSE, etREAL, {&ttol},
"Tolerance on time in appropriate units (usually ps)" },
{ "-n", FALSE, etINT, {&nsets_in},
- "Read # sets separated by &" },
+ "Read this number of sets separated by lines containing only an ampersand" },
{ "-d", FALSE, etBOOL, {&bDer},
"Use the derivative" },
{ "-bw", FALSE, etREAL, {&binwidth},
"[TT]g_sorient[tt] 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]1: the angle with the vector from the first atom of the solvent",
+ "[GRK]theta[grk][SUB]1[sub]: the angle with the vector from the first atom of the solvent",
"molecule to the midpoint between atoms 2 and 3.[BR]",
- "[GRK]theta[grk]2: the angle with the normal of the solvent plane, defined by the",
+ "[GRK]theta[grk][SUB]2[sub]: the angle with the normal of the solvent plane, defined by the",
"same three atoms, or, when the option [TT]-v23[tt] is set, ",
"the angle with the vector between atoms 2 and 3.[PAR]",
"The reference can be a set of atoms or",
"consist of 3 atoms per solvent molecule.",
"Only solvent molecules between [TT]-rmin[tt] and [TT]-rmax[tt] are",
"considered for [TT]-o[tt] and [TT]-no[tt] each frame.[PAR]",
- "[TT]-o[tt]: distribtion of cos([GRK]theta[grk]1) for rmin<=r<=rmax.[PAR]",
- "[TT]-no[tt]: distribution of cos([GRK]theta[grk]2) for rmin<=r<=rmax.[PAR]",
- "[TT]-ro[tt]: <cos([GRK]theta[grk]1)> and <3cos^2([GRK]theta[grk]2)-1> as a function of the",
+ "[TT]-o[tt]: distribtion of [MATH][COS][GRK]theta[grk][SUB]1[sub][cos][math] for rmin<=r<=rmax.[PAR]",
+ "[TT]-no[tt]: distribution of [MATH][COS][GRK]theta[grk][SUB]2[sub][cos][math] for rmin<=r<=rmax.[PAR]",
+ "[TT]-ro[tt]: [MATH][CHEVRON][COS][GRK]theta[grk][SUB]1[sub][cos][chevron][math] and [MATH][CHEVRON]3[COS]^2[GRK]theta[grk][SUB]2[sub][cos]-1[chevron][math] as a function of the",
"distance.[PAR]",
"[TT]-co[tt]: the sum over all solvent molecules within distance r",
- "of cos([GRK]theta[grk]1) and 3cos^2([GRK]theta[grk]2)-1 as a function of r.[PAR]",
+ "of [MATH][COS][GRK]theta[grk][SUB]1[sub][cos][math] and [MATH]3[COS]^2([GRK]theta[grk][SUB]2[sub])-1[cos][math] as a function of r.[PAR]",
"[TT]-rc[tt]: the distribution of the solvent molecules as a function of r"
};
/* { "-cut", bCUTDOWN, etBOOL, {&bCUTDOWN},*/
/* "Display a total cube that is of minimal size" }, */
{ "-bin", FALSE, etREAL, {&rBINWIDTH},
- "Width of the bins in nm" },
+ "Width of the bins (nm)" },
{ "-nab", FALSE, etINT, {&iNAB},
"Number of additional bins to ensure proper memory allocation" }
};
do_view(oenv,fn_tc,"-nxy");
if (fn_cub) {
- fp_cub = xvgropen(fn_cub,"TCAF's and fits", "Time (ps)","TCAF",oenv);
+ fp_cub = xvgropen(fn_cub,"TCAFs and fits", "Time (ps)","TCAF",oenv);
for(kc=0; kc<nkc; kc++) {
fprintf(fp_cub,"%g %g\n",0.0,1.0);
for(i=1; i<ncorr; i++) {
"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 TCAF's. Each of",
- "these TCAF's is fitted to f(t) = exp(-v)(cosh(Wv) + 1/W sinh(Wv)),",
- "v = -t/(2 [GRK]tau[grk]), W = sqrt(1 - 4 [GRK]tau[grk] [GRK]eta[grk]/[GRK]rho[grk] k^2), which gives 16 values of [GRK]tau[grk]",
- "and [GRK]eta[grk]. The fit weights decay with time as exp(-t/wt), and the TCAF and",
- "fit are calculated up to time 5*wt.",
- "The [GRK]eta[grk] values should be fitted to 1 - a [GRK]eta[grk](k) k^2, from which",
+ "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 TCAF's over all k-vectors with the same length.",
- "This results in more accurate tcaf's.",
- "Both the cubic TCAF's and fits are written to [TT]-oc[tt]",
+ "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 [GRK]eta[grk](k) = [GRK]eta[grk]0 (1 - a k^2) to obtain the viscosity at",
+ "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",
static real wt=5;
t_pargs pa[] = {
{ "-mol", FALSE, etBOOL, {&bMol},
- "Calculate tcaf of molecules" },
+ "Calculate TCAF of molecules" },
{ "-k34", FALSE, etBOOL, {&bK34},
"Also use k=(3,0,0) and k=(4,0,0)" },
{ "-wt", FALSE, etREAL, {&wt},
{ "-multi", FALSE, etINT, {&nmultisim},
"Do multiple simulations in parallel" },
{ "-replex", FALSE, etINT, {&repl_ex_nst},
- "Attempt replica exchange every # steps" },
+ "Attempt replica exchange periodically with this period (steps)" },
{ "-reseed", FALSE, etINT, {&repl_ex_seed},
"Seed for replica exchange, -1 is generate a seed" },
{ "-rerunvsite", FALSE, etBOOL, {&bRerunVSite},
{
const char *desc[] = {
"[TT]g_vanhove[tt] 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.",
+ "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.",
"Thus it gives the probability that a particle moves a distance of r",
"in time t.",
"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]).",
+ "of t and r or as a function of [SQRT]t[sqrt] 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,",
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)" },
+ "Use [SQRT]t[sqrt] 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},
fprintf(stderr,"There are %d complete backbone residues (from %d to %d)\n",
rnr,bb[i0].resno,bb[i1].resno);
if (rnr==0)
- gmx_fatal(FARGS,"rnr==0");
+ gmx_fatal(FARGS,"Zero complete backbone residues were found, cannot proceed");
for(i=0; (i<rnr); i++,i0++)
bb[i]=bb[i0];
{ "-hyd", FALSE, etBOOL, {&bH},
"Include angles with atoms with mass < 1.5" },
{ "-hq", FALSE, etREAL, {&hq},
- "Ignore angles with atoms with mass < 1.5 and |q| < hq" }
+ "Ignore angles with atoms with mass < 1.5 and magnitude of their charge less than this value" }
};
output_env_t oenv;
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff