int gmx_genpr(int argc,char *argv[])
{
const char *desc[] = {
"[TT]genrestr[tt] produces an include file for a topology containing",
"a list of atom numbers and three force constants for the",
"[IT]x[it]-, [IT]y[it]-, and [IT]z[it]-direction. A single isotropic force constant may",
"be given on the command line instead of three components.[PAR]",
"WARNING: position restraints only work for the one molecule at a time.",
"Position restraints are interactions within molecules, therefore",
"they should be included within the correct [TT][ moleculetype ][tt]",
"block in the topology. Since the atom numbers in every moleculetype",
"in the topology start at 1 and the numbers in the input file for",
"[TT]genrestr[tt] number consecutively from 1, [TT]genrestr[tt] will only",
"produce a useful file for the first molecule.[PAR]",
"The [TT]-of[tt] option produces an index file that can be used for",
"freezing atoms. In this case, the input file must be a [TT].pdb[tt] file.[PAR]",
"With the [TT]-disre[tt] option, half a matrix of distance restraints",
"is generated instead of position restraints. With this matrix, that",
"one typically would apply to C[GRK]alpha[grk] atoms in a protein, one can",
"maintain the overall conformation of a protein without tieing it to",
"a specific position (as with position restraints)."
};
static rvec fc={1000.0,1000.0,1000.0};
static real freeze_level = 0.0;
static real disre_dist = 0.1;
static real disre_frac = 0.0;
static real disre_up2 = 1.0;
static gmx_bool bDisre=FALSE;
static gmx_bool bConstr=FALSE;
static real cutoff = -1.0;
t_pargs pa[] = {
{ "-fc", FALSE, etRVEC, {fc},
"force constants (kJ/mol nm^2)" },
{ "-freeze", FALSE, etREAL, {&freeze_level},
"if the [TT]-of[tt] option or this one is given an index file will be written containing atom numbers of all atoms that have a B-factor less than the level given here" },
{ "-disre", FALSE, etBOOL, {&bDisre},
"Generate a distance restraint matrix for all the atoms in index" },
{ "-disre_dist", FALSE, etREAL, {&disre_dist},
"Distance range around the actual distance for generating distance restraints" },
{ "-disre_frac", FALSE, etREAL, {&disre_frac},
"Fraction of distance to be used as interval rather than a fixed distance. If the fraction of the distance that you specify here is less than the distance given in the previous option, that one is used instead." },
{ "-disre_up2", FALSE, etREAL, {&disre_up2},
"Distance between upper bound for distance restraints, and the distance at which the force becomes constant (see manual)" },
{ "-cutoff", FALSE, etREAL, {&cutoff},
"Only generate distance restraints for atoms pairs within cutoff (nm)" },
{ "-constr", FALSE, etBOOL, {&bConstr},
"Generate a constraint matrix rather than distance restraints. Constraints of type 2 will be generated that do generate exclusions." }
};
#define npargs asize(pa)
output_env_t oenv;
t_atoms *atoms=NULL;
int i,j,k;
FILE *out;
int igrp;
real d,dd,lo,hi;
atom_id *ind_grp;
const char *xfn,*nfn;
char *gn_grp;
char title[STRLEN];
matrix box;
gmx_bool bFreeze;
rvec dx,*x=NULL,*v=NULL;
t_filenm fnm[] = {
{ efSTX, "-f", NULL, ffREAD },
{ efNDX, "-n", NULL, ffOPTRD },
{ efITP, "-o", "posre", ffWRITE },
{ efNDX, "-of", "freeze", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,0,NFILE,fnm,npargs,pa,
asize(desc),desc,0,NULL,&oenv);
bFreeze = opt2bSet("-of",NFILE,fnm) || opt2parg_bSet("-freeze",asize(pa),pa);
bDisre = bDisre || opt2parg_bSet("-disre_dist",npargs,pa);
xfn = opt2fn_null("-f",NFILE,fnm);
nfn = opt2fn_null("-n",NFILE,fnm);
if (( nfn == NULL ) && ( xfn == NULL))
gmx_fatal(FARGS,"no index file and no structure file suplied");
if ((disre_frac < 0) || (disre_frac >= 1))
gmx_fatal(FARGS,"disre_frac should be between 0 and 1");
if (disre_dist < 0)
gmx_fatal(FARGS,"disre_dist should be >= 0");
if (xfn != NULL) {
snew(atoms,1);
get_stx_coordnum(xfn,&(atoms->nr));
init_t_atoms(atoms,atoms->nr,TRUE);
snew(x,atoms->nr);
snew(v,atoms->nr);
fprintf(stderr,"\nReading structure file\n");
read_stx_conf(xfn,title,atoms,x,v,NULL,box);
}
if (bFreeze) {
if (atoms && atoms->pdbinfo)
gmx_fatal(FARGS,"No B-factors in input file %s, use a pdb file next time.",
xfn);
out=opt2FILE("-of",NFILE,fnm,"w");
fprintf(out,"[ freeze ]\n");
for(i=0; (i<atoms->nr); i++) {
if (atoms->pdbinfo[i].bfac <= freeze_level)
fprintf(out,"%d\n",i+1);
}
ffclose(out);
}
else if ((bDisre || bConstr) && x) {
printf("Select group to generate %s matrix from\n",
bConstr ? "constraint" : "distance restraint");
get_index(atoms,nfn,1,&igrp,&ind_grp,&gn_grp);
out=ftp2FILE(efITP,NFILE,fnm,"w");
if (bConstr) {
fprintf(out,"; constraints for %s of %s\n\n",gn_grp,title);
fprintf(out,"[ constraints ]\n");
fprintf(out,";%4s %5s %1s %10s\n","i","j","tp","dist");
}
else {
fprintf(out,"; distance restraints for %s of %s\n\n",gn_grp,title);
fprintf(out,"[ distance_restraints ]\n");
fprintf(out,";%4s %5s %1s %5s %10s %10s %10s %10s %10s\n","i","j","?",
"label","funct","lo","up1","up2","weight");
}
for(i=k=0; i<igrp; i++)
for(j=i+1; j<igrp; j++,k++) {
rvec_sub(x[ind_grp[i]],x[ind_grp[j]],dx);
d = norm(dx);
if (bConstr)
fprintf(out,"%5d %5d %1d %10g\n",ind_grp[i]+1,ind_grp[j]+1,2,d);
else {
if (cutoff < 0 || d < cutoff)
{
if (disre_frac > 0)
dd = min(disre_dist,disre_frac*d);
else
dd = disre_dist;
lo = max(0,d-dd);
hi = d+dd;
fprintf(out,"%5d %5d %1d %5d %10d %10g %10g %10g %10g\n",
ind_grp[i]+1,ind_grp[j]+1,1,k,1,
lo,hi,hi+1,1.0);
}
}
}
ffclose(out);
}
else {
printf("Select group to position restrain\n");
get_index(atoms,nfn,1,&igrp,&ind_grp,&gn_grp);
out=ftp2FILE(efITP,NFILE,fnm,"w");
fprintf(out,"; position restraints for %s of %s\n\n",gn_grp,title);
fprintf(out,"[ position_restraints ]\n");
fprintf(out,";%3s %5s %9s %10s %10s\n","i","funct","fcx","fcy","fcz");
for(i=0; i<igrp; i++)
fprintf(out,"%4d %4d %10g %10g %10g\n",
ind_grp[i]+1,1,fc[XX],fc[YY],fc[ZZ]);
ffclose(out);
}
if (xfn) {
sfree(x);
sfree(v);
}
thanx(stderr);
return 0;
}
int gmx_analyze(int argc,char *argv[])
{
static const char *desc[] = {
"g_analyze reads an ascii file and analyzes data sets.",
"A line in the input file may start with a time",
"(see option [TT]-time[tt]) and any number of y values may follow.",
"Multiple sets can also be",
"read when they are seperated by & (option [TT]-n[tt]),",
"in this case only one y value is read from each line.",
"All lines starting with # and @ are skipped.",
"All analyses can also be done for the derivative of a set",
"(option [TT]-d[tt]).[PAR]",
"All options, except for [TT]-av[tt] and [TT]-power[tt] assume that the",
"points are equidistant in time.[PAR]",
"g_analyze always shows the average and standard deviation of each",
"set. For each set it also shows the relative deviation of the third",
"and forth cumulant from those of a Gaussian distribution with the same",
"standard deviation.[PAR]",
"Option [TT]-ac[tt] produces the autocorrelation function(s).[PAR]",
"Option [TT]-cc[tt] plots the resemblance of set i with a cosine of",
"i/2 periods. The formula is:[BR]"
"2 (int0-T y(t) cos(i pi t) dt)^2 / int0-T y(t) y(t) dt[BR]",
"This is useful for principal components obtained from covariance",
"analysis, since the principal components of random diffusion are",
"pure cosines.[PAR]",
"Option [TT]-msd[tt] produces the mean square displacement(s).[PAR]",
"Option [TT]-dist[tt] produces distribution plot(s).[PAR]",
"Option [TT]-av[tt] produces the average over the sets.",
"Error bars can be added with the option [TT]-errbar[tt].",
"The errorbars can represent the standard deviation, the error",
"(assuming the points are independent) or the interval containing",
"90% of the points, by discarding 5% of the points at the top and",
"the bottom.[PAR]",
"Option [TT]-ee[tt] produces error estimates using block averaging.",
"A set is divided in a number of blocks and averages are calculated for",
"each block. The error for the total average is calculated from",
"the variance between averages of the m blocks B_i as follows:",
"error^2 = Sum (B_i - <B>)^2 / (m*(m-1)).",
"These errors are plotted as a function of the block size.",
"Also an analytical block average curve is plotted, assuming",
"that the autocorrelation is a sum of two exponentials.",
"The analytical curve for the block average is:[BR]",
"f(t) = sigma sqrt(2/T ( a (tau1 ((exp(-t/tau1) - 1) tau1/t + 1)) +[BR]",
" (1-a) (tau2 ((exp(-t/tau2) - 1) tau2/t + 1)))),[BR]"
"where T is the total time.",
"a, tau1 and tau2 are obtained by fitting f^2(t) to error^2.",
"When the actual block average is very close to the analytical curve,",
"the error is sigma*sqrt(2/T (a tau1 + (1-a) tau2)).",
"The complete derivation is given in",
"B. Hess, J. Chem. Phys. 116:209-217, 2002.[PAR]",
"Option [TT]-filter[tt] prints the RMS high-frequency fluctuation",
"of each set and over all sets with respect to a filtered average.",
"The filter is proportional to cos(pi t/len) where t goes from -len/2",
"to len/2. len is supplied with the option [TT]-filter[tt].",
"This filter reduces oscillations with period len/2 and len by a factor",
"of 0.79 and 0.33 respectively.[PAR]",
"Option [TT]-g[tt] fits the data to the function given with option",
"[TT]-fitfn[tt].[PAR]",
"Option [TT]-power[tt] fits the data to b t^a, which is accomplished",
"by fitting to a t + b on log-log scale. All points after the first",
"zero or negative value are ignored.[PAR]"
"Option [TT]-luzar[tt] performs a Luzar & Chandler kinetics analysis",
"on output from [TT]g_hbond[tt]. The input file can be taken directly",
"from [TT]g_hbond -ac[tt], and then the same result should be produced."
};
static real tb=-1,te=-1,frac=0.5,filtlen=0,binwidth=0.1,aver_start=0;
static bool bHaveT=TRUE,bDer=FALSE,bSubAv=TRUE,bAverCorr=FALSE,bXYdy=FALSE;
static bool bEESEF=FALSE,bEENLC=FALSE,bEeFitAc=FALSE,bPower=FALSE;
static bool bIntegrate=FALSE,bRegression=FALSE,bLuzar=FALSE,bLuzarError=FALSE;
static int nsets_in=1,d=1,nb_min=4,resol=10;
static real temp=298.15,fit_start=1,smooth_tail_start=-1;
/* must correspond to enum avbar* declared at beginning of file */
static const char *avbar_opt[avbarNR+1] = {
NULL, "none", "stddev", "error", "90", NULL
};
t_pargs pa[] = {
{ "-time", FALSE, etBOOL, {&bHaveT},
"Expect a time in the input" },
{ "-b", FALSE, etREAL, {&tb},
"First time to read from set" },
{ "-e", FALSE, etREAL, {&te},
"Last time to read from set" },
{ "-n", FALSE, etINT, {&nsets_in},
"Read # sets seperated by &" },
{ "-d", FALSE, etBOOL, {&bDer},
"Use the derivative" },
{ "-dp", FALSE, etINT, {&d},
"HIDDENThe derivative is the difference over # points" },
{ "-bw", FALSE, etREAL, {&binwidth},
"Binwidth for the distribution" },
{ "-errbar", FALSE, etENUM, {avbar_opt},
"Error bars for -av" },
{ "-integrate",FALSE,etBOOL, {&bIntegrate},
"Integrate data function(s) numerically using trapezium rule" },
{ "-aver_start",FALSE, etREAL, {&aver_start},
"Start averaging the integral from here" },
{ "-xydy", FALSE, etBOOL, {&bXYdy},
"Interpret second data set as error in the y values for integrating" },
{ "-regression",FALSE,etBOOL,{&bRegression},
"Perform a linear regression analysis on the data" },
{ "-luzar", FALSE, etBOOL, {&bLuzar},
"Do a Luzar and Chandler analysis on a correlation function and related as produced by g_hbond. When in addition the -xydy flag is given the second and fourth column will be interpreted as errors in c(t) and n(t)." },
{ "-temp", FALSE, etREAL, {&temp},
"Temperature for the Luzar hydrogen bonding kinetics analysis" },
{ "-fitstart", FALSE, etREAL, {&fit_start},
"Time (ps) from which to start fitting the correlation functions in order to obtain the forward and backward rate constants for HB breaking and formation" },
{ "-smooth",FALSE, etREAL, {&smooth_tail_start},
"If >= 0, the tail of the ACF will be smoothed by fitting it to an exponential function: y = A exp(-x/tau)" },
{ "-nbmin", FALSE, etINT, {&nb_min},
"HIDDENMinimum number of blocks for block averaging" },
{ "-resol", FALSE, etINT, {&resol},
"HIDDENResolution for the block averaging, block size increases with"
" a factor 2^(1/#)" },
{ "-eeexpfit", FALSE, etBOOL, {&bEESEF},
"HIDDENAlways use a single exponential fit for the error estimate" },
{ "-eenlc", FALSE, etBOOL, {&bEENLC},
"HIDDENAllow a negative long-time correlation" },
{ "-eefitac", FALSE, etBOOL, {&bEeFitAc},
"HIDDENAlso plot analytical block average using a autocorrelation fit" },
{ "-filter", FALSE, etREAL, {&filtlen},
"Print the high-frequency fluctuation after filtering with a cosine filter of length #" },
{ "-power", FALSE, etBOOL, {&bPower},
"Fit data to: b t^a" },
{ "-subav", FALSE, etBOOL, {&bSubAv},
"Subtract the average before autocorrelating" },
{ "-oneacf", FALSE, etBOOL, {&bAverCorr},
"Calculate one ACF over all sets" }
};
#define NPA asize(pa)
FILE *out,*out_fit;
int n,nlast,s,nset,i,j=0;
real **val,*t,dt,tot,error;
double *av,*sig,cum1,cum2,cum3,cum4,db;
char *acfile,*msdfile,*ccfile,*distfile,*avfile,*eefile,*fitfile;
t_filenm fnm[] = {
{ efXVG, "-f", "graph", ffREAD },
{ efXVG, "-ac", "autocorr", ffOPTWR },
{ efXVG, "-msd", "msd", ffOPTWR },
{ efXVG, "-cc", "coscont", ffOPTWR },
{ efXVG, "-dist", "distr", ffOPTWR },
{ efXVG, "-av", "average", ffOPTWR },
{ efXVG, "-ee", "errest", ffOPTWR },
{ efLOG, "-g", "fitlog", ffOPTWR }
};
#define NFILE asize(fnm)
int npargs;
t_pargs *ppa;
npargs = asize(pa);
ppa = add_acf_pargs(&npargs,pa);
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_VIEW,
NFILE,fnm,npargs,ppa,asize(desc),desc,0,NULL);
acfile = opt2fn_null("-ac",NFILE,fnm);
msdfile = opt2fn_null("-msd",NFILE,fnm);
ccfile = opt2fn_null("-cc",NFILE,fnm);
distfile = opt2fn_null("-dist",NFILE,fnm);
avfile = opt2fn_null("-av",NFILE,fnm);
eefile = opt2fn_null("-ee",NFILE,fnm);
if (opt2parg_bSet("-fitfn",npargs,ppa))
fitfile = opt2fn("-g",NFILE,fnm);
else
fitfile = opt2fn_null("-g",NFILE,fnm);
val=read_xvg_time(opt2fn("-f",NFILE,fnm),bHaveT,
opt2parg_bSet("-b",npargs,ppa),tb,
opt2parg_bSet("-e",npargs,ppa),te,
nsets_in,&nset,&n,&dt,&t);
printf("Read %d sets of %d points, dt = %g\n\n",nset,n,dt);
if (bDer) {
printf("Calculating the derivative as (f[i+%d]-f[i])/(%d*dt)\n\n",
d,d);
n -= d;
for(s=0; s<nset; s++)
for(i=0; (i<n); i++)
val[s][i] = (val[s][i+d]-val[s][i])/(d*dt);
}
if (bIntegrate) {
real sum,stddev;
printf("Calculating the integral using the trapezium rule\n");
if (bXYdy) {
sum = evaluate_integral(n,t,val[0],val[1],aver_start,&stddev);
printf("Integral %10.3f +/- %10.5f\n",sum,stddev);
}
else {
for(s=0; s<nset; s++) {
sum = evaluate_integral(n,t,val[s],NULL,aver_start,&stddev);
printf("Integral %d %10.5f +/- %10.5f\n",s+1,sum,stddev);
}
}
}
if (fitfile) {
out_fit = ffopen(fitfile,"w");
if (bXYdy && nset>=2) {
do_fit(out_fit,0,TRUE,n,t,val,npargs,ppa);
} else {
for(s=0; s<nset; s++)
do_fit(out_fit,s,FALSE,n,t,val,npargs,ppa);
}
fclose(out_fit);
}
printf(" std. dev. relative deviation of\n");
printf(" standard --------- cumulants from those of\n");
printf("set average deviation sqrt(n-1) a Gaussian distribition\n");
printf(" cum. 3 cum. 4\n");
snew(av,nset);
snew(sig,nset);
for(s=0; (s<nset); s++) {
cum1 = 0;
cum2 = 0;
cum3 = 0;
cum4 = 0;
for(i=0; (i<n); i++)
cum1 += val[s][i];
cum1 /= n;
for(i=0; (i<n); i++) {
db = val[s][i]-cum1;
cum2 += db*db;
cum3 += db*db*db;
cum4 += db*db*db*db;
}
cum2 /= n;
cum3 /= n;
cum4 /= n;
av[s] = cum1;
sig[s] = sqrt(cum2);
if (n > 1)
error = sqrt(cum2/(n-1));
else
error = 0;
printf("SS%d %13.6e %12.6e %12.6e %6.3f %6.3f\n",
s+1,av[s],sig[s],error,
sig[s] ? cum3/(sig[s]*sig[s]*sig[s]*sqrt(8/M_PI)) : 0,
sig[s] ? cum4/(sig[s]*sig[s]*sig[s]*sig[s]*3)-1 : 0);
}
printf("\n");
if (filtlen)
filter(filtlen,n,nset,val,dt);
if (msdfile) {
out=xvgropen(msdfile,"Mean square displacement",
"time","MSD (nm\\S2\\N)");
nlast = (int)(n*frac);
for(s=0; s<nset; s++) {
for(j=0; j<=nlast; j++) {
if (j % 100 == 0)
fprintf(stderr,"\r%d",j);
tot=0;
for(i=0; i<n-j; i++)
tot += sqr(val[s][i]-val[s][i+j]);
tot /= (real)(n-j);
fprintf(out," %g %8g\n",dt*j,tot);
}
if (s<nset-1)
fprintf(out,"&\n");
}
fclose(out);
fprintf(stderr,"\r%d, time=%g\n",j-1,(j-1)*dt);
}
if (ccfile)
plot_coscont(ccfile,n,nset,val);
if (distfile)
histogram(distfile,binwidth,n,nset,val);
if (avfile)
average(avfile,nenum(avbar_opt),n,nset,val,t);
if (eefile)
estimate_error(eefile,nb_min,resol,n,nset,av,sig,val,dt,
bEeFitAc,bEESEF,bEENLC);
if (bPower)
power_fit(n,nset,val,t);
if (acfile) {
if (bSubAv)
for(s=0; s<nset; s++)
for(i=0; i<n; i++)
val[s][i] -= av[s];
do_autocorr(acfile,"Autocorrelation",n,nset,val,dt,
eacNormal,bAverCorr);
}
if (bRegression)
regression_analysis(n,bXYdy,t,val);
if (bLuzar)
luzar_correl(n,t,nset,val,temp,bXYdy,fit_start,smooth_tail_start);
view_all(NFILE, fnm);
thanx(stderr);
return 0;
}
int gmx_trjcat(int argc,char *argv[])
{
static char *desc[] = {
"trjcat 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 -o fixed.trr *.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",
"input files. In that case that particular file will be appended to",
"which implies you do not need to store double the amount of data.",
"Obviously the file to append to has to be the one with lowest starting",
"time since one can only append at the end of a file.[PAR]",
"If the [TT]-demux[tt] option is given, the N trajectories that are",
"read, are written in another order as specified in the xvg file."
"The xvg file should contain something like:[PAR]",
"0 0 1 2 3 4 5[BR]",
"2 1 0 2 3 5 4[BR]",
"Where the first number is the time, and subsequent numbers point to",
"trajectory indices.",
"The frames corresponding to the numbers present at the first line",
"are collected into the output trajectory. If the number of frames in",
"the trajectory does not match that in the xvg file then the program",
"tries to be smart. Beware."
};
static bool bVels=TRUE;
static int prec=3;
static bool bCat=FALSE;
static bool bSort=TRUE;
static bool bKeepLast=FALSE;
static bool bSetTime=FALSE;
static bool bDeMux;
static real begin=-1;
static real end=-1;
static real dt=0;
t_pargs pa[] = {
{ "-b", FALSE, etTIME, {&begin},
"First time to use (%t)"},
{ "-e", FALSE, etTIME, {&end},
"Last time to use (%t)"},
{ "-dt", FALSE, etTIME, {&dt},
"Only write frame when t MOD dt = first time (%t)" },
{ "-prec", FALSE, etINT, {&prec},
"Precision for .xtc and .gro writing in number of decimal places" },
{ "-vel", FALSE, etBOOL, {&bVels},
"Read and write velocities if possible" },
{ "-settime", FALSE, etBOOL, {&bSetTime},
"Change starting time interactively" },
{ "-sort", FALSE, etBOOL, {&bSort},
"Sort trajectory files (not frames)" },
{ "-keeplast",FALSE, etBOOL, {&bKeepLast},
"keep overlapping frames at end of trajectory" },
{ "-cat", FALSE, etBOOL, {&bCat},
"do not discard double time frames" }
};
#define npargs asize(pa)
int status,ftpin,i,frame,frame_out,step=0,trjout=0;
rvec *x,*v;
real xtcpr,t_corr;
t_trxframe fr,frout;
char **fnms,**fnms_out,*in_file,*out_file;
int n_append;
int trxout=-1;
bool bNewFile,bIndex,bWrite;
int earliersteps,nfile_in,nfile_out,*cont_type,last_ok_step;
real *readtime,*timest,*settime;
real first_time=0,lasttime=NOTSET,last_ok_t=-1,timestep;
int isize,j;
atom_id *index=NULL,imax;
char *grpname;
real **val=NULL,*t=NULL,dt_remd;
int n,nset;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffRDMULT },
{ efTRO, "-o", NULL, ffWRMULT },
{ efNDX, "-n", "index", ffOPTRD },
{ efXVG, "-demux", "remd", ffOPTRD }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_BE_NICE|PCA_TIME_UNIT,
NFILE,fnm,asize(pa),pa,asize(desc),desc,
0,NULL);
bIndex = ftp2bSet(efNDX,NFILE,fnm);
bDeMux = ftp2bSet(efXVG,NFILE,fnm);
bSort = bSort && !bDeMux;
imax=NO_ATID;
if (bIndex) {
printf("Select group for output\n");
rd_index(ftp2fn(efNDX,NFILE,fnm),1,&isize,&index,&grpname);
/* scan index */
imax=index[0];
for(i=1; i<isize; i++)
imax = max(imax, index[i]);
}
if (bDeMux) {
nset = 0;
dt_remd = 0;
val=read_xvg_time(opt2fn("-demux",NFILE,fnm),TRUE,
opt2parg_bSet("-b",npargs,pa),begin,
opt2parg_bSet("-e",npargs,pa),end,
1,&nset,&n,&dt_remd,&t);
printf("Read %d sets of %d points, dt = %g\n\n",nset,n,dt_remd);
if (debug) {
fprintf(debug,"Dump of replica_index.xvg\n");
for(i=0; (i<n); i++) {
fprintf(debug,"%10g",t[i]);
for(j=0; (j<nset); j++) {
fprintf(debug," %3d",gmx_nint(val[j][i]));
}
fprintf(debug,"\n");
}
}
}
/* prec is in nr of decimal places, xtcprec is a multiplication factor: */
xtcpr=1;
for (i=0; i<prec; i++)
xtcpr*=10;
nfile_in = opt2fns(&fnms,"-f",NFILE,fnm);
if (!nfile_in)
gmx_fatal(FARGS,"No input files!");
if (bDeMux && (nfile_in != nset))
gmx_fatal(FARGS,"You have specified %d files and %d entries in the demux table",nfile_in,nset);
nfile_out = opt2fns(&fnms_out,"-o",NFILE,fnm);
if (!nfile_out)
gmx_fatal(FARGS,"No output files!");
if ((nfile_out > 1) && !bDeMux)
gmx_fatal(FARGS,"Don't know what to do with more than 1 output file if not demultiplexing");
else if (bDeMux && (nfile_out != nset) && (nfile_out != 1))
gmx_fatal(FARGS,"Number of output files should be 1 or %d (#input files), not %d",nset,nfile_out);
if (bDeMux) {
if (nfile_out != nset) {
char *buf = strdup(fnms_out[0]);
snew(fnms_out,nset);
for(i=0; (i<nset); i++) {
snew(fnms_out[i],strlen(buf)+32);
sprintf(fnms_out[i],"%d_%s",i,buf);
}
}
do_demux(nfile_in,fnms,fnms_out,n,val,t,dt_remd,isize,index,dt);
}
else {
snew(readtime,nfile_in+1);
snew(timest,nfile_in+1);
scan_trj_files(fnms,nfile_in,readtime,timest,imax);
snew(settime,nfile_in+1);
snew(cont_type,nfile_in+1);
edit_files(fnms,nfile_in,readtime,timest,settime,cont_type,bSetTime,bSort);
/* Check whether the output file is amongst the input files
* This has to be done after sorting etc.
*/
out_file = fnms_out[0];
n_append = -1;
for(i=0; ((i<nfile_in) && (n_append==-1)); i++) {
if (strcmp(fnms[i],out_file) == 0) {
n_append = i;
}
}
if (n_append == 0)
fprintf(stderr,"Will append to %s rather than creating a new file\n",
out_file);
else if (n_append != -1)
gmx_fatal(FARGS,"Can only append to the first file which is %s (not %s)",
fnms[0],out_file);
earliersteps=0;
/* Not checking input format, could be dangerous :-) */
/* Not checking output format, equally dangerous :-) */
frame=-1;
frame_out=-1;
/* the default is not to change the time at all,
* but this is overridden by the edit_files routine
*/
t_corr=0;
if (n_append == -1) {
trxout = open_trx(out_file,"w");
memset(&frout,0,sizeof(frout));
}
else {
/* Read file to find what is the last frame in it */
if (!read_first_frame(&status,out_file,&fr,FLAGS))
gmx_fatal(FARGS,"Reading first frame from %s",out_file);
while (read_next_frame(status,&fr))
;
close_trj(status);
lasttime = fr.time;
bKeepLast = TRUE;
trxout = open_trx(out_file,"a");
frout = fr;
}
/* Lets stitch up some files */
timestep = timest[0];
for(i=n_append+1; (i<nfile_in); i++) {
/* Open next file */
/* set the next time from the last frame in previous file */
if (i > 0) {
if (frame_out >= 0) {
if(cont_type[i]==TIME_CONTINUE) {
begin =frout.time;
begin += 0.5*timestep;
settime[i]=frout.time;
cont_type[i]=TIME_EXPLICIT;
}
else if(cont_type[i]==TIME_LAST) {
begin=frout.time;
begin += 0.5*timestep;
}
/* Or, if the time in the next part should be changed by the
* same amount, start at half a timestep from the last time
* so we dont repeat frames.
*/
/* I don't understand the comment above, but for all the cases
* I tried the code seems to work properly. B. Hess 2008-4-2.
*/
}
/* Or, if time is set explicitly, we check for overlap/gap */
if(cont_type[i]==TIME_EXPLICIT)
if( ( i < nfile_in ) &&
( frout.time < settime[i]-1.5*timestep ) )
fprintf(stderr, "WARNING: Frames around t=%f %s have a different "
"spacing than the rest,\n"
"might be a gap or overlap that couldn't be corrected "
"automatically.\n",convert_time(frout.time),time_unit());
}
/* if we don't have a timestep in the current file, use the old one */
if ( timest[i] != 0 )
timestep = timest[i];
read_first_frame(&status,fnms[i],&fr,FLAGS);
if(!fr.bTime) {
fr.time=0;
fprintf(stderr,"\nWARNING: Couldn't find a time in the frame.\n");
}
if(cont_type[i]==TIME_EXPLICIT)
t_corr=settime[i]-fr.time;
/* t_corr is the amount we want to change the time.
* If the user has chosen not to change the time for
* this part of the trajectory t_corr remains at
* the value it had in the last part, changing this
* by the same amount.
* If no value was given for the first trajectory part
* we let the time start at zero, see the edit_files routine.
*/
bNewFile=TRUE;
printf("\n");
if (lasttime != NOTSET)
printf("lasttime %g\n", lasttime);
do {
/* copy the input frame to the output frame */
frout=fr;
/* set the new time by adding the correct calculated above */
frout.time += t_corr;
/* quit if we have reached the end of what should be written */
if((end > 0) && (frout.time > end+GMX_REAL_EPS)) {
i=nfile_in;
break;
}
/* determine if we should write this frame (dt is handled elsewhere) */
if (bCat) /* write all frames of all files */
bWrite = TRUE;
else if ( bKeepLast ) /* write till last frame of this traj
and skip first frame(s) of next traj */
bWrite = ( frout.time > lasttime+0.5*timestep );
else /* write till first frame of next traj */
bWrite = ( frout.time < settime[i+1]-0.5*timestep );
if( bWrite && (frout.time >= begin) ) {
frame++;
if (frame_out == -1)
first_time = frout.time;
lasttime = frout.time;
if (dt==0 || bRmod(frout.time,first_time,dt)) {
frame_out++;
last_ok_t=frout.time;
if(bNewFile) {
fprintf(stderr,"\nContinue writing frames from %s t=%g %s, "
"frame=%d \n",
fnms[i],convert_time(frout.time),time_unit(),frame);
bNewFile=FALSE;
}
if (bIndex)
write_trxframe_indexed(trxout,&frout,isize,index);
else
write_trxframe(trxout,&frout);
if ( ((frame % 10) == 0) || (frame < 10) )
fprintf(stderr," -> frame %6d time %8.3f %s \r",
frame_out,convert_time(frout.time),time_unit());
}
}
} while( read_next_frame(status,&fr));
close_trj(status);
earliersteps+=step;
}
if (trxout >= 0)
close_trx(trxout);
fprintf(stderr,"\nLast frame written was %d, time %f %s\n",
frame,convert_time(last_ok_t),time_unit());
}
thanx(stderr);
return 0;
}
int main(int argc,char *argv[])
{
static char *desc[] = {
"The [TT]pmetest[tt] program tests the scaling of the PME code. When only given",
"a [TT].tpr[tt] file it will compute PME for one frame. When given a trajectory",
"it will do so for all the frames in the trajectory. Before the PME",
"routine is called the coordinates are sorted along the X-axis.[PAR]",
"As an extra service to the public the program can also compute",
"long-range Coulomb energies for components of the system. When the",
"[TT]-groups[tt] flag is given to the program the energy groups",
"from the [TT].tpr[tt] file will be read, and half an energy matrix computed."
};
t_commrec *cr,*mcr;
static t_filenm fnm[] = {
{ efTPX, NULL, NULL, ffREAD },
{ efTRN, "-o", NULL, ffWRITE },
{ efLOG, "-g", "pme", ffWRITE },
{ efTRX, "-f", NULL, ffOPTRD },
{ efXVG, "-x", "ener-pme", ffWRITE }
};
#define NFILE asize(fnm)
/* Command line options ! */
static gmx_bool bVerbose=FALSE;
static gmx_bool bOptFFT=FALSE;
static gmx_bool bSort=FALSE;
static int ewald_geometry=eewg3D;
static int nnodes=1;
static int pme_order=0;
static rvec grid = { -1, -1, -1 };
static real rc = 0.0;
static real dtol = 0.0;
static gmx_bool bGroups = FALSE;
static t_pargs pa[] = {
{ "-np", FALSE, etINT, {&nnodes},
"Number of nodes, must be the same as used for [TT]grompp[tt]" },
{ "-v", FALSE, etBOOL,{&bVerbose},
"Be loud and noisy" },
{ "-sort", FALSE, etBOOL,{&bSort},
"Sort coordinates. Crucial for domain decomposition." },
{ "-grid", FALSE, etRVEC,{&grid},
"Number of grid cells in X, Y, Z dimension (if -1 use from [TT].tpr[tt])" },
{ "-order", FALSE, etINT, {&pme_order},
"Order of the PME spreading algorithm" },
{ "-groups", FALSE, etBOOL, {&bGroups},
"Compute half an energy matrix based on the energy groups in your [TT].tpr[tt] file" },
{ "-rc", FALSE, etREAL, {&rc},
"Rcoulomb for Ewald summation" },
{ "-tol", FALSE, etREAL, {&dtol},
"Tolerance for Ewald summation" }
};
FILE *fp;
t_inputrec *ir;
t_topology top;
t_tpxheader tpx;
t_nrnb nrnb;
t_nsborder *nsb;
t_forcerec *fr;
t_mdatoms *mdatoms;
char title[STRLEN];
int natoms,step,status,i,ncg,root;
real t,lambda,ewaldcoeff,qtot;
rvec *x,*f,*xbuf;
int *index;
gmx_bool bCont;
real *charge,*qbuf,*qqbuf;
matrix box;
/* Start the actual parallel code if necessary */
cr = init_par(&argc,&argv);
root = 0;
if (MASTER(cr))
CopyRight(stderr,argv[0]);
/* Parse command line on all processors, arguments are passed on in
* init_par (see above)
*/
parse_common_args(&argc,argv,
PCA_KEEP_ARGS | PCA_NOEXIT_ON_ARGS | PCA_BE_NICE |
PCA_CAN_SET_DEFFNM | (MASTER(cr) ? 0 : PCA_QUIET),
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL);
#ifndef GMX_MPI
if (nnodes > 1)
gmx_fatal(FARGS,"GROMACS compiled without MPI support - can't do parallel runs");
#endif
/* Open log files on all processors */
open_log(ftp2fn(efLOG,NFILE,fnm),cr);
snew(ir,1);
if (MASTER(cr)) {
/* Read tpr file etc. */
read_tpxheader(ftp2fn(efTPX,NFILE,fnm),&tpx,FALSE,NULL,NULL);
snew(x,tpx.natoms);
read_tpx(ftp2fn(efTPX,NFILE,fnm),&step,&t,&lambda,ir,
box,&natoms,x,NULL,NULL,&top);
/* Charges */
qtot = 0;
snew(charge,natoms);
for(i=0; (i<natoms); i++) {
charge[i] = top.atoms.atom[i].q;
qtot += charge[i];
}
/* Grid stuff */
if (opt2parg_bSet("-grid",asize(pa),pa)) {
ir->nkx = grid[XX];
ir->nky = grid[YY];
ir->nkz = grid[ZZ];
}
/* Check command line parameters for consistency */
if ((ir->nkx <= 0) || (ir->nky <= 0) || (ir->nkz <= 0))
gmx_fatal(FARGS,"PME grid = %d %d %d",ir->nkx,ir->nky,ir->nkz);
if (opt2parg_bSet("-rc",asize(pa),pa))
ir->rcoulomb = rc;
if (ir->rcoulomb <= 0)
gmx_fatal(FARGS,"rcoulomb should be > 0 (not %f)",ir->rcoulomb);
if (opt2parg_bSet("-order",asize(pa),pa))
ir->pme_order = pme_order;
if (ir->pme_order <= 0)
gmx_fatal(FARGS,"pme_order should be > 0 (not %d)",ir->pme_order);
if (opt2parg_bSet("-tol",asize(pa),pa))
ir->ewald_rtol = dtol;
if (ir->ewald_rtol <= 0)
gmx_fatal(FARGS,"ewald_tol should be > 0 (not %f)",ir->ewald_rtol);
}
else {
init_top(&top);
}
/* Add parallellization code here */
snew(nsb,1);
if (MASTER(cr)) {
ncg = top.blocks[ebCGS].multinr[0];
for(i=0; (i<cr->nnodes-1); i++)
top.blocks[ebCGS].multinr[i] = min(ncg,(ncg*(i+1))/cr->nnodes);
for( ; (i<MAXNODES); i++)
top.blocks[ebCGS].multinr[i] = ncg;
}
if (PAR(cr)) {
/* Set some variables to zero to avoid core dumps */
ir->opts.ngtc = ir->opts.ngacc = ir->opts.ngfrz = ir->opts.ngener = 0;
#ifdef GMX_MPI
/* Distribute the data over processors */
MPI_Bcast(&natoms,1,MPI_INT,root,MPI_COMM_WORLD);
MPI_Bcast(ir,sizeof(*ir),MPI_BYTE,root,MPI_COMM_WORLD);
MPI_Bcast(&qtot,1,GMX_MPI_REAL,root,MPI_COMM_WORLD);
#endif
/* Call some dedicated communication routines, master sends n-1 times */
if (MASTER(cr)) {
for(i=1; (i<cr->nnodes); i++) {
mv_block(i,&(top.blocks[ebCGS]));
mv_block(i,&(top.atoms.excl));
}
}
else {
ld_block(root,&(top.blocks[ebCGS]));
ld_block(root,&(top.atoms.excl));
}
if (!MASTER(cr)) {
snew(charge,natoms);
snew(x,natoms);
}
#ifdef GMX_MPI
MPI_Bcast(charge,natoms,GMX_MPI_REAL,root,MPI_COMM_WORLD);
#endif
}
ewaldcoeff = calc_ewaldcoeff(ir->rcoulomb,ir->ewald_rtol);
if (bVerbose)
pr_inputrec(stdlog,0,"Inputrec",ir);
/* Allocate memory for temp arrays etc. */
snew(xbuf,natoms);
snew(f,natoms);
snew(qbuf,natoms);
snew(qqbuf,natoms);
snew(index,natoms);
/* Initialize the PME code */
init_pme(stdlog,cr,ir->nkx,ir->nky,ir->nkz,ir->pme_order,
natoms,FALSE,bOptFFT,ewald_geometry);
/* MFlops accounting */
init_nrnb(&nrnb);
/* Initialize the work division */
calc_nsb(stdlog,&(top.blocks[ebCGS]),cr->nnodes,nsb,0);
nsb->nodeid = cr->nodeid;
print_nsb(stdlog,"pmetest",nsb);
/* Initiate forcerec */
mdatoms = atoms2md(stdlog,&top.atoms,ir->opts.nFreeze,ir->eI,
ir->delta_t,0,ir->opts.tau_t,FALSE,FALSE);
snew(fr,1);
init_forcerec(stdlog,fr,ir,&top,cr,mdatoms,nsb,box,FALSE,NULL,NULL,FALSE);
/* First do PME based on coordinates in tpr file, send them to
* other processors if needed.
*/
if (MASTER(cr))
fprintf(stdlog,"-----\n"
"Results based on tpr file %s\n",ftp2fn(efTPX,NFILE,fnm));
#ifdef GMX_MPI
if (PAR(cr)) {
MPI_Bcast(x[0],natoms*DIM,GMX_MPI_REAL,root,MPI_COMM_WORLD);
MPI_Bcast(box[0],DIM*DIM,GMX_MPI_REAL,root,MPI_COMM_WORLD);
MPI_Bcast(&t,1,GMX_MPI_REAL,root,MPI_COMM_WORLD);
}
#endif
do_my_pme(stdlog,0,bVerbose,ir,x,xbuf,f,charge,qbuf,qqbuf,box,bSort,
cr,nsb,&nrnb,&(top.atoms.excl),qtot,fr,index,NULL,
bGroups ? ir->opts.ngener : 1,mdatoms->cENER);
/* If we have a trajectry file, we will read the frames in it and compute
* the PME energy.
*/
if (ftp2bSet(efTRX,NFILE,fnm)) {
fprintf(stdlog,"-----\n"
"Results based on trx file %s\n",ftp2fn(efTRX,NFILE,fnm));
if (MASTER(cr)) {
sfree(x);
natoms = read_first_x(&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
if (natoms != top.atoms.nr)
gmx_fatal(FARGS,"natoms in trx = %d, in tpr = %d",natoms,top.atoms.nr);
fp = xvgropen(ftp2fn(efXVG,NFILE,fnm),"PME Energy","Time (ps)","E (kJ/mol)");
}
else
fp = NULL;
do {
/* Send coordinates, box and time to the other nodes */
#ifdef GMX_MPI
if (PAR(cr)) {
MPI_Bcast(x[0],natoms*DIM,GMX_MPI_REAL,root,MPI_COMM_WORLD);
MPI_Bcast(box[0],DIM*DIM,GMX_MPI_REAL,root,MPI_COMM_WORLD);
MPI_Bcast(&t,1,GMX_MPI_REAL,root,MPI_COMM_WORLD);
}
#endif
rm_pbc(&top.idef,nsb->natoms,box,x,x);
/* Call the PME wrapper function */
do_my_pme(stdlog,t,bVerbose,ir,x,xbuf,f,charge,qbuf,qqbuf,box,bSort,cr,
nsb,&nrnb,&(top.atoms.excl),qtot,fr,index,fp,
bGroups ? ir->opts.ngener : 1,mdatoms->cENER);
/* Only the master processor reads more data */
if (MASTER(cr))
bCont = read_next_x(status,&t,natoms,x,box);
/* Check whether we need to continue */
#ifdef GMX_MPI
if (PAR(cr))
MPI_Bcast(&bCont,1,MPI_INT,root,MPI_COMM_WORLD);
#endif
} while (bCont);
/* Finish I/O, close files */
if (MASTER(cr)) {
close_trx(status);
ffclose(fp);
}
}
if (bVerbose) {
/* Do some final I/O about performance, might be useful in debugging */
fprintf(stdlog,"-----\n");
print_nrnb(stdlog,&nrnb);
}
/* Finish the parallel stuff */
if (gmx_parallel_env_initialized())
gmx_finalize(cr);
/* Thank the audience, as usual */
if (MASTER(cr))
thanx(stderr);
return 0;
}
int cmain (int argc, char *argv[])
{
const char *desc[] = {
"tpbconv can edit run input files in four ways.[PAR]",
"[BB]1.[bb] by modifying the number of steps in a run input file",
"with options [TT]-extend[tt], [TT]-until[tt] or [TT]-nsteps[tt]",
"(nsteps=-1 means unlimited number of steps)[PAR]",
"[BB]2.[bb] (OBSOLETE) by creating a run input file",
"for a continuation run when your simulation has crashed due to e.g.",
"a full disk, or by making a continuation run input file.",
"This option is obsolete, since mdrun now writes and reads",
"checkpoint files.",
"[BB]Note[bb] that a frame with coordinates and velocities is needed.",
"When pressure and/or Nose-Hoover temperature coupling is used",
"an energy file can be supplied to get an exact continuation",
"of the original run.[PAR]",
"[BB]3.[bb] by creating a [TT].tpx[tt] file for a subset of your original",
"tpx file, which is useful when you want to remove the solvent from",
"your [TT].tpx[tt] file, or when you want to make e.g. a pure C[GRK]alpha[grk] [TT].tpx[tt] file.",
"Note that you may need to use [TT]-nsteps -1[tt] (or similar) to get",
"this to work.",
"[BB]WARNING: this [TT].tpx[tt] file is not fully functional[bb].[PAR]",
"[BB]4.[bb] by setting the charges of a specified group",
"to zero. This is useful when doing free energy estimates",
"using the LIE (Linear Interaction Energy) method."
};
const char *top_fn, *frame_fn;
t_fileio *fp;
ener_file_t fp_ener = NULL;
t_trnheader head;
int i;
gmx_large_int_t nsteps_req, run_step, frame;
double run_t, state_t;
gmx_bool bOK, bNsteps, bExtend, bUntil, bTime, bTraj;
gmx_bool bFrame, bUse, bSel, bNeedEner, bReadEner, bScanEner, bFepState;
gmx_mtop_t mtop;
t_atoms atoms;
t_inputrec *ir, *irnew = NULL;
t_gromppopts *gopts;
t_state state;
rvec *newx = NULL, *newv = NULL, *tmpx, *tmpv;
matrix newbox;
int gnx;
char *grpname;
atom_id *index = NULL;
int nre;
gmx_enxnm_t *enm = NULL;
t_enxframe *fr_ener = NULL;
char buf[200], buf2[200];
output_env_t oenv;
t_filenm fnm[] = {
{ efTPX, NULL, NULL, ffREAD },
{ efTRN, "-f", NULL, ffOPTRD },
{ efEDR, "-e", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTPX, "-o", "tpxout", ffWRITE }
};
#define NFILE asize(fnm)
/* Command line options */
static int nsteps_req_int = 0;
static real start_t = -1.0, extend_t = 0.0, until_t = 0.0;
static int init_fep_state = 0;
static gmx_bool bContinuation = TRUE, bZeroQ = FALSE, bVel = TRUE;
static t_pargs pa[] = {
{ "-extend", FALSE, etREAL, {&extend_t},
"Extend runtime by this amount (ps)" },
{ "-until", FALSE, etREAL, {&until_t},
"Extend runtime until this ending time (ps)" },
{ "-nsteps", FALSE, etINT, {&nsteps_req_int},
"Change the number of steps" },
{ "-time", FALSE, etREAL, {&start_t},
"Continue from frame at this time (ps) instead of the last frame" },
{ "-zeroq", FALSE, etBOOL, {&bZeroQ},
"Set the charges of a group (from the index) to zero" },
{ "-vel", FALSE, etBOOL, {&bVel},
"Require velocities from trajectory" },
{ "-cont", FALSE, etBOOL, {&bContinuation},
"For exact continuation, the constraints should not be applied before the first step" },
{ "-init_fep_state", FALSE, etINT, {&init_fep_state},
"fep state to initialize from" },
};
int nerror = 0;
CopyRight(stderr, argv[0]);
/* Parse the command line */
parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, 0, NULL, &oenv);
/* Convert int to gmx_large_int_t */
nsteps_req = nsteps_req_int;
bNsteps = opt2parg_bSet("-nsteps", asize(pa), pa);
bExtend = opt2parg_bSet("-extend", asize(pa), pa);
bUntil = opt2parg_bSet("-until", asize(pa), pa);
bFepState = opt2parg_bSet("-init_fep_state", asize(pa), pa);
bTime = opt2parg_bSet("-time", asize(pa), pa);
bTraj = (opt2bSet("-f", NFILE, fnm) || bTime);
top_fn = ftp2fn(efTPX, NFILE, fnm);
fprintf(stderr, "Reading toplogy and stuff from %s\n", top_fn);
snew(ir, 1);
read_tpx_state(top_fn, ir, &state, NULL, &mtop);
run_step = ir->init_step;
run_t = ir->init_step*ir->delta_t + ir->init_t;
if (!EI_STATE_VELOCITY(ir->eI))
{
bVel = FALSE;
}
if (bTraj)
{
fprintf(stderr, "\n"
"NOTE: Reading the state from trajectory is an obsolete feature of tpbconv.\n"
" Continuation should be done by loading a checkpoint file with mdrun -cpi\n"
" This guarantees that all state variables are transferred.\n"
" tpbconv is now only useful for increasing nsteps,\n"
" but even that can often be avoided by using mdrun -maxh\n"
"\n");
if (ir->bContinuation != bContinuation)
{
fprintf(stderr, "Modifying ir->bContinuation to %s\n",
bool_names[bContinuation]);
}
ir->bContinuation = bContinuation;
bNeedEner = (ir->epc == epcPARRINELLORAHMAN || ir->etc == etcNOSEHOOVER);
bReadEner = (bNeedEner && ftp2bSet(efEDR, NFILE, fnm));
bScanEner = (bReadEner && !bTime);
if (ir->epc != epcNO || EI_SD(ir->eI) || ir->eI == eiBD)
{
fprintf(stderr, "NOTE: The simulation uses pressure coupling and/or stochastic dynamics.\n"
"tpbconv can not provide binary identical continuation.\n"
"If you want that, supply a checkpoint file to mdrun\n\n");
}
if (EI_SD(ir->eI) || ir->eI == eiBD)
{
fprintf(stderr, "\nChanging ld-seed from %d ", ir->ld_seed);
ir->ld_seed = make_seed();
fprintf(stderr, "to %d\n\n", ir->ld_seed);
}
frame_fn = ftp2fn(efTRN, NFILE, fnm);
if (fn2ftp(frame_fn) == efCPT)
{
int sim_part;
fprintf(stderr,
"\nREADING STATE FROM CHECKPOINT %s...\n\n",
frame_fn);
read_checkpoint_state(frame_fn, &sim_part,
&run_step, &run_t, &state);
}
else
{
fprintf(stderr,
"\nREADING COORDS, VELS AND BOX FROM TRAJECTORY %s...\n\n",
frame_fn);
fp = open_trn(frame_fn, "r");
if (bScanEner)
{
fp_ener = open_enx(ftp2fn(efEDR, NFILE, fnm), "r");
do_enxnms(fp_ener, &nre, &enm);
snew(fr_ener, 1);
fr_ener->t = -1e-12;
}
/* Now scan until the last set of x and v (step == 0)
* or the ones at step step.
*/
bFrame = TRUE;
frame = 0;
while (bFrame)
{
bFrame = fread_trnheader(fp, &head, &bOK);
if (bOK && frame == 0)
{
if (mtop.natoms != head.natoms)
{
gmx_fatal(FARGS, "Number of atoms in Topology (%d) "
"is not the same as in Trajectory (%d)\n",
mtop.natoms, head.natoms);
}
snew(newx, head.natoms);
snew(newv, head.natoms);
}
bFrame = bFrame && bOK;
if (bFrame)
{
bOK = fread_htrn(fp, &head, newbox, newx, newv, NULL);
}
bFrame = bFrame && bOK;
bUse = FALSE;
if (bFrame &&
(head.x_size) && (head.v_size || !bVel))
{
bUse = TRUE;
if (bScanEner)
{
/* Read until the energy time is >= the trajectory time */
while (fr_ener->t < head.t && do_enx(fp_ener, fr_ener))
{
;
}
bUse = (fr_ener->t == head.t);
}
if (bUse)
{
tmpx = newx;
newx = state.x;
state.x = tmpx;
tmpv = newv;
newv = state.v;
state.v = tmpv;
run_t = head.t;
run_step = head.step;
state.fep_state = head.fep_state;
state.lambda[efptFEP] = head.lambda;
copy_mat(newbox, state.box);
}
}
if (bFrame || !bOK)
{
sprintf(buf, "\r%s %s frame %s%s: step %s%s time %s",
"%s", "%s", "%6", gmx_large_int_fmt, "%6", gmx_large_int_fmt, " %8.3f");
fprintf(stderr, buf,
bUse ? "Read " : "Skipped", ftp2ext(fn2ftp(frame_fn)),
frame, head.step, head.t);
frame++;
if (bTime && (head.t >= start_t))
{
bFrame = FALSE;
}
}
}
if (bScanEner)
{
close_enx(fp_ener);
free_enxframe(fr_ener);
free_enxnms(nre, enm);
}
close_trn(fp);
fprintf(stderr, "\n");
if (!bOK)
{
fprintf(stderr, "%s frame %s (step %s, time %g) is incomplete\n",
ftp2ext(fn2ftp(frame_fn)), gmx_step_str(frame-1, buf2),
gmx_step_str(head.step, buf), head.t);
}
fprintf(stderr, "\nUsing frame of step %s time %g\n",
gmx_step_str(run_step, buf), run_t);
if (bNeedEner)
{
if (bReadEner)
{
get_enx_state(ftp2fn(efEDR, NFILE, fnm), run_t, &mtop.groups, ir, &state);
}
else
{
fprintf(stderr, "\nWARNING: The simulation uses %s temperature and/or %s pressure coupling,\n"
" the continuation will only be exact when an energy file is supplied\n\n",
ETCOUPLTYPE(etcNOSEHOOVER),
EPCOUPLTYPE(epcPARRINELLORAHMAN));
}
}
if (bFepState)
{
ir->fepvals->init_fep_state = init_fep_state;
}
}
}
if (bNsteps)
{
fprintf(stderr, "Setting nsteps to %s\n", gmx_step_str(nsteps_req, buf));
ir->nsteps = nsteps_req;
}
else
{
/* Determine total number of steps remaining */
if (bExtend)
{
ir->nsteps = ir->nsteps - (run_step - ir->init_step) + (gmx_large_int_t)(extend_t/ir->delta_t + 0.5);
printf("Extending remaining runtime of by %g ps (now %s steps)\n",
extend_t, gmx_step_str(ir->nsteps, buf));
}
else if (bUntil)
{
printf("nsteps = %s, run_step = %s, current_t = %g, until = %g\n",
gmx_step_str(ir->nsteps, buf),
gmx_step_str(run_step, buf2),
run_t, until_t);
ir->nsteps = (gmx_large_int_t)((until_t - run_t)/ir->delta_t + 0.5);
printf("Extending remaining runtime until %g ps (now %s steps)\n",
until_t, gmx_step_str(ir->nsteps, buf));
}
else
{
ir->nsteps -= run_step - ir->init_step;
/* Print message */
printf("%s steps (%g ps) remaining from first run.\n",
gmx_step_str(ir->nsteps, buf), ir->nsteps*ir->delta_t);
}
}
if (bNsteps || bZeroQ || (ir->nsteps > 0))
{
ir->init_step = run_step;
if (ftp2bSet(efNDX, NFILE, fnm) ||
!(bNsteps || bExtend || bUntil || bTraj))
{
atoms = gmx_mtop_global_atoms(&mtop);
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm), 1,
&gnx, &index, &grpname);
if (!bZeroQ)
{
bSel = (gnx != state.natoms);
for (i = 0; ((i < gnx) && (!bSel)); i++)
{
bSel = (i != index[i]);
}
}
else
{
bSel = FALSE;
}
if (bSel)
{
fprintf(stderr, "Will write subset %s of original tpx containing %d "
"atoms\n", grpname, gnx);
reduce_topology_x(gnx, index, &mtop, state.x, state.v);
state.natoms = gnx;
}
else if (bZeroQ)
{
zeroq(gnx, index, &mtop);
fprintf(stderr, "Zero-ing charges for group %s\n", grpname);
}
else
{
fprintf(stderr, "Will write full tpx file (no selection)\n");
}
}
state_t = ir->init_t + ir->init_step*ir->delta_t;
sprintf(buf, "Writing statusfile with starting step %s%s and length %s%s steps...\n", "%10", gmx_large_int_fmt, "%10", gmx_large_int_fmt);
fprintf(stderr, buf, ir->init_step, ir->nsteps);
fprintf(stderr, " time %10.3f and length %10.3f ps\n",
state_t, ir->nsteps*ir->delta_t);
write_tpx_state(opt2fn("-o", NFILE, fnm), ir, &state, &mtop);
}
else
{
printf("You've simulated long enough. Not writing tpr file\n");
}
thanx(stderr);
return 0;
}
int gmx_xpm2ps(int argc,char *argv[])
{
static char *desc[] = {
"xpm2ps 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 do_dssp, g_rms or",
"g_mdmat.[PAR]",
"Parameters are set in the [TT]m2p[tt] file optionally supplied with",
"[TT]-di[tt]. Reasonable defaults are provided. Settings for the y-axis",
"default to those for the x-axis. Font names have a defaulting hierarchy:",
"titlefont -> legendfont; titlefont -> (xfont -> yfont -> ytickfont)",
"-> xtickfont, e.g. setting titlefont sets all fonts, setting xfont",
"sets yfont, ytickfont and xtickfont.[PAR]",
"When no [TT]m2p[tt] file is supplied, many setting are set by",
"command line options. The most important option is [TT]-size[tt]",
"which sets the size of the whole matrix in postscript units.",
"This option can be overridden with the [TT]-bx[tt] and [TT]-by[tt]",
"options (and the corresponding parameters in the [TT]m2p[tt] file),",
"which set the size of a single matrix element.[PAR]",
"With [TT]-f2[tt] a 2nd matrix file can be supplied, both matrix",
"files will be read simultaneously and the upper left half of the",
"first one ([TT]-f[tt]) is plotted together with the lower right",
"half of the second one ([TT]-f2[tt]). The diagonal will contain",
"values from the matrix file selected with [TT]-diag[tt].",
"Plotting of the diagonal values can be suppressed altogether by",
"setting [TT]-diag[tt] to [TT]none[tt].",
"In this case, a new color map will be generated with",
"a red gradient for negative numbers and a blue for positive.",
"If the color coding and legend labels of both matrices are identical,",
"only one legend will be displayed, else two separate legends are",
"displayed.",
"With [TT]-combine[tt] an alternative operation can be selected",
"to combine the matrices. The output range is automatically set",
"to the actual range of the combined matrix. This can be overridden",
"with [TT]-cmin[tt] and [TT]-cmax[tt].[PAR]",
"[TT]-title[tt] can be set to [TT]none[tt] to suppress the title, or to",
"[TT]ylabel[tt] to show the title in the Y-label position (alongside",
"the Y-axis).[PAR]",
"With the [TT]-rainbow[tt] option dull grey-scale matrices can be turned",
"into attractive color pictures.[PAR]",
"Merged or rainbowed matrices can be written to an XPixelMap file with",
"the [TT]-xpm[tt] option."
};
char *fn,*epsfile=NULL,*xpmfile=NULL;
int i,nmat,nmat2,etitle,elegend,ediag,erainbow,ecombine;
t_matrix *mat=NULL,*mat2=NULL;
bool bTitle,bTitleOnce,bDiag,bFirstDiag,bGrad;
static bool bFrame=TRUE,bZeroLine=FALSE,bYonce=FALSE,bAdd=FALSE;
static real size=400,boxx=0,boxy=0,cmin=0,cmax=0;
static rvec grad={0,0,0};
enum { etSel, etTop, etOnce, etYlabel, etNone, etNR };
static char *title[] = { NULL, "top", "once", "ylabel", "none", NULL };
/* MUST correspond to enum elXxx as defined at top of file */
static char *legend[] = { NULL, "both", "first", "second", "none", NULL };
enum { edSel, edFirst, edSecond, edNone, edNR };
static char *diag[] = { NULL, "first", "second", "none", NULL };
enum { erSel, erNo, erBlue, erRed, erNR };
static char *rainbow[] = { NULL, "no", "blue", "red", NULL };
/* MUST correspond to enum ecXxx as defined at top of file */
static char *combine[] = {
NULL, "halves", "add", "sub", "mult", "div", NULL };
static int skip=1,mapoffset=0;
t_pargs pa[] = {
{ "-frame", FALSE, etBOOL, {&bFrame},
"Display frame, ticks, labels, title and legend" },
{ "-title", FALSE, etENUM, {title}, "Show title at" },
{ "-yonce", FALSE, etBOOL, {&bYonce}, "Show y-label only once" },
{ "-legend", FALSE, etENUM, {legend}, "Show legend" },
{ "-diag", FALSE, etENUM, {diag}, "Diagonal" },
{ "-size", FALSE, etREAL, {&size},
"Horizontal size of the matrix in ps units" },
{ "-bx", FALSE, etREAL, {&boxx},
"Element x-size, overrides -size (also y-size when -by is not set)" },
{ "-by", FALSE, etREAL, {&boxy}, "Element y-size" },
{ "-rainbow", FALSE, etENUM, {rainbow},
"Rainbow colors, convert white to" },
{ "-gradient",FALSE, etRVEC, {grad},
"Re-scale colormap to a smooth gradient from white {1,1,1} to {r,g,b}" },
{ "-skip", FALSE, etINT, {&skip},
"only write out every nr-th row and column" },
{ "-zeroline",FALSE, etBOOL, {&bZeroLine},
"insert line in xpm matrix where axis label is zero"},
{ "-legoffset", FALSE, etINT, {&mapoffset},
"Skip first N colors from xpm file for the legend" },
{ "-combine", FALSE, etENUM, {combine}, "Combine two matrices" },
{ "-cmin", FALSE, etREAL, {&cmin}, "Minimum for combination output" },
{ "-cmax", FALSE, etREAL, {&cmax}, "Maximum for combination output" }
};
#define NPA asize(pa)
t_filenm fnm[] = {
{ efXPM, "-f", NULL, ffREAD },
{ efXPM, "-f2", "root2", ffOPTRD },
{ efM2P, "-di", NULL, ffLIBOPTRD },
{ efM2P, "-do", "out", ffOPTWR },
{ efEPS, "-o", NULL, ffOPTWR },
{ efXPM, "-xpm",NULL, ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_VIEW,
NFILE,fnm,NPA,pa,
asize(desc),desc,0,NULL);
etitle = nenum(title);
elegend = nenum(legend);
ediag = nenum(diag);
erainbow = nenum(rainbow);
ecombine = nenum(combine);
bGrad = opt2parg_bSet("-gradient",NPA,pa);
for(i=0; i<DIM; i++)
if (grad[i] < 0 || grad[i] > 1)
gmx_fatal(FARGS, "RGB value %g out of range (0.0-1.0)", grad[i]);
if (!bFrame) {
etitle = etNone;
elegend = elNone;
}
epsfile=ftp2fn_null(efEPS,NFILE,fnm);
xpmfile=opt2fn_null("-xpm",NFILE,fnm);
if ( epsfile==NULL && xpmfile==NULL ) {
if (ecombine!=ecHalves)
xpmfile=opt2fn("-xpm",NFILE,fnm);
else
epsfile=ftp2fn(efEPS,NFILE,fnm);
}
if (ecombine!=ecHalves && epsfile) {
fprintf(stderr,
"WARNING: can only write result of arithmetic combination "
"of two matrices to .xpm file\n"
" file %s will not be written\n", epsfile);
epsfile = NULL;
}
bDiag = ediag!=edNone;
bFirstDiag = ediag!=edSecond;
fn=opt2fn("-f",NFILE,fnm);
nmat=read_xpm_matrix(fn,&mat);
fprintf(stderr,"There are %d matrices in %s\n",nmat,fn);
fn=opt2fn_null("-f2",NFILE,fnm);
if (fn) {
nmat2=read_xpm_matrix(fn,&mat2);
fprintf(stderr,"There are %d matrices in %s\n",nmat2,fn);
if (nmat != nmat2) {
fprintf(stderr,"Different number of matrices, using the smallest number.\n");
nmat=nmat2=min(nmat,nmat2);
}
} else {
if (ecombine!=ecHalves)
fprintf(stderr,
"WARNING: arithmetic matrix combination selected (-combine), "
"but no second matrix (-f2) supplied\n"
" no matrix combination will be performed\n");
ecombine=0;
nmat2=0;
}
bTitle = etitle==etTop;
bTitleOnce = etitle==etOnce;
if ( etitle==etYlabel )
for (i=0; (i<nmat); i++) {
strcpy(mat[i].label_y, mat[i].title);
if (mat2)
strcpy(mat2[i].label_y, mat2[i].title);
}
if (bGrad) {
gradient_mat(grad,nmat,mat);
if (mat2)
gradient_mat(grad,nmat2,mat2);
}
if (erainbow!=erNo) {
rainbow_mat(erainbow==erBlue,nmat,mat);
if (mat2)
rainbow_mat(erainbow==erBlue,nmat2,mat2);
}
if ((mat2 == NULL) && (elegend!=elNone))
elegend = elFirst;
if (ecombine && ecombine!=ecHalves)
write_combined_matrix(ecombine, xpmfile, nmat, mat, mat2,
opt2parg_bSet("-cmin",NPA,pa) ? &cmin : NULL,
opt2parg_bSet("-cmax",NPA,pa) ? &cmax : NULL);
else
do_mat(nmat,mat,mat2,bFrame,bZeroLine,bDiag,bFirstDiag,
bTitle,bTitleOnce,bYonce,
elegend,size,boxx,boxy,epsfile,xpmfile,
opt2fn_null("-di",NFILE,fnm),opt2fn_null("-do",NFILE,fnm), skip,
mapoffset);
view_all(NFILE, fnm);
thanx(stderr);
return 0;
}
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]",
"When a trajectory is projected on eigenvectors, all structures are",
"fitted to the structure in the eigenvector file, if present, otherwise",
"to the structure in the structure file. When no run input file is",
"supplied, periodicity will not be taken into account. Most analyses",
"are performed on eigenvectors [TT]-first[tt] to [TT]-last[tt], but when",
"[TT]-first[tt] is set to -1 you will be prompted for a selection.[PAR]",
"[TT]-comp[tt]: plot the vector components per atom of eigenvectors",
"[TT]-first[tt] to [TT]-last[tt].[PAR]",
"[TT]-rmsf[tt]: plot the RMS fluctuation per atom of eigenvectors",
"[TT]-first[tt] to [TT]-last[tt] (requires [TT]-eig[tt]).[PAR]",
"[TT]-proj[tt]: calculate projections of a trajectory on eigenvectors",
"[TT]-first[tt] to [TT]-last[tt].",
"The projections of a trajectory on the eigenvectors of its",
"covariance matrix are called principal components (pc's).",
"It is often useful to check the cosine content of the pc's,",
"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]",
"[TT]-2d[tt]: calculate a 2d projection of a trajectory on eigenvectors",
"[TT]-first[tt] and [TT]-last[tt].[PAR]",
"[TT]-3d[tt]: calculate a 3d projection of a trajectory on the first",
"three selected eigenvectors.[PAR]",
"[TT]-filt[tt]: filter the trajectory to show only the motion along",
"eigenvectors [TT]-first[tt] to [TT]-last[tt].[PAR]",
"[TT]-extr[tt]: calculate the two extreme projections along a trajectory",
"on the average structure and interpolate [TT]-nframes[tt] frames",
"between them, or set your own extremes with [TT]-max[tt]. The",
"eigenvector [TT]-first[tt] will be written unless [TT]-first[tt] and",
"[TT]-last[tt] have been set explicitly, in which case all eigenvectors",
"will be written to separate files. Chain identifiers will be added",
"when writing a [TT].pdb[tt] file with two or three structures (you",
"can use [TT]rasmol -nmrpdb[tt] to view such a [TT].pdb[tt] file).[PAR]",
" Overlap calculations between covariance analysis:[BR]",
" [BB]Note:[bb] the analysis should use the same fitting structure[PAR]",
"[TT]-over[tt]: calculate the subspace overlap of the eigenvectors in",
"file [TT]-v2[tt] with eigenvectors [TT]-first[tt] to [TT]-last[tt]",
"in file [TT]-v[tt].[PAR]",
"[TT]-inpr[tt]: calculate a matrix of inner-products between",
"eigenvectors in files [TT]-v[tt] and [TT]-v2[tt]. All eigenvectors",
"of both files will be used unless [TT]-first[tt] and [TT]-last[tt]",
"have been set explicitly.[PAR]",
"When [TT]-v[tt], [TT]-eig[tt], [TT]-v2[tt] and [TT]-eig2[tt] are given,",
"a single number for the overlap between the covariance matrices is",
"generated. The formulas are:[BR]",
" difference = sqrt(tr((sqrt(M1) - sqrt(M2))^2))[BR]",
"normalized overlap = 1 - difference/sqrt(tr(M1) + tr(M2))[BR]",
" shape overlap = 1 - sqrt(tr((sqrt(M1/tr(M1)) - sqrt(M2/tr(M2)))^2))[BR]",
"where M1 and M2 are the two covariance matrices and tr is the trace",
"of a matrix. The numbers are proportional to the overlap of the square",
"root of the fluctuations. The normalized overlap is the most useful",
"number, it is 1 for identical matrices and 0 when the sampled",
"subspaces are orthogonal.[PAR]",
"When the [TT]-entropy[tt] flag is given an entropy estimate will be",
"computed based on the Quasiharmonic approach and based on",
"Schlitter's formula."
};
static int first=1,last=-1,skip=1,nextr=2,nskip=6;
static real max=0.0,temp=298.15;
static gmx_bool bSplit=FALSE,bEntropy=FALSE;
t_pargs pa[] = {
{ "-first", FALSE, etINT, {&first},
"First eigenvector for analysis (-1 is select)" },
{ "-last", FALSE, etINT, {&last},
"Last eigenvector for analysis (-1 is till the last)" },
{ "-skip", FALSE, etINT, {&skip},
"Only analyse every nr-th frame" },
{ "-max", FALSE, etREAL, {&max},
"Maximum for projection of the eigenvector on the average structure, "
"max=0 gives the extremes" },
{ "-nframes", FALSE, etINT, {&nextr},
"Number of frames for the extremes output" },
{ "-split", FALSE, etBOOL, {&bSplit},
"Split eigenvector projections where time is zero" },
{ "-entropy", FALSE, etBOOL, {&bEntropy},
"Compute entropy according to the Quasiharmonic formula or Schlitter's method." },
{ "-temp", FALSE, etREAL, {&temp},
"Temperature for entropy calculations" },
{ "-nevskip", FALSE, etINT, {&nskip},
"Number of eigenvalues to skip when computing the entropy due to the quasi harmonic approximation. When you do a rotational and/or translational fit prior to the covariance analysis, you get 3 or 6 eigenvalues that are very close to zero, and which should not be taken into account when computing the entropy." }
};
#define NPA asize(pa)
FILE *out;
int status,trjout;
t_topology top;
int ePBC=-1;
t_atoms *atoms=NULL;
rvec *xtop,*xref1,*xref2,*xrefp=NULL;
gmx_bool bDMR1,bDMA1,bDMR2,bDMA2;
int nvec1,nvec2,*eignr1=NULL,*eignr2=NULL;
rvec *x,*xread,*xav1,*xav2,**eigvec1=NULL,**eigvec2=NULL;
matrix topbox;
real xid,totmass,*sqrtm,*w_rls,t,lambda;
int natoms,step;
char *grpname;
const char *indexfile;
char title[STRLEN];
int i,j,d;
int nout,*iout,noutvec,*outvec,nfit;
atom_id *index,*ifit;
const char *VecFile,*Vec2File,*topfile;
const char *EigFile,*Eig2File;
const char *CompFile,*RmsfFile,*ProjOnVecFile;
const char *TwoDPlotFile,*ThreeDPlotFile;
const char *FilterFile,*ExtremeFile;
const char *OverlapFile,*InpMatFile;
gmx_bool bFit1,bFit2,bM,bIndex,bTPS,bTop,bVec2,bProj;
gmx_bool bFirstToLast,bFirstLastSet,bTraj,bCompare,bPDB3D;
real *eigval1=NULL,*eigval2=NULL;
int neig1,neig2;
double **xvgdata;
output_env_t oenv;
gmx_rmpbc_t gpbc;
t_filenm fnm[] = {
{ efTRN, "-v", "eigenvec", ffREAD },
{ efTRN, "-v2", "eigenvec2", ffOPTRD },
{ efTRX, "-f", NULL, ffOPTRD },
{ efTPS, NULL, NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-eig", "eigenval", ffOPTRD },
{ efXVG, "-eig2", "eigenval2", ffOPTRD },
{ efXVG, "-comp", "eigcomp", ffOPTWR },
{ efXVG, "-rmsf", "eigrmsf", ffOPTWR },
{ efXVG, "-proj", "proj", ffOPTWR },
{ efXVG, "-2d", "2dproj", ffOPTWR },
{ efSTO, "-3d", "3dproj.pdb", ffOPTWR },
{ efTRX, "-filt", "filtered", ffOPTWR },
{ efTRX, "-extr", "extreme.pdb", ffOPTWR },
{ efXVG, "-over", "overlap", ffOPTWR },
{ efXPM, "-inpr", "inprod", ffOPTWR }
};
#define NFILE asize(fnm)
parse_common_args(&argc,argv,
PCA_CAN_TIME | PCA_TIME_UNIT | PCA_CAN_VIEW | PCA_BE_NICE ,
NFILE,fnm,NPA,pa,asize(desc),desc,0,NULL,&oenv);
indexfile=ftp2fn_null(efNDX,NFILE,fnm);
VecFile = opt2fn("-v",NFILE,fnm);
Vec2File = opt2fn_null("-v2",NFILE,fnm);
topfile = ftp2fn(efTPS,NFILE,fnm);
EigFile = opt2fn_null("-eig",NFILE,fnm);
Eig2File = opt2fn_null("-eig2",NFILE,fnm);
CompFile = opt2fn_null("-comp",NFILE,fnm);
RmsfFile = opt2fn_null("-rmsf",NFILE,fnm);
ProjOnVecFile = opt2fn_null("-proj",NFILE,fnm);
TwoDPlotFile = opt2fn_null("-2d",NFILE,fnm);
ThreeDPlotFile = opt2fn_null("-3d",NFILE,fnm);
FilterFile = opt2fn_null("-filt",NFILE,fnm);
ExtremeFile = opt2fn_null("-extr",NFILE,fnm);
OverlapFile = opt2fn_null("-over",NFILE,fnm);
InpMatFile = ftp2fn_null(efXPM,NFILE,fnm);
bTop = fn2bTPX(topfile);
bProj = ProjOnVecFile || TwoDPlotFile || ThreeDPlotFile
|| FilterFile || ExtremeFile;
bFirstLastSet =
opt2parg_bSet("-first",NPA,pa) && opt2parg_bSet("-last",NPA,pa);
bFirstToLast = CompFile || RmsfFile || ProjOnVecFile || FilterFile ||
OverlapFile || ((ExtremeFile || InpMatFile) && bFirstLastSet);
bVec2 = Vec2File || OverlapFile || InpMatFile;
bM = RmsfFile || bProj;
bTraj = ProjOnVecFile || FilterFile || (ExtremeFile && (max==0))
|| TwoDPlotFile || ThreeDPlotFile;
bIndex = bM || bProj;
bTPS = ftp2bSet(efTPS,NFILE,fnm) || bM || bTraj ||
FilterFile || (bIndex && indexfile);
bCompare = Vec2File || Eig2File;
bPDB3D = fn2ftp(ThreeDPlotFile)==efPDB;
read_eigenvectors(VecFile,&natoms,&bFit1,
&xref1,&bDMR1,&xav1,&bDMA1,
&nvec1,&eignr1,&eigvec1,&eigval1);
neig1 = DIM*natoms;
/* Overwrite eigenvalues from separate files if the user provides them */
if (EigFile != NULL) {
int neig_tmp = read_xvg(EigFile,&xvgdata,&i);
if (neig_tmp != neig1)
fprintf(stderr,"Warning: number of eigenvalues in xvg file (%d) does not mtch trr file (%d)\n",neig1,natoms);
neig1 = neig_tmp;
srenew(eigval1,neig1);
for(j=0;j<neig1;j++) {
real tmp = eigval1[j];
eigval1[j]=xvgdata[1][j];
if (debug && (eigval1[j] != tmp))
fprintf(debug,"Replacing eigenvalue %d. From trr: %10g, from xvg: %10g\n",
j,tmp,eigval1[j]);
}
for(j=0;j<i;j++)
sfree(xvgdata[j]);
sfree(xvgdata);
fprintf(stderr,"Read %d eigenvalues from %s\n",neig1,EigFile);
}
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);
}
if (bVec2) {
if (!Vec2File)
gmx_fatal(FARGS,"Need a second eigenvector file to do this analysis.");
read_eigenvectors(Vec2File,&neig2,&bFit2,
&xref2,&bDMR2,&xav2,&bDMA2,&nvec2,&eignr2,&eigvec2,&eigval2);
neig2 = DIM*neig2;
if (neig2 != neig1)
gmx_fatal(FARGS,"Dimensions in the eigenvector files don't match");
}
if(Eig2File != NULL) {
neig2 = read_xvg(Eig2File,&xvgdata,&i);
srenew(eigval2,neig2);
for(j=0;j<neig2;j++)
eigval2[j]=xvgdata[1][j];
for(j=0;j<i;j++)
sfree(xvgdata[j]);
sfree(xvgdata);
fprintf(stderr,"Read %d eigenvalues from %s\n",neig2,Eig2File);
}
if ((!bFit1 || xref1) && !bDMR1 && !bDMA1)
bM=FALSE;
if ((xref1==NULL) && (bM || bTraj))
bTPS=TRUE;
xtop=NULL;
nfit=0;
ifit=NULL;
w_rls=NULL;
if (!bTPS) {
bTop=FALSE;
} else {
bTop=read_tps_conf(ftp2fn(efTPS,NFILE,fnm),
title,&top,&ePBC,&xtop,NULL,topbox,bM);
atoms=&top.atoms;
gpbc = gmx_rmpbc_init(&top.idef,ePBC,atoms->nr,topbox);
gmx_rmpbc(gpbc,atoms->nr,topbox,xtop);
/* Fitting is only required for the projection */
if (bProj && bFit1) {
if (xref1 == NULL) {
printf("\nNote: the structure in %s should be the same\n"
" as the one used for the fit in g_covar\n",topfile);
}
printf("\nSelect the index group that was used for the least squares fit in g_covar\n");
get_index(atoms,indexfile,1,&nfit,&ifit,&grpname);
snew(w_rls,atoms->nr);
for(i=0; (i<nfit); i++) {
if (bDMR1) {
w_rls[ifit[i]] = atoms->atom[ifit[i]].m;
} else {
w_rls[ifit[i]] = 1.0;
}
}
snew(xrefp,atoms->nr);
if (xref1 != NULL) {
for(i=0; (i<nfit); i++) {
copy_rvec(xref1[i],xrefp[ifit[i]]);
}
} else {
/* The top coordinates are the fitting reference */
for(i=0; (i<nfit); i++) {
copy_rvec(xtop[ifit[i]],xrefp[ifit[i]]);
}
reset_x(nfit,ifit,atoms->nr,NULL,xrefp,w_rls);
}
}
gmx_rmpbc_done(gpbc);
}
if (bIndex) {
printf("\nSelect an index group of %d elements that corresponds to the eigenvectors\n",natoms);
get_index(atoms,indexfile,1,&i,&index,&grpname);
if (i!=natoms)
gmx_fatal(FARGS,"you selected a group with %d elements instead of %d",i,natoms);
printf("\n");
}
snew(sqrtm,natoms);
if (bM && bDMA1) {
proj_unit="u\\S1/2\\Nnm";
for(i=0; (i<natoms); i++)
sqrtm[i]=sqrt(atoms->atom[index[i]].m);
}
else {
proj_unit="nm";
for(i=0; (i<natoms); i++)
sqrtm[i]=1.0;
}
if (bVec2) {
t=0;
totmass=0;
for(i=0; (i<natoms); i++)
for(d=0;(d<DIM);d++) {
t+=sqr((xav1[i][d]-xav2[i][d])*sqrtm[i]);
totmass+=sqr(sqrtm[i]);
}
fprintf(stdout,"RMSD (without fit) between the two average structures:"
" %.3f (nm)\n\n",sqrt(t/totmass));
}
if (last==-1)
last=natoms*DIM;
if (first>-1) {
if (bFirstToLast) {
/* make an index from first to last */
nout=last-first+1;
snew(iout,nout);
for(i=0; i<nout; i++)
iout[i]=first-1+i;
}
else if (ThreeDPlotFile) {
/* make an index of first+(0,1,2) and last */
nout = bPDB3D ? 4 : 3;
nout = min(last-first+1, nout);
snew(iout,nout);
iout[0]=first-1;
iout[1]=first;
if (nout>3)
iout[2]=first+1;
iout[nout-1]=last-1;
}
else {
/* make an index of first and last */
nout=2;
snew(iout,nout);
iout[0]=first-1;
iout[1]=last-1;
}
}
else {
printf("Select eigenvectors for output, end your selection with 0\n");
nout=-1;
iout=NULL;
do {
nout++;
srenew(iout,nout+1);
if(1 != scanf("%d",&iout[nout]))
{
gmx_fatal(FARGS,"Error reading user input");
}
iout[nout]--;
}
while (iout[nout]>=0);
printf("\n");
}
/* make an index of the eigenvectors which are present */
snew(outvec,nout);
noutvec=0;
for(i=0; i<nout; i++)
{
j=0;
while ((j<nvec1) && (eignr1[j]!=iout[i]))
j++;
if ((j<nvec1) && (eignr1[j]==iout[i]))
{
outvec[noutvec]=j;
noutvec++;
}
}
fprintf(stderr,"%d eigenvectors selected for output",noutvec);
if (noutvec <= 100)
{
fprintf(stderr,":");
for(j=0; j<noutvec; j++)
fprintf(stderr," %d",eignr1[outvec[j]]+1);
}
fprintf(stderr,"\n");
if (CompFile)
components(CompFile,natoms,eignr1,eigvec1,noutvec,outvec,oenv);
if (RmsfFile)
rmsf(RmsfFile,natoms,sqrtm,eignr1,eigvec1,noutvec,outvec,eigval1,
neig1,oenv);
if (bProj)
project(bTraj ? opt2fn("-f",NFILE,fnm) : NULL,
bTop ? &top : NULL,ePBC,topbox,
ProjOnVecFile,TwoDPlotFile,ThreeDPlotFile,FilterFile,skip,
ExtremeFile,bFirstLastSet,max,nextr,atoms,natoms,index,
bFit1,xrefp,nfit,ifit,w_rls,
sqrtm,xav1,eignr1,eigvec1,noutvec,outvec,bSplit,
oenv);
if (OverlapFile)
overlap(OverlapFile,natoms,
eigvec1,nvec2,eignr2,eigvec2,noutvec,outvec,oenv);
if (InpMatFile)
inprod_matrix(InpMatFile,natoms,
nvec1,eignr1,eigvec1,nvec2,eignr2,eigvec2,
bFirstLastSet,noutvec,outvec);
if (bCompare)
compare(natoms,nvec1,eigvec1,nvec2,eigvec2,eigval1,neig1,eigval2,neig2);
if (!CompFile && !bProj && !OverlapFile && !InpMatFile &&
!bCompare && !bEntropy)
{
fprintf(stderr,"\nIf you want some output,"
" set one (or two or ...) of the output file options\n");
}
view_all(oenv,NFILE, fnm);
thanx(stdout);
return 0;
}
int gmx_traj(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] plots coordinates, velocities, forces and/or the box.",
"With [TT]-com[tt] the coordinates, velocities and forces are",
"calculated for the center of mass of each group.",
"When [TT]-mol[tt] is set, the numbers in the index file are",
"interpreted as molecule numbers and the same procedure as with",
"[TT]-com[tt] is used for each molecule.[PAR]",
"Option [TT]-ot[tt] plots the temperature of each group,",
"provided velocities are present in the trajectory file.",
"No corrections are made for constrained degrees of freedom!",
"This implies [TT]-com[tt].[PAR]",
"Options [TT]-ekt[tt] and [TT]-ekr[tt] plot the translational and",
"rotational kinetic energy of each group,",
"provided velocities are present in the trajectory file.",
"This implies [TT]-com[tt].[PAR]",
"Options [TT]-cv[tt] and [TT]-cf[tt] write the average velocities",
"and average forces as temperature factors to a [REF].pdb[ref] file with",
"the average coordinates or the coordinates at [TT]-ctime[tt].",
"The temperature factors are scaled such that the maximum is 10.",
"The scaling can be changed with the option [TT]-scale[tt].",
"To get the velocities or forces of one",
"frame set both [TT]-b[tt] and [TT]-e[tt] to the time of",
"desired frame. When averaging over frames you might need to use",
"the [TT]-nojump[tt] option to obtain the correct average coordinates.",
"If you select either of these option the average force and velocity",
"for each atom are written to an [REF].xvg[ref] file as well",
"(specified with [TT]-av[tt] or [TT]-af[tt]).[PAR]",
"Option [TT]-vd[tt] computes a velocity distribution, i.e. the",
"norm of the vector is plotted. In addition in the same graph",
"the kinetic energy distribution is given."
};
static gmx_bool bMol = FALSE, bCom = FALSE, bPBC = TRUE, bNoJump = FALSE;
static gmx_bool bX = TRUE, bY = TRUE, bZ = TRUE, bNorm = FALSE, bFP = FALSE;
static int ngroups = 1;
static real ctime = -1, scale = 0, binwidth = 1;
t_pargs pa[] = {
{ "-com", FALSE, etBOOL, {&bCom},
"Plot data for the com of each group" },
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Make molecules whole for COM" },
{ "-mol", FALSE, etBOOL, {&bMol},
"Index contains molecule numbers iso atom numbers" },
{ "-nojump", FALSE, etBOOL, {&bNoJump},
"Remove jumps of atoms across the box" },
{ "-x", FALSE, etBOOL, {&bX},
"Plot X-component" },
{ "-y", FALSE, etBOOL, {&bY},
"Plot Y-component" },
{ "-z", FALSE, etBOOL, {&bZ},
"Plot Z-component" },
{ "-ng", FALSE, etINT, {&ngroups},
"Number of groups to consider" },
{ "-len", FALSE, etBOOL, {&bNorm},
"Plot vector length" },
{ "-fp", FALSE, etBOOL, {&bFP},
"Full precision output" },
{ "-bin", FALSE, etREAL, {&binwidth},
"Binwidth for velocity histogram (nm/ps)" },
{ "-ctime", FALSE, etREAL, {&ctime},
"Use frame at this time for x in [TT]-cv[tt] and [TT]-cf[tt] instead of the average x" },
{ "-scale", FALSE, etREAL, {&scale},
"Scale factor for [REF].pdb[ref] output, 0 is autoscale" }
};
FILE *outx = NULL, *outv = NULL, *outf = NULL, *outb = NULL, *outt = NULL;
FILE *outekt = NULL, *outekr = NULL;
t_topology top;
int ePBC;
real *mass, time;
const char *indexfn;
t_trxframe fr, frout;
int flags, nvhisto = 0, *vhisto = NULL;
rvec *xtop, *xp = NULL;
rvec *sumx = NULL, *sumv = NULL, *sumf = NULL;
matrix topbox;
t_trxstatus *status;
t_trxstatus *status_out = NULL;
gmx_rmpbc_t gpbc = NULL;
int i, j;
int nr_xfr, nr_vfr, nr_ffr;
char **grpname;
int *isize0, *isize;
int **index0, **index;
int *atndx;
t_block *mols;
gmx_bool bTop, bOX, bOXT, bOV, bOF, bOB, bOT, bEKT, bEKR, bCV, bCF;
gmx_bool bDim[4], bDum[4], bVD;
char sffmt[STRLEN], sffmt6[STRLEN];
const char *box_leg[6] = { "XX", "YY", "ZZ", "YX", "ZX", "ZY" };
gmx_output_env_t *oenv;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-ox", "coord", ffOPTWR },
{ efTRX, "-oxt", "coord", ffOPTWR },
{ efXVG, "-ov", "veloc", ffOPTWR },
{ efXVG, "-of", "force", ffOPTWR },
{ efXVG, "-ob", "box", ffOPTWR },
{ efXVG, "-ot", "temp", ffOPTWR },
{ efXVG, "-ekt", "ektrans", ffOPTWR },
{ efXVG, "-ekr", "ekrot", ffOPTWR },
{ efXVG, "-vd", "veldist", ffOPTWR },
{ efPDB, "-cv", "veloc", ffOPTWR },
{ efPDB, "-cf", "force", ffOPTWR },
{ efXVG, "-av", "all_veloc", ffOPTWR },
{ efXVG, "-af", "all_force", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv,
PCA_CAN_TIME | PCA_TIME_UNIT | PCA_CAN_VIEW,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
if (bMol)
{
fprintf(stderr, "Interpreting indexfile entries as molecules.\n"
"Using center of mass.\n");
}
bOX = opt2bSet("-ox", NFILE, fnm);
bOXT = opt2bSet("-oxt", NFILE, fnm);
bOV = opt2bSet("-ov", NFILE, fnm);
bOF = opt2bSet("-of", NFILE, fnm);
bOB = opt2bSet("-ob", NFILE, fnm);
bOT = opt2bSet("-ot", NFILE, fnm);
bEKT = opt2bSet("-ekt", NFILE, fnm);
bEKR = opt2bSet("-ekr", NFILE, fnm);
bCV = opt2bSet("-cv", NFILE, fnm) || opt2bSet("-av", NFILE, fnm);
bCF = opt2bSet("-cf", NFILE, fnm) || opt2bSet("-af", NFILE, fnm);
bVD = opt2bSet("-vd", NFILE, fnm) || opt2parg_bSet("-bin", asize(pa), pa);
if (bMol || bOT || bEKT || bEKR)
{
bCom = TRUE;
}
bDim[XX] = bX;
bDim[YY] = bY;
bDim[ZZ] = bZ;
bDim[DIM] = bNorm;
if (bFP)
{
sprintf(sffmt, "\t%s", gmx_real_fullprecision_pfmt);
}
else
{
sprintf(sffmt, "\t%%g");
}
sprintf(sffmt6, "%s%s%s%s%s%s", sffmt, sffmt, sffmt, sffmt, sffmt, sffmt);
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC,
&xtop, NULL, topbox,
bCom && (bOX || bOXT || bOV || bOT || bEKT || bEKR));
sfree(xtop);
if ((bMol || bCV || bCF) && !bTop)
{
gmx_fatal(FARGS, "Need a run input file for option -mol, -cv or -cf");
}
if (bMol)
{
indexfn = ftp2fn(efNDX, NFILE, fnm);
}
else
{
indexfn = ftp2fn_null(efNDX, NFILE, fnm);
}
if (!(bCom && !bMol))
{
ngroups = 1;
}
snew(grpname, ngroups);
snew(isize0, ngroups);
snew(index0, ngroups);
get_index(&(top.atoms), indexfn, ngroups, isize0, index0, grpname);
if (bMol)
{
mols = &(top.mols);
atndx = mols->index;
ngroups = isize0[0];
snew(isize, ngroups);
snew(index, ngroups);
for (i = 0; i < ngroups; i++)
{
if (index0[0][i] < 0 || index0[0][i] >= mols->nr)
{
gmx_fatal(FARGS, "Molecule index (%d) is out of range (%d-%d)",
index0[0][i]+1, 1, mols->nr);
}
isize[i] = atndx[index0[0][i]+1] - atndx[index0[0][i]];
snew(index[i], isize[i]);
for (j = 0; j < isize[i]; j++)
{
index[i][j] = atndx[index0[0][i]] + j;
}
}
}
else
{
isize = isize0;
index = index0;
}
if (bCom)
{
snew(mass, top.atoms.nr);
for (i = 0; i < top.atoms.nr; i++)
{
mass[i] = top.atoms.atom[i].m;
}
}
else
{
mass = NULL;
}
flags = 0;
if (bOX)
{
flags = flags | TRX_READ_X;
outx = xvgropen(opt2fn("-ox", NFILE, fnm),
bCom ? "Center of mass" : "Coordinate",
output_env_get_xvgr_tlabel(oenv), "Coordinate (nm)", oenv);
make_legend(outx, ngroups, isize0[0], index0[0], grpname, bCom, bMol, bDim, oenv);
}
if (bOXT)
{
flags = flags | TRX_READ_X;
status_out = open_trx(opt2fn("-oxt", NFILE, fnm), "w");
}
if (bOV)
{
flags = flags | TRX_READ_V;
outv = xvgropen(opt2fn("-ov", NFILE, fnm),
bCom ? "Center of mass velocity" : "Velocity",
output_env_get_xvgr_tlabel(oenv), "Velocity (nm/ps)", oenv);
make_legend(outv, ngroups, isize0[0], index0[0], grpname, bCom, bMol, bDim, oenv);
}
if (bOF)
{
flags = flags | TRX_READ_F;
outf = xvgropen(opt2fn("-of", NFILE, fnm), "Force",
output_env_get_xvgr_tlabel(oenv), "Force (kJ mol\\S-1\\N nm\\S-1\\N)",
oenv);
make_legend(outf, ngroups, isize0[0], index0[0], grpname, bCom, bMol, bDim, oenv);
}
if (bOB)
{
outb = xvgropen(opt2fn("-ob", NFILE, fnm), "Box vector elements",
output_env_get_xvgr_tlabel(oenv), "(nm)", oenv);
xvgr_legend(outb, 6, box_leg, oenv);
}
if (bOT)
{
bDum[XX] = FALSE;
bDum[YY] = FALSE;
bDum[ZZ] = FALSE;
bDum[DIM] = TRUE;
flags = flags | TRX_READ_V;
outt = xvgropen(opt2fn("-ot", NFILE, fnm), "Temperature",
output_env_get_xvgr_tlabel(oenv), "(K)", oenv);
make_legend(outt, ngroups, isize[0], index[0], grpname, bCom, bMol, bDum, oenv);
}
if (bEKT)
{
bDum[XX] = FALSE;
bDum[YY] = FALSE;
bDum[ZZ] = FALSE;
bDum[DIM] = TRUE;
flags = flags | TRX_READ_V;
outekt = xvgropen(opt2fn("-ekt", NFILE, fnm), "Center of mass translation",
output_env_get_xvgr_tlabel(oenv), "Energy (kJ mol\\S-1\\N)", oenv);
make_legend(outekt, ngroups, isize[0], index[0], grpname, bCom, bMol, bDum, oenv);
}
if (bEKR)
{
bDum[XX] = FALSE;
bDum[YY] = FALSE;
bDum[ZZ] = FALSE;
bDum[DIM] = TRUE;
flags = flags | TRX_READ_X | TRX_READ_V;
outekr = xvgropen(opt2fn("-ekr", NFILE, fnm), "Center of mass rotation",
output_env_get_xvgr_tlabel(oenv), "Energy (kJ mol\\S-1\\N)", oenv);
make_legend(outekr, ngroups, isize[0], index[0], grpname, bCom, bMol, bDum, oenv);
}
if (bVD)
{
flags = flags | TRX_READ_V;
}
if (bCV)
{
flags = flags | TRX_READ_X | TRX_READ_V;
}
if (bCF)
{
flags = flags | TRX_READ_X | TRX_READ_F;
}
if ((flags == 0) && !bOB)
{
fprintf(stderr, "Please select one or more output file options\n");
exit(0);
}
read_first_frame(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &fr, flags);
if ((bOV || bOF) && fn2ftp(ftp2fn(efTRX, NFILE, fnm)) == efXTC)
{
gmx_fatal(FARGS, "Cannot extract velocities or forces since your input XTC file does not contain them.");
}
if (bCV || bCF)
{
snew(sumx, fr.natoms);
}
if (bCV)
{
snew(sumv, fr.natoms);
}
if (bCF)
{
snew(sumf, fr.natoms);
}
nr_xfr = 0;
nr_vfr = 0;
nr_ffr = 0;
if (bCom && bPBC)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, fr.natoms);
}
do
{
time = output_env_conv_time(oenv, fr.time);
if (fr.bX && bNoJump && fr.bBox)
{
if (xp)
{
remove_jump(fr.box, fr.natoms, xp, fr.x);
}
else
{
snew(xp, fr.natoms);
}
for (i = 0; i < fr.natoms; i++)
{
copy_rvec(fr.x[i], xp[i]);
}
}
if (fr.bX && bCom && bPBC)
{
gmx_rmpbc_trxfr(gpbc, &fr);
}
if (bVD && fr.bV)
{
update_histo(isize[0], index[0], fr.v, &nvhisto, &vhisto, binwidth);
}
if (bOX && fr.bX)
{
print_data(outx, time, fr.x, mass, bCom, ngroups, isize, index, bDim, sffmt);
}
if (bOXT && fr.bX)
{
frout = fr;
if (!frout.bAtoms)
{
frout.atoms = &top.atoms;
frout.bAtoms = TRUE;
}
write_trx_x(status_out, &frout, mass, bCom, ngroups, isize, index);
}
if (bOV && fr.bV)
{
print_data(outv, time, fr.v, mass, bCom, ngroups, isize, index, bDim, sffmt);
}
if (bOF && fr.bF)
{
print_data(outf, time, fr.f, NULL, bCom, ngroups, isize, index, bDim, sffmt);
}
if (bOB && fr.bBox)
{
fprintf(outb, "\t%g", fr.time);
fprintf(outb, sffmt6,
fr.box[XX][XX], fr.box[YY][YY], fr.box[ZZ][ZZ],
fr.box[YY][XX], fr.box[ZZ][XX], fr.box[ZZ][YY]);
fprintf(outb, "\n");
}
if (bOT && fr.bV)
{
fprintf(outt, " %g", time);
for (i = 0; i < ngroups; i++)
{
fprintf(outt, sffmt, temp(fr.v, mass, isize[i], index[i]));
}
fprintf(outt, "\n");
}
if (bEKT && fr.bV)
{
fprintf(outekt, " %g", time);
for (i = 0; i < ngroups; i++)
{
fprintf(outekt, sffmt, ektrans(fr.v, mass, isize[i], index[i]));
}
fprintf(outekt, "\n");
}
if (bEKR && fr.bX && fr.bV)
{
fprintf(outekr, " %g", time);
for (i = 0; i < ngroups; i++)
{
fprintf(outekr, sffmt, ekrot(fr.x, fr.v, mass, isize[i], index[i]));
}
fprintf(outekr, "\n");
}
if ((bCV || bCF) && fr.bX &&
(ctime < 0 || (fr.time >= ctime*0.999999 &&
fr.time <= ctime*1.000001)))
{
for (i = 0; i < fr.natoms; i++)
{
rvec_inc(sumx[i], fr.x[i]);
}
nr_xfr++;
}
if (bCV && fr.bV)
{
for (i = 0; i < fr.natoms; i++)
{
rvec_inc(sumv[i], fr.v[i]);
}
nr_vfr++;
}
if (bCF && fr.bF)
{
for (i = 0; i < fr.natoms; i++)
{
rvec_inc(sumf[i], fr.f[i]);
}
nr_ffr++;
}
}
while (read_next_frame(oenv, status, &fr));
if (gpbc != NULL)
{
gmx_rmpbc_done(gpbc);
}
/* clean up a bit */
close_trj(status);
if (bOX)
{
xvgrclose(outx);
}
if (bOXT)
{
close_trx(status_out);
}
if (bOV)
{
xvgrclose(outv);
}
if (bOF)
{
xvgrclose(outf);
}
if (bOB)
{
xvgrclose(outb);
}
if (bOT)
{
xvgrclose(outt);
}
if (bEKT)
{
xvgrclose(outekt);
}
if (bEKR)
{
xvgrclose(outekr);
}
if (bVD)
{
print_histo(opt2fn("-vd", NFILE, fnm), nvhisto, vhisto, binwidth, oenv);
}
if (bCV || bCF)
{
if (nr_xfr > 1)
{
if (ePBC != epbcNONE && !bNoJump)
{
fprintf(stderr, "\nWARNING: More than one frame was used for option -cv or -cf\n"
"If atoms jump across the box you should use the -nojump or -ctime option\n\n");
}
for (i = 0; i < isize[0]; i++)
{
svmul(1.0/nr_xfr, sumx[index[0][i]], sumx[index[0][i]]);
}
}
else if (nr_xfr == 0)
{
fprintf(stderr, "\nWARNING: No coordinate frames found for option -cv or -cf\n\n");
}
}
if (bCV)
{
write_pdb_bfac(opt2fn("-cv", NFILE, fnm),
opt2fn("-av", NFILE, fnm), "average velocity", &(top.atoms),
ePBC, topbox, isize[0], index[0], nr_xfr, sumx,
nr_vfr, sumv, bDim, scale, oenv);
}
if (bCF)
{
write_pdb_bfac(opt2fn("-cf", NFILE, fnm),
opt2fn("-af", NFILE, fnm), "average force", &(top.atoms),
ePBC, topbox, isize[0], index[0], nr_xfr, sumx,
nr_ffr, sumf, bDim, scale, oenv);
}
/* view it */
view_all(oenv, NFILE, fnm);
return 0;
}
int gmx_enemat(int argc, char *argv[])
{
const char *desc[] = {
"[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",
"by looking for energy groups with names corresponding to pairs",
"of groups of atoms, e.g. if your [TT]-groups[tt] file contains::",
"",
" 2",
" Protein",
" SOL",
"",
"then energy groups with names like 'Coul-SR:Protein-SOL' and ",
"'LJ:Protein-SOL' are expected in the energy file (although",
"[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], ",
"[TT]-[no]lj[tt], [TT]-[no]lj14[tt], ",
"[TT]-[no]bham[tt] and [TT]-[no]free[tt] options.",
"Finally, the total interaction energy energy per group can be ",
"calculated ([TT]-etot[tt]).[PAR]",
"An approximation of the free energy can be calculated using:",
"[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)",
"in the reference file should correspond to the group names",
"as used in the [TT]-groups[tt] file, but a appended number",
"(e.g. residue number) in the [TT]-groups[tt] will be ignored",
"in the comparison."
};
static gmx_bool bSum = FALSE;
static gmx_bool bMeanEmtx = TRUE;
static int skip = 0, nlevels = 20;
static real cutmax = 1e20, cutmin = -1e20, reftemp = 300.0;
static gmx_bool bCoulSR = TRUE, bCoul14 = FALSE;
static gmx_bool bLJSR = TRUE, bLJ14 = FALSE, bBhamSR = FALSE,
bFree = TRUE;
t_pargs pa[] = {
{ "-sum", FALSE, etBOOL, {&bSum},
"Sum the energy terms selected rather than display them all" },
{ "-skip", FALSE, etINT, {&skip},
"Skip number of frames between data points" },
{ "-mean", FALSE, etBOOL, {&bMeanEmtx},
"with [TT]-groups[tt] extracts matrix of mean energies instead of "
"matrix for each timestep" },
{ "-nlevels", FALSE, etINT, {&nlevels}, "number of levels for matrix colors"},
{ "-max", FALSE, etREAL, {&cutmax}, "max value for energies"},
{ "-min", FALSE, etREAL, {&cutmin}, "min value for energies"},
{ "-coulsr", FALSE, etBOOL, {&bCoulSR}, "extract Coulomb SR energies"},
{ "-coul14", FALSE, etBOOL, {&bCoul14}, "extract Coulomb 1-4 energies"},
{ "-ljsr", FALSE, etBOOL, {&bLJSR}, "extract Lennard-Jones SR energies"},
{ "-lj14", FALSE, etBOOL, {&bLJ14}, "extract Lennard-Jones 1-4 energies"},
{ "-bhamsr", FALSE, etBOOL, {&bBhamSR}, "extract Buckingham SR energies"},
{ "-free", FALSE, etBOOL, {&bFree}, "calculate free energy"},
{ "-temp", FALSE, etREAL, {&reftemp},
"reference temperature for free energy calculation"}
};
/* We will define egSP more energy-groups:
egTotal (total energy) */
#define egTotal egNR
#define egSP 1
gmx_bool egrp_use[egNR+egSP];
ener_file_t in;
FILE *out;
int timecheck = 0;
gmx_enxnm_t *enm = NULL;
t_enxframe *fr;
int teller = 0;
real sum;
gmx_bool bCont, bRef;
gmx_bool bCutmax, bCutmin;
real **eneset, *time = NULL;
int *set, i, j, k, prevk, m = 0, n, nre, nset, nenergy;
char **groups = NULL;
char groupname[255], fn[255];
int ngroups;
t_rgb rlo, rhi, rmid;
real emax, emid, emin;
real ***emat, **etot, *groupnr;
double beta, expE, **e, *eaver, *efree = NULL, edum;
char label[234];
char **ereflines, **erefres = NULL;
real *eref = NULL, *edif = NULL;
int neref = 0;
gmx_output_env_t *oenv;
t_filenm fnm[] = {
{ efEDR, "-f", NULL, ffOPTRD },
{ efDAT, "-groups", "groups", ffREAD },
{ efDAT, "-eref", "eref", ffOPTRD },
{ efXPM, "-emat", "emat", ffWRITE },
{ efXVG, "-etot", "energy", ffWRITE }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_VIEW | PCA_CAN_TIME,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
for (i = 0; (i < egNR+egSP); i++)
{
egrp_use[i] = FALSE;
}
egrp_use[egCOULSR] = bCoulSR;
egrp_use[egLJSR] = bLJSR;
egrp_use[egBHAMSR] = bBhamSR;
egrp_use[egCOUL14] = bCoul14;
egrp_use[egLJ14] = bLJ14;
egrp_use[egTotal] = TRUE;
bRef = opt2bSet("-eref", NFILE, fnm);
in = open_enx(ftp2fn(efEDR, NFILE, fnm), "r");
do_enxnms(in, &nre, &enm);
if (nre == 0)
{
gmx_fatal(FARGS, "No energies!\n");
}
bCutmax = opt2parg_bSet("-max", asize(pa), pa);
bCutmin = opt2parg_bSet("-min", asize(pa), pa);
nenergy = 0;
/* Read groupnames from input file and construct selection of
energy groups from it*/
fprintf(stderr, "Will read groupnames from inputfile\n");
ngroups = get_lines(opt2fn("-groups", NFILE, fnm), &groups);
fprintf(stderr, "Read %d groups\n", ngroups);
snew(set, static_cast<size_t>(gmx::square(ngroups)*egNR/2));
n = 0;
prevk = 0;
for (i = 0; (i < ngroups); i++)
{
fprintf(stderr, "\rgroup %d", i);
for (j = i; (j < ngroups); j++)
{
for (m = 0; (m < egNR); m++)
{
if (egrp_use[m])
{
sprintf(groupname, "%s:%s-%s", egrp_nm[m], groups[i], groups[j]);
#ifdef DEBUG
fprintf(stderr, "\r%-15s %5d", groupname, n);
#endif
for (k = prevk; (k < prevk+nre); k++)
{
if (std::strcmp(enm[k%nre].name, groupname) == 0)
{
set[n++] = k;
break;
}
}
if (k == prevk+nre)
{
fprintf(stderr, "WARNING! could not find group %s (%d,%d)"
"in energy file\n", groupname, i, j);
}
else
{
prevk = k;
}
}
}
}
}
fprintf(stderr, "\n");
nset = n;
snew(eneset, nset+1);
fprintf(stderr, "Will select half-matrix of energies with %d elements\n", n);
/* Start reading energy frames */
snew(fr, 1);
do
{
do
{
bCont = do_enx(in, fr);
if (bCont)
{
timecheck = check_times(fr->t);
}
}
while (bCont && (timecheck < 0));
if (timecheck == 0)
{
#define DONTSKIP(cnt) (skip) ? ((cnt % skip) == 0) : TRUE
if (bCont)
{
fprintf(stderr, "\rRead frame: %d, Time: %.3f", teller, fr->t);
if ((nenergy % 1000) == 0)
{
srenew(time, nenergy+1000);
for (i = 0; (i <= nset); i++)
{
srenew(eneset[i], nenergy+1000);
}
}
time[nenergy] = fr->t;
sum = 0;
for (i = 0; (i < nset); i++)
{
eneset[i][nenergy] = fr->ener[set[i]].e;
sum += fr->ener[set[i]].e;
}
if (bSum)
{
eneset[nset][nenergy] = sum;
}
nenergy++;
}
teller++;
}
}
while (bCont && (timecheck == 0));
fprintf(stderr, "\n");
fprintf(stderr, "Will build energy half-matrix of %d groups, %d elements, "
"over %d frames\n", ngroups, nset, nenergy);
snew(emat, egNR+egSP);
for (j = 0; (j < egNR+egSP); j++)
{
if (egrp_use[m])
{
snew(emat[j], ngroups);
for (i = 0; (i < ngroups); i++)
{
snew(emat[j][i], ngroups);
}
}
}
snew(groupnr, ngroups);
for (i = 0; (i < ngroups); i++)
{
groupnr[i] = i+1;
}
rlo.r = 1.0, rlo.g = 0.0, rlo.b = 0.0;
rmid.r = 1.0, rmid.g = 1.0, rmid.b = 1.0;
rhi.r = 0.0, rhi.g = 0.0, rhi.b = 1.0;
if (bMeanEmtx)
{
snew(e, ngroups);
for (i = 0; (i < ngroups); i++)
{
snew(e[i], nenergy);
}
n = 0;
for (i = 0; (i < ngroups); i++)
{
for (j = i; (j < ngroups); j++)
{
for (m = 0; (m < egNR); m++)
{
if (egrp_use[m])
{
for (k = 0; (k < nenergy); k++)
{
emat[m][i][j] += eneset[n][k];
e[i][k] += eneset[n][k]; /* *0.5; */
e[j][k] += eneset[n][k]; /* *0.5; */
}
n++;
emat[egTotal][i][j] += emat[m][i][j];
emat[m][i][j] /= nenergy;
emat[m][j][i] = emat[m][i][j];
}
}
emat[egTotal][i][j] /= nenergy;
emat[egTotal][j][i] = emat[egTotal][i][j];
}
}
if (bFree)
{
if (bRef)
{
fprintf(stderr, "Will read reference energies from inputfile\n");
neref = get_lines(opt2fn("-eref", NFILE, fnm), &ereflines);
fprintf(stderr, "Read %d reference energies\n", neref);
snew(eref, neref);
snew(erefres, neref);
for (i = 0; (i < neref); i++)
{
snew(erefres[i], 5);
sscanf(ereflines[i], "%s %lf", erefres[i], &edum);
eref[i] = edum;
}
}
snew(eaver, ngroups);
for (i = 0; (i < ngroups); i++)
{
for (k = 0; (k < nenergy); k++)
{
eaver[i] += e[i][k];
}
eaver[i] /= nenergy;
}
beta = 1.0/(BOLTZ*reftemp);
snew(efree, ngroups);
snew(edif, ngroups);
for (i = 0; (i < ngroups); i++)
{
expE = 0;
for (k = 0; (k < nenergy); k++)
{
expE += std::exp(beta*(e[i][k]-eaver[i]));
}
efree[i] = std::log(expE/nenergy)/beta + eaver[i];
if (bRef)
{
n = search_str2(neref, erefres, groups[i]);
if (n != -1)
{
edif[i] = efree[i]-eref[n];
}
else
{
edif[i] = efree[i];
fprintf(stderr, "WARNING: group %s not found "
"in reference energies.\n", groups[i]);
}
}
else
{
edif[i] = 0;
}
}
}
emid = 0.0; /*(emin+emax)*0.5;*/
egrp_nm[egTotal] = "total";
for (m = 0; (m < egNR+egSP); m++)
{
if (egrp_use[m])
{
emin = 1e10;
emax = -1e10;
for (i = 0; (i < ngroups); i++)
{
for (j = i; (j < ngroups); j++)
{
if (emat[m][i][j] > emax)
{
emax = emat[m][i][j];
}
else if (emat[m][i][j] < emin)
{
emin = emat[m][i][j];
}
}
}
if (emax == emin)
{
fprintf(stderr, "Matrix of %s energy is uniform at %f "
"(will not produce output).\n", egrp_nm[m], emax);
}
else
{
fprintf(stderr, "Matrix of %s energy ranges from %f to %f\n",
egrp_nm[m], emin, emax);
if ((bCutmax) || (emax > cutmax))
{
emax = cutmax;
}
if ((bCutmin) || (emin < cutmin))
{
emin = cutmin;
}
if ((emax == cutmax) || (emin == cutmin))
{
fprintf(stderr, "Energy range adjusted: %f to %f\n", emin, emax);
}
sprintf(fn, "%s%s", egrp_nm[m], ftp2fn(efXPM, NFILE, fnm));
sprintf(label, "%s Interaction Energies", egrp_nm[m]);
out = gmx_ffopen(fn, "w");
if (emin >= emid)
{
write_xpm(out, 0, label, "Energy (kJ/mol)",
"Residue Index", "Residue Index",
ngroups, ngroups, groupnr, groupnr, emat[m],
emid, emax, rmid, rhi, &nlevels);
}
else if (emax <= emid)
{
write_xpm(out, 0, label, "Energy (kJ/mol)",
"Residue Index", "Residue Index",
ngroups, ngroups, groupnr, groupnr, emat[m],
emin, emid, rlo, rmid, &nlevels);
}
else
{
write_xpm3(out, 0, label, "Energy (kJ/mol)",
"Residue Index", "Residue Index",
ngroups, ngroups, groupnr, groupnr, emat[m],
emin, emid, emax, rlo, rmid, rhi, &nlevels);
}
gmx_ffclose(out);
}
}
}
snew(etot, egNR+egSP);
for (m = 0; (m < egNR+egSP); m++)
{
snew(etot[m], ngroups);
for (i = 0; (i < ngroups); i++)
{
for (j = 0; (j < ngroups); j++)
{
etot[m][i] += emat[m][i][j];
}
}
}
out = xvgropen(ftp2fn(efXVG, NFILE, fnm), "Mean Energy", "Residue", "kJ/mol",
oenv);
xvgr_legend(out, 0, NULL, oenv);
j = 0;
if (output_env_get_print_xvgr_codes(oenv))
{
char str1[STRLEN], str2[STRLEN];
if (output_env_get_xvg_format(oenv) == exvgXMGR)
{
sprintf(str1, "@ legend string ");
sprintf(str2, " ");
}
else
{
sprintf(str1, "@ s");
sprintf(str2, " legend ");
}
for (m = 0; (m < egNR+egSP); m++)
{
if (egrp_use[m])
{
fprintf(out, "%s%d%s \"%s\"\n", str1, j++, str2, egrp_nm[m]);
}
}
if (bFree)
{
fprintf(out, "%s%d%s \"%s\"\n", str1, j++, str2, "Free");
}
if (bFree)
{
fprintf(out, "%s%d%s \"%s\"\n", str1, j++, str2, "Diff");
}
fprintf(out, "@TYPE xy\n");
fprintf(out, "#%3s", "grp");
for (m = 0; (m < egNR+egSP); m++)
{
if (egrp_use[m])
{
fprintf(out, " %9s", egrp_nm[m]);
}
}
if (bFree)
{
fprintf(out, " %9s", "Free");
}
if (bFree)
{
fprintf(out, " %9s", "Diff");
}
fprintf(out, "\n");
}
for (i = 0; (i < ngroups); i++)
{
fprintf(out, "%3.0f", groupnr[i]);
for (m = 0; (m < egNR+egSP); m++)
{
if (egrp_use[m])
{
fprintf(out, " %9.5g", etot[m][i]);
}
}
if (bFree)
{
fprintf(out, " %9.5g", efree[i]);
}
if (bRef)
{
fprintf(out, " %9.5g", edif[i]);
}
fprintf(out, "\n");
}
xvgrclose(out);
}
else
{
fprintf(stderr, "While typing at your keyboard, suddenly...\n"
"...nothing happens.\nWARNING: Not Implemented Yet\n");
/*
out=ftp2FILE(efMAT,NFILE,fnm,"w");
n=0;
emin=emax=0.0;
for (k=0; (k<nenergy); k++) {
for (i=0; (i<ngroups); i++)
for (j=i+1; (j<ngroups); j++)
emat[i][j]=eneset[n][k];
sprintf(label,"t=%.0f ps",time[k]);
write_matrix(out,ngroups,1,ngroups,groupnr,emat,label,emin,emax,nlevels);
n++;
}
gmx_ffclose(out);
*/
}
close_enx(in);
return 0;
}
int gmx_make_edi(int argc, char *argv[])
{
static const char *desc[] = {
"[THISMODULE] generates an essential dynamics (ED) sampling input file to be used with [TT]mdrun[tt]",
"based on eigenvectors of a covariance matrix ([gmx-covar]) or from a",
"normal modes analysis ([gmx-nmeig]).",
"ED sampling can be used to manipulate the position along collective coordinates",
"(eigenvectors) of (biological) macromolecules during a simulation. Particularly,",
"it may be used to enhance the sampling efficiency of MD simulations by stimulating",
"the system to explore new regions along these collective coordinates. A number",
"of different algorithms are implemented to drive the system along the eigenvectors",
"([TT]-linfix[tt], [TT]-linacc[tt], [TT]-radfix[tt], [TT]-radacc[tt], [TT]-radcon[tt]),",
"to keep the position along a certain (set of) coordinate(s) fixed ([TT]-linfix[tt]),",
"or to only monitor the projections of the positions onto",
"these coordinates ([TT]-mon[tt]).[PAR]",
"References:[BR]",
"A. Amadei, A.B.M. Linssen, B.L. de Groot, D.M.F. van Aalten and ",
"H.J.C. Berendsen; An efficient method for sampling the essential subspace ",
"of proteins., J. Biomol. Struct. Dyn. 13:615-626 (1996)[BR]",
"B.L. de Groot, A. Amadei, D.M.F. van Aalten and H.J.C. Berendsen; ",
"Towards an exhaustive sampling of the configurational spaces of the ",
"two forms of the peptide hormone guanylin,",
"J. Biomol. Struct. Dyn. 13 : 741-751 (1996)[BR]",
"B.L. de Groot, A.Amadei, R.M. Scheek, N.A.J. van Nuland and H.J.C. Berendsen; ",
"An extended sampling of the configurational space of HPr from E. coli",
"Proteins: Struct. Funct. Gen. 26: 314-322 (1996)",
"[PAR]You will be prompted for one or more index groups that correspond to the eigenvectors,",
"reference structure, target positions, etc.[PAR]",
"[TT]-mon[tt]: monitor projections of the coordinates onto selected eigenvectors.[PAR]",
"[TT]-linfix[tt]: perform fixed-step linear expansion along selected eigenvectors.[PAR]",
"[TT]-linacc[tt]: perform acceptance linear expansion along selected eigenvectors.",
"(steps in the desired directions will be accepted, others will be rejected).[PAR]",
"[TT]-radfix[tt]: perform fixed-step radius expansion along selected eigenvectors.[PAR]",
"[TT]-radacc[tt]: perform acceptance radius expansion along selected eigenvectors.",
"(steps in the desired direction will be accepted, others will be rejected).",
"[BB]Note:[bb] by default the starting MD structure will be taken as origin of the first",
"expansion cycle for radius expansion. If [TT]-ori[tt] is specified, you will be able",
"to read in a structure file that defines an external origin.[PAR]",
"[TT]-radcon[tt]: perform acceptance radius contraction along selected eigenvectors",
"towards a target structure specified with [TT]-tar[tt].[PAR]",
"NOTE: each eigenvector can be selected only once. [PAR]",
"[TT]-outfrq[tt]: frequency (in steps) of writing out projections etc. to [TT].xvg[tt] file[PAR]",
"[TT]-slope[tt]: minimal slope in acceptance radius expansion. A new expansion",
"cycle will be started if the spontaneous increase of the radius (in nm/step)",
"is less than the value specified.[PAR]",
"[TT]-maxedsteps[tt]: maximum number of steps per cycle in radius expansion",
"before a new cycle is started.[PAR]",
"Note on the parallel implementation: since ED sampling is a 'global' thing",
"(collective coordinates etc.), at least on the 'protein' side, ED sampling",
"is not very parallel-friendly from an implementation point of view. Because",
"parallel ED requires some extra communication, expect the performance to be",
"lower as in a free MD simulation, especially on a large number of nodes and/or",
"when the ED group contains a lot of atoms. [PAR]",
"Please also note that if your ED group contains more than a single protein,",
"then the [TT].tpr[tt] file must contain the correct PBC representation of the ED group.",
"Take a look on the initial RMSD from the reference structure, which is printed",
"out at the start of the simulation; if this is much higher than expected, one",
"of the ED molecules might be shifted by a box vector. [PAR]",
"All ED-related output of [TT]mdrun[tt] (specify with [TT]-eo[tt]) is written to a [TT].xvg[tt] file",
"as a function of time in intervals of OUTFRQ steps.[PAR]",
"[BB]Note[bb] that you can impose multiple ED constraints and flooding potentials in",
"a single simulation (on different molecules) if several [TT].edi[tt] files were concatenated",
"first. The constraints are applied in the order they appear in the [TT].edi[tt] file. ",
"Depending on what was specified in the [TT].edi[tt] input file, the output file contains for each ED dataset[PAR]",
"[TT]*[tt] the RMSD of the fitted molecule to the reference structure (for atoms involved in fitting prior to calculating the ED constraints)[BR]",
"[TT]*[tt] projections of the positions onto selected eigenvectors[BR]",
"[PAR][PAR]",
"FLOODING:[PAR]",
"with [TT]-flood[tt], you can specify which eigenvectors are used to compute a flooding potential,",
"which will lead to extra forces expelling the structure out of the region described",
"by the covariance matrix. If you switch -restrain the potential is inverted and the structure",
"is kept in that region.",
"[PAR]",
"The origin is normally the average structure stored in the [TT]eigvec.trr[tt] file.",
"It can be changed with [TT]-ori[tt] to an arbitrary position in configuration space.",
"With [TT]-tau[tt], [TT]-deltaF0[tt], and [TT]-Eflnull[tt] you control the flooding behaviour.",
"Efl is the flooding strength, it is updated according to the rule of adaptive flooding.",
"Tau is the time constant of adaptive flooding, high [GRK]tau[grk] means slow adaption (i.e. growth). ",
"DeltaF0 is the flooding strength you want to reach after tau ps of simulation.",
"To use constant Efl set [TT]-tau[tt] to zero.",
"[PAR]",
"[TT]-alpha[tt] is a fudge parameter to control the width of the flooding potential. A value of 2 has been found",
"to give good results for most standard cases in flooding of proteins.",
"[GRK]alpha[grk] basically accounts for incomplete sampling, if you sampled further the width of the ensemble would",
"increase, this is mimicked by [GRK]alpha[grk] > 1.",
"For restraining, [GRK]alpha[grk] < 1 can give you smaller width in the restraining potential.",
"[PAR]",
"RESTART and FLOODING:",
"If you want to restart a crashed flooding simulation please find the values deltaF and Efl in",
"the output file and manually put them into the [TT].edi[tt] file under DELTA_F0 and EFL_NULL."
};
/* Save all the params in this struct and then save it in an edi file.
* ignoring fields nmass,massnrs,mass,tmass,nfit,fitnrs,edo
*/
static t_edipar edi_params;
enum {
evStepNr = evRADFIX + 1
};
static const char* evSelections[evNr] = {NULL, NULL, NULL, NULL, NULL, NULL};
static const char* evOptions[evNr] = {"-linfix", "-linacc", "-flood", "-radfix", "-radacc", "-radcon", "-mon"};
static const char* evParams[evStepNr] = {NULL, NULL};
static const char* evStepOptions[evStepNr] = {"-linstep", "-accdir", "-not_used", "-radstep"};
static const char* ConstForceStr;
static real * evStepList[evStepNr];
static real radstep = 0.0;
static real deltaF0 = 150;
static real deltaF = 0;
static real tau = .1;
static real constEfl = 0.0;
static real alpha = 1;
static int eqSteps = 0;
static int * listen[evNr];
static real T = 300.0;
const real kB = 2.5 / 300.0; /* k_boltzmann in MD units */
static gmx_bool bRestrain = FALSE;
static gmx_bool bHesse = FALSE;
static gmx_bool bHarmonic = FALSE;
t_pargs pa[] = {
{ "-mon", FALSE, etSTR, {&evSelections[evMON]},
"Indices of eigenvectors for projections of x (e.g. 1,2-5,9) or 1-100:10 means 1 11 21 31 ... 91" },
{ "-linfix", FALSE, etSTR, {&evSelections[0]},
"Indices of eigenvectors for fixed increment linear sampling" },
{ "-linacc", FALSE, etSTR, {&evSelections[1]},
"Indices of eigenvectors for acceptance linear sampling" },
{ "-radfix", FALSE, etSTR, {&evSelections[3]},
"Indices of eigenvectors for fixed increment radius expansion" },
{ "-radacc", FALSE, etSTR, {&evSelections[4]},
"Indices of eigenvectors for acceptance radius expansion" },
{ "-radcon", FALSE, etSTR, {&evSelections[5]},
"Indices of eigenvectors for acceptance radius contraction" },
{ "-flood", FALSE, etSTR, {&evSelections[2]},
"Indices of eigenvectors for flooding"},
{ "-outfrq", FALSE, etINT, {&edi_params.outfrq},
"Freqency (in steps) of writing output in [TT].xvg[tt] file" },
{ "-slope", FALSE, etREAL, { &edi_params.slope},
"Minimal slope in acceptance radius expansion"},
{ "-linstep", FALSE, etSTR, {&evParams[0]},
"Stepsizes (nm/step) for fixed increment linear sampling (put in quotes! \"1.0 2.3 5.1 -3.1\")"},
{ "-accdir", FALSE, etSTR, {&evParams[1]},
"Directions for acceptance linear sampling - only sign counts! (put in quotes! \"-1 +1 -1.1\")"},
{ "-radstep", FALSE, etREAL, {&radstep},
"Stepsize (nm/step) for fixed increment radius expansion"},
{ "-maxedsteps", FALSE, etINT, {&edi_params.maxedsteps},
"Maximum number of steps per cycle" },
{ "-eqsteps", FALSE, etINT, {&eqSteps},
"Number of steps to run without any perturbations "},
{ "-deltaF0", FALSE, etREAL, {&deltaF0},
"Target destabilization energy for flooding"},
{ "-deltaF", FALSE, etREAL, {&deltaF},
"Start deltaF with this parameter - default 0, nonzero values only needed for restart"},
{ "-tau", FALSE, etREAL, {&tau},
"Coupling constant for adaption of flooding strength according to deltaF0, 0 = infinity i.e. constant flooding strength"},
{ "-Eflnull", FALSE, etREAL, {&constEfl},
"The starting value of the flooding strength. The flooding strength is updated "
"according to the adaptive flooding scheme. For a constant flooding strength use [TT]-tau[tt] 0. "},
{ "-T", FALSE, etREAL, {&T},
"T is temperature, the value is needed if you want to do flooding "},
{ "-alpha", FALSE, etREAL, {&alpha},
"Scale width of gaussian flooding potential with alpha^2 "},
{ "-restrain", FALSE, etBOOL, {&bRestrain},
"Use the flooding potential with inverted sign -> effects as quasiharmonic restraining potential"},
{ "-hessian", FALSE, etBOOL, {&bHesse},
"The eigenvectors and eigenvalues are from a Hessian matrix"},
{ "-harmonic", FALSE, etBOOL, {&bHarmonic},
"The eigenvalues are interpreted as spring constant"},
{ "-constF", FALSE, etSTR, {&ConstForceStr},
"Constant force flooding: manually set the forces for the eigenvectors selected with -flood "
"(put in quotes! \"1.0 2.3 5.1 -3.1\"). No other flooding parameters are needed when specifying the forces directly."}
};
#define NPA asize(pa)
rvec *xref1;
int nvec1, *eignr1 = NULL;
rvec *xav1, **eigvec1 = NULL;
t_atoms *atoms = NULL;
int nav; /* Number of atoms in the average structure */
char *grpname;
const char *indexfile;
int i;
atom_id *index, *ifit;
int nfit; /* Number of atoms in the reference/fit structure */
int ev_class; /* parameter _class i.e. evMON, evRADFIX etc. */
int nvecs;
real *eigval1 = NULL; /* in V3.3 this is parameter of read_eigenvectors */
const char *EdiFile;
const char *TargetFile;
const char *OriginFile;
const char *EigvecFile;
output_env_t oenv;
/*to read topology file*/
t_topology top;
int ePBC;
char title[STRLEN];
matrix topbox;
rvec *xtop;
gmx_bool bTop, bFit1;
t_filenm fnm[] = {
{ efTRN, "-f", "eigenvec", ffREAD },
{ efXVG, "-eig", "eigenval", ffOPTRD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efSTX, "-tar", "target", ffOPTRD},
{ efSTX, "-ori", "origin", ffOPTRD},
{ efEDI, "-o", "sam", ffWRITE }
};
#define NFILE asize(fnm)
edi_params.outfrq = 100; edi_params.slope = 0.0; edi_params.maxedsteps = 0;
if (!parse_common_args(&argc, argv, 0,
NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
indexfile = ftp2fn_null(efNDX, NFILE, fnm);
EdiFile = ftp2fn(efEDI, NFILE, fnm);
TargetFile = opt2fn_null("-tar", NFILE, fnm);
OriginFile = opt2fn_null("-ori", NFILE, fnm);
for (ev_class = 0; ev_class < evNr; ++ev_class)
{
if (opt2parg_bSet(evOptions[ev_class], NPA, pa))
{
/*get list of eigenvectors*/
nvecs = sscan_list(&(listen[ev_class]), opt2parg_str(evOptions[ev_class], NPA, pa), evOptions[ev_class]);
if (ev_class < evStepNr-2)
{
/*if apropriate get list of stepsizes for these eigenvectors*/
if (opt2parg_bSet(evStepOptions[ev_class], NPA, pa))
{
evStepList[ev_class] =
scan_vecparams(opt2parg_str(evStepOptions[ev_class], NPA, pa), evStepOptions[ev_class], nvecs);
}
else /*if list is not given fill with zeros */
{
snew(evStepList[ev_class], nvecs);
for (i = 0; i < nvecs; i++)
{
evStepList[ev_class][i] = 0.0;
}
}
}
else if (ev_class == evRADFIX)
{
snew(evStepList[ev_class], nvecs);
for (i = 0; i < nvecs; i++)
{
evStepList[ev_class][i] = radstep;
}
}
else if (ev_class == evFLOOD)
{
snew(evStepList[ev_class], nvecs);
/* Are we doing constant force flooding? In that case, we read in
* the fproj values from the command line */
if (opt2parg_bSet("-constF", NPA, pa))
{
evStepList[ev_class] = scan_vecparams(opt2parg_str("-constF", NPA, pa), "-constF", nvecs);
}
}
else
{
}; /*to avoid ambiguity */
}
else /* if there are no eigenvectors for this option set list to zero */
{
listen[ev_class] = NULL;
snew(listen[ev_class], 1);
listen[ev_class][0] = 0;
}
}
/* print the interpreted list of eigenvectors - to give some feedback*/
for (ev_class = 0; ev_class < evNr; ++ev_class)
{
printf("Eigenvector list %7s consists of the indices: ", evOptions[ev_class]);
i = 0;
while (listen[ev_class][i])
{
printf("%d ", listen[ev_class][i++]);
}
printf("\n");
}
EigvecFile = NULL;
EigvecFile = opt2fn("-f", NFILE, fnm);
/*read eigenvectors from eigvec.trr*/
read_eigenvectors(EigvecFile, &nav, &bFit1,
&xref1, &edi_params.fitmas, &xav1, &edi_params.pcamas, &nvec1, &eignr1, &eigvec1, &eigval1);
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm),
title, &top, &ePBC, &xtop, NULL, topbox, 0);
atoms = &top.atoms;
printf("\nSelect an index group of %d elements that corresponds to the eigenvectors\n", nav);
get_index(atoms, indexfile, 1, &i, &index, &grpname); /*if indexfile != NULL parameter 'atoms' is ignored */
if (i != nav)
{
gmx_fatal(FARGS, "you selected a group with %d elements instead of %d",
i, nav);
}
printf("\n");
if (xref1 == NULL)
{
if (bFit1)
{
/* if g_covar used different coordinate groups to fit and to do the PCA */
printf("\nNote: the structure in %s should be the same\n"
" as the one used for the fit in g_covar\n", ftp2fn(efTPS, NFILE, fnm));
printf("\nSelect the index group that was used for the least squares fit in g_covar\n");
}
else
{
printf("\nNote: Apparently no fitting was done in g_covar.\n"
" However, you need to select a reference group for fitting in mdrun\n");
}
get_index(atoms, indexfile, 1, &nfit, &ifit, &grpname);
snew(xref1, nfit);
for (i = 0; i < nfit; i++)
{
copy_rvec(xtop[ifit[i]], xref1[i]);
}
}
else
{
nfit = nav;
ifit = index;
}
if (opt2parg_bSet("-constF", NPA, pa))
{
/* Constant force flooding is special: Most of the normal flooding
* options are not needed. */
edi_params.flood.bConstForce = TRUE;
}
else
{
/* For normal flooding read eigenvalues and store them in evSteplist[evFLOOD] */
if (listen[evFLOOD][0] != 0)
{
read_eigenvalues(listen[evFLOOD], opt2fn("-eig", NFILE, fnm), evStepList[evFLOOD], bHesse, kB*T);
}
edi_params.flood.tau = tau;
edi_params.flood.deltaF0 = deltaF0;
edi_params.flood.deltaF = deltaF;
edi_params.presteps = eqSteps;
edi_params.flood.kT = kB*T;
edi_params.flood.bHarmonic = bHarmonic;
if (bRestrain)
{
/* Trick: invert sign of Efl and alpha2 then this will give the same sign in the exponential and inverted sign outside */
edi_params.flood.constEfl = -constEfl;
edi_params.flood.alpha2 = -sqr(alpha);
}
else
{
edi_params.flood.constEfl = constEfl;
edi_params.flood.alpha2 = sqr(alpha);
}
}
edi_params.ned = nav;
/*number of system atoms */
edi_params.nini = atoms->nr;
/*store reference and average structure in edi_params*/
make_t_edx(&edi_params.sref, nfit, xref1, ifit );
make_t_edx(&edi_params.sav, nav, xav1, index);
/* Store target positions in edi_params */
if (opt2bSet("-tar", NFILE, fnm))
{
if (0 != listen[evFLOOD][0])
{
fprintf(stderr, "\nNote: Providing a TARGET structure has no effect when using flooding.\n"
" You may want to use -ori to define the flooding potential center.\n\n");
}
get_structure(atoms, indexfile, TargetFile, &edi_params.star, nfit, ifit, nav, index);
}
else
{
make_t_edx(&edi_params.star, 0, NULL, index);
}
/* Store origin positions */
if (opt2bSet("-ori", NFILE, fnm))
{
get_structure(atoms, indexfile, OriginFile, &edi_params.sori, nfit, ifit, nav, index);
}
else
{
make_t_edx(&edi_params.sori, 0, NULL, index);
}
/* Write edi-file */
write_the_whole_thing(gmx_ffopen(EdiFile, "w"), &edi_params, eigvec1, nvec1, listen, evStepList);
return 0;
}
int gmx_make_ndx(int argc, char *argv[])
{
const char *desc[] = {
"Index groups are necessary for almost every GROMACS program.",
"All these programs can generate default index groups. You ONLY",
"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 [THISMODULE] will generate the",
"default groups.",
"With the index editor you can select on atom, residue and chain names",
"and numbers.",
"When a run input file is supplied you can also select on atom type.",
"You can use NOT, AND and OR, you can split groups",
"into chains, residues or atoms. You can delete and rename groups.[PAR]",
"The atom numbering in the editor and the index file starts at 1.[PAR]",
"The [TT]-twin[tt] switch duplicates all index groups with an offset of",
"[TT]-natoms[tt], which is useful for Computational Electrophysiology",
"double-layer membrane setups."
};
static int natoms = 0;
static gmx_bool bVerbose = FALSE;
static gmx_bool bDuplicate = FALSE;
t_pargs pa[] = {
{ "-natoms", FALSE, etINT, {&natoms},
"set number of atoms (default: read from coordinate or index file)" },
{ "-twin", FALSE, etBOOL, {&bDuplicate},
"Duplicate all index groups with an offset of -natoms" },
{ "-verbose", FALSE, etBOOL, {&bVerbose},
"HIDDENVerbose output" }
};
#define NPA asize(pa)
output_env_t oenv;
char title[STRLEN];
int nndxin;
const char *stxfile;
char **ndxinfiles;
const char *ndxoutfile;
gmx_bool bNatoms;
int i, j;
t_atoms *atoms;
rvec *x, *v;
int ePBC;
matrix box;
t_blocka *block, *block2;
char **gnames, **gnames2;
t_filenm fnm[] = {
{ efSTX, "-f", NULL, ffOPTRD },
{ efNDX, "-n", NULL, ffOPTRDMULT },
{ efNDX, "-o", NULL, ffWRITE }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, 0, NFILE, fnm, NPA, pa, asize(desc), desc,
0, NULL, &oenv))
{
return 0;
}
stxfile = ftp2fn_null(efSTX, NFILE, fnm);
if (opt2bSet("-n", NFILE, fnm))
{
nndxin = opt2fns(&ndxinfiles, "-n", NFILE, fnm);
}
else
{
nndxin = 0;
}
ndxoutfile = opt2fn("-o", NFILE, fnm);
bNatoms = opt2parg_bSet("-natoms", NPA, pa);
if (!stxfile && !nndxin)
{
gmx_fatal(FARGS, "No input files (structure or index)");
}
if (stxfile)
{
snew(atoms, 1);
get_stx_coordnum(stxfile, &(atoms->nr));
init_t_atoms(atoms, atoms->nr, TRUE);
snew(x, atoms->nr);
snew(v, atoms->nr);
fprintf(stderr, "\nReading structure file\n");
read_stx_conf(stxfile, title, atoms, x, v, &ePBC, box);
natoms = atoms->nr;
bNatoms = TRUE;
}
else
{
atoms = NULL;
x = NULL;
}
/* read input file(s) */
block = new_blocka();
gnames = NULL;
printf("Going to read %d old index file(s)\n", nndxin);
if (nndxin)
{
for (i = 0; i < nndxin; i++)
{
block2 = init_index(ndxinfiles[i], &gnames2);
srenew(gnames, block->nr+block2->nr);
for (j = 0; j < block2->nr; j++)
{
gnames[block->nr+j] = gnames2[j];
}
sfree(gnames2);
merge_blocks(block, block2);
sfree(block2->a);
sfree(block2->index);
/* done_block(block2); */
sfree(block2);
}
}
else
{
snew(gnames, 1);
analyse(atoms, block, &gnames, FALSE, TRUE);
}
if (!bNatoms)
{
natoms = block2natoms(block);
printf("Counted atom numbers up to %d in index file\n", natoms);
}
edit_index(natoms, atoms, x, block, &gnames, bVerbose);
write_index(ndxoutfile, block, gnames, bDuplicate, natoms);
return 0;
}
int gmx_trjcat(int argc, char *argv[])
{
const char *desc[] =
{
"[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]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",
"input files. In that case that particular file will be appended to",
"which implies you do not need to store double the amount of data.",
"Obviously the file to append to has to be the one with lowest starting",
"time since one can only append at the end of a file.[PAR]",
"If the [TT]-demux[tt] option is given, the N trajectories that are",
"read, are written in another order as specified in the [REF].xvg[ref] file.",
"The [REF].xvg[ref] file should contain something like::",
"",
" 0 0 1 2 3 4 5",
" 2 1 0 2 3 5 4",
"",
"The first number is the time, and subsequent numbers point to",
"trajectory indices.",
"The frames corresponding to the numbers present at the first line",
"are collected into the output trajectory. If the number of frames in",
"the trajectory does not match that in the [REF].xvg[ref] file then the program",
"tries to be smart. Beware."
};
static gmx_bool bCat = FALSE;
static gmx_bool bSort = TRUE;
static gmx_bool bKeepLast = FALSE;
static gmx_bool bKeepLastAppend = FALSE;
static gmx_bool bOverwrite = FALSE;
static gmx_bool bSetTime = FALSE;
static gmx_bool bDeMux;
static real begin = -1;
static real end = -1;
static real dt = 0;
t_pargs
pa[] =
{
{ "-b", FALSE, etTIME,
{ &begin }, "First time to use (%t)" },
{ "-e", FALSE, etTIME,
{ &end }, "Last time to use (%t)" },
{ "-dt", FALSE, etTIME,
{ &dt }, "Only write frame when t MOD dt = first time (%t)" },
{ "-settime", FALSE, etBOOL,
{ &bSetTime }, "Change starting time interactively" },
{ "-sort", FALSE, etBOOL,
{ &bSort }, "Sort trajectory files (not frames)" },
{ "-keeplast", FALSE, etBOOL,
{ &bKeepLast }, "Keep overlapping frames at end of trajectory" },
{ "-overwrite", FALSE, etBOOL,
{ &bOverwrite }, "Overwrite overlapping frames during appending" },
{ "-cat", FALSE, etBOOL,
{ &bCat }, "Do not discard double time frames" }
};
#define npargs asize(pa)
int ftpin, i, frame, frame_out;
t_trxstatus *status, *trxout = NULL;
real t_corr;
t_trxframe fr, frout;
char **fnms, **fnms_out, *out_file;
int n_append;
gmx_bool bNewFile, bIndex, bWrite;
int nfile_in, nfile_out, *cont_type;
real *readtime, *timest, *settime;
real first_time = 0, lasttime, last_ok_t = -1, timestep;
gmx_bool lastTimeSet = FALSE;
real last_frame_time, searchtime;
int isize = 0, j;
int *index = NULL, imax;
char *grpname;
real **val = NULL, *t = NULL, dt_remd;
int n, nset, ftpout = -1, prevEndStep = 0, filetype;
gmx_off_t fpos;
gmx_output_env_t *oenv;
t_filenm fnm[] =
{
{ efTRX, "-f", NULL, ffRDMULT },
{ efTRO, "-o", NULL, ffWRMULT },
{ efNDX, "-n", "index", ffOPTRD },
{ efXVG, "-demux", "remd", ffOPTRD }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_TIME_UNIT, NFILE, fnm,
asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
bIndex = ftp2bSet(efNDX, NFILE, fnm);
bDeMux = ftp2bSet(efXVG, NFILE, fnm);
bSort = bSort && !bDeMux;
imax = -1;
if (bIndex)
{
printf("Select group for output\n");
rd_index(ftp2fn(efNDX, NFILE, fnm), 1, &isize, &index, &grpname);
/* scan index */
imax = index[0];
for (i = 1; i < isize; i++)
{
imax = std::max(imax, index[i]);
}
}
if (bDeMux)
{
nset = 0;
dt_remd = 0;
val = read_xvg_time(opt2fn("-demux", NFILE, fnm), TRUE,
opt2parg_bSet("-b", npargs, pa), begin,
opt2parg_bSet("-e", npargs, pa), end, 1, &nset, &n,
&dt_remd, &t);
printf("Read %d sets of %d points, dt = %g\n\n", nset, n, dt_remd);
if (debug)
{
fprintf(debug, "Dump of replica_index.xvg\n");
for (i = 0; (i < n); i++)
{
fprintf(debug, "%10g", t[i]);
for (j = 0; (j < nset); j++)
{
fprintf(debug, " %3d", static_cast<int>(std::round(val[j][i])));
}
fprintf(debug, "\n");
}
}
}
nfile_in = opt2fns(&fnms, "-f", NFILE, fnm);
if (!nfile_in)
{
gmx_fatal(FARGS, "No input files!" );
}
if (bDeMux && (nfile_in != nset))
{
gmx_fatal(FARGS, "You have specified %d files and %d entries in the demux table", nfile_in, nset);
}
ftpin = fn2ftp(fnms[0]);
for (i = 1; i < nfile_in; i++)
{
if (ftpin != fn2ftp(fnms[i]))
{
gmx_fatal(FARGS, "All input files must be of the same format");
}
}
nfile_out = opt2fns(&fnms_out, "-o", NFILE, fnm);
if (!nfile_out)
{
gmx_fatal(FARGS, "No output files!");
}
if ((nfile_out > 1) && !bDeMux)
{
gmx_fatal(FARGS, "Don't know what to do with more than 1 output file if not demultiplexing");
}
else if (bDeMux && (nfile_out != nset) && (nfile_out != 1))
{
gmx_fatal(FARGS, "Number of output files should be 1 or %d (#input files), not %d", nset, nfile_out);
}
if (bDeMux)
{
if (nfile_out != nset)
{
char *buf = gmx_strdup(fnms_out[0]);
snew(fnms_out, nset);
for (i = 0; (i < nset); i++)
{
snew(fnms_out[i], std::strlen(buf)+32);
sprintf(fnms_out[i], "%d_%s", i, buf);
}
sfree(buf);
}
do_demux(nfile_in, fnms, fnms_out, n, val, t, dt_remd, isize, index, dt, oenv);
}
else
{
snew(readtime, nfile_in+1);
snew(timest, nfile_in+1);
scan_trj_files(fnms, nfile_in, readtime, timest, imax, oenv);
snew(settime, nfile_in+1);
snew(cont_type, nfile_in+1);
edit_files(fnms, nfile_in, readtime, timest, settime, cont_type, bSetTime, bSort,
oenv);
/* Check whether the output file is amongst the input files
* This has to be done after sorting etc.
*/
out_file = fnms_out[0];
ftpout = fn2ftp(out_file);
n_append = -1;
for (i = 0; ((i < nfile_in) && (n_append == -1)); i++)
{
if (std::strcmp(fnms[i], out_file) == 0)
{
n_append = i;
}
}
if (n_append == 0)
{
fprintf(stderr, "Will append to %s rather than creating a new file\n",
out_file);
}
else if (n_append != -1)
{
gmx_fatal(FARGS, "Can only append to the first file which is %s (not %s)",
fnms[0], out_file);
}
/* Not checking input format, could be dangerous :-) */
/* Not checking output format, equally dangerous :-) */
frame = -1;
frame_out = -1;
/* the default is not to change the time at all,
* but this is overridden by the edit_files routine
*/
t_corr = 0;
if (n_append == -1)
{
if (ftpout == efTNG)
{
if (ftpout != ftpin)
{
gmx_fatal(FARGS, "When writing TNG the input file format must also be TNG");
}
if (bIndex)
{
trjtools_gmx_prepare_tng_writing(out_file, 'w', NULL, &trxout,
fnms[0], isize, NULL, index, grpname);
}
else
{
trjtools_gmx_prepare_tng_writing(out_file, 'w', NULL, &trxout,
fnms[0], -1, NULL, NULL, NULL);
}
}
else
{
trxout = open_trx(out_file, "w");
}
std::memset(&frout, 0, sizeof(frout));
}
else
{
t_fileio *stfio;
if (!read_first_frame(oenv, &status, out_file, &fr, FLAGS))
{
gmx_fatal(FARGS, "Reading first frame from %s", out_file);
}
stfio = trx_get_fileio(status);
if (!bKeepLast && !bOverwrite)
{
fprintf(stderr, "\n\nWARNING: Appending without -overwrite implies -keeplast "
"between the first two files. \n"
"If the trajectories have an overlap and have not been written binary \n"
"reproducible this will produce an incorrect trajectory!\n\n");
filetype = gmx_fio_getftp(stfio);
/* Fails if last frame is incomplete
* We can't do anything about it without overwriting
* */
if (filetype == efXTC || filetype == efTNG)
{
lasttime = trx_get_time_of_final_frame(status);
fr.time = lasttime;
}
else
{
while (read_next_frame(oenv, status, &fr))
{
;
}
lasttime = fr.time;
}
lastTimeSet = TRUE;
bKeepLastAppend = TRUE;
close_trj(status);
trxout = open_trx(out_file, "a");
}
else if (bOverwrite)
{
if (gmx_fio_getftp(stfio) != efXTC)
{
gmx_fatal(FARGS, "Overwrite only supported for XTC." );
}
last_frame_time = trx_get_time_of_final_frame(status);
/* xtc_seek_time broken for trajectories containing only 1 or 2 frames
* or when seek time = 0 */
if (nfile_in > 1 && settime[1] < last_frame_time+timest[0]*0.5)
{
/* Jump to one time-frame before the start of next
* trajectory file */
searchtime = settime[1]-timest[0]*1.25;
}
else
{
searchtime = last_frame_time;
}
if (xtc_seek_time(stfio, searchtime, fr.natoms, TRUE))
{
gmx_fatal(FARGS, "Error seeking to append position.");
}
read_next_frame(oenv, status, &fr);
if (std::abs(searchtime - fr.time) > timest[0]*0.5)
{
gmx_fatal(FARGS, "Error seeking: attempted to seek to %f but got %f.",
searchtime, fr.time);
}
lasttime = fr.time;
lastTimeSet = TRUE;
fpos = gmx_fio_ftell(stfio);
close_trj(status);
trxout = open_trx(out_file, "r+");
if (gmx_fio_seek(trx_get_fileio(trxout), fpos))
{
gmx_fatal(FARGS, "Error seeking to append position.");
}
}
if (lastTimeSet)
{
printf("\n Will append after %f \n", lasttime);
}
frout = fr;
}
/* Lets stitch up some files */
timestep = timest[0];
for (i = n_append+1; (i < nfile_in); i++)
{
/* Open next file */
/* set the next time from the last frame in previous file */
if (i > 0)
{
/* When writing TNG the step determine which frame to write. Use an
* offset to be able to increase steps properly when changing files. */
if (ftpout == efTNG)
{
prevEndStep = frout.step;
}
if (frame_out >= 0)
{
if (cont_type[i] == TIME_CONTINUE)
{
begin = frout.time;
begin += 0.5*timestep;
settime[i] = frout.time;
cont_type[i] = TIME_EXPLICIT;
}
else if (cont_type[i] == TIME_LAST)
{
begin = frout.time;
begin += 0.5*timestep;
}
/* Or, if the time in the next part should be changed by the
* same amount, start at half a timestep from the last time
* so we dont repeat frames.
*/
/* I don't understand the comment above, but for all the cases
* I tried the code seems to work properly. B. Hess 2008-4-2.
*/
}
/* Or, if time is set explicitly, we check for overlap/gap */
if (cont_type[i] == TIME_EXPLICIT)
{
if ( ( i < nfile_in ) &&
( frout.time < settime[i]-1.5*timestep ) )
{
fprintf(stderr, "WARNING: Frames around t=%f %s have a different "
"spacing than the rest,\n"
"might be a gap or overlap that couldn't be corrected "
"automatically.\n", output_env_conv_time(oenv, frout.time),
output_env_get_time_unit(oenv));
}
}
}
/* if we don't have a timestep in the current file, use the old one */
if (timest[i] != 0)
{
timestep = timest[i];
}
read_first_frame(oenv, &status, fnms[i], &fr, FLAGS);
if (!fr.bTime)
{
fr.time = 0;
fprintf(stderr, "\nWARNING: Couldn't find a time in the frame.\n");
}
if (cont_type[i] == TIME_EXPLICIT)
{
t_corr = settime[i]-fr.time;
}
/* t_corr is the amount we want to change the time.
* If the user has chosen not to change the time for
* this part of the trajectory t_corr remains at
* the value it had in the last part, changing this
* by the same amount.
* If no value was given for the first trajectory part
* we let the time start at zero, see the edit_files routine.
*/
bNewFile = TRUE;
if (!lastTimeSet)
{
lasttime = 0;
lastTimeSet = true;
}
printf("\n");
printf("lasttime %g\n", lasttime);
do
{
/* copy the input frame to the output frame */
frout = fr;
/* set the new time by adding the correct calculated above */
frout.time += t_corr;
if (ftpout == efTNG)
{
frout.step += prevEndStep;
}
/* quit if we have reached the end of what should be written */
if ((end > 0) && (frout.time > end+GMX_REAL_EPS))
{
i = nfile_in;
break;
}
/* determine if we should write this frame (dt is handled elsewhere) */
if (bCat) /* write all frames of all files */
{
bWrite = TRUE;
}
else if (bKeepLast || (bKeepLastAppend && i == 1))
/* write till last frame of this traj
and skip first frame(s) of next traj */
{
bWrite = ( frout.time > lasttime+0.5*timestep );
}
else /* write till first frame of next traj */
{
bWrite = ( frout.time < settime[i+1]-0.5*timestep );
}
if (bWrite && (frout.time >= begin) )
{
frame++;
if (frame_out == -1)
{
first_time = frout.time;
}
lasttime = frout.time;
lastTimeSet = TRUE;
if (dt == 0 || bRmod(frout.time, first_time, dt))
{
frame_out++;
last_ok_t = frout.time;
if (bNewFile)
{
fprintf(stderr, "\nContinue writing frames from %s t=%g %s, "
"frame=%d \n",
fnms[i], output_env_conv_time(oenv, frout.time), output_env_get_time_unit(oenv),
frame);
bNewFile = FALSE;
}
if (bIndex)
{
write_trxframe_indexed(trxout, &frout, isize, index,
NULL);
}
else
{
write_trxframe(trxout, &frout, NULL);
}
if ( ((frame % 10) == 0) || (frame < 10) )
{
fprintf(stderr, " -> frame %6d time %8.3f %s \r",
frame_out, output_env_conv_time(oenv, frout.time), output_env_get_time_unit(oenv));
fflush(stderr);
}
}
}
}
while (read_next_frame(oenv, status, &fr));
close_trj(status);
}
if (trxout)
{
close_trx(trxout);
}
fprintf(stderr, "\nLast frame written was %d, time %f %s\n",
frame, output_env_conv_time(oenv, last_ok_t), output_env_get_time_unit(oenv));
}
return 0;
}
int gmx_sham(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] makes multi-dimensional free-energy, enthalpy and entropy plots.",
"[THISMODULE] reads one or more [TT].xvg[tt] files and analyzes data sets.",
"The basic purpose of [THISMODULE] is to plot Gibbs free energy landscapes",
"(option [TT]-ls[tt])",
"by Bolzmann inverting multi-dimensional histograms (option [TT]-lp[tt]),",
"but it can also",
"make enthalpy (option [TT]-lsh[tt]) and entropy (option [TT]-lss[tt])",
"plots. The histograms can be made for any quantities the user supplies.",
"A line in the input file may start with a time",
"(see option [TT]-time[tt]) and any number of [IT]y[it]-values may follow.",
"Multiple sets can also be",
"read when they are separated by & (option [TT]-n[tt]),",
"in this case only one [IT]y[it]-value is read from each line.",
"All lines starting with # and @ are skipped.",
"[PAR]",
"Option [TT]-ge[tt] can be used to supply a file with free energies",
"when the ensemble is not a Boltzmann ensemble, but needs to be biased",
"by this free energy. One free energy value is required for each",
"(multi-dimensional) data point in the [TT]-f[tt] input.",
"[PAR]",
"Option [TT]-ene[tt] can be used to supply a file with energies.",
"These energies are used as a weighting function in the single",
"histogram analysis method by Kumar et al. When temperatures",
"are supplied (as a second column in the file), an experimental",
"weighting scheme is applied. In addition the vales",
"are used for making enthalpy and entropy plots.",
"[PAR]",
"With option [TT]-dim[tt], dimensions can be gives for distances.",
"When a distance is 2- or 3-dimensional, the circumference or surface",
"sampled by two particles increases with increasing distance.",
"Depending on what one would like to show, one can choose to correct",
"the histogram and free-energy for this volume effect.",
"The probability is normalized by r and r^2 for dimensions of 2 and 3, ",
"respectively.",
"A value of -1 is used to indicate an angle in degrees between two",
"vectors: a sin(angle) normalization will be applied.",
"[BB]Note[bb] that for angles between vectors the inner-product or cosine",
"is the natural quantity to use, as it will produce bins of the same",
"volume."
};
static real tb = -1, te = -1, frac = 0.5, filtlen = 0;
static gmx_bool bHaveT = TRUE, bDer = FALSE, bSubAv = TRUE, bAverCorr = FALSE, bXYdy = FALSE;
static gmx_bool bEESEF = FALSE, bEENLC = FALSE, bEeFitAc = FALSE, bPower = FALSE;
static gmx_bool bShamEner = TRUE, bSham = TRUE;
static real Tref = 298.15, pmin = 0, ttol = 0, pmax = 0, gmax = 0, emin = 0, emax = 0;
static rvec nrdim = {1, 1, 1};
static rvec nrbox = {32, 32, 32};
static rvec xmin = {0, 0, 0}, xmax = {1, 1, 1};
static int nsets_in = 1, nb_min = 4, resol = 10, nlevels = 25;
t_pargs pa[] = {
{ "-time", FALSE, etBOOL, {&bHaveT},
"Expect a time in the input" },
{ "-b", FALSE, etREAL, {&tb},
"First time to read from set" },
{ "-e", FALSE, etREAL, {&te},
"Last time to read from set" },
{ "-ttol", FALSE, etREAL, {&ttol},
"Tolerance on time in appropriate units (usually ps)" },
{ "-n", FALSE, etINT, {&nsets_in},
"Read this number of sets separated by lines containing only an ampersand" },
{ "-d", FALSE, etBOOL, {&bDer},
"Use the derivative" },
{ "-sham", FALSE, etBOOL, {&bSham},
"Turn off energy weighting even if energies are given" },
{ "-tsham", FALSE, etREAL, {&Tref},
"Temperature for single histogram analysis" },
{ "-pmin", FALSE, etREAL, {&pmin},
"Minimum probability. Anything lower than this will be set to zero" },
{ "-dim", FALSE, etRVEC, {nrdim},
"Dimensions for distances, used for volume correction (max 3 values, dimensions > 3 will get the same value as the last)" },
{ "-ngrid", FALSE, etRVEC, {nrbox},
"Number of bins for energy landscapes (max 3 values, dimensions > 3 will get the same value as the last)" },
{ "-xmin", FALSE, etRVEC, {xmin},
"Minimum for the axes in energy landscape (see above for > 3 dimensions)" },
{ "-xmax", FALSE, etRVEC, {xmax},
"Maximum for the axes in energy landscape (see above for > 3 dimensions)" },
{ "-pmax", FALSE, etREAL, {&pmax},
"Maximum probability in output, default is calculate" },
{ "-gmax", FALSE, etREAL, {&gmax},
"Maximum free energy in output, default is calculate" },
{ "-emin", FALSE, etREAL, {&emin},
"Minimum enthalpy in output, default is calculate" },
{ "-emax", FALSE, etREAL, {&emax},
"Maximum enthalpy in output, default is calculate" },
{ "-nlevels", FALSE, etINT, {&nlevels},
"Number of levels for energy landscape" },
};
#define NPA asize(pa)
FILE *out;
int n, e_n, nlast, s, nset, e_nset, d_nset, i, j = 0, *idim, *ibox;
real **val, **et_val, *t, *e_t, e_dt, d_dt, dt, tot, error;
real *rmin, *rmax;
double *av, *sig, cum1, cum2, cum3, cum4, db;
const char *fn_ge, *fn_ene;
output_env_t oenv;
gmx_int64_t num_grid_points;
t_filenm fnm[] = {
{ efXVG, "-f", "graph", ffREAD },
{ efXVG, "-ge", "gibbs", ffOPTRD },
{ efXVG, "-ene", "esham", ffOPTRD },
{ efXVG, "-dist", "ener", ffOPTWR },
{ efXVG, "-histo", "edist", ffOPTWR },
{ efNDX, "-bin", "bindex", ffOPTWR },
{ efXPM, "-lp", "prob", ffOPTWR },
{ efXPM, "-ls", "gibbs", ffOPTWR },
{ efXPM, "-lsh", "enthalpy", ffOPTWR },
{ efXPM, "-lss", "entropy", ffOPTWR },
{ efPDB, "-ls3", "gibbs3", ffOPTWR },
{ efLOG, "-g", "shamlog", ffOPTWR }
};
#define NFILE asize(fnm)
int npargs;
npargs = asize(pa);
if (!parse_common_args(&argc, argv, PCA_CAN_VIEW,
NFILE, fnm, npargs, pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
val = read_xvg_time(opt2fn("-f", NFILE, fnm), bHaveT,
opt2parg_bSet("-b", npargs, pa), tb-ttol,
opt2parg_bSet("-e", npargs, pa), te+ttol,
nsets_in, &nset, &n, &dt, &t);
printf("Read %d sets of %d points, dt = %g\n\n", nset, n, dt);
fn_ge = opt2fn_null("-ge", NFILE, fnm);
fn_ene = opt2fn_null("-ene", NFILE, fnm);
if (fn_ge && fn_ene)
{
gmx_fatal(FARGS, "Can not do free energy and energy corrections at the same time");
}
if (fn_ge || fn_ene)
{
et_val = read_xvg_time(fn_ge ? fn_ge : fn_ene, bHaveT,
opt2parg_bSet("-b", npargs, pa), tb-ttol,
opt2parg_bSet("-e", npargs, pa), te+ttol,
1, &e_nset, &e_n, &e_dt, &e_t);
if (fn_ge)
{
if (e_nset != 1)
{
gmx_fatal(FARGS, "Can only handle one free energy component in %s",
fn_ge);
}
}
else
{
if (e_nset != 1 && e_nset != 2)
{
gmx_fatal(FARGS, "Can only handle one energy component or one energy and one T in %s",
fn_ene);
}
}
if (e_n != n)
{
gmx_fatal(FARGS, "Number of energies (%d) does not match number of entries (%d) in %s", e_n, n, opt2fn("-f", NFILE, fnm));
}
}
else
{
et_val = NULL;
}
if (fn_ene && et_val)
{
ehisto(opt2fn("-histo", NFILE, fnm), e_n, et_val, oenv);
}
snew(idim, max(3, nset));
snew(ibox, max(3, nset));
snew(rmin, max(3, nset));
snew(rmax, max(3, nset));
for (i = 0; (i < min(3, nset)); i++)
{
idim[i] = nrdim[i];
ibox[i] = nrbox[i];
rmin[i] = xmin[i];
rmax[i] = xmax[i];
}
for (; (i < nset); i++)
{
idim[i] = nrdim[2];
ibox[i] = nrbox[2];
rmin[i] = xmin[2];
rmax[i] = xmax[2];
}
/* Check that the grid size is manageable. */
num_grid_points = ibox[0];
for (i = 1; i < nset; i++)
{
gmx_int64_t result;
if (!check_int_multiply_for_overflow(num_grid_points, ibox[i], &result))
{
gmx_fatal(FARGS,
"The number of dimensions and grid points is too large for this tool.\n");
}
num_grid_points = result;
}
/* The number of grid points fits in a gmx_int64_t. */
do_sham(opt2fn("-dist", NFILE, fnm), opt2fn("-bin", NFILE, fnm),
opt2fn("-lp", NFILE, fnm),
opt2fn("-ls", NFILE, fnm), opt2fn("-lsh", NFILE, fnm),
opt2fn("-lss", NFILE, fnm),
opt2fn("-ls3", NFILE, fnm), opt2fn("-g", NFILE, fnm),
n, nset, val, fn_ge != NULL, e_nset, et_val, Tref,
pmax, gmax,
opt2parg_bSet("-emin", NPA, pa) ? &emin : NULL,
opt2parg_bSet("-emax", NPA, pa) ? &emax : NULL,
nlevels, pmin,
idim, ibox,
opt2parg_bSet("-xmin", NPA, pa), rmin,
opt2parg_bSet("-xmax", NPA, pa), rmax);
return 0;
}
int gmx_helix(int argc, char *argv[])
{
const char *desc[] = {
"[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",
"to an ideal helix around the [IT]z[it]-axis and centered around the origin.",
"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 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,",
"for 3-10 helices it will be smaller, and ",
"for 5-helices it will be larger.[BR]",
"[BB]3.[bb] Rise per residue (file [TT]rise.xvg[tt]). The helical rise per",
"residue is plotted as the difference in [IT]z[it]-coordinate between C[GRK]alpha[grk]",
"atoms. For an ideal helix, this is 0.15 nm[BR]",
"[BB]4.[bb] Total helix length (file [TT]len-ahx.xvg[tt]). The total length",
"of the",
"helix in nm. This is simply the average rise (see above) times the",
"number of helical residues (see below).[BR]",
"[BB]5.[bb] Helix dipole, backbone only (file [TT]dip-ahx.xvg[tt]).[BR]",
"[BB]6.[bb] RMS deviation from ideal helix, calculated for the C[GRK]alpha[grk]",
"atoms only (file [TT]rms-ahx.xvg[tt]).[BR]",
"[BB]7.[bb] Average C[GRK]alpha[grk] - C[GRK]alpha[grk] dihedral angle (file [TT]phi-ahx.xvg[tt]).[BR]",
"[BB]8.[bb] Average [GRK]phi[grk] and [GRK]psi[grk] angles (file [TT]phipsi.xvg[tt]).[BR]",
"[BB]9.[bb] Ellipticity at 222 nm according to Hirst and Brooks.",
"[PAR]"
};
static gmx_bool bCheck = FALSE, bFit = TRUE, bDBG = FALSE, bEV = FALSE;
static int rStart = 0, rEnd = 0, r0 = 1;
t_pargs pa [] = {
{ "-r0", FALSE, etINT, {&r0},
"The first residue number in the sequence" },
{ "-q", FALSE, etBOOL, {&bCheck},
"Check at every step which part of the sequence is helical" },
{ "-F", FALSE, etBOOL, {&bFit},
"Toggle fit to a perfect helix" },
{ "-db", FALSE, etBOOL, {&bDBG},
"Print debug info" },
{ "-ev", FALSE, etBOOL, {&bEV},
"Write a new 'trajectory' file for ED" },
{ "-ahxstart", FALSE, etINT, {&rStart},
"First residue in helix" },
{ "-ahxend", FALSE, etINT, {&rEnd},
"Last residue in helix" }
};
typedef struct {
FILE *fp, *fp2;
gmx_bool bfp2;
const char *filenm;
const char *title;
const char *xaxis;
const char *yaxis;
real val;
} t_xvgrfile;
t_xvgrfile xf[efhNR] = {
{ NULL, NULL, TRUE, "radius", "Helix radius", NULL, "r (nm)", 0.0 },
{ NULL, NULL, TRUE, "twist", "Twist per residue", NULL, "Angle (deg)", 0.0 },
{ NULL, NULL, TRUE, "rise", "Rise per residue", NULL, "Rise (nm)", 0.0 },
{ NULL, NULL, FALSE, "len-ahx", "Length of the Helix", NULL, "Length (nm)", 0.0 },
{ NULL, NULL, FALSE, "dip-ahx", "Helix Backbone Dipole", NULL, "rq (nm e)", 0.0 },
{ NULL, NULL, TRUE, "rms-ahx", "RMS Deviation from Ideal Helix", NULL, "RMS (nm)", 0.0 },
{ NULL, NULL, FALSE, "rmsa-ahx", "Average RMSD per Residue", "Residue", "RMS (nm)", 0.0 },
{ NULL, NULL, FALSE, "cd222", "Ellipticity at 222 nm", NULL, "nm", 0.0 },
{ NULL, NULL, TRUE, "pprms", "RMS Distance from \\8a\\4-helix", NULL, "deg", 0.0 },
{ NULL, NULL, TRUE, "caphi", "Average Ca-Ca Dihedral", NULL, "\\8F\\4(deg)", 0.0 },
{ NULL, NULL, TRUE, "phi", "Average \\8F\\4 angles", NULL, "deg", 0.0 },
{ NULL, NULL, TRUE, "psi", "Average \\8Y\\4 angles", NULL, "deg", 0.0 },
{ NULL, NULL, TRUE, "hb3", "Average n-n+3 hbond length", NULL, "nm", 0.0 },
{ NULL, NULL, TRUE, "hb4", "Average n-n+4 hbond length", NULL, "nm", 0.0 },
{ NULL, NULL, TRUE, "hb5", "Average n-n+5 hbond length", NULL, "nm", 0.0 },
{ NULL, NULL, FALSE, "JCaHa", "J-Coupling Values", "Residue", "Hz", 0.0 },
{ NULL, NULL, FALSE, "helicity", "Helicity per Residue", "Residue", "% of time", 0.0 }
};
output_env_t oenv;
char buf[54];
t_trxstatus *status;
int natoms, nre, nres;
t_bb *bb;
int i, j, m, nall, nbb, nca, teller, nSel = 0;
atom_id *bbindex, *caindex, *allindex;
t_topology *top;
int ePBC;
rvec *x, *xref;
real t;
real rms;
matrix box;
gmx_rmpbc_t gpbc = NULL;
gmx_bool bRange;
t_filenm fnm[] = {
{ efTPX, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffREAD },
{ efTRX, "-f", NULL, ffREAD },
{ efSTO, "-cz", "zconf", ffWRITE },
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_VIEW | PCA_CAN_TIME | PCA_BE_NICE,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
bRange = (opt2parg_bSet("-ahxstart", asize(pa), pa) &&
opt2parg_bSet("-ahxend", asize(pa), pa));
top = read_top(ftp2fn(efTPX, NFILE, fnm), &ePBC);
natoms = read_first_x(oenv, &status, opt2fn("-f", NFILE, fnm), &t, &x, box);
if (natoms != top->atoms.nr)
{
gmx_fatal(FARGS, "Sorry can only run when the number of atoms in the run input file (%d) is equal to the number in the trajectory (%d)",
top->atoms.nr, natoms);
}
bb = mkbbind(ftp2fn(efNDX, NFILE, fnm), &nres, &nbb, r0, &nall, &allindex,
top->atoms.atomname, top->atoms.atom, top->atoms.resinfo);
snew(bbindex, natoms);
snew(caindex, nres);
fprintf(stderr, "nall=%d\n", nall);
/* Open output files, default x-axis is time */
for (i = 0; (i < efhNR); i++)
{
sprintf(buf, "%s.xvg", xf[i].filenm);
remove(buf);
xf[i].fp = xvgropen(buf, xf[i].title,
xf[i].xaxis ? xf[i].xaxis : "Time (ps)",
xf[i].yaxis, oenv);
if (xf[i].bfp2)
{
sprintf(buf, "%s.out", xf[i].filenm);
remove(buf);
xf[i].fp2 = gmx_ffopen(buf, "w");
}
}
/* Read reference frame from tpx file to compute helix length */
snew(xref, top->atoms.nr);
read_tpx(ftp2fn(efTPX, NFILE, fnm),
NULL, NULL, &natoms, xref, NULL, NULL, NULL);
calc_hxprops(nres, bb, xref);
do_start_end(nres, bb, &nbb, bbindex, &nca, caindex, bRange, rStart, rEnd);
sfree(xref);
if (bDBG)
{
fprintf(stderr, "nca=%d, nbb=%d\n", nca, nbb);
pr_bb(stdout, nres, bb);
}
gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
teller = 0;
do
{
if ((teller++ % 10) == 0)
{
fprintf(stderr, "\rt=%.2f", t);
}
gmx_rmpbc(gpbc, natoms, box, x);
calc_hxprops(nres, bb, x);
if (bCheck)
{
do_start_end(nres, bb, &nbb, bbindex, &nca, caindex, FALSE, 0, 0);
}
if (nca >= 5)
{
rms = fit_ahx(nres, bb, natoms, nall, allindex, x, nca, caindex, bFit);
if (teller == 1)
{
write_sto_conf(opt2fn("-cz", NFILE, fnm), "Helix fitted to Z-Axis",
&(top->atoms), x, NULL, ePBC, box);
}
xf[efhRAD].val = radius(xf[efhRAD].fp2, nca, caindex, x);
xf[efhTWIST].val = twist(nca, caindex, x);
xf[efhRISE].val = rise(nca, caindex, x);
xf[efhLEN].val = ahx_len(nca, caindex, x);
xf[efhCD222].val = ellipticity(nres, bb);
xf[efhDIP].val = dip(nbb, bbindex, x, top->atoms.atom);
xf[efhRMS].val = rms;
xf[efhCPHI].val = ca_phi(nca, caindex, x);
xf[efhPPRMS].val = pprms(xf[efhPPRMS].fp2, nres, bb);
for (j = 0; (j <= efhCPHI); j++)
{
fprintf(xf[j].fp, "%10g %10g\n", t, xf[j].val);
}
av_phipsi(xf[efhPHI].fp, xf[efhPSI].fp, xf[efhPHI].fp2, xf[efhPSI].fp2,
t, nres, bb);
av_hblen(xf[efhHB3].fp, xf[efhHB3].fp2,
xf[efhHB4].fp, xf[efhHB4].fp2,
xf[efhHB5].fp, xf[efhHB5].fp2,
t, nres, bb);
}
}
while (read_next_x(oenv, status, &t, x, box));
fprintf(stderr, "\n");
gmx_rmpbc_done(gpbc);
close_trj(status);
for (i = 0; (i < nres); i++)
{
if (bb[i].nrms > 0)
{
fprintf(xf[efhRMSA].fp, "%10d %10g\n", r0+i, bb[i].rmsa/bb[i].nrms);
}
fprintf(xf[efhAHX].fp, "%10d %10g\n", r0+i, (bb[i].nhx*100.0)/(real )teller);
fprintf(xf[efhJCA].fp, "%10d %10g\n",
r0+i, 140.3+(bb[i].jcaha/(double)teller));
}
for (i = 0; (i < efhNR); i++)
{
gmx_ffclose(xf[i].fp);
if (xf[i].bfp2)
{
gmx_ffclose(xf[i].fp2);
}
do_view(oenv, xf[i].filenm, "-nxy");
}
return 0;
}
int gmx_dist(int argc,char *argv[])
{
const char *desc[] = {
"[TT]g_dist[tt] can calculate the distance between the centers of mass of two",
"groups of atoms as a function of time. The total distance and its",
"[IT]x[it]-, [IT]y[it]-, and [IT]z[it]-components are plotted.[PAR]",
"Or when [TT]-dist[tt] is set, print all the atoms in group 2 that are",
"closer than a certain distance to the center of mass of group 1.[PAR]",
"With options [TT]-lt[tt] and [TT]-dist[tt] the number of contacts",
"of all atoms in group 2 that are closer than a certain distance",
"to the center of mass of group 1 are plotted as a function of the time",
"that the contact was continuously present.[PAR]",
"Other programs that calculate distances are [TT]g_mindist[tt]",
"and [TT]g_bond[tt]."
};
t_topology *top=NULL;
int ePBC;
real t,t0,cut2,dist2;
rvec *x=NULL,*v=NULL,dx;
matrix box;
t_trxstatus *status;
int natoms;
int g,d,i,j,res,teller=0;
atom_id aid;
int ngrps; /* the number of index groups */
atom_id **index,max; /* the index for the atom numbers */
int *isize; /* the size of each group */
char **grpname; /* the name of each group */
rvec *com;
real *mass;
FILE *fp=NULL,*fplt=NULL;
gmx_bool bCutoff,bPrintDist,bLifeTime;
t_pbc *pbc;
int *contact_time=NULL,*ccount=NULL,ccount_nalloc=0,sum;
char buf[STRLEN];
output_env_t oenv;
gmx_rmpbc_t gpbc=NULL;
const char *leg[4] = { "|d|","d\\sx\\N","d\\sy\\N","d\\sz\\N" };
static real cut=0;
static t_pargs pa[] = {
{ "-dist", FALSE, etREAL, {&cut},
"Print all atoms in group 2 closer than dist to the center of mass of group 1" }
};
#define NPA asize(pa)
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPX, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "dist", ffOPTWR },
{ efXVG, "-lt", "lifetime", ffOPTWR },
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_BE_NICE,
NFILE,fnm,NPA,pa,asize(desc),desc,0,NULL,&oenv);
bCutoff = opt2parg_bSet("-dist",NPA,pa);
cut2 = cut*cut;
bLifeTime = opt2bSet("-lt",NFILE,fnm);
bPrintDist = (bCutoff && !bLifeTime);
top=read_top(ftp2fn(efTPX,NFILE,fnm),&ePBC);
/* read index files */
ngrps = 2;
snew(com,ngrps);
snew(grpname,ngrps);
snew(index,ngrps);
snew(isize,ngrps);
get_index(&top->atoms,ftp2fn(efNDX,NFILE,fnm),ngrps,isize,index,grpname);
/* calculate mass */
max=0;
snew(mass,ngrps);
for(g=0;(g<ngrps);g++) {
mass[g]=0;
for(i=0;(i<isize[g]);i++) {
if (index[g][i]>max)
max=index[g][i];
if (index[g][i] >= top->atoms.nr)
gmx_fatal(FARGS,"Atom number %d, item %d of group %d, is larger than number of atoms in the topolgy (%d)\n",index[g][i]+1,i+1,g+1,top->atoms.nr+1);
mass[g]+=top->atoms.atom[index[g][i]].m;
}
}
natoms=read_first_x(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
t0 = t;
if (max>=natoms)
gmx_fatal(FARGS,"Atom number %d in an index group is larger than number of atoms in the trajectory (%d)\n",(int)max+1,natoms);
if (!bCutoff) {
/* open output file */
fp = xvgropen(ftp2fn(efXVG,NFILE,fnm),
"Distance","Time (ps)","Distance (nm)",oenv);
xvgr_legend(fp,4,leg,oenv);
} else {
ngrps = 1;
if (bLifeTime)
snew(contact_time,isize[1]);
}
if (ePBC != epbcNONE)
snew(pbc,1);
else
pbc = NULL;
gpbc = gmx_rmpbc_init(&top->idef,ePBC,natoms,box);
do {
/* initialisation for correct distance calculations */
if (pbc) {
set_pbc(pbc,ePBC,box);
/* make molecules whole again */
gmx_rmpbc(gpbc,natoms,box,x);
}
/* calculate center of masses */
for(g=0;(g<ngrps);g++) {
if (isize[g] == 1) {
copy_rvec(x[index[g][0]],com[g]);
} else {
for(d=0;(d<DIM);d++) {
com[g][d]=0;
for(i=0;(i<isize[g]);i++) {
com[g][d] += x[index[g][i]][d] * top->atoms.atom[index[g][i]].m;
}
com[g][d] /= mass[g];
}
}
}
if (!bCutoff) {
/* write to output */
fprintf(fp,"%12.7f ",t);
for(g=0;(g<ngrps/2);g++) {
if (pbc)
pbc_dx(pbc,com[2*g],com[2*g+1],dx);
else
rvec_sub(com[2*g],com[2*g+1],dx);
fprintf(fp,"%12.7f %12.7f %12.7f %12.7f",
norm(dx),dx[XX],dx[YY],dx[ZZ]);
}
fprintf(fp,"\n");
} else {
for(i=0;(i<isize[1]);i++) {
j=index[1][i];
if (pbc)
pbc_dx(pbc,x[j],com[0],dx);
else
rvec_sub(x[j],com[0],dx);
dist2 = norm2(dx);
if (dist2<cut2) {
if (bPrintDist) {
res=top->atoms.atom[j].resind;
fprintf(stdout,"\rt: %g %d %s %d %s %g (nm)\n",
t,top->atoms.resinfo[res].nr,*top->atoms.resinfo[res].name,
j+1,*top->atoms.atomname[j],sqrt(dist2));
}
if (bLifeTime)
contact_time[i]++;
} else {
if (bLifeTime) {
if (contact_time[i]) {
add_contact_time(&ccount,&ccount_nalloc,contact_time[i]-1);
contact_time[i] = 0;
}
}
}
}
}
teller++;
} while (read_next_x(oenv,status,&t,natoms,x,box));
gmx_rmpbc_done(gpbc);
if (!bCutoff)
ffclose(fp);
close_trj(status);
if (bCutoff && bLifeTime) {
/* Add the contacts still present in the last frame */
for(i=0; i<isize[1]; i++)
if (contact_time[i])
add_contact_time(&ccount,&ccount_nalloc,contact_time[i]-1);
sprintf(buf,"%s - %s within %g nm",
grpname[0],grpname[1],cut);
fp = xvgropen(opt2fn("-lt",NFILE,fnm),
buf,"Time (ps)","Number of contacts",oenv);
for(i=0; i<min(ccount_nalloc,teller-1); i++) {
/* Account for all subintervals of longer intervals */
sum = 0;
for(j=i; j<ccount_nalloc; j++)
sum += (j-i+1)*ccount[j];
fprintf(fp,"%10.3f %10.3f\n",i*(t-t0)/(teller-1),sum/(double)(teller-i));
}
ffclose(fp);
}
thanx(stderr);
return 0;
}
int gmx_vanhove(int argc,char *argv[])
{
const char *desc[] = {
"g_vanhove computes the Van Hove correlation function.",
"The Van Hove G(r,t) is the probability that a particle that is at r0",
"at time zero can be found at position r0+r at time t.",
"g_vanhove determines G not for a vector r, but for the length of r.",
"Thus it gives the probability that a particle moves a distance of r",
"in time t.",
"Jumps across the periodic boundaries are removed.",
"Corrections are made for scaling due to isotropic",
"or anisotropic pressure coupling.",
"[PAR]",
"With option [TT]-om[tt] the whole matrix can be written as a function",
"of t and r or as a function of sqrt(t) and r (option [TT]-sqrt[tt]).",
"[PAR]",
"With option [TT]-or[tt] the Van Hove function is plotted for one",
"or more values of t. Option [TT]-nr[tt] sets the number of times,",
"option [TT]-fr[tt] the number spacing between the times.",
"The binwidth is set with option [TT]-rbin[tt]. The number of bins",
"is determined automatically.",
"[PAR]",
"With option [TT]-ot[tt] the integral up to a certain distance",
"(option [TT]-rt[tt]) is plotted as a function of time.",
"[PAR]",
"For all frames that are read the coordinates of the selected particles",
"are stored in memory. Therefore the program may use a lot of memory.",
"For options [TT]-om[tt] and [TT]-ot[tt] the program may be slow.",
"This is because the calculation scales as the number of frames times",
"[TT]-fm[tt] or [TT]-ft[tt].",
"Note that with the [TT]-dt[tt] option the memory usage and calculation",
"time can be reduced."
};
static int fmmax=0,ftmax=0,nlev=81,nr=1,fshift=0;
static real sbin=0,rmax=2,rbin=0.01,mmax=0,rint=0;
t_pargs pa[] = {
{ "-sqrt", FALSE, etREAL,{&sbin},
"Use sqrt(t) on the matrix axis which binspacing # in sqrt(ps)" },
{ "-fm", FALSE, etINT, {&fmmax},
"Number of frames in the matrix, 0 is plot all" },
{ "-rmax", FALSE, etREAL, {&rmax},
"Maximum r in the matrix (nm)" },
{ "-rbin", FALSE, etREAL, {&rbin},
"Binwidth in the matrix and for -or (nm)" },
{ "-mmax", FALSE, etREAL, {&mmax},
"Maximum density in the matrix, 0 is calculate (1/nm)" },
{ "-nlevels" ,FALSE, etINT, {&nlev},
"Number of levels in the matrix" },
{ "-nr", FALSE, etINT, {&nr},
"Number of curves for the -or output" },
{ "-fr", FALSE, etINT, {&fshift},
"Frame spacing for the -or output" },
{ "-rt", FALSE, etREAL, {&rint},
"Integration limit for the -ot output (nm)" },
{ "-ft", FALSE, etINT, {&ftmax},
"Number of frames in the -ot output, 0 is plot all" }
};
#define NPA asize(pa)
t_filenm fnm[] = {
{ efTRX, NULL, NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXPM, "-om", "vanhove", ffOPTWR },
{ efXVG, "-or", "vanhove_r", ffOPTWR },
{ efXVG, "-ot", "vanhove_t", ffOPTWR }
};
#define NFILE asize(fnm)
output_env_t oenv;
const char *matfile,*otfile,*orfile;
char title[256];
t_topology top;
int ePBC;
matrix boxtop,box,*sbox,avbox,corr;
rvec *xtop,*x,**sx;
int isize,nalloc,nallocn,natom;
t_trxstatus *status;
atom_id *index;
char *grpname;
int nfr,f,ff,i,m,mat_nx=0,nbin=0,bin,mbin,fbin;
real *time,t,invbin=0,rmax2=0,rint2=0,d2;
real invsbin=0,matmax,normfac,dt,*tickx,*ticky;
char buf[STRLEN],**legend;
real **mat=NULL;
int *pt=NULL,**pr=NULL,*mcount=NULL,*tcount=NULL,*rcount=NULL;
FILE *fp;
t_rgb rlo={1,1,1}, rhi={0,0,0};
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_VIEW | PCA_CAN_TIME | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL,&oenv);
matfile = opt2fn_null("-om",NFILE,fnm);
if (opt2parg_bSet("-fr",NPA,pa))
orfile = opt2fn("-or",NFILE,fnm);
else
orfile = opt2fn_null("-or",NFILE,fnm);
if (opt2parg_bSet("-rt",NPA,pa))
otfile = opt2fn("-ot",NFILE,fnm);
else
otfile = opt2fn_null("-ot",NFILE,fnm);
if (!matfile && !otfile && !orfile) {
fprintf(stderr,
"For output set one (or more) of the output file options\n");
exit(0);
}
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xtop,NULL,boxtop,
FALSE);
get_index(&top.atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&isize,&index,&grpname);
nalloc = 0;
time = NULL;
sbox = NULL;
sx = NULL;
clear_mat(avbox);
natom=read_first_x(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
nfr = 0;
do {
if (nfr >= nalloc) {
nalloc += 100;
srenew(time,nalloc);
srenew(sbox,nalloc);
srenew(sx,nalloc);
}
time[nfr] = t;
copy_mat(box,sbox[nfr]);
/* This assumes that the off-diagonal box elements
* are not affected by jumps across the periodic boundaries.
*/
m_add(avbox,box,avbox);
snew(sx[nfr],isize);
for(i=0; i<isize; i++)
copy_rvec(x[index[i]],sx[nfr][i]);
nfr++;
} while (read_next_x(oenv,status,&t,natom,x,box));
/* clean up */
sfree(x);
close_trj(status);
fprintf(stderr,"Read %d frames\n",nfr);
dt = (time[nfr-1] - time[0])/(nfr - 1);
/* Some ugly rounding to get nice nice times in the output */
dt = (int)(10000.0*dt + 0.5)/10000.0;
invbin = 1.0/rbin;
if (matfile) {
if (fmmax <= 0 || fmmax >= nfr)
fmmax = nfr - 1;
snew(mcount,fmmax);
nbin = (int)(rmax*invbin + 0.5);
if (sbin == 0) {
mat_nx = fmmax + 1;
} else {
invsbin = 1.0/sbin;
mat_nx = sqrt(fmmax*dt)*invsbin + 1;
}
snew(mat,mat_nx);
for(f=0; f<mat_nx; f++)
snew(mat[f],nbin);
rmax2 = sqr(nbin*rbin);
/* Initialize time zero */
mat[0][0] = nfr*isize;
mcount[0] += nfr;
} else {
fmmax = 0;
}
if (orfile) {
snew(pr,nr);
nalloc = 0;
snew(rcount,nr);
}
if (otfile) {
if (ftmax <= 0)
ftmax = nfr - 1;
snew(tcount,ftmax);
snew(pt,nfr);
rint2 = rint*rint;
/* Initialize time zero */
pt[0] = nfr*isize;
tcount[0] += nfr;
} else {
ftmax = 0;
}
msmul(avbox,1.0/nfr,avbox);
for(f=0; f<nfr; f++) {
if (f % 100 == 0)
fprintf(stderr,"\rProcessing frame %d",f);
/* Scale all the configuration to the average box */
m_inv_ur0(sbox[f],corr);
mmul_ur0(avbox,corr,corr);
for(i=0; i<isize; i++) {
mvmul_ur0(corr,sx[f][i],sx[f][i]);
if (f > 0) {
/* Correct for periodic jumps */
for(m=DIM-1; m>=0; m--) {
while(sx[f][i][m] - sx[f-1][i][m] > 0.5*avbox[m][m])
rvec_dec(sx[f][i],avbox[m]);
while(sx[f][i][m] - sx[f-1][i][m] <= -0.5*avbox[m][m])
rvec_inc(sx[f][i],avbox[m]);
}
}
}
for(ff=0; ff<f; ff++) {
fbin = f - ff;
if (fbin <= fmmax || fbin <= ftmax) {
if (sbin == 0)
mbin = fbin;
else
mbin = (int)(sqrt(fbin*dt)*invsbin + 0.5);
for(i=0; i<isize; i++) {
d2 = distance2(sx[f][i],sx[ff][i]);
if (mbin < mat_nx && d2 < rmax2) {
bin = (int)(sqrt(d2)*invbin + 0.5);
if (bin < nbin) {
mat[mbin][bin] += 1;
}
}
if (fbin <= ftmax && d2 <= rint2)
pt[fbin]++;
}
if (matfile)
mcount[mbin]++;
if (otfile)
tcount[fbin]++;
}
}
if (orfile) {
for(fbin=0; fbin<nr; fbin++) {
ff = f - (fbin + 1)*fshift;
if (ff >= 0) {
for(i=0; i<isize; i++) {
d2 = distance2(sx[f][i],sx[ff][i]);
bin = (int)(sqrt(d2)*invbin);
if (bin >= nalloc) {
nallocn = 10*(bin/10) + 11;
for(m=0; m<nr; m++) {
srenew(pr[m],nallocn);
for(i=nalloc; i<nallocn; i++)
pr[m][i] = 0;
}
nalloc = nallocn;
}
pr[fbin][bin]++;
}
rcount[fbin]++;
}
}
}
}
fprintf(stderr,"\n");
if (matfile) {
matmax = 0;
for(f=0; f<mat_nx; f++) {
normfac = 1.0/(mcount[f]*isize*rbin);
for(i=0; i<nbin; i++) {
mat[f][i] *= normfac;
if (mat[f][i] > matmax && (f!=0 || i!=0))
matmax = mat[f][i];
}
}
fprintf(stdout,"Value at (0,0): %.3f, maximum of the rest %.3f\n",
mat[0][0],matmax);
if (mmax > 0)
matmax = mmax;
snew(tickx,mat_nx);
for(f=0; f<mat_nx; f++) {
if (sbin == 0)
tickx[f] = f*dt;
else
tickx[f] = f*sbin;
}
snew(ticky,nbin+1);
for(i=0; i<=nbin; i++)
ticky[i] = i*rbin;
fp = ffopen(matfile,"w");
write_xpm(fp,MAT_SPATIAL_Y,"Van Hove function","G (1/nm)",
sbin==0 ? "time (ps)" : "sqrt(time) (ps^1/2)","r (nm)",
mat_nx,nbin,tickx,ticky,mat,0,matmax,rlo,rhi,&nlev);
ffclose(fp);
}
if (orfile) {
fp = xvgropen(orfile,"Van Hove function","r (nm)","G (nm\\S-1\\N)",oenv);
fprintf(fp,"@ subtitle \"for particles in group %s\"\n",grpname);
snew(legend,nr);
for(fbin=0; fbin<nr; fbin++) {
sprintf(buf,"%g ps",(fbin + 1)*fshift*dt);
legend[fbin] = strdup(buf);
}
xvgr_legend(fp,nr,(const char**)legend,oenv);
for(i=0; i<nalloc; i++) {
fprintf(fp,"%g",i*rbin);
for(fbin=0; fbin<nr; fbin++)
fprintf(fp," %g",
(real)pr[fbin][i]/(rcount[fbin]*isize*rbin*(i==0 ? 0.5 : 1)));
fprintf(fp,"\n");
}
ffclose(fp);
}
if (otfile) {
sprintf(buf,"Probability of moving less than %g nm",rint);
fp = xvgropen(otfile,buf,"t (ps)","",oenv);
fprintf(fp,"@ subtitle \"for particles in group %s\"\n",grpname);
for(f=0; f<=ftmax; f++)
fprintf(fp,"%g %g\n",f*dt,(real)pt[f]/(tcount[f]*isize));
ffclose(fp);
}
do_view(oenv, matfile,NULL);
do_view(oenv, orfile,NULL);
do_view(oenv, otfile,NULL);
thanx(stderr);
return 0;
}
int gmx_analyze(int argc, char *argv[])
{
static const char *desc[] = {
"[TT]g_analyze[tt] reads an ASCII file and analyzes data sets.",
"A line in the input file may start with a time",
"(see option [TT]-time[tt]) and any number of [IT]y[it]-values may follow.",
"Multiple sets can also be",
"read when they are separated by & (option [TT]-n[tt]);",
"in this case only one [IT]y[it]-value is read from each line.",
"All lines starting with # and @ are skipped.",
"All analyses can also be done for the derivative of a set",
"(option [TT]-d[tt]).[PAR]",
"All options, except for [TT]-av[tt] and [TT]-power[tt], assume that the",
"points are equidistant in time.[PAR]",
"[TT]g_analyze[tt] always shows the average and standard deviation of each",
"set, as well as the relative deviation of the third",
"and fourth cumulant from those of a Gaussian distribution with the same",
"standard deviation.[PAR]",
"Option [TT]-ac[tt] produces the autocorrelation function(s).",
"Be sure that the time interval between data points is",
"much shorter than the time scale of the autocorrelation.[PAR]",
"Option [TT]-cc[tt] plots the resemblance of set i with a cosine of",
"i/2 periods. The formula is:[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]-msd[tt] produces the mean square displacement(s).[PAR]",
"Option [TT]-dist[tt] produces distribution plot(s).[PAR]",
"Option [TT]-av[tt] produces the average over the sets.",
"Error bars can be added with the option [TT]-errbar[tt].",
"The errorbars can represent the standard deviation, the error",
"(assuming the points are independent) or the interval containing",
"90% of the points, by discarding 5% of the points at the top and",
"the bottom.[PAR]",
"Option [TT]-ee[tt] produces error estimates using block averaging.",
"A set is divided in a number of blocks and averages are calculated for",
"each block. The error for the total average is calculated from",
"the variance between averages of the m blocks B[SUB]i[sub] as follows:",
"error^2 = [SUM][sum] (B[SUB]i[sub] - [CHEVRON]B[chevron])^2 / (m*(m-1)).",
"These errors are plotted as a function of the block size.",
"Also an analytical block average curve is plotted, assuming",
"that the autocorrelation is a sum of two exponentials.",
"The analytical curve for the block average is:[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][SUB]1[sub] and [GRK]tau[grk][SUB]2[sub] are obtained by fitting f^2(t) to error^2.",
"When the actual block average is very close to the analytical curve,",
"the error is [MATH][GRK]sigma[grk][TT]*[tt][SQRT]2/T (a [GRK]tau[grk][SUB]1[sub] + (1-a) [GRK]tau[grk][SUB]2[sub])[sqrt][math].",
"The complete derivation is given in",
"B. Hess, J. Chem. Phys. 116:209-217, 2002.[PAR]",
"Option [TT]-bal[tt] finds and subtracts the ultrafast \"ballistic\"",
"component from a hydrogen bond autocorrelation function by the fitting",
"of a sum of exponentials, as described in e.g.",
"O. Markovitch, J. Chem. Phys. 129:084505, 2008. The fastest term",
"is the one with the most negative coefficient in the exponential,",
"or with [TT]-d[tt], the one with most negative time derivative at time 0.",
"[TT]-nbalexp[tt] sets the number of exponentials to fit.[PAR]",
"Option [TT]-gem[tt] fits bimolecular rate constants ka and kb",
"(and optionally kD) to the hydrogen bond autocorrelation function",
"according to the reversible geminate recombination model. Removal of",
"the ballistic component first is strongly advised. The model is presented in",
"O. Markovitch, J. Chem. Phys. 129:084505, 2008.[PAR]",
"Option [TT]-filter[tt] prints the RMS high-frequency fluctuation",
"of each set and over all sets with respect to a filtered average.",
"The filter is proportional to cos([GRK]pi[grk] t/len) where t goes from -len/2",
"to len/2. len is supplied with the option [TT]-filter[tt].",
"This filter reduces oscillations with period len/2 and len by a factor",
"of 0.79 and 0.33 respectively.[PAR]",
"Option [TT]-g[tt] fits the data to the function given with option",
"[TT]-fitfn[tt].[PAR]",
"Option [TT]-power[tt] fits the data to [MATH]b t^a[math], which is accomplished",
"by fitting to [MATH]a t + b[math] on log-log scale. All points after the first",
"zero or with a negative value are ignored.[PAR]"
"Option [TT]-luzar[tt] performs a Luzar & Chandler kinetics analysis",
"on output from [TT]g_hbond[tt]. The input file can be taken directly",
"from [TT]g_hbond -ac[tt], and then the same result should be produced."
};
static real tb = -1, te = -1, frac = 0.5, filtlen = 0, binwidth = 0.1, aver_start = 0;
static gmx_bool bHaveT = TRUE, bDer = FALSE, bSubAv = TRUE, bAverCorr = FALSE, bXYdy = FALSE;
static gmx_bool bEESEF = FALSE, bEENLC = FALSE, bEeFitAc = FALSE, bPower = FALSE;
static gmx_bool bIntegrate = FALSE, bRegression = FALSE, bLuzar = FALSE, bLuzarError = FALSE;
static int nsets_in = 1, d = 1, nb_min = 4, resol = 10, nBalExp = 4, nFitPoints = 100;
static real temp = 298.15, fit_start = 1, fit_end = 60, smooth_tail_start = -1, balTime = 0.2, diffusion = 5e-5, rcut = 0.35;
/* must correspond to enum avbar* declared at beginning of file */
static const char *avbar_opt[avbarNR+1] = {
NULL, "none", "stddev", "error", "90", NULL
};
t_pargs pa[] = {
{ "-time", FALSE, etBOOL, {&bHaveT},
"Expect a time in the input" },
{ "-b", FALSE, etREAL, {&tb},
"First time to read from set" },
{ "-e", FALSE, etREAL, {&te},
"Last time to read from set" },
{ "-n", FALSE, etINT, {&nsets_in},
"Read this number of sets separated by &" },
{ "-d", FALSE, etBOOL, {&bDer},
"Use the derivative" },
{ "-dp", FALSE, etINT, {&d},
"HIDDENThe derivative is the difference over this number of points" },
{ "-bw", FALSE, etREAL, {&binwidth},
"Binwidth for the distribution" },
{ "-errbar", FALSE, etENUM, {avbar_opt},
"Error bars for [TT]-av[tt]" },
{ "-integrate", FALSE, etBOOL, {&bIntegrate},
"Integrate data function(s) numerically using trapezium rule" },
{ "-aver_start", FALSE, etREAL, {&aver_start},
"Start averaging the integral from here" },
{ "-xydy", FALSE, etBOOL, {&bXYdy},
"Interpret second data set as error in the y values for integrating" },
{ "-regression", FALSE, etBOOL, {&bRegression},
"Perform a linear regression analysis on the data. If [TT]-xydy[tt] is set a second set will be interpreted as the error bar in the Y value. Otherwise, if multiple data sets are present a multilinear regression will be performed yielding the constant A that minimize [MATH][GRK]chi[grk]^2 = (y - A[SUB]0[sub] x[SUB]0[sub] - A[SUB]1[sub] x[SUB]1[sub] - ... - A[SUB]N[sub] x[SUB]N[sub])^2[math] where now Y is the first data set in the input file and x[SUB]i[sub] the others. Do read the information at the option [TT]-time[tt]." },
{ "-luzar", FALSE, etBOOL, {&bLuzar},
"Do a Luzar and Chandler analysis on a correlation function and related as produced by [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 (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 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/resol)" },
{ "-eeexpfit", FALSE, etBOOL, {&bEESEF},
"HIDDENAlways use a single exponential fit for the error estimate" },
{ "-eenlc", FALSE, etBOOL, {&bEENLC},
"HIDDENAllow a negative long-time correlation" },
{ "-eefitac", FALSE, etBOOL, {&bEeFitAc},
"HIDDENAlso plot analytical block average using a autocorrelation fit" },
{ "-filter", FALSE, etREAL, {&filtlen},
"Print the high-frequency fluctuation after filtering with a cosine filter of this length" },
{ "-power", FALSE, etBOOL, {&bPower},
"Fit data to: b t^a" },
{ "-subav", FALSE, etBOOL, {&bSubAv},
"Subtract the average before autocorrelating" },
{ "-oneacf", FALSE, etBOOL, {&bAverCorr},
"Calculate one ACF over all sets" },
{ "-nbalexp", FALSE, etINT, {&nBalExp},
"HIDDENNumber of exponentials to fit to the ultrafast component" },
{ "-baltime", FALSE, etREAL, {&balTime},
"HIDDENTime up to which the ballistic component will be fitted" },
/* { "-gemnp", FALSE, etINT, {&nFitPoints}, */
/* "HIDDENNumber of data points taken from the ACF to use for fitting to rev. gem. recomb. model."}, */
/* { "-rcut", FALSE, etREAL, {&rcut}, */
/* "Cut-off for hydrogen bonds in geminate algorithms" }, */
/* { "-gemtype", FALSE, etENUM, {gemType}, */
/* "What type of gminate recombination to use"}, */
/* { "-D", FALSE, etREAL, {&diffusion}, */
/* "The self diffusion coefficient which is used for the reversible geminate recombination model."} */
};
#define NPA asize(pa)
FILE *out, *out_fit;
int n, nlast, s, nset, i, j = 0;
real **val, *t, dt, tot, error;
double *av, *sig, cum1, cum2, cum3, cum4, db;
const char *acfile, *msdfile, *ccfile, *distfile, *avfile, *eefile, *balfile, *gemfile, *fitfile;
output_env_t oenv;
t_filenm fnm[] = {
{ efXVG, "-f", "graph", ffREAD },
{ efXVG, "-ac", "autocorr", ffOPTWR },
{ efXVG, "-msd", "msd", ffOPTWR },
{ efXVG, "-cc", "coscont", ffOPTWR },
{ efXVG, "-dist", "distr", ffOPTWR },
{ efXVG, "-av", "average", ffOPTWR },
{ efXVG, "-ee", "errest", ffOPTWR },
{ efXVG, "-bal", "ballisitc", ffOPTWR },
/* { efXVG, "-gem", "geminate", ffOPTWR }, */
{ efLOG, "-g", "fitlog", ffOPTWR }
};
#define NFILE asize(fnm)
int npargs;
t_pargs *ppa;
npargs = asize(pa);
ppa = add_acf_pargs(&npargs, pa);
parse_common_args(&argc, argv, PCA_CAN_VIEW,
NFILE, fnm, npargs, ppa, asize(desc), desc, 0, NULL, &oenv);
acfile = opt2fn_null("-ac", NFILE, fnm);
msdfile = opt2fn_null("-msd", NFILE, fnm);
ccfile = opt2fn_null("-cc", NFILE, fnm);
distfile = opt2fn_null("-dist", NFILE, fnm);
avfile = opt2fn_null("-av", NFILE, fnm);
eefile = opt2fn_null("-ee", NFILE, fnm);
balfile = opt2fn_null("-bal", NFILE, fnm);
/* gemfile = opt2fn_null("-gem",NFILE,fnm); */
/* When doing autocorrelation we don't want a fitlog for fitting
* the function itself (not the acf) when the user did not ask for it.
*/
if (opt2parg_bSet("-fitfn", npargs, ppa) && acfile == NULL)
{
fitfile = opt2fn("-g", NFILE, fnm);
}
else
{
fitfile = opt2fn_null("-g", NFILE, fnm);
}
val = read_xvg_time(opt2fn("-f", NFILE, fnm), bHaveT,
opt2parg_bSet("-b", npargs, ppa), tb,
opt2parg_bSet("-e", npargs, ppa), te,
nsets_in, &nset, &n, &dt, &t);
printf("Read %d sets of %d points, dt = %g\n\n", nset, n, dt);
if (bDer)
{
printf("Calculating the derivative as (f[i+%d]-f[i])/(%d*dt)\n\n",
d, d);
n -= d;
for (s = 0; s < nset; s++)
{
for (i = 0; (i < n); i++)
{
val[s][i] = (val[s][i+d]-val[s][i])/(d*dt);
}
}
}
if (bIntegrate)
{
real sum, stddev;
printf("Calculating the integral using the trapezium rule\n");
if (bXYdy)
{
sum = evaluate_integral(n, t, val[0], val[1], aver_start, &stddev);
printf("Integral %10.3f +/- %10.5f\n", sum, stddev);
}
else
{
for (s = 0; s < nset; s++)
{
sum = evaluate_integral(n, t, val[s], NULL, aver_start, &stddev);
printf("Integral %d %10.5f +/- %10.5f\n", s+1, sum, stddev);
}
}
}
if (fitfile != NULL)
{
out_fit = ffopen(fitfile, "w");
if (bXYdy && nset >= 2)
{
do_fit(out_fit, 0, TRUE, n, t, val, npargs, ppa, oenv);
}
else
{
for (s = 0; s < nset; s++)
{
do_fit(out_fit, s, FALSE, n, t, val, npargs, ppa, oenv);
}
}
ffclose(out_fit);
}
printf(" std. dev. relative deviation of\n");
printf(" standard --------- cumulants from those of\n");
printf("set average deviation sqrt(n-1) a Gaussian distribition\n");
printf(" cum. 3 cum. 4\n");
snew(av, nset);
snew(sig, nset);
for (s = 0; (s < nset); s++)
{
cum1 = 0;
cum2 = 0;
cum3 = 0;
cum4 = 0;
for (i = 0; (i < n); i++)
{
cum1 += val[s][i];
}
cum1 /= n;
for (i = 0; (i < n); i++)
{
db = val[s][i]-cum1;
cum2 += db*db;
cum3 += db*db*db;
cum4 += db*db*db*db;
}
cum2 /= n;
cum3 /= n;
cum4 /= n;
av[s] = cum1;
sig[s] = sqrt(cum2);
if (n > 1)
{
error = sqrt(cum2/(n-1));
}
else
{
error = 0;
}
printf("SS%d %13.6e %12.6e %12.6e %6.3f %6.3f\n",
s+1, av[s], sig[s], error,
sig[s] ? cum3/(sig[s]*sig[s]*sig[s]*sqrt(8/M_PI)) : 0,
sig[s] ? cum4/(sig[s]*sig[s]*sig[s]*sig[s]*3)-1 : 0);
}
printf("\n");
if (filtlen)
{
filter(filtlen, n, nset, val, dt);
}
if (msdfile)
{
out = xvgropen(msdfile, "Mean square displacement",
"time", "MSD (nm\\S2\\N)", oenv);
nlast = (int)(n*frac);
for (s = 0; s < nset; s++)
{
for (j = 0; j <= nlast; j++)
{
if (j % 100 == 0)
{
fprintf(stderr, "\r%d", j);
}
tot = 0;
for (i = 0; i < n-j; i++)
{
tot += sqr(val[s][i]-val[s][i+j]);
}
tot /= (real)(n-j);
fprintf(out, " %g %8g\n", dt*j, tot);
}
if (s < nset-1)
{
fprintf(out, "&\n");
}
}
ffclose(out);
fprintf(stderr, "\r%d, time=%g\n", j-1, (j-1)*dt);
}
if (ccfile)
{
plot_coscont(ccfile, n, nset, val, oenv);
}
if (distfile)
{
histogram(distfile, binwidth, n, nset, val, oenv);
}
if (avfile)
{
average(avfile, nenum(avbar_opt), n, nset, val, t);
}
if (eefile)
{
estimate_error(eefile, nb_min, resol, n, nset, av, sig, val, dt,
bEeFitAc, bEESEF, bEENLC, oenv);
}
if (balfile)
{
do_ballistic(balfile, n, t, val, nset, balTime, nBalExp, oenv);
}
/* if (gemfile) */
/* do_geminate(gemfile,n,t,val,nset,diffusion,rcut,balTime, */
/* nFitPoints, fit_start, fit_end, oenv); */
if (bPower)
{
power_fit(n, nset, val, t);
}
if (acfile != NULL)
{
if (bSubAv)
{
for (s = 0; s < nset; s++)
{
for (i = 0; i < n; i++)
{
val[s][i] -= av[s];
}
}
}
do_autocorr(acfile, oenv, "Autocorrelation", n, nset, val, dt,
eacNormal, bAverCorr);
}
if (bRegression)
{
regression_analysis(n, bXYdy, t, nset, val);
}
if (bLuzar)
{
luzar_correl(n, t, nset, val, temp, bXYdy, fit_start, smooth_tail_start, oenv);
}
view_all(oenv, NFILE, fnm);
return 0;
}
static void do_fit(FILE *out, int n, gmx_bool bYdy,
int ny, real *x0, real **val,
int npargs, t_pargs *ppa, const gmx_output_env_t *oenv,
const char *fn_fitted)
{
real *c1 = NULL, *sig = NULL;
double *fitparm;
real tendfit, tbeginfit;
int i, efitfn, nparm;
efitfn = get_acffitfn();
nparm = effnNparams(efitfn);
fprintf(out, "Will fit to the following function:\n");
fprintf(out, "%s\n", effnDescription(efitfn));
c1 = val[n];
if (bYdy)
{
c1 = val[n];
sig = val[n+1];
fprintf(out, "Using two columns as y and sigma values\n");
}
else
{
snew(sig, ny);
}
if (opt2parg_bSet("-beginfit", npargs, ppa))
{
tbeginfit = opt2parg_real("-beginfit", npargs, ppa);
}
else
{
tbeginfit = x0[0];
}
if (opt2parg_bSet("-endfit", npargs, ppa))
{
tendfit = opt2parg_real("-endfit", npargs, ppa);
}
else
{
tendfit = x0[ny-1];
}
snew(fitparm, nparm);
switch (efitfn)
{
case effnEXP1:
fitparm[0] = 0.5;
break;
case effnEXP2:
fitparm[0] = 0.5;
fitparm[1] = c1[0];
break;
case effnEXPEXP:
fitparm[0] = 1.0;
fitparm[1] = 0.5*c1[0];
fitparm[2] = 10.0;
break;
case effnEXP5:
fitparm[0] = fitparm[2] = 0.5*c1[0];
fitparm[1] = 10;
fitparm[3] = 40;
fitparm[4] = 0;
break;
case effnEXP7:
fitparm[0] = fitparm[2] = fitparm[4] = 0.33*c1[0];
fitparm[1] = 1;
fitparm[3] = 10;
fitparm[5] = 100;
fitparm[6] = 0;
break;
case effnEXP9:
fitparm[0] = fitparm[2] = fitparm[4] = fitparm[6] = 0.25*c1[0];
fitparm[1] = 0.1;
fitparm[3] = 1;
fitparm[5] = 10;
fitparm[7] = 100;
fitparm[8] = 0;
break;
default:
fprintf(out, "Warning: don't know how to initialize the parameters\n");
for (i = 0; (i < nparm); i++)
{
fitparm[i] = 1;
}
}
fprintf(out, "Starting parameters:\n");
for (i = 0; (i < nparm); i++)
{
fprintf(out, "a%-2d = %12.5e\n", i+1, fitparm[i]);
}
if (do_lmfit(ny, c1, sig, 0, x0, tbeginfit, tendfit,
oenv, bDebugMode(), efitfn, fitparm, 0,
fn_fitted) > 0)
{
for (i = 0; (i < nparm); i++)
{
fprintf(out, "a%-2d = %12.5e\n", i+1, fitparm[i]);
}
}
else
{
fprintf(out, "No solution was found\n");
}
}
int gmx_editconf(int argc, char *argv[])
{
const char
*desc[] =
{
"editconf converts generic structure format to [TT].gro[tt], [TT].g96[tt]",
"or [TT].pdb[tt].",
"[PAR]",
"The box can be modified with options [TT]-box[tt], [TT]-d[tt] and",
"[TT]-angles[tt]. Both [TT]-box[tt] and [TT]-d[tt]",
"will center the system in the box, unless [TT]-noc[tt] is used.",
"[PAR]",
"Option [TT]-bt[tt] determines the box type: [TT]triclinic[tt] is a",
"triclinic box, [TT]cubic[tt] is a rectangular box with all sides equal",
"[TT]dodecahedron[tt] represents a rhombic dodecahedron and",
"[TT]octahedron[tt] is a truncated octahedron.",
"The last two are special cases of a triclinic box.",
"The length of the three box vectors of the truncated octahedron is the",
"shortest distance between two opposite hexagons.",
"The volume of a dodecahedron is 0.71 and that of a truncated octahedron",
"is 0.77 of that of a cubic box with the same periodic image distance.",
"[PAR]",
"Option [TT]-box[tt] requires only",
"one value for a cubic box, dodecahedron and a truncated octahedron.",
"[PAR]",
"With [TT]-d[tt] and a [TT]triclinic[tt] box the size of the system in the x, y",
"and z directions is used. With [TT]-d[tt] and [TT]cubic[tt],",
"[TT]dodecahedron[tt] or [TT]octahedron[tt] boxes, the dimensions are set",
"to the diameter of the system (largest distance between atoms) plus twice",
"the specified distance.",
"[PAR]",
"Option [TT]-angles[tt] is only meaningful with option [TT]-box[tt] and",
"a triclinic box and can not be used with option [TT]-d[tt].",
"[PAR]",
"When [TT]-n[tt] or [TT]-ndef[tt] is set, a group",
"can be selected for calculating the size and the geometric center,",
"otherwise the whole system is used.",
"[PAR]",
"[TT]-rotate[tt] rotates the coordinates and velocities.",
"[PAR]",
"[TT]-princ[tt] aligns the principal axes of the system along the",
"coordinate axes, this may allow you to decrease the box volume,",
"but beware that molecules can rotate significantly in a nanosecond.",
"[PAR]",
"Scaling is applied before any of the other operations are",
"performed. Boxes and coordinates can be scaled to give a certain density (option",
"[TT]-density[tt]). Note that this may be inaccurate in case a gro",
"file is given as input. A special feature of the scaling option, when the",
"factor -1 is given in one dimension, one obtains a mirror image,",
"mirrored in one of the plains, when one uses -1 in three dimensions",
"a point-mirror image is obtained.[PAR]",
"Groups are selected after all operations have been applied.[PAR]",
"Periodicity can be removed in a crude manner.",
"It is important that the box sizes at the bottom of your input file",
"are correct when the periodicity is to be removed.",
"[PAR]",
"When writing [TT].pdb[tt] files, B-factors can be",
"added with the [TT]-bf[tt] option. B-factors are read",
"from a file with with following format: first line states number of",
"entries in the file, next lines state an index",
"followed by a B-factor. The B-factors will be attached per residue",
"unless an index is larger than the number of residues or unless the",
"[TT]-atom[tt] option is set. Obviously, any type of numeric data can",
"be added instead of B-factors. [TT]-legend[tt] will produce",
"a row of CA atoms with B-factors ranging from the minimum to the",
"maximum value found, effectively making a legend for viewing.",
"[PAR]",
"With the option -mead a special pdb (pqr) file for the MEAD electrostatics",
"program (Poisson-Boltzmann solver) can be made. A further prerequisite",
"is that the input file is a run input file.",
"The B-factor field is then filled with the Van der Waals radius",
"of the atoms while the occupancy field will hold the charge.",
"[PAR]",
"The option -grasp is similar, but it puts the charges in the B-factor",
"and the radius in the occupancy.",
"[PAR]",
"Option [TT]-align[tt] allows alignment",
"of the principal axis of a specified group against the given vector, ",
"with an optional center of rotation specified by [TT]-aligncenter[tt].",
"[PAR]",
"Finally with option [TT]-label[tt] editconf can add a chain identifier",
"to a pdb file, which can be useful for analysis with e.g. rasmol.",
"[PAR]",
"To convert a truncated octrahedron file produced by a package which uses",
"a cubic box with the corners cut off (such as Gromos) use:[BR]",
"[TT]editconf -f <in> -rotate 0 45 35.264 -bt o -box <veclen> -o <out>[tt][BR]",
"where [TT]veclen[tt] is the size of the cubic box times sqrt(3)/2." };
const char *bugs[] =
{
"For complex molecules, the periodicity removal routine may break down, ",
"in that case you can use trjconv." };
static real dist = 0.0, rbox = 0.0, to_diam = 0.0;
static gmx_bool bNDEF = FALSE, bRMPBC = FALSE, bCenter = FALSE, bReadVDW =
FALSE, bCONECT = FALSE;
static gmx_bool peratom = FALSE, bLegend = FALSE, bOrient = FALSE, bMead =
FALSE, bGrasp = FALSE, bSig56 = FALSE;
static rvec scale =
{ 1, 1, 1 }, newbox =
{ 0, 0, 0 }, newang =
{ 90, 90, 90 };
static real rho = 1000.0, rvdw = 0.12;
static rvec center =
{ 0, 0, 0 }, translation =
{ 0, 0, 0 }, rotangles =
{ 0, 0, 0 }, aligncenter =
{ 0, 0, 0 }, targetvec =
{ 0, 0, 0 };
static const char *btype[] =
{ NULL, "triclinic", "cubic", "dodecahedron", "octahedron", NULL },
*label = "A";
static rvec visbox =
{ 0, 0, 0 };
t_pargs
pa[] =
{
{ "-ndef", FALSE, etBOOL,
{ &bNDEF }, "Choose output from default index groups" },
{ "-visbox", FALSE, etRVEC,
{ visbox },
"HIDDENVisualize a grid of boxes, -1 visualizes the 14 box images" },
{ "-bt", FALSE, etENUM,
{ btype }, "Box type for -box and -d" },
{ "-box", FALSE, etRVEC,
{ newbox }, "Box vector lengths (a,b,c)" },
{ "-angles", FALSE, etRVEC,
{ newang }, "Angles between the box vectors (bc,ac,ab)" },
{ "-d", FALSE, etREAL,
{ &dist }, "Distance between the solute and the box" },
{ "-c", FALSE, etBOOL,
{ &bCenter },
"Center molecule in box (implied by -box and -d)" },
{ "-center", FALSE, etRVEC,
{ center }, "Coordinates of geometrical center" },
{ "-aligncenter", FALSE, etRVEC,
{ aligncenter }, "Center of rotation for alignment" },
{ "-align", FALSE, etRVEC,
{ targetvec },
"Align to target vector" },
{ "-translate", FALSE, etRVEC,
{ translation }, "Translation" },
{ "-rotate", FALSE, etRVEC,
{ rotangles },
"Rotation around the X, Y and Z axes in degrees" },
{ "-princ", FALSE, etBOOL,
{ &bOrient },
"Orient molecule(s) along their principal axes" },
{ "-scale", FALSE, etRVEC,
{ scale }, "Scaling factor" },
{ "-density", FALSE, etREAL,
{ &rho },
"Density (g/l) of the output box achieved by scaling" },
{ "-pbc", FALSE, etBOOL,
{ &bRMPBC },
"Remove the periodicity (make molecule whole again)" },
{ "-grasp", FALSE, etBOOL,
{ &bGrasp },
"Store the charge of the atom in the B-factor field and the radius of the atom in the occupancy field" },
{
"-rvdw", FALSE, etREAL,
{ &rvdw },
"Default Van der Waals radius (in nm) if one can not be found in the database or if no parameters are present in the topology file" },
{ "-sig56", FALSE, etREAL,
{ &bSig56 },
"Use rmin/2 (minimum in the Van der Waals potential) rather than sigma/2 " },
{
"-vdwread", FALSE, etBOOL,
{ &bReadVDW },
"Read the Van der Waals radii from the file vdwradii.dat rather than computing the radii based on the force field" },
{ "-atom", FALSE, etBOOL,
{ &peratom }, "Force B-factor attachment per atom" },
{ "-legend", FALSE, etBOOL,
{ &bLegend }, "Make B-factor legend" },
{ "-label", FALSE, etSTR,
{ &label }, "Add chain label for all residues" },
{
"-conect", FALSE, etBOOL,
{ &bCONECT },
"Add CONECT records to a pdb file when written. Can only be done when a topology is present" } };
#define NPA asize(pa)
FILE *out;
const char *infile, *outfile;
char title[STRLEN];
int outftp, inftp, natom, i, j, n_bfac, itype, ntype;
double *bfac = NULL, c6, c12;
int *bfac_nr = NULL;
t_topology *top = NULL;
t_atoms atoms;
char *grpname, *sgrpname, *agrpname;
int isize, ssize, tsize, asize;
atom_id *index, *sindex, *tindex, *aindex;
rvec *x, *v, gc, min, max, size;
int ePBC;
matrix box,rotmatrix,trans;
rvec princd,tmpvec;
gmx_bool bIndex, bSetSize, bSetAng, bCubic, bDist, bSetCenter, bAlign;
gmx_bool bHaveV, bScale, bRho, bTranslate, bRotate, bCalcGeom, bCalcDiam;
real xs, ys, zs, xcent, ycent, zcent, diam = 0, mass = 0, d, vdw;
gmx_atomprop_t aps;
gmx_conect conect;
output_env_t oenv;
t_filenm fnm[] =
{
{ efSTX, "-f", NULL, ffREAD },
{ efNDX, "-n", NULL, ffOPTRD },
{ efSTO, NULL, NULL, ffOPTWR },
{ efPQR, "-mead", "mead", ffOPTWR },
{ efDAT, "-bf", "bfact", ffOPTRD } };
#define NFILE asize(fnm)
CopyRight(stderr, argv[0]);
parse_common_args(&argc, argv, PCA_CAN_VIEW, NFILE, fnm, NPA, pa,
asize(desc), desc, asize(bugs), bugs, &oenv);
bIndex = opt2bSet("-n", NFILE, fnm) || bNDEF;
bMead = opt2bSet("-mead", NFILE, fnm);
bSetSize = opt2parg_bSet("-box", NPA, pa);
bSetAng = opt2parg_bSet("-angles", NPA, pa);
bSetCenter = opt2parg_bSet("-center", NPA, pa);
bDist = opt2parg_bSet("-d", NPA, pa);
bAlign = opt2parg_bSet("-align", NPA, pa);
/* Only automatically turn on centering without -noc */
if ((bDist || bSetSize || bSetCenter) && !opt2parg_bSet("-c", NPA, pa))
{
bCenter = TRUE;
}
bScale = opt2parg_bSet("-scale", NPA, pa);
bRho = opt2parg_bSet("-density", NPA, pa);
bTranslate = opt2parg_bSet("-translate", NPA, pa);
bRotate = opt2parg_bSet("-rotate", NPA, pa);
if (bScale && bRho)
fprintf(stderr, "WARNING: setting -density overrides -scale\n");
bScale = bScale || bRho;
bCalcGeom = bCenter || bRotate || bOrient || bScale;
bCalcDiam = btype[0][0] == 'c' || btype[0][0] == 'd' || btype[0][0] == 'o';
infile = ftp2fn(efSTX, NFILE, fnm);
if (bMead)
outfile = ftp2fn(efPQR, NFILE, fnm);
else
outfile = ftp2fn(efSTO, NFILE, fnm);
outftp = fn2ftp(outfile);
inftp = fn2ftp(infile);
aps = gmx_atomprop_init();
if (bMead && bGrasp)
{
printf("Incompatible options -mead and -grasp. Turning off -grasp\n");
bGrasp = FALSE;
}
if (bGrasp && (outftp != efPDB))
gmx_fatal(FARGS, "Output file should be a .pdb file"
" when using the -grasp option\n");
if ((bMead || bGrasp) && !((fn2ftp(infile) == efTPR) ||
(fn2ftp(infile) == efTPA) ||
(fn2ftp(infile) == efTPB)))
gmx_fatal(FARGS,"Input file should be a .tp[abr] file"
" when using the -mead option\n");
get_stx_coordnum(infile,&natom);
init_t_atoms(&atoms,natom,TRUE);
snew(x,natom);
snew(v,natom);
read_stx_conf(infile,title,&atoms,x,v,&ePBC,box);
if (fn2ftp(infile) == efPDB)
{
get_pdb_atomnumber(&atoms,aps);
}
printf("Read %d atoms\n",atoms.nr);
/* Get the element numbers if available in a pdb file */
if (fn2ftp(infile) == efPDB)
get_pdb_atomnumber(&atoms,aps);
if (ePBC != epbcNONE)
{
real vol = det(box);
printf("Volume: %g nm^3, corresponds to roughly %d electrons\n",
vol,100*((int)(vol*4.5)));
}
if (bMead || bGrasp || bCONECT)
top = read_top(infile,NULL);
if (bMead || bGrasp)
{
if (atoms.nr != top->atoms.nr)
gmx_fatal(FARGS,"Atom numbers don't match (%d vs. %d)",atoms.nr,top->atoms.nr);
snew(atoms.pdbinfo,top->atoms.nr);
ntype = top->idef.atnr;
for(i=0; (i<atoms.nr); i++) {
/* Determine the Van der Waals radius from the force field */
if (bReadVDW) {
if (!gmx_atomprop_query(aps,epropVDW,
*top->atoms.resinfo[top->atoms.atom[i].resind].name,
*top->atoms.atomname[i],&vdw))
vdw = rvdw;
}
else {
itype = top->atoms.atom[i].type;
c12 = top->idef.iparams[itype*ntype+itype].lj.c12;
c6 = top->idef.iparams[itype*ntype+itype].lj.c6;
if ((c6 != 0) && (c12 != 0)) {
real sig6;
if (bSig56)
sig6 = 2*c12/c6;
else
sig6 = c12/c6;
vdw = 0.5*pow(sig6,1.0/6.0);
}
else
vdw = rvdw;
}
/* Factor of 10 for nm -> Angstroms */
vdw *= 10;
if (bMead) {
atoms.pdbinfo[i].occup = top->atoms.atom[i].q;
atoms.pdbinfo[i].bfac = vdw;
}
else {
atoms.pdbinfo[i].occup = vdw;
atoms.pdbinfo[i].bfac = top->atoms.atom[i].q;
}
}
}
bHaveV=FALSE;
for (i=0; (i<natom) && !bHaveV; i++)
for (j=0; (j<DIM) && !bHaveV; j++)
bHaveV=bHaveV || (v[i][j]!=0);
printf("%selocities found\n",bHaveV?"V":"No v");
if (visbox[0] > 0) {
if (bIndex)
gmx_fatal(FARGS,"Sorry, can not visualize box with index groups");
if (outftp != efPDB)
gmx_fatal(FARGS,"Sorry, can only visualize box with a pdb file");
} else if (visbox[0] == -1)
visualize_images("images.pdb",ePBC,box);
/* remove pbc */
if (bRMPBC)
rm_gropbc(&atoms,x,box);
if (bCalcGeom) {
if (bIndex) {
fprintf(stderr,"\nSelect a group for determining the system size:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&ssize,&sindex,&sgrpname);
} else {
ssize = atoms.nr;
sindex = NULL;
}
diam=calc_geom(ssize,sindex,x,gc,min,max,bCalcDiam);
rvec_sub(max, min, size);
printf(" system size :%7.3f%7.3f%7.3f (nm)\n",
size[XX], size[YY], size[ZZ]);
if (bCalcDiam)
printf(" diameter :%7.3f (nm)\n",diam);
printf(" center :%7.3f%7.3f%7.3f (nm)\n", gc[XX], gc[YY], gc[ZZ]);
printf(" box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf(" box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[YY],box[ZZ])),
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[ZZ])),
norm2(box[YY])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[YY])));
printf(" box volume :%7.2f (nm^3)\n",det(box));
}
if (bRho || bOrient || bAlign)
mass = calc_mass(&atoms,!fn2bTPX(infile),aps);
if (bOrient) {
atom_id *index;
char *grpnames;
/* Get a group for principal component analysis */
fprintf(stderr,"\nSelect group for the determining the orientation\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&isize,&index,&grpnames);
/* Orient the principal axes along the coordinate axes */
orient_princ(&atoms,isize,index,natom,x,bHaveV ? v : NULL, NULL);
sfree(index);
sfree(grpnames);
}
if ( bScale ) {
/* scale coordinates and box */
if (bRho) {
/* Compute scaling constant */
real vol,dens;
vol = det(box);
dens = (mass*AMU)/(vol*NANO*NANO*NANO);
fprintf(stderr,"Volume of input %g (nm^3)\n",vol);
fprintf(stderr,"Mass of input %g (a.m.u.)\n",mass);
fprintf(stderr,"Density of input %g (g/l)\n",dens);
if (vol==0 || mass==0)
gmx_fatal(FARGS,"Cannot scale density with "
"zero mass (%g) or volume (%g)\n",mass,vol);
scale[XX] = scale[YY] = scale[ZZ] = pow(dens/rho,1.0/3.0);
fprintf(stderr,"Scaling all box vectors by %g\n",scale[XX]);
}
scale_conf(atoms.nr,x,box,scale);
}
if (bAlign) {
if (bIndex) {
fprintf(stderr,"\nSelect a group that you want to align:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&asize,&aindex,&agrpname);
} else {
asize = atoms.nr;
snew(aindex,asize);
for (i=0;i<asize;i++)
aindex[i]=i;
}
printf("Aligning %d atoms (out of %d) to %g %g %g, center of rotation %g %g %g\n",asize,natom,
targetvec[XX],targetvec[YY],targetvec[ZZ],
aligncenter[XX],aligncenter[YY],aligncenter[ZZ]);
/*subtract out pivot point*/
for(i=0; i<asize; i++)
rvec_dec(x[aindex[i]],aligncenter);
/*now determine transform and rotate*/
/*will this work?*/
principal_comp(asize,aindex,atoms.atom,x, trans,princd);
unitv(targetvec,targetvec);
printf("Using %g %g %g as principal axis\n", trans[0][2],trans[1][2],trans[2][2]);
tmpvec[XX]=trans[0][2]; tmpvec[YY]=trans[1][2]; tmpvec[ZZ]=trans[2][2];
calc_rotmatrix(tmpvec, targetvec, rotmatrix);
/* rotmatrix finished */
for (i=0;i<asize;++i)
{
mvmul(rotmatrix,x[aindex[i]],tmpvec);
copy_rvec(tmpvec,x[aindex[i]]);
}
/*add pivot point back*/
for(i=0; i<asize; i++)
rvec_inc(x[aindex[i]],aligncenter);
if (!bIndex)
sfree(aindex);
}
if (bTranslate) {
if (bIndex) {
fprintf(stderr,"\nSelect a group that you want to translate:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&ssize,&sindex,&sgrpname);
} else {
ssize = atoms.nr;
sindex = NULL;
}
printf("Translating %d atoms (out of %d) by %g %g %g nm\n",ssize,natom,
translation[XX],translation[YY],translation[ZZ]);
if (sindex) {
for(i=0; i<ssize; i++)
rvec_inc(x[sindex[i]],translation);
}
else {
for(i=0; i<natom; i++)
rvec_inc(x[i],translation);
}
}
if (bRotate) {
/* Rotate */
printf("Rotating %g, %g, %g degrees around the X, Y and Z axis respectively\n",rotangles[XX],rotangles[YY],rotangles[ZZ]);
for(i=0; i<DIM; i++)
rotangles[i] *= DEG2RAD;
rotate_conf(natom,x,v,rotangles[XX],rotangles[YY],rotangles[ZZ]);
}
if (bCalcGeom) {
/* recalc geometrical center and max and min coordinates and size */
calc_geom(ssize,sindex,x,gc,min,max,FALSE);
rvec_sub(max, min, size);
if (bScale || bOrient || bRotate)
printf("new system size : %6.3f %6.3f %6.3f\n",
size[XX],size[YY],size[ZZ]);
}
if (bSetSize || bDist || (btype[0][0]=='t' && bSetAng)) {
ePBC = epbcXYZ;
if (!(bSetSize || bDist))
for (i=0; i<DIM; i++)
newbox[i] = norm(box[i]);
clear_mat(box);
/* calculate new boxsize */
switch(btype[0][0]){
case 't':
if (bDist)
for(i=0; i<DIM; i++)
newbox[i] = size[i]+2*dist;
if (!bSetAng) {
box[XX][XX] = newbox[XX];
box[YY][YY] = newbox[YY];
box[ZZ][ZZ] = newbox[ZZ];
} else {
matrix_convert(box,newbox,newang);
}
break;
case 'c':
case 'd':
case 'o':
if (bSetSize)
d = newbox[0];
else
d = diam+2*dist;
if (btype[0][0] == 'c')
for(i=0; i<DIM; i++)
box[i][i] = d;
else if (btype[0][0] == 'd') {
box[XX][XX] = d;
box[YY][YY] = d;
box[ZZ][XX] = d/2;
box[ZZ][YY] = d/2;
box[ZZ][ZZ] = d*sqrt(2)/2;
} else {
box[XX][XX] = d;
box[YY][XX] = d/3;
box[YY][YY] = d*sqrt(2)*2/3;
box[ZZ][XX] = -d/3;
box[ZZ][YY] = d*sqrt(2)/3;
box[ZZ][ZZ] = d*sqrt(6)/3;
}
break;
}
}
/* calculate new coords for geometrical center */
if (!bSetCenter)
calc_box_center(ecenterDEF,box,center);
/* center molecule on 'center' */
if (bCenter)
center_conf(natom,x,center,gc);
/* print some */
if (bCalcGeom) {
calc_geom(ssize,sindex,x, gc, min, max, FALSE);
printf("new center :%7.3f%7.3f%7.3f (nm)\n",gc[XX],gc[YY],gc[ZZ]);
}
if (bOrient || bScale || bDist || bSetSize) {
printf("new box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf("new box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[YY],box[ZZ])),
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[ZZ])),
norm2(box[YY])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[YY])));
printf("new box volume :%7.2f (nm^3)\n",det(box));
}
if (check_box(epbcXYZ,box))
printf("\nWARNING: %s\n",check_box(epbcXYZ,box));
if (bDist && btype[0][0]=='t')
{
if(TRICLINIC(box))
{
printf("\nWARNING: Your box is triclinic with non-orthogonal axes. In this case, the\n"
"distance from the solute to a box surface along the corresponding normal\n"
"vector might be somewhat smaller than your specified value %f.\n"
"You can check the actual value with g_mindist -pi\n",dist);
}
else
{
printf("\nWARNING: No boxtype specified - distance condition applied in each dimension.\n"
"If the molecule rotates the actual distance will be smaller. You might want\n"
"to use a cubic box instead, or why not try a dodecahedron today?\n");
}
}
if (bCONECT && (outftp == efPDB) && (inftp == efTPR))
conect = gmx_conect_generate(top);
else
conect = NULL;
if (bIndex) {
fprintf(stderr,"\nSelect a group for output:\n");
get_index(&atoms,opt2fn_null("-n",NFILE,fnm),
1,&isize,&index,&grpname);
if (opt2parg_bSet("-label",NPA,pa)) {
for(i=0; (i<atoms.nr); i++)
atoms.resinfo[atoms.atom[i].resind].chainid=label[0];
}
if (opt2bSet("-bf",NFILE,fnm) || bLegend)
{
gmx_fatal(FARGS,"Sorry, cannot do bfactors with an index group.");
}
if (outftp == efPDB)
{
out=ffopen(outfile,"w");
write_pdbfile_indexed(out,title,&atoms,x,ePBC,box,' ',1,isize,index,conect,TRUE);
ffclose(out);
}
else
{
write_sto_conf_indexed(outfile,title,&atoms,x,bHaveV?v:NULL,ePBC,box,isize,index);
}
}
else {
if ((outftp == efPDB) || (outftp == efPQR)) {
out=ffopen(outfile,"w");
if (bMead) {
set_pdb_wide_format(TRUE);
fprintf(out,"REMARK "
"The B-factors in this file hold atomic radii\n");
fprintf(out,"REMARK "
"The occupancy in this file hold atomic charges\n");
}
else if (bGrasp) {
fprintf(out,"GRASP PDB FILE\nFORMAT NUMBER=1\n");
fprintf(out,"REMARK "
"The B-factors in this file hold atomic charges\n");
fprintf(out,"REMARK "
"The occupancy in this file hold atomic radii\n");
}
else if (opt2bSet("-bf",NFILE,fnm)) {
read_bfac(opt2fn("-bf",NFILE,fnm),&n_bfac,&bfac,&bfac_nr);
set_pdb_conf_bfac(atoms.nr,atoms.nres,&atoms,
n_bfac,bfac,bfac_nr,peratom);
}
if (opt2parg_bSet("-label",NPA,pa)) {
for(i=0; (i<atoms.nr); i++)
atoms.resinfo[atoms.atom[i].resind].chainid=label[0];
}
write_pdbfile(out,title,&atoms,x,ePBC,box,' ',-1,conect,TRUE);
if (bLegend)
pdb_legend(out,atoms.nr,atoms.nres,&atoms,x);
if (visbox[0] > 0)
visualize_box(out,bLegend ? atoms.nr+12 : atoms.nr,
bLegend? atoms.nres=12 : atoms.nres,box,visbox);
ffclose(out);
}
else
write_sto_conf(outfile,title,&atoms,x,bHaveV?v:NULL,ePBC,box);
}
gmx_atomprop_destroy(aps);
do_view(oenv,outfile,NULL);
thanx(stderr);
return 0;
}
//! Implements C-style main function for mdrun
int gmx_mdrun(int argc, char *argv[])
{
const char *desc[] = {
"[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.",
"Normal mode analysis is another option. In this case [TT]mdrun[tt]",
"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 [gmx-nmeig].[PAR]",
"The [TT]mdrun[tt] program reads the run input file ([TT]-s[tt])",
"and distributes the topology over ranks if needed.",
"[TT]mdrun[tt] produces at least four output files.",
"A single log file ([TT]-g[tt]) is written.",
"The trajectory file ([TT]-o[tt]), contains coordinates, velocities and",
"optionally forces.",
"The structure file ([TT]-c[tt]) contains the coordinates and",
"velocities of the last step.",
"The energy file ([TT]-e[tt]) contains energies, the temperature,",
"pressure, etc, a lot of these things are also printed in the log file.",
"Optionally coordinates can be written to a compressed trajectory file",
"([TT]-x[tt]).[PAR]",
"The option [TT]-dhdl[tt] is only used when free energy calculation is",
"turned on.[PAR]",
"Running mdrun efficiently in parallel is a complex topic topic,",
"many aspects of which are covered in the online User Guide. You",
"should look there for practical advice on using many of the options",
"available in mdrun.[PAR]",
"ED (essential dynamics) sampling and/or additional flooding potentials",
"are switched on by using the [TT]-ei[tt] flag followed by an [REF].edi[ref]",
"file. The [REF].edi[ref] file can be produced with the [TT]make_edi[tt] tool",
"or by using options in the essdyn menu of the WHAT IF program.",
"[TT]mdrun[tt] produces a [REF].xvg[ref] output file that",
"contains projections of positions, velocities and forces onto selected",
"eigenvectors.[PAR]",
"When user-defined potential functions have been selected in the",
"[REF].mdp[ref] file the [TT]-table[tt] option is used to pass [TT]mdrun[tt]",
"a formatted table with potential functions. The file is read from",
"either the current directory or from the [TT]GMXLIB[tt] directory.",
"A number of pre-formatted tables are presented in the [TT]GMXLIB[tt] dir,",
"for 6-8, 6-9, 6-10, 6-11, 6-12 Lennard-Jones potentials with",
"normal Coulomb.",
"When pair interactions are present, a separate table for pair interaction",
"functions is read using the [TT]-tablep[tt] option.[PAR]",
"When tabulated bonded functions are present in the topology,",
"interaction functions are read using the [TT]-tableb[tt] option.",
"For each different tabulated interaction type used, a table file name must",
"be given. For the topology to work, a file name given here must match a",
"character sequence before the file extension. That sequence is: an underscore,",
"then a 'b' for bonds, an 'a' for angles or a 'd' for dihedrals,",
"and finally the matching table number index used in the topology.[PAR]",
"The options [TT]-px[tt] and [TT]-pf[tt] are used for writing pull COM",
"coordinates and forces when pulling is selected",
"in the [REF].mdp[ref] file.[PAR]",
"Finally some experimental algorithms can be tested when the",
"appropriate options have been given. Currently under",
"investigation are: polarizability.",
"[PAR]",
"The option [TT]-membed[tt] does what used to be g_membed, i.e. embed",
"a protein into a membrane. This module requires a number of settings",
"that are provided in a data file that is the argument of this option.",
"For more details in membrane embedding, see the documentation in the",
"user guide. The options [TT]-mn[tt] and [TT]-mp[tt] are used to provide",
"the index and topology files used for the embedding.",
"[PAR]",
"The option [TT]-pforce[tt] is useful when you suspect a simulation",
"crashes due to too large forces. With this option coordinates and",
"forces of atoms with a force larger than a certain value will",
"be printed to stderr. It will also terminate the run when non-finite",
"forces are present.",
"[PAR]",
"Checkpoints containing the complete state of the system are written",
"at regular intervals (option [TT]-cpt[tt]) to the file [TT]-cpo[tt],",
"unless option [TT]-cpt[tt] is set to -1.",
"The previous checkpoint is backed up to [TT]state_prev.cpt[tt] to",
"make sure that a recent state of the system is always available,",
"even when the simulation is terminated while writing a checkpoint.",
"With [TT]-cpnum[tt] all checkpoint files are kept and appended",
"with the step number.",
"A simulation can be continued by reading the full state from file",
"with option [TT]-cpi[tt]. This option is intelligent in the way that",
"if no checkpoint file is found, GROMACS just assumes a normal run and",
"starts from the first step of the [REF].tpr[ref] file. By default the output",
"will be appending to the existing output files. The checkpoint file",
"contains checksums of all output files, such that you will never",
"loose data when some output files are modified, corrupt or removed.",
"There are three scenarios with [TT]-cpi[tt]:[PAR]",
"[TT]*[tt] no files with matching names are present: new output files are written[PAR]",
"[TT]*[tt] all files are present with names and checksums matching those stored",
"in the checkpoint file: files are appended[PAR]",
"[TT]*[tt] otherwise no files are modified and a fatal error is generated[PAR]",
"With [TT]-noappend[tt] new output files are opened and the simulation",
"part number is added to all output file names.",
"Note that in all cases the checkpoint file itself is not renamed",
"and will be overwritten, unless its name does not match",
"the [TT]-cpo[tt] option.",
"[PAR]",
"With checkpointing the output is appended to previously written",
"output files, unless [TT]-noappend[tt] is used or none of the previous",
"output files are present (except for the checkpoint file).",
"The integrity of the files to be appended is verified using checksums",
"which are stored in the checkpoint file. This ensures that output can",
"not be mixed up or corrupted due to file appending. When only some",
"of the previous output files are present, a fatal error is generated",
"and no old output files are modified and no new output files are opened.",
"The result with appending will be the same as from a single run.",
"The contents will be binary identical, unless you use a different number",
"of ranks or dynamic load balancing or the FFT library uses optimizations",
"through timing.",
"[PAR]",
"With option [TT]-maxh[tt] a simulation is terminated and a checkpoint",
"file is written at the first neighbor search step where the run time",
"exceeds [TT]-maxh[tt]\\*0.99 hours. This option is particularly useful in",
"combination with setting [TT]nsteps[tt] to -1 either in the mdp or using the",
"similarly named command line option. This results in an infinite run,",
"terminated only when the time limit set by [TT]-maxh[tt] is reached (if any)"
"or upon receiving a signal."
"[PAR]",
"When [TT]mdrun[tt] receives a TERM signal, it will stop as soon as",
"checkpoint file can be written, i.e. after the next global communication step.",
"When [TT]mdrun[tt] receives an INT signal (e.g. when ctrl+C is",
"pressed), it will stop at the next neighbor search step or at the",
"second global communication step, whichever happens later.",
"In both cases all the usual output will be written to file.",
"When running with MPI, a signal to one of the [TT]mdrun[tt] ranks",
"is sufficient, this signal should not be sent to mpirun or",
"the [TT]mdrun[tt] process that is the parent of the others.",
"[PAR]",
"Interactive molecular dynamics (IMD) can be activated by using at least one",
"of the three IMD switches: The [TT]-imdterm[tt] switch allows one to terminate",
"the simulation from the molecular viewer (e.g. VMD). With [TT]-imdwait[tt],",
"[TT]mdrun[tt] pauses whenever no IMD client is connected. Pulling from the",
"IMD remote can be turned on by [TT]-imdpull[tt].",
"The port [TT]mdrun[tt] listens to can be altered by [TT]-imdport[tt].The",
"file pointed to by [TT]-if[tt] contains atom indices and forces if IMD",
"pulling is used."
"[PAR]",
"When [TT]mdrun[tt] is started with MPI, it does not run niced by default."
};
t_commrec *cr;
t_filenm fnm[] = {
{ efTPR, NULL, NULL, ffREAD },
{ efTRN, "-o", NULL, ffWRITE },
{ efCOMPRESSED, "-x", NULL, ffOPTWR },
{ efCPT, "-cpi", NULL, ffOPTRD | ffALLOW_MISSING },
{ efCPT, "-cpo", NULL, ffOPTWR },
{ efSTO, "-c", "confout", ffWRITE },
{ efEDR, "-e", "ener", ffWRITE },
{ efLOG, "-g", "md", ffWRITE },
{ efXVG, "-dhdl", "dhdl", ffOPTWR },
{ efXVG, "-field", "field", ffOPTWR },
{ efXVG, "-table", "table", ffOPTRD },
{ efXVG, "-tablep", "tablep", ffOPTRD },
{ efXVG, "-tableb", "table", ffOPTRDMULT },
{ efTRX, "-rerun", "rerun", ffOPTRD },
{ efXVG, "-tpi", "tpi", ffOPTWR },
{ efXVG, "-tpid", "tpidist", ffOPTWR },
{ efEDI, "-ei", "sam", ffOPTRD },
{ efXVG, "-eo", "edsam", ffOPTWR },
{ efXVG, "-devout", "deviatie", ffOPTWR },
{ efXVG, "-runav", "runaver", ffOPTWR },
{ efXVG, "-px", "pullx", ffOPTWR },
{ efXVG, "-pf", "pullf", ffOPTWR },
{ efXVG, "-ro", "rotation", ffOPTWR },
{ efLOG, "-ra", "rotangles", ffOPTWR },
{ efLOG, "-rs", "rotslabs", ffOPTWR },
{ efLOG, "-rt", "rottorque", ffOPTWR },
{ efMTX, "-mtx", "nm", ffOPTWR },
{ efRND, "-multidir", NULL, ffOPTRDMULT},
{ efDAT, "-membed", "membed", ffOPTRD },
{ efTOP, "-mp", "membed", ffOPTRD },
{ efNDX, "-mn", "membed", ffOPTRD },
{ efXVG, "-if", "imdforces", ffOPTWR },
{ efXVG, "-swap", "swapions", ffOPTWR }
};
const int NFILE = asize(fnm);
/* Command line options ! */
gmx_bool bDDBondCheck = TRUE;
gmx_bool bDDBondComm = TRUE;
gmx_bool bTunePME = TRUE;
gmx_bool bVerbose = FALSE;
gmx_bool bRerunVSite = FALSE;
gmx_bool bConfout = TRUE;
gmx_bool bReproducible = FALSE;
gmx_bool bIMDwait = FALSE;
gmx_bool bIMDterm = FALSE;
gmx_bool bIMDpull = FALSE;
int npme = -1;
int nstlist = 0;
int nmultisim = 0;
int nstglobalcomm = -1;
int repl_ex_nst = 0;
int repl_ex_seed = -1;
int repl_ex_nex = 0;
int nstepout = 100;
int resetstep = -1;
gmx_int64_t nsteps = -2; /* the value -2 means that the mdp option will be used */
int imdport = 8888; /* can be almost anything, 8888 is easy to remember */
rvec realddxyz = {0, 0, 0};
const char *ddrank_opt[ddrankorderNR+1] =
{ NULL, "interleave", "pp_pme", "cartesian", NULL };
const char *dddlb_opt[] =
{ NULL, "auto", "no", "yes", NULL };
const char *thread_aff_opt[threadaffNR+1] =
{ NULL, "auto", "on", "off", NULL };
const char *nbpu_opt[] =
{ NULL, "auto", "cpu", "gpu", "gpu_cpu", NULL };
real rdd = 0.0, rconstr = 0.0, dlb_scale = 0.8, pforce = -1;
char *ddcsx = NULL, *ddcsy = NULL, *ddcsz = NULL;
real cpt_period = 15.0, max_hours = -1;
gmx_bool bTryToAppendFiles = TRUE;
gmx_bool bKeepAndNumCPT = FALSE;
gmx_bool bResetCountersHalfWay = FALSE;
gmx_output_env_t *oenv = NULL;
/* Non transparent initialization of a complex gmx_hw_opt_t struct.
* 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 }
};
t_pargs pa[] = {
{ "-dd", FALSE, etRVEC, {&realddxyz},
"Domain decomposition grid, 0 is optimize" },
{ "-ddorder", FALSE, etENUM, {ddrank_opt},
"DD rank order" },
{ "-npme", FALSE, etINT, {&npme},
"Number of separate ranks to be used for PME, -1 is guess" },
{ "-nt", FALSE, etINT, {&hw_opt.nthreads_tot},
"Total number of threads to start (0 is guess)" },
{ "-ntmpi", FALSE, etINT, {&hw_opt.nthreads_tmpi},
"Number of thread-MPI threads to start (0 is guess)" },
{ "-ntomp", FALSE, etINT, {&hw_opt.nthreads_omp},
"Number of OpenMP threads per MPI rank to start (0 is guess)" },
{ "-ntomp_pme", FALSE, etINT, {&hw_opt.nthreads_omp_pme},
"Number of OpenMP threads per MPI rank to start (0 is -ntomp)" },
{ "-pin", FALSE, etENUM, {thread_aff_opt},
"Whether mdrun should try to set thread affinities" },
{ "-pinoffset", FALSE, etINT, {&hw_opt.core_pinning_offset},
"The lowest logical core number to which mdrun should pin the first thread" },
{ "-pinstride", FALSE, etINT, {&hw_opt.core_pinning_stride},
"Pinning distance in logical cores for threads, use 0 to minimize the number of threads per physical core" },
{ "-gpu_id", FALSE, etSTR, {&hw_opt.gpu_opt.gpu_id},
"List of GPU device id-s to use, specifies the per-node PP rank to GPU mapping" },
{ "-ddcheck", FALSE, etBOOL, {&bDDBondCheck},
"Check for all bonded interactions with DD" },
{ "-ddbondcomm", FALSE, etBOOL, {&bDDBondComm},
"HIDDENUse special bonded atom communication when [TT]-rdd[tt] > cut-off" },
{ "-rdd", FALSE, etREAL, {&rdd},
"The maximum distance for bonded interactions with DD (nm), 0 is determine from initial coordinates" },
{ "-rcon", FALSE, etREAL, {&rconstr},
"Maximum distance for P-LINCS (nm), 0 is estimate" },
{ "-dlb", FALSE, etENUM, {dddlb_opt},
"Dynamic load balancing (with DD)" },
{ "-dds", FALSE, etREAL, {&dlb_scale},
"Fraction in (0,1) by whose reciprocal the initial DD cell size will be increased in order to "
"provide a margin in which dynamic load balancing can act while preserving the minimum cell size." },
{ "-ddcsx", FALSE, etSTR, {&ddcsx},
"HIDDENA string containing a vector of the relative sizes in the x "
"direction of the corresponding DD cells. Only effective with static "
"load balancing." },
{ "-ddcsy", FALSE, etSTR, {&ddcsy},
"HIDDENA string containing a vector of the relative sizes in the y "
"direction of the corresponding DD cells. Only effective with static "
"load balancing." },
{ "-ddcsz", FALSE, etSTR, {&ddcsz},
"HIDDENA string containing a vector of the relative sizes in the z "
"direction of the corresponding DD cells. Only effective with static "
"load balancing." },
{ "-gcom", FALSE, etINT, {&nstglobalcomm},
"Global communication frequency" },
{ "-nb", FALSE, etENUM, {&nbpu_opt},
"Calculate non-bonded interactions on" },
{ "-nstlist", FALSE, etINT, {&nstlist},
"Set nstlist when using a Verlet buffer tolerance (0 is guess)" },
{ "-tunepme", FALSE, etBOOL, {&bTunePME},
"Optimize PME load between PP/PME ranks or GPU/CPU" },
{ "-v", FALSE, etBOOL, {&bVerbose},
"Be loud and noisy" },
{ "-pforce", FALSE, etREAL, {&pforce},
"Print all forces larger than this (kJ/mol nm)" },
{ "-reprod", FALSE, etBOOL, {&bReproducible},
"Try to avoid optimizations that affect binary reproducibility" },
{ "-cpt", FALSE, etREAL, {&cpt_period},
"Checkpoint interval (minutes)" },
{ "-cpnum", FALSE, etBOOL, {&bKeepAndNumCPT},
"Keep and number checkpoint files" },
{ "-append", FALSE, etBOOL, {&bTryToAppendFiles},
"Append to previous output files when continuing from checkpoint instead of adding the simulation part number to all file names" },
{ "-nsteps", FALSE, etINT64, {&nsteps},
"Run this number of steps, overrides .mdp file option (-1 means infinite, -2 means use mdp option, smaller is invalid)" },
{ "-maxh", FALSE, etREAL, {&max_hours},
"Terminate after 0.99 times this time (hours)" },
{ "-multi", FALSE, etINT, {&nmultisim},
"Do multiple simulations in parallel" },
{ "-replex", FALSE, etINT, {&repl_ex_nst},
"Attempt replica exchange periodically with this period (steps)" },
{ "-nex", FALSE, etINT, {&repl_ex_nex},
"Number of random exchanges to carry out each exchange interval (N^3 is one suggestion). -nex zero or not specified gives neighbor replica exchange." },
{ "-reseed", FALSE, etINT, {&repl_ex_seed},
"Seed for replica exchange, -1 is generate a seed" },
{ "-imdport", FALSE, etINT, {&imdport},
"HIDDENIMD listening port" },
{ "-imdwait", FALSE, etBOOL, {&bIMDwait},
"HIDDENPause the simulation while no IMD client is connected" },
{ "-imdterm", FALSE, etBOOL, {&bIMDterm},
"HIDDENAllow termination of the simulation from IMD client" },
{ "-imdpull", FALSE, etBOOL, {&bIMDpull},
"HIDDENAllow pulling in the simulation from IMD client" },
{ "-rerunvsite", FALSE, etBOOL, {&bRerunVSite},
"HIDDENRecalculate virtual site coordinates with [TT]-rerun[tt]" },
{ "-confout", FALSE, etBOOL, {&bConfout},
"HIDDENWrite the last configuration with [TT]-c[tt] and force checkpointing at the last step" },
{ "-stepout", FALSE, etINT, {&nstepout},
"HIDDENFrequency of writing the remaining wall clock time for the run" },
{ "-resetstep", FALSE, etINT, {&resetstep},
"HIDDENReset cycle counters after these many time steps" },
{ "-resethway", FALSE, etBOOL, {&bResetCountersHalfWay},
"HIDDENReset the cycle counters after half the number of steps or halfway [TT]-maxh[tt]" }
};
unsigned long Flags;
ivec ddxyz;
int dd_rank_order;
gmx_bool bDoAppendFiles, bStartFromCpt;
FILE *fplog;
int rc;
char **multidir = NULL;
cr = init_commrec();
unsigned long PCA_Flags = PCA_CAN_SET_DEFFNM;
// With -multi or -multidir, the file names are going to get processed
// further (or the working directory changed), so we can't check for their
// existence during parsing. It isn't useful to do any completion based on
// file system contents, either.
if (is_multisim_option_set(argc, argv))
{
PCA_Flags |= PCA_DISABLE_INPUT_FILE_CHECKING;
}
/* Comment this in to do fexist calls only on master
* works not with rerun or tables at the moment
* also comment out the version of init_forcerec in md.c
* with NULL instead of opt2fn
*/
/*
if (!MASTER(cr))
{
PCA_Flags |= PCA_NOT_READ_NODE;
}
*/
if (!parse_common_args(&argc, argv, PCA_Flags, NFILE, fnm, asize(pa), pa,
asize(desc), desc, 0, NULL, &oenv))
{
sfree(cr);
return 0;
}
dd_rank_order = nenum(ddrank_opt);
hw_opt.thread_affinity = nenum(thread_aff_opt);
/* now check the -multi and -multidir option */
if (opt2bSet("-multidir", NFILE, fnm))
{
if (nmultisim > 0)
{
gmx_fatal(FARGS, "mdrun -multi and -multidir options are mutually exclusive.");
}
nmultisim = opt2fns(&multidir, "-multidir", NFILE, fnm);
}
if (repl_ex_nst != 0 && nmultisim < 2)
{
gmx_fatal(FARGS, "Need at least two replicas for replica exchange (option -multi)");
}
if (repl_ex_nex < 0)
{
gmx_fatal(FARGS, "Replica exchange number of exchanges needs to be positive");
}
if (nmultisim >= 1)
{
#if !GMX_THREAD_MPI
init_multisystem(cr, nmultisim, multidir, NFILE, fnm);
#else
gmx_fatal(FARGS, "mdrun -multi or -multidir are not supported with the thread-MPI library. "
"Please compile GROMACS with a proper external MPI library.");
#endif
}
if (!opt2bSet("-cpi", NFILE, fnm))
{
// If we are not starting from a checkpoint we never allow files to be appended
// to, since that has caused a ton of strange behaviour and bugs in the past.
if (opt2parg_bSet("-append", asize(pa), pa))
{
// If the user explicitly used the -append option, explain that it is not possible.
gmx_fatal(FARGS, "GROMACS can only append to files when restarting from a checkpoint.");
}
else
{
// If the user did not say anything explicit, just disable appending.
bTryToAppendFiles = FALSE;
}
}
handleRestart(cr, bTryToAppendFiles, NFILE, fnm, &bDoAppendFiles, &bStartFromCpt);
Flags = opt2bSet("-rerun", NFILE, fnm) ? MD_RERUN : 0;
Flags = Flags | (bDDBondCheck ? MD_DDBONDCHECK : 0);
Flags = Flags | (bDDBondComm ? MD_DDBONDCOMM : 0);
Flags = Flags | (bTunePME ? MD_TUNEPME : 0);
Flags = Flags | (bConfout ? MD_CONFOUT : 0);
Flags = Flags | (bRerunVSite ? MD_RERUN_VSITE : 0);
Flags = Flags | (bReproducible ? MD_REPRODUCIBLE : 0);
Flags = Flags | (bDoAppendFiles ? MD_APPENDFILES : 0);
Flags = Flags | (opt2parg_bSet("-append", asize(pa), pa) ? MD_APPENDFILESSET : 0);
Flags = Flags | (bKeepAndNumCPT ? MD_KEEPANDNUMCPT : 0);
Flags = Flags | (bStartFromCpt ? MD_STARTFROMCPT : 0);
Flags = Flags | (bResetCountersHalfWay ? MD_RESETCOUNTERSHALFWAY : 0);
Flags = Flags | (opt2parg_bSet("-ntomp", asize(pa), pa) ? MD_NTOMPSET : 0);
Flags = Flags | (bIMDwait ? MD_IMDWAIT : 0);
Flags = Flags | (bIMDterm ? MD_IMDTERM : 0);
Flags = Flags | (bIMDpull ? MD_IMDPULL : 0);
/* We postpone opening the log file if we are appending, so we can
first truncate the old log file and append to the correct position
there instead. */
if (MASTER(cr) && !bDoAppendFiles)
{
gmx_log_open(ftp2fn(efLOG, NFILE, fnm), cr,
Flags & MD_APPENDFILES, &fplog);
}
else
{
fplog = NULL;
}
ddxyz[XX] = (int)(realddxyz[XX] + 0.5);
ddxyz[YY] = (int)(realddxyz[YY] + 0.5);
ddxyz[ZZ] = (int)(realddxyz[ZZ] + 0.5);
rc = gmx::mdrunner(&hw_opt, fplog, cr, NFILE, fnm, oenv, bVerbose,
nstglobalcomm, ddxyz, dd_rank_order, npme, rdd, rconstr,
dddlb_opt[0], dlb_scale, ddcsx, ddcsy, ddcsz,
nbpu_opt[0], nstlist,
nsteps, nstepout, resetstep,
nmultisim, repl_ex_nst, repl_ex_nex, repl_ex_seed,
pforce, cpt_period, max_hours, imdport, Flags);
/* Log file has to be closed in mdrunner if we are appending to it
(fplog not set here) */
if (MASTER(cr) && !bDoAppendFiles)
{
gmx_log_close(fplog);
}
return rc;
}
gmx_bool parse_common_args(int *argc, char *argv[], unsigned long Flags,
int nfile, t_filenm fnm[], int npargs, t_pargs *pa,
int ndesc, const char **desc,
int nbugs, const char **bugs,
output_env_t *oenv)
{
/* This array should match the order of the enum in oenv.h */
const char *xvg_format[] = { NULL, "xmgrace", "xmgr", "none", NULL };
/* This array should match the order of the enum in oenv.h */
const char *time_units[] = {
NULL, "fs", "ps", "ns", "us", "ms", "s",
NULL
};
int nicelevel = 0, debug_level = 0;
char *deffnm = NULL;
real tbegin = 0, tend = 0, tdelta = 0;
gmx_bool bView = FALSE;
t_pargs *all_pa = NULL;
t_pargs nice_pa = {
"-nice", FALSE, etINT, {&nicelevel},
"Set the nicelevel"
};
t_pargs deffnm_pa = {
"-deffnm", FALSE, etSTR, {&deffnm},
"Set the default filename for all file options"
};
t_pargs begin_pa = {
"-b", FALSE, etTIME, {&tbegin},
"First frame (%t) to read from trajectory"
};
t_pargs end_pa = {
"-e", FALSE, etTIME, {&tend},
"Last frame (%t) to read from trajectory"
};
t_pargs dt_pa = {
"-dt", FALSE, etTIME, {&tdelta},
"Only use frame when t MOD dt = first time (%t)"
};
t_pargs view_pa = {
"-w", FALSE, etBOOL, {&bView},
"View output [TT].xvg[tt], [TT].xpm[tt], [TT].eps[tt] and [TT].pdb[tt] files"
};
t_pargs xvg_pa = {
"-xvg", FALSE, etENUM, {xvg_format},
"xvg plot formatting"
};
t_pargs time_pa = {
"-tu", FALSE, etENUM, {time_units},
"Time unit"
};
/* Maximum number of extra arguments */
#define EXTRA_PA 16
t_pargs pca_pa[] = {
{ "-debug", FALSE, etINT, {&debug_level},
"HIDDENWrite file with debug information, 1: short, 2: also x and f" },
};
#define NPCA_PA asize(pca_pa)
gmx_bool bXvgr;
int i, j, k, npall, max_pa;
// Handle the flags argument, which is a bit field
// The FF macro returns whether or not the bit is set
#define FF(arg) ((Flags & arg) == arg)
/* Check for double arguments */
for (i = 1; (i < *argc); i++)
{
if (argv[i] && (strlen(argv[i]) > 1) && (!std::isdigit(argv[i][1])))
{
for (j = i+1; (j < *argc); j++)
{
if ( (argv[i][0] == '-') && (argv[j][0] == '-') &&
(strcmp(argv[i], argv[j]) == 0) )
{
if (FF(PCA_NOEXIT_ON_ARGS))
{
fprintf(stderr, "Double command line argument %s\n",
argv[i]);
}
else
{
gmx_fatal(FARGS, "Double command line argument %s\n",
argv[i]);
}
}
}
}
}
debug_gmx();
/* Check ALL the flags ... */
max_pa = NPCA_PA + EXTRA_PA + npargs+1;
snew(all_pa, max_pa);
for (i = npall = 0; (i < static_cast<int>(NPCA_PA)); i++)
{
npall = add_parg(npall, all_pa, &(pca_pa[i]));
}
if (FF(PCA_BE_NICE))
{
nicelevel = 19;
}
npall = add_parg(npall, all_pa, &nice_pa);
if (FF(PCA_CAN_SET_DEFFNM))
{
npall = add_parg(npall, all_pa, &deffnm_pa);
}
if (FF(PCA_CAN_BEGIN))
{
npall = add_parg(npall, all_pa, &begin_pa);
}
if (FF(PCA_CAN_END))
{
npall = add_parg(npall, all_pa, &end_pa);
}
if (FF(PCA_CAN_DT))
{
npall = add_parg(npall, all_pa, &dt_pa);
}
if (FF(PCA_TIME_UNIT))
{
npall = add_parg(npall, all_pa, &time_pa);
}
if (FF(PCA_CAN_VIEW))
{
npall = add_parg(npall, all_pa, &view_pa);
}
bXvgr = FALSE;
for (i = 0; (i < nfile); i++)
{
bXvgr = bXvgr || (fnm[i].ftp == efXVG);
}
if (bXvgr)
{
npall = add_parg(npall, all_pa, &xvg_pa);
}
/* Now append the program specific arguments */
for (i = 0; (i < npargs); i++)
{
npall = add_parg(npall, all_pa, &(pa[i]));
}
/* set etENUM options to default */
for (i = 0; (i < npall); i++)
{
if (all_pa[i].type == etENUM)
{
all_pa[i].u.c[0] = all_pa[i].u.c[1];
}
}
set_default_time_unit(time_units, FF(PCA_TIME_UNIT));
set_default_xvg_format(xvg_format);
/* Now parse all the command-line options */
get_pargs(argc, argv, npall, all_pa);
/* set program name, command line, and default values for output options */
output_env_init(oenv, gmx::getProgramContext(), (time_unit_t)nenum(time_units), bView,
(xvg_format_t)nenum(xvg_format), 0, debug_level);
/* Parse the file args */
parse_file_args(argc, argv, nfile, fnm, deffnm, !FF(PCA_NOT_READ_NODE));
/* Open the debug file */
if (debug_level > 0)
{
char buf[256];
if (gmx_mpi_initialized())
{
sprintf(buf, "%s%d.debug", output_env_get_short_program_name(*oenv),
gmx_node_rank());
}
else
{
sprintf(buf, "%s.debug", output_env_get_short_program_name(*oenv));
}
init_debug(debug_level, buf);
fprintf(stderr, "Opening debug file %s (src code file %s, line %d)\n",
buf, __FILE__, __LINE__);
}
/* Now copy the results back... */
for (i = 0, k = npall-npargs; (i < npargs); i++, k++)
{
memcpy(&(pa[i]), &(all_pa[k]), (size_t)sizeof(pa[i]));
}
bool bExit = false;
try
{
const gmx::CommandLineHelpContext *context =
gmx::GlobalCommandLineHelpContext::get();
bExit = (context != NULL);
if (context != NULL && !(FF(PCA_QUIET)))
{
gmx::Options options(NULL, NULL);
options.setDescription(gmx::constArrayRefFromArray(desc, ndesc));
for (i = 0; i < nfile; i++)
{
gmx::filenmToOptions(&options, &fnm[i]);
}
for (i = 0; i < npall; i++)
{
gmx::pargsToOptions(&options, &all_pa[i]);
}
gmx::CommandLineHelpWriter(options)
.setShowDescriptions(true)
.setTimeUnitString(output_env_get_time_unit(*oenv))
.setKnownIssues(gmx::constArrayRefFromArray(bugs, nbugs))
.writeHelp(*context);
}
}
GMX_CATCH_ALL_AND_EXIT_WITH_FATAL_ERROR;
/* Set the nice level */
#if defined(HAVE_UNISTD_H) && !defined(__MINGW32__)
#ifndef GMX_NO_NICE
/* The some system, e.g. the catamount kernel on cray xt3 do not have nice(2). */
if (nicelevel != 0 && !bExit)
{
static gmx_bool nice_set = FALSE; /* only set it once */
static tMPI_Thread_mutex_t init_mutex = TMPI_THREAD_MUTEX_INITIALIZER;
tMPI_Thread_mutex_lock(&init_mutex);
if (!nice_set)
{
if (nice(nicelevel) == -1)
{
/* Do nothing, but use the return value to avoid warnings. */
}
nice_set = TRUE;
}
tMPI_Thread_mutex_unlock(&init_mutex);
}
#endif
#endif
/* convert time options, must be done after printing! */
for (i = 0; i < npall; i++)
{
if (all_pa[i].type == etTIME && all_pa[i].bSet)
{
*all_pa[i].u.r *= output_env_get_time_invfactor(*oenv);
}
}
/* Extract Time info from arguments */
if (FF(PCA_CAN_BEGIN) && opt2parg_bSet("-b", npall, all_pa))
{
setTimeValue(TBEGIN, opt2parg_real("-b", npall, all_pa));
}
if (FF(PCA_CAN_END) && opt2parg_bSet("-e", npall, all_pa))
{
setTimeValue(TEND, opt2parg_real("-e", npall, all_pa));
}
if (FF(PCA_CAN_DT) && opt2parg_bSet("-dt", npall, all_pa))
{
setTimeValue(TDELTA, opt2parg_real("-dt", npall, all_pa));
}
/* clear memory */
sfree(all_pa);
if (!FF(PCA_NOEXIT_ON_ARGS))
{
if (*argc > 1)
{
gmx_cmd(argv[1]);
}
}
return !bExit;
#undef FF
}
int gmx_trjorder(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] orders molecules according to the smallest distance",
"to atoms in a reference group",
"or on z-coordinate (with option [TT]-z[tt]).",
"With distance ordering, it will ask for a group of reference",
"atoms and a group of molecules. For each frame of the trajectory",
"the selected molecules will be reordered according to the shortest",
"distance between atom number [TT]-da[tt] in the molecule and all the",
"atoms in the reference group. The center of mass of the molecules can",
"be used instead of a reference atom by setting [TT]-da[tt] to 0.",
"All atoms in the trajectory are written",
"to the output trajectory.[PAR]",
"[THISMODULE] can be useful for e.g. analyzing the n waters closest to a",
"protein.",
"In that case the reference group would be the protein and the group",
"of molecules would consist of all the water atoms. When an index group",
"of the first n waters is made, the ordered trajectory can be used",
"with any GROMACS program to analyze the n closest waters.",
"[PAR]",
"If the output file is a [REF].pdb[ref] file, the distance to the reference target",
"will be stored in the B-factor field in order to color with e.g. Rasmol.",
"[PAR]",
"With option [TT]-nshell[tt] the number of molecules within a shell",
"of radius [TT]-r[tt] around the reference group are printed."
};
static int na = 3, ref_a = 1;
static real rcut = 0;
static gmx_bool bCOM = FALSE, bZ = FALSE;
t_pargs pa[] = {
{ "-na", FALSE, etINT, {&na},
"Number of atoms in a molecule" },
{ "-da", FALSE, etINT, {&ref_a},
"Atom used for the distance calculation, 0 is COM" },
{ "-com", FALSE, etBOOL, {&bCOM},
"Use the distance to the center of mass of the reference group" },
{ "-r", FALSE, etREAL, {&rcut},
"Cutoff used for the distance calculation when computing the number of molecules in a shell around e.g. a protein" },
{ "-z", FALSE, etBOOL, {&bZ},
"Order molecules on z-coordinate" }
};
FILE *fp;
t_trxstatus *out;
t_trxstatus *status;
gmx_bool bNShell, bPDBout;
t_topology top;
int ePBC;
rvec *x, *xsol, xcom, dx;
matrix box;
t_pbc pbc;
gmx_rmpbc_t gpbc;
real t, totmass, mass, rcut2 = 0, n2;
int natoms, nwat, ncut;
char **grpname;
int i, j, d, *isize, isize_ref = 0, isize_sol;
atom_id sa, sr, *swi, **index, *ind_ref = NULL, *ind_sol;
output_env_t oenv;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTRO, "-o", "ordered", ffOPTWR },
{ efXVG, "-nshell", "nshell", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, &x, NULL, box, TRUE);
sfree(x);
/* get index groups */
printf("Select %sa group of molecules to be ordered:\n",
bZ ? "" : "a group of reference atoms and ");
snew(grpname, 2);
snew(index, 2);
snew(isize, 2);
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), bZ ? 1 : 2,
isize, index, grpname);
if (!bZ)
{
isize_ref = isize[0];
isize_sol = isize[1];
ind_ref = index[0];
ind_sol = index[1];
}
else
{
isize_sol = isize[0];
ind_sol = index[0];
}
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
if (natoms > top.atoms.nr)
{
gmx_fatal(FARGS, "Number of atoms in the run input file is larger than in the trjactory");
}
for (i = 0; (i < 2); i++)
{
for (j = 0; (j < isize[i]); j++)
{
if (index[i][j] > natoms)
{
gmx_fatal(FARGS, "An atom number in group %s is larger than the number of atoms in the trajectory");
}
}
}
if ((isize_sol % na) != 0)
{
gmx_fatal(FARGS, "Number of atoms in the molecule group (%d) is not a multiple of na (%d)",
isize[1], na);
}
nwat = isize_sol/na;
if (ref_a > na)
{
gmx_fatal(FARGS, "The reference atom can not be larger than the number of atoms in a molecule");
}
ref_a--;
snew(xsol, nwat);
snew(order, nwat);
snew(swi, natoms);
for (i = 0; (i < natoms); i++)
{
swi[i] = i;
}
out = NULL;
fp = NULL;
bNShell = ((opt2bSet("-nshell", NFILE, fnm)) ||
(opt2parg_bSet("-r", asize(pa), pa)));
bPDBout = FALSE;
if (bNShell)
{
rcut2 = rcut*rcut;
fp = xvgropen(opt2fn("-nshell", NFILE, fnm), "Number of molecules",
"Time (ps)", "N", oenv);
printf("Will compute the number of molecules within a radius of %g\n",
rcut);
}
if (!bNShell || opt2bSet("-o", NFILE, fnm))
{
bPDBout = (fn2ftp(opt2fn("-o", NFILE, fnm)) == efPDB);
if (bPDBout && !top.atoms.pdbinfo)
{
fprintf(stderr, "Creating pdbfino records\n");
snew(top.atoms.pdbinfo, top.atoms.nr);
}
out = open_trx(opt2fn("-o", NFILE, fnm), "w");
}
gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
do
{
gmx_rmpbc(gpbc, natoms, box, x);
set_pbc(&pbc, ePBC, box);
if (ref_a == -1)
{
/* Calculate the COM of all solvent molecules */
for (i = 0; i < nwat; i++)
{
totmass = 0;
clear_rvec(xsol[i]);
for (j = 0; j < na; j++)
{
sa = ind_sol[i*na+j];
mass = top.atoms.atom[sa].m;
totmass += mass;
for (d = 0; d < DIM; d++)
{
xsol[i][d] += mass*x[sa][d];
}
}
svmul(1.0/totmass, xsol[i], xsol[i]);
}
}
else
{
/* Copy the reference atom of all solvent molecules */
for (i = 0; i < nwat; i++)
{
copy_rvec(x[ind_sol[i*na+ref_a]], xsol[i]);
}
}
if (bZ)
{
for (i = 0; (i < nwat); i++)
{
sa = ind_sol[na*i];
order[i].i = sa;
order[i].d2 = xsol[i][ZZ];
}
}
else if (bCOM)
{
totmass = 0;
clear_rvec(xcom);
for (i = 0; i < isize_ref; i++)
{
mass = top.atoms.atom[ind_ref[i]].m;
totmass += mass;
for (j = 0; j < DIM; j++)
{
xcom[j] += mass*x[ind_ref[i]][j];
}
}
svmul(1/totmass, xcom, xcom);
for (i = 0; (i < nwat); i++)
{
sa = ind_sol[na*i];
pbc_dx(&pbc, xcom, xsol[i], dx);
order[i].i = sa;
order[i].d2 = norm2(dx);
}
}
else
{
/* Set distance to first atom */
for (i = 0; (i < nwat); i++)
{
sa = ind_sol[na*i];
pbc_dx(&pbc, x[ind_ref[0]], xsol[i], dx);
order[i].i = sa;
order[i].d2 = norm2(dx);
}
for (j = 1; (j < isize_ref); j++)
{
sr = ind_ref[j];
for (i = 0; (i < nwat); i++)
{
pbc_dx(&pbc, x[sr], xsol[i], dx);
n2 = norm2(dx);
if (n2 < order[i].d2)
{
order[i].d2 = n2;
}
}
}
}
if (bNShell)
{
ncut = 0;
for (i = 0; (i < nwat); i++)
{
if (order[i].d2 <= rcut2)
{
ncut++;
}
}
fprintf(fp, "%10.3f %8d\n", t, ncut);
}
if (out)
{
qsort(order, nwat, sizeof(*order), ocomp);
for (i = 0; (i < nwat); i++)
{
for (j = 0; (j < na); j++)
{
swi[ind_sol[na*i]+j] = order[i].i+j;
}
}
/* Store the distance as the B-factor */
if (bPDBout)
{
for (i = 0; (i < nwat); i++)
{
for (j = 0; (j < na); j++)
{
top.atoms.pdbinfo[order[i].i+j].bfac = std::sqrt(order[i].d2);
}
}
}
write_trx(out, natoms, swi, &top.atoms, 0, t, box, x, NULL, NULL);
}
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (out)
{
close_trx(out);
}
if (fp)
{
xvgrclose(fp);
}
gmx_rmpbc_done(gpbc);
return 0;
}
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",
"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."
};
static real c6 = 1.0e-3, cn = 1.0e-6, qi = 0, qj = 0, sig = 0.3, eps = 1, sigfac = 0.7;
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}, "[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 [GRK]sigma[grk] for starting the plot" }
};
t_filenm fnm[] = {
{ efXVG, "-o", "potje", ffWRITE }
};
output_env_t oenv;
#define NFILE asize(fnm)
const char *legend[] = { "Lennard-Jones", "Buckingham" };
FILE *fp;
int i;
gmx_bool bBham;
real qq, x, oldx, minimum, mval, dp[2], pp[2];
int cur = 0;
#define next (1-cur)
parse_common_args(&argc, argv, PCA_CAN_VIEW,
NFILE, fnm, asize(pa), pa, asize(desc),
desc, 0, NULL, &oenv);
bBham = (opt2parg_bSet("-A", asize(pa), pa) ||
opt2parg_bSet("-B", asize(pa), pa) ||
opt2parg_bSet("-C", asize(pa), pa));
if (bBham)
{
c6 = Cbh;
sig = pow((6.0/npow)*pow(npow/Bbh, npow-6.0), 1.0/(npow-6.0));
eps = c6/(4*pow(sig, 6.0));
cn = 4*eps*pow(sig, npow);
}
else
{
if (opt2parg_bSet("-sig", asize(pa), pa) ||
opt2parg_bSet("-eps", asize(pa), pa))
{
c6 = 4*eps*pow(sig, 6);
cn = 4*eps*pow(sig, npow);
}
else if (opt2parg_bSet("-c6", asize(pa), pa) ||
opt2parg_bSet("-cn", asize(pa), pa) ||
opt2parg_bSet("-pow", asize(pa), pa))
{
sig = pow(cn/c6, 1.0/(npow-6.0));
eps = 0.25*c6*pow(sig, -6.0);
}
else
{
sig = eps = 0;
}
printf("c6 = %12.5e, c%d = %12.5e\n", c6, npow, cn);
printf("sigma = %12.5f, epsilon = %12.5f\n", sig, eps);
minimum = pow(npow/6.0*pow(sig, npow-6.0), 1.0/(npow-6));
printf("Van der Waals minimum at %g, V = %g\n\n",
minimum, pot(minimum, 0, c6, cn, npow));
printf("Fit of Lennard Jones (%d-6) to Buckingham:\n", npow);
Bbh = npow/minimum;
Cbh = c6;
Abh = 4*eps*pow(sig/minimum, npow)*exp(npow);
printf("A = %g, B = %g, C = %g\n", Abh, Bbh, Cbh);
}
qq = qi*qj;
fp = xvgropen(ftp2fn(efXVG, NFILE, fnm), "Potential", "r (nm)", "E (kJ/mol)",
oenv);
xvgr_legend(fp, asize(legend), legend,
oenv);
if (sig == 0)
{
sig = 0.25;
}
minimum = -1;
mval = 0;
oldx = 0;
for (i = 0; (i < 100); i++)
{
x = sigfac*sig+sig*i*0.02;
dp[next] = dpot(x, qq, c6, cn, npow);
fprintf(fp, "%10g %10g %10g\n", x, pot(x, qq, c6, cn, npow),
bhpot(x, Abh, Bbh, Cbh));
if (qq != 0)
{
if ((i > 0) && (dp[cur]*dp[next] < 0))
{
minimum = oldx + dp[cur]*(x-oldx)/(dp[cur]-dp[next]);
mval = pot(minimum, qq, c6, cn, npow);
printf("Van der Waals + Coulomb minimum at r = %g (nm). Value = %g (kJ/mol)\n",
minimum, mval);
}
}
cur = next;
oldx = x;
}
ffclose(fp);
do_view(oenv, ftp2fn(efXVG, NFILE, fnm), NULL);
return 0;
}
int gmx_rms(int argc, char *argv[])
{
const char *desc[] =
{
"[THISMODULE] compares two structures by computing the root mean square",
"deviation (RMSD), the size-independent [GRK]rho[grk] similarity parameter",
"([TT]rho[tt]) or the scaled [GRK]rho[grk] ([TT]rhosc[tt]), ",
"see Maiorov & Crippen, Proteins [BB]22[bb], 273 (1995).",
"This is selected by [TT]-what[tt].[PAR]"
"Each structure from a trajectory ([TT]-f[tt]) is compared to a",
"reference structure. The reference structure",
"is taken from the structure file ([TT]-s[tt]).[PAR]",
"With option [TT]-mir[tt] also a comparison with the mirror image of",
"the reference structure is calculated.",
"This is useful as a reference for 'significant' values, see",
"Maiorov & Crippen, Proteins [BB]22[bb], 273 (1995).[PAR]",
"Option [TT]-prev[tt] produces the comparison with a previous frame",
"the specified number of frames ago.[PAR]",
"Option [TT]-m[tt] produces a matrix in [TT].xpm[tt] format of",
"comparison values of each structure in the trajectory with respect to",
"each other structure. This file can be visualized with for instance",
"[TT]xv[tt] and can be converted to postscript with [gmx-xpm2ps].[PAR]",
"Option [TT]-fit[tt] controls the least-squares fitting of",
"the structures on top of each other: complete fit (rotation and",
"translation), translation only, or no fitting at all.[PAR]",
"Option [TT]-mw[tt] controls whether mass weighting is done or not.",
"If you select the option (default) and ",
"supply a valid [TT].tpr[tt] file masses will be taken from there, ",
"otherwise the masses will be deduced from the [TT]atommass.dat[tt] file in",
"[TT]GMXLIB[tt]. This is fine for proteins, but not",
"necessarily for other molecules. A default mass of 12.011 amu (carbon)",
"is assigned to unknown atoms. You can check whether this happend by",
"turning on the [TT]-debug[tt] flag and inspecting the log file.[PAR]",
"With [TT]-f2[tt], the 'other structures' are taken from a second",
"trajectory, this generates a comparison matrix of one trajectory",
"versus the other.[PAR]",
"Option [TT]-bin[tt] does a binary dump of the comparison matrix.[PAR]",
"Option [TT]-bm[tt] produces a matrix of average bond angle deviations",
"analogously to the [TT]-m[tt] option. Only bonds between atoms in the",
"comparison group are considered."
};
static gmx_bool bPBC = TRUE, bFitAll = TRUE, bSplit = FALSE;
static gmx_bool bDeltaLog = FALSE;
static int prev = 0, freq = 1, freq2 = 1, nlevels = 80, avl = 0;
static real rmsd_user_max = -1, rmsd_user_min = -1, bond_user_max = -1,
bond_user_min = -1, delta_maxy = 0.0;
/* strings and things for selecting difference method */
enum
{
ewSel, ewRMSD, ewRho, ewRhoSc, ewNR
};
int ewhat;
const char *what[ewNR + 1] =
{ NULL, "rmsd", "rho", "rhosc", NULL };
const char *whatname[ewNR] =
{ NULL, "RMSD", "Rho", "Rho sc" };
const char *whatlabel[ewNR] =
{ NULL, "RMSD (nm)", "Rho", "Rho sc" };
const char *whatxvgname[ewNR] =
{ NULL, "RMSD", "\\8r\\4", "\\8r\\4\\ssc\\N" };
const char *whatxvglabel[ewNR] =
{ NULL, "RMSD (nm)", "\\8r\\4", "\\8r\\4\\ssc\\N" };
/* strings and things for fitting methods */
enum
{
efSel, efFit, efReset, efNone, efNR
};
int efit;
const char *fit[efNR + 1] =
{ NULL, "rot+trans", "translation", "none", NULL };
const char *fitgraphlabel[efNR + 1] =
{ NULL, "lsq fit", "translational fit", "no fit" };
static int nrms = 1;
static gmx_bool bMassWeighted = TRUE;
t_pargs pa[] =
{
{ "-what", FALSE, etENUM,
{ what }, "Structural difference measure" },
{ "-pbc", FALSE, etBOOL,
{ &bPBC }, "PBC check" },
{ "-fit", FALSE, etENUM,
{ fit }, "Fit to reference structure" },
{ "-prev", FALSE, etINT,
{ &prev }, "Compare with previous frame" },
{ "-split", FALSE, etBOOL,
{ &bSplit }, "Split graph where time is zero" },
{ "-fitall", FALSE, etBOOL,
{ &bFitAll }, "HIDDENFit all pairs of structures in matrix" },
{ "-skip", FALSE, etINT,
{ &freq }, "Only write every nr-th frame to matrix" },
{ "-skip2", FALSE, etINT,
{ &freq2 }, "Only write every nr-th frame to matrix" },
{ "-max", FALSE, etREAL,
{ &rmsd_user_max }, "Maximum level in comparison matrix" },
{ "-min", FALSE, etREAL,
{ &rmsd_user_min }, "Minimum level in comparison matrix" },
{ "-bmax", FALSE, etREAL,
{ &bond_user_max }, "Maximum level in bond angle matrix" },
{ "-bmin", FALSE, etREAL,
{ &bond_user_min }, "Minimum level in bond angle matrix" },
{ "-mw", FALSE, etBOOL,
{ &bMassWeighted }, "Use mass weighting for superposition" },
{ "-nlevels", FALSE, etINT,
{ &nlevels }, "Number of levels in the matrices" },
{ "-ng", FALSE, etINT,
{ &nrms }, "Number of groups to compute RMS between" },
{ "-dlog", FALSE, etBOOL,
{ &bDeltaLog },
"HIDDENUse a log x-axis in the delta t matrix" },
{ "-dmax", FALSE, etREAL,
{ &delta_maxy }, "HIDDENMaximum level in delta matrix" },
{ "-aver", FALSE, etINT,
{ &avl },
"HIDDENAverage over this distance in the RMSD matrix" }
};
int natoms_trx, natoms_trx2, natoms;
int i, j, k, m, teller, teller2, tel_mat, tel_mat2;
#define NFRAME 5000
int maxframe = NFRAME, maxframe2 = NFRAME;
real t, *w_rls, *w_rms, *w_rls_m = NULL, *w_rms_m = NULL;
gmx_bool bNorm, bAv, bFreq2, bFile2, bMat, bBond, bDelta, bMirror, bMass;
gmx_bool bFit, bReset;
t_topology top;
int ePBC;
t_iatom *iatom = NULL;
matrix box;
rvec *x, *xp, *xm = NULL, **mat_x = NULL, **mat_x2, *mat_x2_j = NULL, vec1,
vec2;
t_trxstatus *status;
char buf[256], buf2[256];
int ncons = 0;
FILE *fp;
real rlstot = 0, **rls, **rlsm = NULL, *time, *time2, *rlsnorm = NULL,
**rmsd_mat = NULL, **bond_mat = NULL, *axis, *axis2, *del_xaxis,
*del_yaxis, rmsd_max, rmsd_min, rmsd_avg, bond_max, bond_min, ang;
real **rmsdav_mat = NULL, av_tot, weight, weight_tot;
real **delta = NULL, delta_max, delta_scalex = 0, delta_scaley = 0,
*delta_tot;
int delta_xsize = 0, del_lev = 100, mx, my, abs_my;
gmx_bool bA1, bA2, bPrev, bTop, *bInMat = NULL;
int ifit, *irms, ibond = 0, *ind_bond1 = NULL, *ind_bond2 = NULL, n_ind_m =
0;
atom_id *ind_fit, **ind_rms, *ind_m = NULL, *rev_ind_m = NULL, *ind_rms_m =
NULL;
char *gn_fit, **gn_rms;
t_rgb rlo, rhi;
output_env_t oenv;
gmx_rmpbc_t gpbc = NULL;
t_filenm fnm[] =
{
{ efTPS, NULL, NULL, ffREAD },
{ efTRX, "-f", NULL, ffREAD },
{ efTRX, "-f2", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "rmsd", ffWRITE },
{ efXVG, "-mir", "rmsdmir", ffOPTWR },
{ efXVG, "-a", "avgrp", ffOPTWR },
{ efXVG, "-dist", "rmsd-dist", ffOPTWR },
{ efXPM, "-m", "rmsd", ffOPTWR },
{ efDAT, "-bin", "rmsd", ffOPTWR },
{ efXPM, "-bm", "bond", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_TIME_UNIT | PCA_CAN_VIEW
| PCA_BE_NICE, NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL,
&oenv))
{
return 0;
}
/* parse enumerated options: */
ewhat = nenum(what);
if (ewhat == ewRho || ewhat == ewRhoSc)
{
please_cite(stdout, "Maiorov95");
}
efit = nenum(fit);
bFit = efit == efFit;
bReset = efit == efReset;
if (bFit)
{
bReset = TRUE; /* for fit, reset *must* be set */
}
else
{
bFitAll = FALSE;
}
/* mark active cmdline options */
bMirror = opt2bSet("-mir", NFILE, fnm); /* calc RMSD vs mirror of ref. */
bFile2 = opt2bSet("-f2", NFILE, fnm);
bMat = opt2bSet("-m", NFILE, fnm);
bBond = opt2bSet("-bm", NFILE, fnm);
bDelta = (delta_maxy > 0); /* calculate rmsd vs delta t matrix from *
* your RMSD matrix (hidden option */
bNorm = opt2bSet("-a", NFILE, fnm);
bFreq2 = opt2parg_bSet("-skip2", asize(pa), pa);
if (freq <= 0)
{
fprintf(stderr, "The number of frames to skip is <= 0. "
"Writing out all frames.\n\n");
freq = 1;
}
if (!bFreq2)
{
freq2 = freq;
}
else if (bFile2 && freq2 <= 0)
{
fprintf(stderr,
"The number of frames to skip in second trajectory is <= 0.\n"
" Writing out all frames.\n\n");
freq2 = 1;
}
bPrev = (prev > 0);
if (bPrev)
{
prev = abs(prev);
if (freq != 1)
{
fprintf(stderr, "WARNING: option -skip also applies to -prev\n");
}
}
if (bFile2 && !bMat && !bBond)
{
fprintf(
stderr,
"WARNING: second trajectory (-f2) useless when not calculating matrix (-m/-bm),\n"
" will not read from %s\n", opt2fn("-f2", NFILE,
fnm));
bFile2 = FALSE;
}
if (bDelta)
{
bMat = TRUE;
if (bFile2)
{
fprintf(stderr,
"WARNING: second trajectory (-f2) useless when making delta matrix,\n"
" will not read from %s\n", opt2fn("-f2",
NFILE, fnm));
bFile2 = FALSE;
}
}
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm), buf, &top, &ePBC, &xp,
NULL, box, TRUE);
snew(w_rls, top.atoms.nr);
snew(w_rms, top.atoms.nr);
if (!bTop && bBond)
{
fprintf(stderr,
"WARNING: Need a run input file for bond angle matrix,\n"
" will not calculate bond angle matrix.\n");
bBond = FALSE;
}
if (bReset)
{
fprintf(stderr, "Select group for %s fit\n", bFit ? "least squares"
: "translational");
get_index(&(top.atoms), ftp2fn_null(efNDX, NFILE, fnm), 1, &ifit,
&ind_fit, &gn_fit);
}
else
{
ifit = 0;
}
if (bReset)
{
if (bFit && ifit < 3)
{
gmx_fatal(FARGS, "Need >= 3 points to fit!\n" );
}
bMass = FALSE;
for (i = 0; i < ifit; i++)
{
if (bMassWeighted)
{
w_rls[ind_fit[i]] = top.atoms.atom[ind_fit[i]].m;
}
else
{
w_rls[ind_fit[i]] = 1;
}
bMass = bMass || (top.atoms.atom[ind_fit[i]].m != 0);
}
if (!bMass)
{
fprintf(stderr, "All masses in the fit group are 0, using masses of 1\n");
for (i = 0; i < ifit; i++)
{
w_rls[ind_fit[i]] = 1;
}
}
}
if (bMat || bBond)
{
nrms = 1;
}
snew(gn_rms, nrms);
snew(ind_rms, nrms);
snew(irms, nrms);
fprintf(stderr, "Select group%s for %s calculation\n",
(nrms > 1) ? "s" : "", whatname[ewhat]);
get_index(&(top.atoms), ftp2fn_null(efNDX, NFILE, fnm),
nrms, irms, ind_rms, gn_rms);
if (bNorm)
{
snew(rlsnorm, irms[0]);
}
snew(rls, nrms);
for (j = 0; j < nrms; j++)
{
snew(rls[j], maxframe);
}
if (bMirror)
{
snew(rlsm, nrms);
for (j = 0; j < nrms; j++)
{
snew(rlsm[j], maxframe);
}
}
snew(time, maxframe);
for (j = 0; j < nrms; j++)
{
bMass = FALSE;
for (i = 0; i < irms[j]; i++)
{
if (bMassWeighted)
{
w_rms[ind_rms[j][i]] = top.atoms.atom[ind_rms[j][i]].m;
}
else
{
w_rms[ind_rms[j][i]] = 1.0;
}
bMass = bMass || (top.atoms.atom[ind_rms[j][i]].m != 0);
}
if (!bMass)
{
fprintf(stderr, "All masses in group %d are 0, using masses of 1\n", j);
for (i = 0; i < irms[j]; i++)
{
w_rms[ind_rms[j][i]] = 1;
}
}
}
/* Prepare reference frame */
if (bPBC)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr);
gmx_rmpbc(gpbc, top.atoms.nr, box, xp);
}
if (bReset)
{
reset_x(ifit, ind_fit, top.atoms.nr, NULL, xp, w_rls);
}
if (bMirror)
{
/* generate reference structure mirror image: */
snew(xm, top.atoms.nr);
for (i = 0; i < top.atoms.nr; i++)
{
copy_rvec(xp[i], xm[i]);
xm[i][XX] = -xm[i][XX];
}
}
if (ewhat == ewRhoSc)
{
norm_princ(&top.atoms, ifit, ind_fit, top.atoms.nr, xp);
}
/* read first frame */
natoms_trx = read_first_x(oenv, &status, opt2fn("-f", NFILE, fnm), &t, &x, box);
if (natoms_trx != top.atoms.nr)
{
fprintf(stderr,
"\nWARNING: topology has %d atoms, whereas trajectory has %d\n",
top.atoms.nr, natoms_trx);
}
natoms = min(top.atoms.nr, natoms_trx);
if (bMat || bBond || bPrev)
{
snew(mat_x, NFRAME);
if (bPrev)
{
/* With -prev we use all atoms for simplicity */
n_ind_m = natoms;
}
else
{
/* Check which atoms we need (fit/rms) */
snew(bInMat, natoms);
for (i = 0; i < ifit; i++)
{
bInMat[ind_fit[i]] = TRUE;
}
n_ind_m = ifit;
for (i = 0; i < irms[0]; i++)
{
if (!bInMat[ind_rms[0][i]])
{
bInMat[ind_rms[0][i]] = TRUE;
n_ind_m++;
}
}
}
/* Make an index of needed atoms */
snew(ind_m, n_ind_m);
snew(rev_ind_m, natoms);
j = 0;
for (i = 0; i < natoms; i++)
{
if (bPrev || bInMat[i])
{
ind_m[j] = i;
rev_ind_m[i] = j;
j++;
}
}
snew(w_rls_m, n_ind_m);
snew(ind_rms_m, irms[0]);
snew(w_rms_m, n_ind_m);
for (i = 0; i < ifit; i++)
{
w_rls_m[rev_ind_m[ind_fit[i]]] = w_rls[ind_fit[i]];
}
for (i = 0; i < irms[0]; i++)
{
ind_rms_m[i] = rev_ind_m[ind_rms[0][i]];
w_rms_m[ind_rms_m[i]] = w_rms[ind_rms[0][i]];
}
sfree(bInMat);
}
if (bBond)
{
ncons = 0;
for (k = 0; k < F_NRE; k++)
{
if (IS_CHEMBOND(k))
{
iatom = top.idef.il[k].iatoms;
ncons += top.idef.il[k].nr/3;
}
}
fprintf(stderr, "Found %d bonds in topology\n", ncons);
snew(ind_bond1, ncons);
snew(ind_bond2, ncons);
ibond = 0;
for (k = 0; k < F_NRE; k++)
{
if (IS_CHEMBOND(k))
{
iatom = top.idef.il[k].iatoms;
ncons = top.idef.il[k].nr/3;
for (i = 0; i < ncons; i++)
{
bA1 = FALSE;
bA2 = FALSE;
for (j = 0; j < irms[0]; j++)
{
if (iatom[3*i+1] == ind_rms[0][j])
{
bA1 = TRUE;
}
if (iatom[3*i+2] == ind_rms[0][j])
{
bA2 = TRUE;
}
}
if (bA1 && bA2)
{
ind_bond1[ibond] = rev_ind_m[iatom[3*i+1]];
ind_bond2[ibond] = rev_ind_m[iatom[3*i+2]];
ibond++;
}
}
}
}
fprintf(stderr, "Using %d bonds for bond angle matrix\n", ibond);
if (ibond == 0)
{
gmx_fatal(FARGS, "0 bonds found");
}
}
/* start looping over frames: */
tel_mat = 0;
teller = 0;
do
{
if (bPBC)
{
gmx_rmpbc(gpbc, natoms, box, x);
}
if (bReset)
{
reset_x(ifit, ind_fit, natoms, NULL, x, w_rls);
}
if (ewhat == ewRhoSc)
{
norm_princ(&top.atoms, ifit, ind_fit, natoms, x);
}
if (bFit)
{
/*do the least squares fit to original structure*/
do_fit(natoms, w_rls, xp, x);
}
if (teller % freq == 0)
{
/* keep frame for matrix calculation */
if (bMat || bBond || bPrev)
{
if (tel_mat >= NFRAME)
{
srenew(mat_x, tel_mat+1);
}
snew(mat_x[tel_mat], n_ind_m);
for (i = 0; i < n_ind_m; i++)
{
copy_rvec(x[ind_m[i]], mat_x[tel_mat][i]);
}
}
tel_mat++;
}
/*calculate energy of root_least_squares*/
if (bPrev)
{
j = tel_mat-prev-1;
if (j < 0)
{
j = 0;
}
for (i = 0; i < n_ind_m; i++)
{
copy_rvec(mat_x[j][i], xp[ind_m[i]]);
}
if (bReset)
{
reset_x(ifit, ind_fit, natoms, NULL, xp, w_rls);
}
if (bFit)
{
do_fit(natoms, w_rls, x, xp);
}
}
for (j = 0; (j < nrms); j++)
{
rls[j][teller] =
calc_similar_ind(ewhat != ewRMSD, irms[j], ind_rms[j], w_rms, x, xp);
}
if (bNorm)
{
for (j = 0; (j < irms[0]); j++)
{
rlsnorm[j] +=
calc_similar_ind(ewhat != ewRMSD, 1, &(ind_rms[0][j]), w_rms, x, xp);
}
}
if (bMirror)
{
if (bFit)
{
/*do the least squares fit to mirror of original structure*/
do_fit(natoms, w_rls, xm, x);
}
for (j = 0; j < nrms; j++)
{
rlsm[j][teller] =
calc_similar_ind(ewhat != ewRMSD, irms[j], ind_rms[j], w_rms, x, xm);
}
}
time[teller] = output_env_conv_time(oenv, t);
teller++;
if (teller >= maxframe)
{
maxframe += NFRAME;
srenew(time, maxframe);
for (j = 0; (j < nrms); j++)
{
srenew(rls[j], maxframe);
}
if (bMirror)
{
for (j = 0; (j < nrms); j++)
{
srenew(rlsm[j], maxframe);
}
}
}
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (bFile2)
{
snew(time2, maxframe2);
fprintf(stderr, "\nWill read second trajectory file\n");
snew(mat_x2, NFRAME);
natoms_trx2 =
read_first_x(oenv, &status, opt2fn("-f2", NFILE, fnm), &t, &x, box);
if (natoms_trx2 != natoms_trx)
{
gmx_fatal(FARGS,
"Second trajectory (%d atoms) does not match the first one"
" (%d atoms)", natoms_trx2, natoms_trx);
}
tel_mat2 = 0;
teller2 = 0;
do
{
if (bPBC)
{
gmx_rmpbc(gpbc, natoms, box, x);
}
if (bReset)
{
reset_x(ifit, ind_fit, natoms, NULL, x, w_rls);
}
if (ewhat == ewRhoSc)
{
norm_princ(&top.atoms, ifit, ind_fit, natoms, x);
}
if (bFit)
{
/*do the least squares fit to original structure*/
do_fit(natoms, w_rls, xp, x);
}
if (teller2 % freq2 == 0)
{
/* keep frame for matrix calculation */
if (bMat)
{
if (tel_mat2 >= NFRAME)
{
srenew(mat_x2, tel_mat2+1);
}
snew(mat_x2[tel_mat2], n_ind_m);
for (i = 0; i < n_ind_m; i++)
{
copy_rvec(x[ind_m[i]], mat_x2[tel_mat2][i]);
}
}
tel_mat2++;
}
time2[teller2] = output_env_conv_time(oenv, t);
teller2++;
if (teller2 >= maxframe2)
{
maxframe2 += NFRAME;
srenew(time2, maxframe2);
}
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
}
else
{
mat_x2 = mat_x;
time2 = time;
tel_mat2 = tel_mat;
freq2 = freq;
}
gmx_rmpbc_done(gpbc);
if (bMat || bBond)
{
/* calculate RMS matrix */
fprintf(stderr, "\n");
if (bMat)
{
fprintf(stderr, "Building %s matrix, %dx%d elements\n",
whatname[ewhat], tel_mat, tel_mat2);
snew(rmsd_mat, tel_mat);
}
if (bBond)
{
fprintf(stderr, "Building bond angle matrix, %dx%d elements\n",
tel_mat, tel_mat2);
snew(bond_mat, tel_mat);
}
snew(axis, tel_mat);
snew(axis2, tel_mat2);
rmsd_max = 0;
if (bFile2)
{
rmsd_min = 1e10;
}
else
{
rmsd_min = 0;
}
rmsd_avg = 0;
bond_max = 0;
bond_min = 1e10;
for (j = 0; j < tel_mat2; j++)
{
axis2[j] = time2[freq2*j];
}
if (bDelta)
{
if (bDeltaLog)
{
delta_scalex = 8.0/log(2.0);
delta_xsize = (int)(log(tel_mat/2)*delta_scalex+0.5)+1;
}
else
{
delta_xsize = tel_mat/2;
}
delta_scaley = 1.0/delta_maxy;
snew(delta, delta_xsize);
for (j = 0; j < delta_xsize; j++)
{
snew(delta[j], del_lev+1);
}
if (avl > 0)
{
snew(rmsdav_mat, tel_mat);
for (j = 0; j < tel_mat; j++)
{
snew(rmsdav_mat[j], tel_mat);
}
}
}
if (bFitAll)
{
snew(mat_x2_j, natoms);
}
for (i = 0; i < tel_mat; i++)
{
axis[i] = time[freq*i];
fprintf(stderr, "\r element %5d; time %5.2f ", i, axis[i]);
if (bMat)
{
snew(rmsd_mat[i], tel_mat2);
}
if (bBond)
{
snew(bond_mat[i], tel_mat2);
}
for (j = 0; j < tel_mat2; j++)
{
if (bFitAll)
{
for (k = 0; k < n_ind_m; k++)
{
copy_rvec(mat_x2[j][k], mat_x2_j[k]);
}
do_fit(n_ind_m, w_rls_m, mat_x[i], mat_x2_j);
}
else
{
mat_x2_j = mat_x2[j];
}
if (bMat)
{
if (bFile2 || (i < j))
{
rmsd_mat[i][j] =
calc_similar_ind(ewhat != ewRMSD, irms[0], ind_rms_m,
w_rms_m, mat_x[i], mat_x2_j);
if (rmsd_mat[i][j] > rmsd_max)
{
rmsd_max = rmsd_mat[i][j];
}
if (rmsd_mat[i][j] < rmsd_min)
{
rmsd_min = rmsd_mat[i][j];
}
rmsd_avg += rmsd_mat[i][j];
}
else
{
rmsd_mat[i][j] = rmsd_mat[j][i];
}
}
if (bBond)
{
if (bFile2 || (i <= j))
{
ang = 0.0;
for (m = 0; m < ibond; m++)
{
rvec_sub(mat_x[i][ind_bond1[m]], mat_x[i][ind_bond2[m]], vec1);
rvec_sub(mat_x2_j[ind_bond1[m]], mat_x2_j[ind_bond2[m]], vec2);
ang += acos(cos_angle(vec1, vec2));
}
bond_mat[i][j] = ang*180.0/(M_PI*ibond);
if (bond_mat[i][j] > bond_max)
{
bond_max = bond_mat[i][j];
}
if (bond_mat[i][j] < bond_min)
{
bond_min = bond_mat[i][j];
}
}
else
{
bond_mat[i][j] = bond_mat[j][i];
}
}
}
}
if (bFile2)
{
rmsd_avg /= tel_mat*tel_mat2;
}
else
{
rmsd_avg /= tel_mat*(tel_mat - 1)/2;
}
if (bMat && (avl > 0))
{
rmsd_max = 0.0;
rmsd_min = 0.0;
rmsd_avg = 0.0;
for (j = 0; j < tel_mat-1; j++)
{
for (i = j+1; i < tel_mat; i++)
{
av_tot = 0;
weight_tot = 0;
for (my = -avl; my <= avl; my++)
{
if ((j+my >= 0) && (j+my < tel_mat))
{
abs_my = abs(my);
for (mx = -avl; mx <= avl; mx++)
{
if ((i+mx >= 0) && (i+mx < tel_mat))
{
weight = (real)(avl+1-max(abs(mx), abs_my));
av_tot += weight*rmsd_mat[i+mx][j+my];
weight_tot += weight;
}
}
}
}
rmsdav_mat[i][j] = av_tot/weight_tot;
rmsdav_mat[j][i] = rmsdav_mat[i][j];
if (rmsdav_mat[i][j] > rmsd_max)
{
rmsd_max = rmsdav_mat[i][j];
}
}
}
rmsd_mat = rmsdav_mat;
}
if (bMat)
{
fprintf(stderr, "\n%s: Min %f, Max %f, Avg %f\n",
whatname[ewhat], rmsd_min, rmsd_max, rmsd_avg);
rlo.r = 1; rlo.g = 1; rlo.b = 1;
rhi.r = 0; rhi.g = 0; rhi.b = 0;
if (rmsd_user_max != -1)
{
rmsd_max = rmsd_user_max;
}
if (rmsd_user_min != -1)
{
rmsd_min = rmsd_user_min;
}
if ((rmsd_user_max != -1) || (rmsd_user_min != -1))
{
fprintf(stderr, "Min and Max value set to resp. %f and %f\n",
rmsd_min, rmsd_max);
}
sprintf(buf, "%s %s matrix", gn_rms[0], whatname[ewhat]);
write_xpm(opt2FILE("-m", NFILE, fnm, "w"), 0, buf, whatlabel[ewhat],
output_env_get_time_label(oenv), output_env_get_time_label(oenv), tel_mat, tel_mat2,
axis, axis2, rmsd_mat, rmsd_min, rmsd_max, rlo, rhi, &nlevels);
/* Print the distribution of RMSD values */
if (opt2bSet("-dist", NFILE, fnm))
{
low_rmsd_dist(opt2fn("-dist", NFILE, fnm), rmsd_max, tel_mat, rmsd_mat, oenv);
}
if (bDelta)
{
snew(delta_tot, delta_xsize);
for (j = 0; j < tel_mat-1; j++)
{
for (i = j+1; i < tel_mat; i++)
{
mx = i-j;
if (mx < tel_mat/2)
{
if (bDeltaLog)
{
mx = (int)(log(mx)*delta_scalex+0.5);
}
my = (int)(rmsd_mat[i][j]*delta_scaley*del_lev+0.5);
delta_tot[mx] += 1.0;
if ((rmsd_mat[i][j] >= 0) && (rmsd_mat[i][j] <= delta_maxy))
{
delta[mx][my] += 1.0;
}
}
}
}
delta_max = 0;
for (i = 0; i < delta_xsize; i++)
{
if (delta_tot[i] > 0.0)
{
delta_tot[i] = 1.0/delta_tot[i];
for (j = 0; j <= del_lev; j++)
{
delta[i][j] *= delta_tot[i];
if (delta[i][j] > delta_max)
{
delta_max = delta[i][j];
}
}
}
}
fprintf(stderr, "Maximum in delta matrix: %f\n", delta_max);
snew(del_xaxis, delta_xsize);
snew(del_yaxis, del_lev+1);
for (i = 0; i < delta_xsize; i++)
{
del_xaxis[i] = axis[i]-axis[0];
}
for (i = 0; i < del_lev+1; i++)
{
del_yaxis[i] = delta_maxy*i/del_lev;
}
sprintf(buf, "%s %s vs. delta t", gn_rms[0], whatname[ewhat]);
fp = gmx_ffopen("delta.xpm", "w");
write_xpm(fp, 0, buf, "density", output_env_get_time_label(oenv), whatlabel[ewhat],
delta_xsize, del_lev+1, del_xaxis, del_yaxis,
delta, 0.0, delta_max, rlo, rhi, &nlevels);
gmx_ffclose(fp);
}
if (opt2bSet("-bin", NFILE, fnm))
{
/* NB: File must be binary if we use fwrite */
fp = ftp2FILE(efDAT, NFILE, fnm, "wb");
for (i = 0; i < tel_mat; i++)
{
if (fwrite(rmsd_mat[i], sizeof(**rmsd_mat), tel_mat2, fp) != tel_mat2)
{
gmx_fatal(FARGS, "Error writing to output file");
}
}
gmx_ffclose(fp);
}
}
if (bBond)
{
fprintf(stderr, "\nMin. angle: %f, Max. angle: %f\n", bond_min, bond_max);
if (bond_user_max != -1)
{
bond_max = bond_user_max;
}
if (bond_user_min != -1)
{
bond_min = bond_user_min;
}
if ((bond_user_max != -1) || (bond_user_min != -1))
{
fprintf(stderr, "Bond angle Min and Max set to:\n"
"Min. angle: %f, Max. angle: %f\n", bond_min, bond_max);
}
rlo.r = 1; rlo.g = 1; rlo.b = 1;
rhi.r = 0; rhi.g = 0; rhi.b = 0;
sprintf(buf, "%s av. bond angle deviation", gn_rms[0]);
write_xpm(opt2FILE("-bm", NFILE, fnm, "w"), 0, buf, "degrees",
output_env_get_time_label(oenv), output_env_get_time_label(oenv), tel_mat, tel_mat2,
axis, axis2, bond_mat, bond_min, bond_max, rlo, rhi, &nlevels);
}
}
bAv = opt2bSet("-a", NFILE, fnm);
/* Write the RMSD's to file */
if (!bPrev)
{
sprintf(buf, "%s", whatxvgname[ewhat]);
}
else
{
sprintf(buf, "%s with frame %g %s ago", whatxvgname[ewhat],
time[prev*freq]-time[0], output_env_get_time_label(oenv));
}
fp = xvgropen(opt2fn("-o", NFILE, fnm), buf, output_env_get_xvgr_tlabel(oenv),
whatxvglabel[ewhat], oenv);
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"%s%s after %s%s%s\"\n",
(nrms == 1) ? "" : "of ", gn_rms[0], fitgraphlabel[efit],
bFit ? " to " : "", bFit ? gn_fit : "");
}
if (nrms != 1)
{
xvgr_legend(fp, nrms, (const char**)gn_rms, oenv);
}
for (i = 0; (i < teller); i++)
{
if (bSplit && i > 0 &&
abs(time[bPrev ? freq*i : i]/output_env_get_time_factor(oenv)) < 1e-5)
{
fprintf(fp, "&\n");
}
fprintf(fp, "%12.7f", time[bPrev ? freq*i : i]);
for (j = 0; (j < nrms); j++)
{
fprintf(fp, " %12.7f", rls[j][i]);
if (bAv)
{
rlstot += rls[j][i];
}
}
fprintf(fp, "\n");
}
gmx_ffclose(fp);
if (bMirror)
{
/* Write the mirror RMSD's to file */
sprintf(buf, "%s with Mirror", whatxvgname[ewhat]);
sprintf(buf2, "Mirror %s", whatxvglabel[ewhat]);
fp = xvgropen(opt2fn("-mir", NFILE, fnm), buf, output_env_get_xvgr_tlabel(oenv),
buf2, oenv);
if (nrms == 1)
{
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"of %s after lsq fit to mirror of %s\"\n",
gn_rms[0], gn_fit);
}
}
else
{
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"after lsq fit to mirror %s\"\n", gn_fit);
}
xvgr_legend(fp, nrms, (const char**)gn_rms, oenv);
}
for (i = 0; (i < teller); i++)
{
if (bSplit && i > 0 && abs(time[i]) < 1e-5)
{
fprintf(fp, "&\n");
}
fprintf(fp, "%12.7f", time[i]);
for (j = 0; (j < nrms); j++)
{
fprintf(fp, " %12.7f", rlsm[j][i]);
}
fprintf(fp, "\n");
}
gmx_ffclose(fp);
}
if (bAv)
{
sprintf(buf, "Average %s", whatxvgname[ewhat]);
sprintf(buf2, "Average %s", whatxvglabel[ewhat]);
fp = xvgropen(opt2fn("-a", NFILE, fnm), buf, "Residue", buf2, oenv);
for (j = 0; (j < nrms); j++)
{
fprintf(fp, "%10d %10g\n", j, rlstot/teller);
}
gmx_ffclose(fp);
}
if (bNorm)
{
fp = xvgropen("aver.xvg", gn_rms[0], "Residue", whatxvglabel[ewhat], oenv);
for (j = 0; (j < irms[0]); j++)
{
fprintf(fp, "%10d %10g\n", j, rlsnorm[j]/teller);
}
gmx_ffclose(fp);
}
do_view(oenv, opt2fn_null("-a", NFILE, fnm), "-graphtype bar");
do_view(oenv, opt2fn("-o", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-mir", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-m", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-bm", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-dist", NFILE, fnm), NULL);
return 0;
}
static void do_fit(FILE *out,int n,bool bYdy,int ny,real *x0,real **val,
int npargs,t_pargs *ppa)
{
real *c1=NULL,*sig=NULL,*fitparm;
real dt=0,tendfit,tbeginfit;
int i,efitfn,nparm;
efitfn = get_acffitfn();
nparm = nfp_ffn[efitfn];
fprintf(out,"Will fit to the following function:\n");
fprintf(out,"%s\n",longs_ffn[efitfn]);
c1 = val[n];
if (bYdy) {
c1 = val[n];
sig = val[n+1];
fprintf(out,"Using two columns as y and sigma values\n");
} else {
snew(sig,ny);
}
if (opt2parg_bSet("-beginfit",npargs,ppa)) {
tbeginfit = opt2parg_real("-beginfit",npargs,ppa);
} else {
tbeginfit = x0 ? x0[0] : 0;
}
if (opt2parg_bSet("-endfit",npargs,ppa)) {
tendfit = opt2parg_real("-endfit",npargs,ppa);
} else {
tendfit = x0 ? x0[ny-1] : (ny-1)*dt;
}
snew(fitparm,nparm);
switch(efitfn) {
case effnEXP1:
fitparm[0] = 0.5;
break;
case effnEXP2:
fitparm[0] = 0.5;
fitparm[1] = c1[0];
break;
case effnEXP3:
fitparm[0] = 1.0;
fitparm[1] = 0.5*c1[0];
fitparm[2] = 10.0;
break;
case effnEXP5:
fitparm[0] = fitparm[2] = 0.5*c1[0];
fitparm[1] = 10;
fitparm[3] = 40;
fitparm[4] = 0;
break;
case effnEXP7:
fitparm[0] = fitparm[2] = fitparm[4] = 0.33*c1[0];
fitparm[1] = 1;
fitparm[3] = 10;
fitparm[5] = 100;
fitparm[6] = 0;
break;
case effnEXP9:
fitparm[0] = fitparm[2] = fitparm[4] = fitparm[6] = 0.25*c1[0];
fitparm[1] = 0.1;
fitparm[3] = 1;
fitparm[5] = 10;
fitparm[7] = 100;
fitparm[8] = 0;
break;
default:
fprintf(out,"Warning: don't know how to initialize the parameters\n");
for(i=0; (i<nparm); i++)
fitparm[i] = 1;
}
fprintf(out,"Starting parameters:\n");
for(i=0; (i<nparm); i++)
fprintf(out,"a%-2d = %12.5e\n",i+1,fitparm[i]);
if (do_lmfit(ny,c1,sig,dt,x0,tbeginfit,tendfit,
bDebugMode(),efitfn,fitparm,0)) {
for(i=0; (i<nparm); i++)
fprintf(out,"a%-2d = %12.5e\n",i+1,fitparm[i]);
}
else {
fprintf(out,"No solution was found\n");
}
}
int gmx_mdrun(int argc, char *argv[])
{
const char *desc[] = {
"[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.",
"Normal mode analysis is another option. In this case [TT]mdrun[tt]",
"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 [gmx-nmeig].[PAR]",
"The [TT]mdrun[tt] program reads the run input file ([TT]-s[tt])",
"and distributes the topology over ranks if needed.",
"[TT]mdrun[tt] produces at least four output files.",
"A single log file ([TT]-g[tt]) is written, unless the option",
"[TT]-seppot[tt] is used, in which case each rank writes a log file.",
"The trajectory file ([TT]-o[tt]), contains coordinates, velocities and",
"optionally forces.",
"The structure file ([TT]-c[tt]) contains the coordinates and",
"velocities of the last step.",
"The energy file ([TT]-e[tt]) contains energies, the temperature,",
"pressure, etc, a lot of these things are also printed in the log file.",
"Optionally coordinates can be written to a compressed trajectory file",
"([TT]-x[tt]).[PAR]",
"The option [TT]-dhdl[tt] is only used when free energy calculation is",
"turned on.[PAR]",
"A simulation can be run in parallel using two different parallelization",
"schemes: MPI parallelization and/or OpenMP thread parallelization.",
"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 [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 ranks can use OpenMP parallelization.",
"In all cases [TT]mdrun[tt] will by default try to use all the available",
"hardware resources. With a normal MPI library only the options",
"[TT]-ntomp[tt] (with the Verlet cut-off scheme) and [TT]-ntomp_pme[tt],",
"for PME-only ranks, can be used to control the number of threads.",
"With thread-MPI there are additional options [TT]-nt[tt], which sets",
"the total number of threads, and [TT]-ntmpi[tt], which sets the number",
"of thread-MPI threads.",
"The number of OpenMP threads used by [TT]mdrun[tt] can also be set with",
"the standard environment variable, [TT]OMP_NUM_THREADS[tt].",
"The [TT]GMX_PME_NUM_THREADS[tt] environment variable can be used to specify",
"the number of threads used by the PME-only ranks.[PAR]",
"Note that combined MPI+OpenMP parallelization is in many cases",
"slower than either on its own. However, at high parallelization, using the",
"combination is often beneficial as it reduces the number of domains and/or",
"the number of MPI ranks. (Less and larger domains can improve scaling,",
"with separate PME ranks, using fewer MPI ranks reduces communication costs.)",
"OpenMP-only parallelization is typically faster than MPI-only parallelization",
"on a single CPU(-die). Since we currently don't have proper hardware",
"topology detection, [TT]mdrun[tt] compiled with thread-MPI will only",
"automatically use OpenMP-only parallelization when you use up to 4",
"threads, up to 12 threads with Intel Nehalem/Westmere, or up to 16",
"threads with Intel Sandy Bridge or newer CPUs. Otherwise MPI-only",
"parallelization is used (except with GPUs, see below).",
"[PAR]",
"To quickly test the performance of the new Verlet cut-off scheme",
"with old [TT].tpr[tt] files, either on CPUs or CPUs+GPUs, you can use",
"the [TT]-testverlet[tt] option. This should not be used for production,",
"since it can slightly modify potentials and it will remove charge groups",
"making analysis difficult, as the [TT].tpr[tt] file will still contain",
"charge groups. For production simulations it is highly recommended",
"to specify [TT]cutoff-scheme = Verlet[tt] in the [TT].mdp[tt] file.",
"[PAR]",
"With GPUs (only supported with the Verlet cut-off scheme), the number",
"of GPUs should match the number of particle-particle ranks, i.e.",
"excluding PME-only ranks. With thread-MPI, unless set on the command line, the number",
"of MPI threads will automatically be set to the number of GPUs detected.",
"To use a subset of the available GPUs, or to manually provide a mapping of",
"GPUs to PP ranks, you can use the [TT]-gpu_id[tt] option. The argument of [TT]-gpu_id[tt] is",
"a string of digits (without delimiter) representing device id-s of the GPUs to be used.",
"For example, \"[TT]02[tt]\" specifies using GPUs 0 and 2 in the first and second PP ranks per compute node",
"respectively. To select different sets of GPU-s",
"on different nodes of a compute cluster, use the [TT]GMX_GPU_ID[tt] environment",
"variable instead. The format for [TT]GMX_GPU_ID[tt] is identical to ",
"[TT]-gpu_id[tt], with the difference that an environment variable can have",
"different values on different compute nodes. Multiple MPI ranks on each node",
"can share GPUs. This is accomplished by specifying the id(s) of the GPU(s)",
"multiple times, e.g. \"[TT]0011[tt]\" for four ranks sharing two GPUs in this node.",
"This works within a single simulation, or a multi-simulation, with any form of MPI.",
"[PAR]",
"With the Verlet cut-off scheme and verlet-buffer-tolerance set,",
"the pair-list update interval nstlist can be chosen freely with",
"the option [TT]-nstlist[tt]. [TT]mdrun[tt] will then adjust",
"the pair-list cut-off to maintain accuracy, and not adjust nstlist.",
"Otherwise, by default, [TT]mdrun[tt] will try to increase the",
"value of nstlist set in the [TT].mdp[tt] file to improve the",
"performance. For CPU-only runs, nstlist might increase to 20, for",
"GPU runs up to 40. For medium to high parallelization or with",
"fast GPUs, a (user-supplied) larger nstlist value can give much",
"better performance.",
"[PAR]",
"When using PME with separate PME ranks or with a GPU, the two major",
"compute tasks, the non-bonded force calculation and the PME calculation",
"run on different compute resources. If this load is not balanced,",
"some of the resources will be idle part of time. With the Verlet",
"cut-off scheme this load is automatically balanced when the PME load",
"is too high (but not when it is too low). This is done by scaling",
"the Coulomb cut-off and PME grid spacing by the same amount. In the first",
"few hundred steps different settings are tried and the fastest is chosen",
"for the rest of the simulation. This does not affect the accuracy of",
"the results, but it does affect the decomposition of the Coulomb energy",
"into particle and mesh contributions. The auto-tuning can be turned off",
"with the option [TT]-notunepme[tt].",
"[PAR]",
"[TT]mdrun[tt] pins (sets affinity of) threads to specific cores,",
"when all (logical) cores on a compute node are used by [TT]mdrun[tt],",
"even when no multi-threading is used,",
"as this usually results in significantly better performance.",
"If the queuing systems or the OpenMP library pinned threads, we honor",
"this and don't pin again, even though the layout may be sub-optimal.",
"If you want to have [TT]mdrun[tt] override an already set thread affinity",
"or pin threads when using less cores, use [TT]-pin on[tt].",
"With SMT (simultaneous multithreading), e.g. Intel Hyper-Threading,",
"there are multiple logical cores per physical core.",
"The option [TT]-pinstride[tt] sets the stride in logical cores for",
"pinning consecutive threads. Without SMT, 1 is usually the best choice.",
"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 [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 [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.",
"[PAR]",
"When [TT]mdrun[tt] is started with more than 1 rank,",
"parallelization with domain decomposition is used.",
"[PAR]",
"With domain decomposition, the spatial decomposition can be set",
"with option [TT]-dd[tt]. By default [TT]mdrun[tt] selects a good decomposition.",
"The user only needs to change this when the system is very inhomogeneous.",
"Dynamic load balancing is set with the option [TT]-dlb[tt],",
"which can give a significant performance improvement,",
"especially for inhomogeneous systems. The only disadvantage of",
"dynamic load balancing is that runs are no longer binary reproducible,",
"but in most cases this is not important.",
"By default the dynamic load balancing is automatically turned on",
"when the measured performance loss due to load imbalance is 5% or more.",
"At low parallelization these are the only important options",
"for domain decomposition.",
"At high parallelization the options in the next two sections",
"could be important for increasing the performace.",
"[PAR]",
"When PME is used with domain decomposition, separate ranks can",
"be assigned to do only the PME mesh calculation;",
"this is computationally more efficient starting at about 12 ranks,",
"or even fewer when OpenMP parallelization is used.",
"The number of PME ranks is set with option [TT]-npme[tt],",
"but this cannot be more than half of the ranks.",
"By default [TT]mdrun[tt] makes a guess for the number of PME",
"ranks when the number of ranks is larger than 16. With GPUs,",
"using separate PME ranks is not selected automatically,",
"since the optimal setup depends very much on the details",
"of the hardware. In all cases, you might gain performance",
"by optimizing [TT]-npme[tt]. Performance statistics on this issue",
"are written at the end of the log file.",
"For good load balancing at high parallelization, the PME grid x and y",
"dimensions should be divisible by the number of PME ranks",
"(the simulation will run correctly also when this is not the case).",
"[PAR]",
"This section lists all options that affect the domain decomposition.",
"[PAR]",
"Option [TT]-rdd[tt] can be used to set the required maximum distance",
"for inter charge-group bonded interactions.",
"Communication for two-body bonded interactions below the non-bonded",
"cut-off distance always comes for free with the non-bonded communication.",
"Atoms beyond the non-bonded cut-off are only communicated when they have",
"missing bonded interactions; this means that the extra cost is minor",
"and nearly indepedent of the value of [TT]-rdd[tt].",
"With dynamic load balancing option [TT]-rdd[tt] also sets",
"the lower limit for the domain decomposition cell sizes.",
"By default [TT]-rdd[tt] is determined by [TT]mdrun[tt] based on",
"the initial coordinates. The chosen value will be a balance",
"between interaction range and communication cost.",
"[PAR]",
"When inter charge-group bonded interactions are beyond",
"the bonded cut-off distance, [TT]mdrun[tt] terminates with an error message.",
"For pair interactions and tabulated bonds",
"that do not generate exclusions, this check can be turned off",
"with the option [TT]-noddcheck[tt].",
"[PAR]",
"When constraints are present, option [TT]-rcon[tt] influences",
"the cell size limit as well.",
"Atoms connected by NC constraints, where NC is the LINCS order plus 1,",
"should not be beyond the smallest cell size. A error message is",
"generated when this happens and the user should change the decomposition",
"or decrease the LINCS order and increase the number of LINCS iterations.",
"By default [TT]mdrun[tt] estimates the minimum cell size required for P-LINCS",
"in a conservative fashion. For high parallelization it can be useful",
"to set the distance required for P-LINCS with the option [TT]-rcon[tt].",
"[PAR]",
"The [TT]-dds[tt] option sets the minimum allowed x, y and/or z scaling",
"of the cells with dynamic load balancing. [TT]mdrun[tt] will ensure that",
"the cells can scale down by at least this factor. This option is used",
"for the automated spatial decomposition (when not using [TT]-dd[tt])",
"as well as for determining the number of grid pulses, which in turn",
"sets the minimum allowed cell size. Under certain circumstances",
"the value of [TT]-dds[tt] might need to be adjusted to account for",
"high or low spatial inhomogeneity of the system.",
"[PAR]",
"The option [TT]-gcom[tt] can be used to only do global communication",
"every n steps.",
"This can improve performance for highly parallel simulations",
"where this global communication step becomes the bottleneck.",
"For a global thermostat and/or barostat the temperature",
"and/or pressure will also only be updated every [TT]-gcom[tt] steps.",
"By default it is set to the minimum of nstcalcenergy and nstlist.[PAR]",
"With [TT]-rerun[tt] an input trajectory can be given for which ",
"forces and energies will be (re)calculated. Neighbor searching will be",
"performed for every frame, unless [TT]nstlist[tt] is zero",
"(see the [TT].mdp[tt] file).[PAR]",
"ED (essential dynamics) sampling and/or additional flooding potentials",
"are switched on by using the [TT]-ei[tt] flag followed by an [TT].edi[tt]",
"file. The [TT].edi[tt] file can be produced with the [TT]make_edi[tt] tool",
"or by using options in the essdyn menu of the WHAT IF program.",
"[TT]mdrun[tt] produces a [TT].xvg[tt] output file that",
"contains projections of positions, velocities and forces onto selected",
"eigenvectors.[PAR]",
"When user-defined potential functions have been selected in the",
"[TT].mdp[tt] file the [TT]-table[tt] option is used to pass [TT]mdrun[tt]",
"a formatted table with potential functions. The file is read from",
"either the current directory or from the [TT]GMXLIB[tt] directory.",
"A number of pre-formatted tables are presented in the [TT]GMXLIB[tt] dir,",
"for 6-8, 6-9, 6-10, 6-11, 6-12 Lennard-Jones potentials with",
"normal Coulomb.",
"When pair interactions are present, a separate table for pair interaction",
"functions is read using the [TT]-tablep[tt] option.[PAR]",
"When tabulated bonded functions are present in the topology,",
"interaction functions are read using the [TT]-tableb[tt] option.",
"For each different tabulated interaction type the table file name is",
"modified in a different way: before the file extension an underscore is",
"appended, then a 'b' for bonds, an 'a' for angles or a 'd' for dihedrals",
"and finally the table number of the interaction type.[PAR]",
"The options [TT]-px[tt] and [TT]-pf[tt] are used for writing pull COM",
"coordinates and forces when pulling is selected",
"in the [TT].mdp[tt] file.[PAR]",
"With [TT]-multi[tt] or [TT]-multidir[tt], multiple systems can be ",
"simulated in parallel.",
"As many input files/directories are required as the number of systems. ",
"The [TT]-multidir[tt] option takes a list of directories (one for each ",
"system) and runs in each of them, using the input/output file names, ",
"such as specified by e.g. the [TT]-s[tt] option, relative to these ",
"directories.",
"With [TT]-multi[tt], the system number is appended to the run input ",
"and each output filename, for instance [TT]topol.tpr[tt] becomes",
"[TT]topol0.tpr[tt], [TT]topol1.tpr[tt] etc.",
"The number of ranks per system is the total number of ranks",
"divided by the number of systems.",
"One use of this option is for NMR refinement: when distance",
"or orientation restraints are present these can be ensemble averaged",
"over all the systems.[PAR]",
"With [TT]-replex[tt] replica exchange is attempted every given number",
"of steps. The number of replicas is set with the [TT]-multi[tt] or ",
"[TT]-multidir[tt] option, described above.",
"All run input files should use a different coupling temperature,",
"the order of the files is not important. The random seed is set with",
"[TT]-reseed[tt]. The velocities are scaled and neighbor searching",
"is performed after every exchange.[PAR]",
"Finally some experimental algorithms can be tested when the",
"appropriate options have been given. Currently under",
"investigation are: polarizability.",
"[PAR]",
"The option [TT]-membed[tt] does what used to be g_membed, i.e. embed",
"a protein into a membrane. The data file should contain the options",
"that where passed to g_membed before. The [TT]-mn[tt] and [TT]-mp[tt]",
"both apply to this as well.",
"[PAR]",
"The option [TT]-pforce[tt] is useful when you suspect a simulation",
"crashes due to too large forces. With this option coordinates and",
"forces of atoms with a force larger than a certain value will",
"be printed to stderr.",
"[PAR]",
"Checkpoints containing the complete state of the system are written",
"at regular intervals (option [TT]-cpt[tt]) to the file [TT]-cpo[tt],",
"unless option [TT]-cpt[tt] is set to -1.",
"The previous checkpoint is backed up to [TT]state_prev.cpt[tt] to",
"make sure that a recent state of the system is always available,",
"even when the simulation is terminated while writing a checkpoint.",
"With [TT]-cpnum[tt] all checkpoint files are kept and appended",
"with the step number.",
"A simulation can be continued by reading the full state from file",
"with option [TT]-cpi[tt]. This option is intelligent in the way that",
"if no checkpoint file is found, Gromacs just assumes a normal run and",
"starts from the first step of the [TT].tpr[tt] file. By default the output",
"will be appending to the existing output files. The checkpoint file",
"contains checksums of all output files, such that you will never",
"loose data when some output files are modified, corrupt or removed.",
"There are three scenarios with [TT]-cpi[tt]:[PAR]",
"[TT]*[tt] no files with matching names are present: new output files are written[PAR]",
"[TT]*[tt] all files are present with names and checksums matching those stored",
"in the checkpoint file: files are appended[PAR]",
"[TT]*[tt] otherwise no files are modified and a fatal error is generated[PAR]",
"With [TT]-noappend[tt] new output files are opened and the simulation",
"part number is added to all output file names.",
"Note that in all cases the checkpoint file itself is not renamed",
"and will be overwritten, unless its name does not match",
"the [TT]-cpo[tt] option.",
"[PAR]",
"With checkpointing the output is appended to previously written",
"output files, unless [TT]-noappend[tt] is used or none of the previous",
"output files are present (except for the checkpoint file).",
"The integrity of the files to be appended is verified using checksums",
"which are stored in the checkpoint file. This ensures that output can",
"not be mixed up or corrupted due to file appending. When only some",
"of the previous output files are present, a fatal error is generated",
"and no old output files are modified and no new output files are opened.",
"The result with appending will be the same as from a single run.",
"The contents will be binary identical, unless you use a different number",
"of ranks or dynamic load balancing or the FFT library uses optimizations",
"through timing.",
"[PAR]",
"With option [TT]-maxh[tt] a simulation is terminated and a checkpoint",
"file is written at the first neighbor search step where the run time",
"exceeds [TT]-maxh[tt]*0.99 hours.",
"[PAR]",
"When [TT]mdrun[tt] receives a TERM signal, it will set nsteps to the current",
"step plus one. When [TT]mdrun[tt] receives an INT signal (e.g. when ctrl+C is",
"pressed), it will stop after the next neighbor search step ",
"(with nstlist=0 at the next step).",
"In both cases all the usual output will be written to file.",
"When running with MPI, a signal to one of the [TT]mdrun[tt] ranks",
"is sufficient, this signal should not be sent to mpirun or",
"the [TT]mdrun[tt] process that is the parent of the others.",
"[PAR]",
"Interactive molecular dynamics (IMD) can be activated by using at least one",
"of the three IMD switches: The [TT]-imdterm[tt] switch allows to terminate the",
"simulation from the molecular viewer (e.g. VMD). With [TT]-imdwait[tt],",
"[TT]mdrun[tt] pauses whenever no IMD client is connected. Pulling from the",
"IMD remote can be turned on by [TT]-imdpull[tt].",
"The port [TT]mdrun[tt] listens to can be altered by [TT]-imdport[tt].The",
"file pointed to by [TT]-if[tt] contains atom indices and forces if IMD",
"pulling is used."
"[PAR]",
"When [TT]mdrun[tt] is started with MPI, it does not run niced by default."
};
t_commrec *cr;
t_filenm fnm[] = {
{ efTPX, NULL, NULL, ffREAD },
{ efTRN, "-o", NULL, ffWRITE },
{ efCOMPRESSED, "-x", NULL, ffOPTWR },
{ efCPT, "-cpi", NULL, ffOPTRD },
{ efCPT, "-cpo", NULL, ffOPTWR },
{ efSTO, "-c", "confout", ffWRITE },
{ efEDR, "-e", "ener", ffWRITE },
{ efLOG, "-g", "md", ffWRITE },
{ efXVG, "-dhdl", "dhdl", ffOPTWR },
{ efXVG, "-field", "field", ffOPTWR },
{ efXVG, "-table", "table", ffOPTRD },
{ efXVG, "-tabletf", "tabletf", ffOPTRD },
{ efXVG, "-tablep", "tablep", ffOPTRD },
{ efXVG, "-tableb", "table", ffOPTRD },
{ efTRX, "-rerun", "rerun", ffOPTRD },
{ efXVG, "-tpi", "tpi", ffOPTWR },
{ efXVG, "-tpid", "tpidist", ffOPTWR },
{ efEDI, "-ei", "sam", ffOPTRD },
{ efXVG, "-eo", "edsam", ffOPTWR },
{ efXVG, "-devout", "deviatie", ffOPTWR },
{ efXVG, "-runav", "runaver", ffOPTWR },
{ efXVG, "-px", "pullx", ffOPTWR },
{ efXVG, "-pf", "pullf", ffOPTWR },
{ efXVG, "-ro", "rotation", ffOPTWR },
{ efLOG, "-ra", "rotangles", ffOPTWR },
{ efLOG, "-rs", "rotslabs", ffOPTWR },
{ efLOG, "-rt", "rottorque", ffOPTWR },
{ efMTX, "-mtx", "nm", ffOPTWR },
{ efNDX, "-dn", "dipole", ffOPTWR },
{ efRND, "-multidir", NULL, ffOPTRDMULT},
{ efDAT, "-membed", "membed", ffOPTRD },
{ efTOP, "-mp", "membed", ffOPTRD },
{ efNDX, "-mn", "membed", ffOPTRD },
{ efXVG, "-if", "imdforces", ffOPTWR },
{ efXVG, "-swap", "swapions", ffOPTWR },
{ efMDP, "-at", NULL, ffOPTRD }, /* at.cfg, only for do_md */
{ efMDP, "-addtop", NULL, ffOPTRD }, /* add additional topology */
};
#define NFILE asize(fnm)
/* Command line options ! */
gmx_bool bDDBondCheck = TRUE;
gmx_bool bDDBondComm = TRUE;
gmx_bool bTunePME = TRUE;
gmx_bool bTestVerlet = FALSE;
gmx_bool bVerbose = FALSE;
gmx_bool bCompact = TRUE;
gmx_bool bSepPot = FALSE;
gmx_bool bRerunVSite = FALSE;
gmx_bool bConfout = TRUE;
gmx_bool bReproducible = FALSE;
gmx_bool bIMDwait = FALSE;
gmx_bool bIMDterm = FALSE;
gmx_bool bIMDpull = FALSE;
int npme = -1;
int nstlist = 0;
int nmultisim = 0;
int nstglobalcomm = -1;
int repl_ex_nst = 0;
int repl_ex_seed = -1;
int repl_ex_nex = 0;
int nstepout = 100;
int resetstep = -1;
gmx_int64_t nsteps = -2; /* the value -2 means that the mdp option will be used */
int imdport = 8888; /* can be almost anything, 8888 is easy to remember */
rvec realddxyz = {0, 0, 0};
const char *ddno_opt[ddnoNR+1] =
{ NULL, "interleave", "pp_pme", "cartesian", NULL };
const char *dddlb_opt[] =
{ NULL, "auto", "no", "yes", NULL };
const char *thread_aff_opt[threadaffNR+1] =
{ NULL, "auto", "on", "off", NULL };
const char *nbpu_opt[] =
{ NULL, "auto", "cpu", "gpu", "gpu_cpu", NULL };
real rdd = 0.0, rconstr = 0.0, dlb_scale = 0.8, pforce = -1;
char *ddcsx = NULL, *ddcsy = NULL, *ddcsz = NULL;
real cpt_period = 15.0, max_hours = -1;
gmx_bool bAppendFiles = TRUE;
gmx_bool bKeepAndNumCPT = FALSE;
gmx_bool bResetCountersHalfWay = FALSE;
output_env_t oenv = NULL;
const char *deviceOptions = "";
/* Non transparent initialization of a complex gmx_hw_opt_t struct.
* 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 }
};
t_pargs pa[] = {
{ "-dd", FALSE, etRVEC, {&realddxyz},
"Domain decomposition grid, 0 is optimize" },
{ "-ddorder", FALSE, etENUM, {ddno_opt},
"DD rank order" },
{ "-npme", FALSE, etINT, {&npme},
"Number of separate ranks to be used for PME, -1 is guess" },
{ "-nt", FALSE, etINT, {&hw_opt.nthreads_tot},
"Total number of threads to start (0 is guess)" },
{ "-ntmpi", FALSE, etINT, {&hw_opt.nthreads_tmpi},
"Number of thread-MPI threads to start (0 is guess)" },
{ "-ntomp", FALSE, etINT, {&hw_opt.nthreads_omp},
"Number of OpenMP threads per MPI rank to start (0 is guess)" },
{ "-ntomp_pme", FALSE, etINT, {&hw_opt.nthreads_omp_pme},
"Number of OpenMP threads per MPI rank to start (0 is -ntomp)" },
{ "-pin", FALSE, etENUM, {thread_aff_opt},
"Set thread affinities" },
{ "-pinoffset", FALSE, etINT, {&hw_opt.core_pinning_offset},
"The starting logical core number for pinning to cores; used to avoid pinning threads from different mdrun instances to the same core" },
{ "-pinstride", FALSE, etINT, {&hw_opt.core_pinning_stride},
"Pinning distance in logical cores for threads, use 0 to minimize the number of threads per physical core" },
{ "-gpu_id", FALSE, etSTR, {&hw_opt.gpu_opt.gpu_id},
"List of GPU device id-s to use, specifies the per-node PP rank to GPU mapping" },
{ "-ddcheck", FALSE, etBOOL, {&bDDBondCheck},
"Check for all bonded interactions with DD" },
{ "-ddbondcomm", FALSE, etBOOL, {&bDDBondComm},
"HIDDENUse special bonded atom communication when [TT]-rdd[tt] > cut-off" },
{ "-rdd", FALSE, etREAL, {&rdd},
"The maximum distance for bonded interactions with DD (nm), 0 is determine from initial coordinates" },
{ "-rcon", FALSE, etREAL, {&rconstr},
"Maximum distance for P-LINCS (nm), 0 is estimate" },
{ "-dlb", FALSE, etENUM, {dddlb_opt},
"Dynamic load balancing (with DD)" },
{ "-dds", FALSE, etREAL, {&dlb_scale},
"Fraction in (0,1) by whose reciprocal the initial DD cell size will be increased in order to "
"provide a margin in which dynamic load balancing can act while preserving the minimum cell size." },
{ "-ddcsx", FALSE, etSTR, {&ddcsx},
"HIDDENA string containing a vector of the relative sizes in the x "
"direction of the corresponding DD cells. Only effective with static "
"load balancing." },
{ "-ddcsy", FALSE, etSTR, {&ddcsy},
"HIDDENA string containing a vector of the relative sizes in the y "
"direction of the corresponding DD cells. Only effective with static "
"load balancing." },
{ "-ddcsz", FALSE, etSTR, {&ddcsz},
"HIDDENA string containing a vector of the relative sizes in the z "
"direction of the corresponding DD cells. Only effective with static "
"load balancing." },
{ "-gcom", FALSE, etINT, {&nstglobalcomm},
"Global communication frequency" },
{ "-nb", FALSE, etENUM, {&nbpu_opt},
"Calculate non-bonded interactions on" },
{ "-nstlist", FALSE, etINT, {&nstlist},
"Set nstlist when using a Verlet buffer tolerance (0 is guess)" },
{ "-tunepme", FALSE, etBOOL, {&bTunePME},
"Optimize PME load between PP/PME ranks or GPU/CPU" },
{ "-testverlet", FALSE, etBOOL, {&bTestVerlet},
"Test the Verlet non-bonded scheme" },
{ "-v", FALSE, etBOOL, {&bVerbose},
"Be loud and noisy" },
{ "-compact", FALSE, etBOOL, {&bCompact},
"Write a compact log file" },
{ "-seppot", FALSE, etBOOL, {&bSepPot},
"Write separate V and dVdl terms for each interaction type and rank to the log file(s)" },
{ "-pforce", FALSE, etREAL, {&pforce},
"Print all forces larger than this (kJ/mol nm)" },
{ "-reprod", FALSE, etBOOL, {&bReproducible},
"Try to avoid optimizations that affect binary reproducibility" },
{ "-cpt", FALSE, etREAL, {&cpt_period},
"Checkpoint interval (minutes)" },
{ "-cpnum", FALSE, etBOOL, {&bKeepAndNumCPT},
"Keep and number checkpoint files" },
{ "-append", FALSE, etBOOL, {&bAppendFiles},
"Append to previous output files when continuing from checkpoint instead of adding the simulation part number to all file names" },
{ "-nsteps", FALSE, etINT64, {&nsteps},
"Run this number of steps, overrides .mdp file option" },
{ "-maxh", FALSE, etREAL, {&max_hours},
"Terminate after 0.99 times this time (hours)" },
{ "-multi", FALSE, etINT, {&nmultisim},
"Do multiple simulations in parallel" },
{ "-replex", FALSE, etINT, {&repl_ex_nst},
"Attempt replica exchange periodically with this period (steps)" },
{ "-nex", FALSE, etINT, {&repl_ex_nex},
"Number of random exchanges to carry out each exchange interval (N^3 is one suggestion). -nex zero or not specified gives neighbor replica exchange." },
{ "-reseed", FALSE, etINT, {&repl_ex_seed},
"Seed for replica exchange, -1 is generate a seed" },
{ "-imdport", FALSE, etINT, {&imdport},
"HIDDENIMD listening port" },
{ "-imdwait", FALSE, etBOOL, {&bIMDwait},
"HIDDENPause the simulation while no IMD client is connected" },
{ "-imdterm", FALSE, etBOOL, {&bIMDterm},
"HIDDENAllow termination of the simulation from IMD client" },
{ "-imdpull", FALSE, etBOOL, {&bIMDpull},
"HIDDENAllow pulling in the simulation from IMD client" },
{ "-rerunvsite", FALSE, etBOOL, {&bRerunVSite},
"HIDDENRecalculate virtual site coordinates with [TT]-rerun[tt]" },
{ "-confout", FALSE, etBOOL, {&bConfout},
"HIDDENWrite the last configuration with [TT]-c[tt] and force checkpointing at the last step" },
{ "-stepout", FALSE, etINT, {&nstepout},
"HIDDENFrequency of writing the remaining wall clock time for the run" },
{ "-resetstep", FALSE, etINT, {&resetstep},
"HIDDENReset cycle counters after these many time steps" },
{ "-resethway", FALSE, etBOOL, {&bResetCountersHalfWay},
"HIDDENReset the cycle counters after half the number of steps or halfway [TT]-maxh[tt]" }
};
unsigned long Flags, PCA_Flags;
ivec ddxyz;
int dd_node_order;
gmx_bool bAddPart;
FILE *fplog, *fpmulti;
int sim_part, sim_part_fn;
const char *part_suffix = ".part";
char suffix[STRLEN];
int rc;
char **multidir = NULL;
cr = init_commrec();
PCA_Flags = (PCA_CAN_SET_DEFFNM | (MASTER(cr) ? 0 : PCA_QUIET));
/* Comment this in to do fexist calls only on master
* works not with rerun or tables at the moment
* also comment out the version of init_forcerec in md.c
* with NULL instead of opt2fn
*/
/*
if (!MASTER(cr))
{
PCA_Flags |= PCA_NOT_READ_NODE;
}
*/
if (!parse_common_args(&argc, argv, PCA_Flags, NFILE, fnm, asize(pa), pa,
asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
/* we set these early because they might be used in init_multisystem()
Note that there is the potential for npme>nnodes until the number of
threads is set later on, if there's thread parallelization. That shouldn't
lead to problems. */
dd_node_order = nenum(ddno_opt);
cr->npmenodes = npme;
hw_opt.thread_affinity = nenum(thread_aff_opt);
/* now check the -multi and -multidir option */
if (opt2bSet("-multidir", NFILE, fnm))
{
if (nmultisim > 0)
{
gmx_fatal(FARGS, "mdrun -multi and -multidir options are mutually exclusive.");
}
nmultisim = opt2fns(&multidir, "-multidir", NFILE, fnm);
}
if (repl_ex_nst != 0 && nmultisim < 2)
{
gmx_fatal(FARGS, "Need at least two replicas for replica exchange (option -multi)");
}
if (repl_ex_nex < 0)
{
gmx_fatal(FARGS, "Replica exchange number of exchanges needs to be positive");
}
if (nmultisim > 1)
{
#ifndef GMX_THREAD_MPI
gmx_bool bParFn = (multidir == NULL);
init_multisystem(cr, nmultisim, multidir, NFILE, fnm, bParFn);
#else
gmx_fatal(FARGS, "mdrun -multi is not supported with the thread library. "
"Please compile GROMACS with MPI support");
#endif
}
bAddPart = !bAppendFiles;
/* Check if there is ANY checkpoint file available */
sim_part = 1;
sim_part_fn = sim_part;
if (opt2bSet("-cpi", NFILE, fnm))
{
if (bSepPot && bAppendFiles)
{
gmx_fatal(FARGS, "Output file appending is not supported with -seppot");
}
bAppendFiles =
read_checkpoint_simulation_part(opt2fn_master("-cpi", NFILE,
fnm, cr),
&sim_part_fn, NULL, cr,
bAppendFiles, NFILE, fnm,
part_suffix, &bAddPart);
if (sim_part_fn == 0 && MULTIMASTER(cr))
{
fprintf(stdout, "No previous checkpoint file present, assuming this is a new run.\n");
}
else
{
sim_part = sim_part_fn + 1;
}
if (MULTISIM(cr) && MASTER(cr))
{
if (MULTIMASTER(cr))
{
/* Log file is not yet available, so if there's a
* problem we can only write to stderr. */
fpmulti = stderr;
}
else
{
fpmulti = NULL;
}
check_multi_int(fpmulti, cr->ms, sim_part, "simulation part", TRUE);
}
}
else
{
bAppendFiles = FALSE;
}
if (!bAppendFiles)
{
sim_part_fn = sim_part;
}
if (bAddPart)
{
/* Rename all output files (except checkpoint files) */
/* create new part name first (zero-filled) */
sprintf(suffix, "%s%04d", part_suffix, sim_part_fn);
add_suffix_to_output_names(fnm, NFILE, suffix);
if (MULTIMASTER(cr))
{
fprintf(stdout, "Checkpoint file is from part %d, new output files will be suffixed '%s'.\n", sim_part-1, suffix);
}
}
Flags = opt2bSet("-rerun", NFILE, fnm) ? MD_RERUN : 0;
Flags = Flags | (bSepPot ? MD_SEPPOT : 0);
Flags = Flags | (bDDBondCheck ? MD_DDBONDCHECK : 0);
Flags = Flags | (bDDBondComm ? MD_DDBONDCOMM : 0);
Flags = Flags | (bTunePME ? MD_TUNEPME : 0);
Flags = Flags | (bTestVerlet ? MD_TESTVERLET : 0);
Flags = Flags | (bConfout ? MD_CONFOUT : 0);
Flags = Flags | (bRerunVSite ? MD_RERUN_VSITE : 0);
Flags = Flags | (bReproducible ? MD_REPRODUCIBLE : 0);
Flags = Flags | (bAppendFiles ? MD_APPENDFILES : 0);
Flags = Flags | (opt2parg_bSet("-append", asize(pa), pa) ? MD_APPENDFILESSET : 0);
Flags = Flags | (bKeepAndNumCPT ? MD_KEEPANDNUMCPT : 0);
Flags = Flags | (sim_part > 1 ? MD_STARTFROMCPT : 0);
Flags = Flags | (bResetCountersHalfWay ? MD_RESETCOUNTERSHALFWAY : 0);
Flags = Flags | (bIMDwait ? MD_IMDWAIT : 0);
Flags = Flags | (bIMDterm ? MD_IMDTERM : 0);
Flags = Flags | (bIMDpull ? MD_IMDPULL : 0);
Flags = Flags | ((opt2bSet("-at", NFILE, fnm)) ? MD_ADAPTIVETEMPERING : 0);
Flags = Flags | ((opt2bSet("-addtop", NFILE, fnm)) ? MD_MULTOP : 0);
/* We postpone opening the log file if we are appending, so we can
first truncate the old log file and append to the correct position
there instead. */
if ((MASTER(cr) || bSepPot) && !bAppendFiles)
{
gmx_log_open(ftp2fn(efLOG, NFILE, fnm), cr,
!bSepPot, Flags & MD_APPENDFILES, &fplog);
please_cite(fplog, "Hess2008b");
please_cite(fplog, "Spoel2005a");
please_cite(fplog, "Lindahl2001a");
please_cite(fplog, "Berendsen95a");
}
else if (!MASTER(cr) && bSepPot)
{
gmx_log_open(ftp2fn(efLOG, NFILE, fnm), cr, !bSepPot, Flags, &fplog);
}
else
{
fplog = NULL;
}
ddxyz[XX] = (int)(realddxyz[XX] + 0.5);
ddxyz[YY] = (int)(realddxyz[YY] + 0.5);
ddxyz[ZZ] = (int)(realddxyz[ZZ] + 0.5);
rc = mdrunner(&hw_opt, fplog, cr, NFILE, fnm, oenv, bVerbose, bCompact,
nstglobalcomm, ddxyz, dd_node_order, rdd, rconstr,
dddlb_opt[0], dlb_scale, ddcsx, ddcsy, ddcsz,
nbpu_opt[0], nstlist,
nsteps, nstepout, resetstep,
nmultisim, repl_ex_nst, repl_ex_nex, repl_ex_seed,
pforce, cpt_period, max_hours, deviceOptions, imdport, Flags);
/* Log file has to be closed in mdrunner if we are appending to it
(fplog not set here) */
if (MASTER(cr) && !bAppendFiles)
{
gmx_log_close(fplog);
}
return rc;
}
int gmx_densmap(int argc,char *argv[])
{
const char *desc[] = {
"[TT]g_densmap[tt] 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].",
"Optionally, output can be in text form to a [TT].dat[tt] file with [TT]-od[tt], instead of the usual [TT].xpm[tt] file with [TT]-o[tt].",
"[PAR]",
"The default analysis is a 2-D number-density map for a selected",
"group of atoms in the x-y plane.",
"The averaging direction can be changed with the option [TT]-aver[tt].",
"When [TT]-xmin[tt] and/or [TT]-xmax[tt] are set only atoms that are",
"within the limit(s) in the averaging direction are taken into account.",
"The grid spacing is set with the option [TT]-bin[tt].",
"When [TT]-n1[tt] or [TT]-n2[tt] is non-zero, the grid",
"size is set by this option.",
"Box size fluctuations are properly taken into account.",
"[PAR]",
"When options [TT]-amax[tt] and [TT]-rmax[tt] are set, an axial-radial",
"number-density map is made. Three groups should be supplied, the centers",
"of mass of the first two groups define the axis, the third defines the",
"analysis group. The axial direction goes from -amax to +amax, where",
"the center is defined as the midpoint between the centers of mass and",
"the positive direction goes from the first to the second center of mass.",
"The radial direction goes from 0 to rmax or from -rmax to +rmax",
"when the [TT]-mirror[tt] option has been set.",
"[PAR]",
"The normalization of the output is set with the [TT]-unit[tt] option.",
"The default produces a true number density. Unit [TT]nm-2[tt] leaves out",
"the normalization for the averaging or the angular direction.",
"Option [TT]count[tt] produces the count for each grid cell.",
"When you do not want the scale in the output to go",
"from zero to the maximum density, you can set the maximum",
"with the option [TT]-dmax[tt]."
};
static int n1=0,n2=0;
static real xmin=-1,xmax=-1,bin=0.02,dmin=0,dmax=0,amax=0,rmax=0;
static gmx_bool bMirror=FALSE, bSums=FALSE;
static const char *eaver[]= { NULL, "z", "y", "x", NULL };
static const char *eunit[]= { NULL, "nm-3", "nm-2", "count", NULL };
t_pargs pa[] = {
{ "-bin", FALSE, etREAL, {&bin},
"Grid size (nm)"
},
{ "-aver", FALSE, etENUM, {eaver},
"The direction to average over"
},
{ "-xmin", FALSE, etREAL, {&xmin},
"Minimum coordinate for averaging"
},
{ "-xmax", FALSE, etREAL, {&xmax},
"Maximum coordinate for averaging"
},
{ "-n1", FALSE, etINT, {&n1},
"Number of grid cells in the first direction"
},
{ "-n2", FALSE, etINT, {&n2},
"Number of grid cells in the second direction"
},
{ "-amax", FALSE, etREAL, {&amax},
"Maximum axial distance from the center"
},
{ "-rmax", FALSE, etREAL, {&rmax},
"Maximum radial distance"
},
{ "-mirror", FALSE, etBOOL, {&bMirror},
"Add the mirror image below the axial axis"
},
{ "-sums", FALSE, etBOOL, {&bSums},
"Print density sums (1D map) to stdout"
},
{ "-unit", FALSE, etENUM, {eunit},
"Unit for the output"
},
{ "-dmin", FALSE, etREAL, {&dmin},
"Minimum density in output"
},
{ "-dmax", FALSE, etREAL, {&dmax},
"Maximum density in output (0 means calculate it)"
},
};
gmx_bool bXmin,bXmax,bRadial;
FILE *fp;
t_trxstatus *status;
t_topology top;
int ePBC=-1;
rvec *x,xcom[2],direction,center,dx;
matrix box;
real t,m,mtot;
t_pbc pbc;
int cav=0,c1=0,c2=0,natoms;
char **grpname,title[256],buf[STRLEN];
const char *unit;
int i,j,k,l,ngrps,anagrp,*gnx=NULL,nindex,nradial=0,nfr,nmpower;
atom_id **ind=NULL,*index;
real **grid,maxgrid,m1,m2,box1,box2,*tickx,*tickz,invcellvol;
real invspa=0,invspz=0,axial,r,vol_old,vol,rowsum;
int nlev=51;
t_rgb rlo= {1,1,1}, rhi= {0,0,0};
output_env_t oenv;
const char *label[]= { "x (nm)", "y (nm)", "z (nm)" };
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efDAT, "-od", "densmap", ffOPTWR },
{ efXPM, "-o", "densmap", ffWRITE }
};
#define NFILE asize(fnm)
int npargs;
CopyRight(stderr,argv[0]);
npargs = asize(pa);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_BE_NICE,
NFILE,fnm,npargs,pa,asize(desc),desc,0,NULL,&oenv);
bXmin = opt2parg_bSet("-xmin",npargs,pa);
bXmax = opt2parg_bSet("-xmax",npargs,pa);
bRadial = (amax>0 || rmax>0);
if (bRadial) {
if (amax<=0 || rmax<=0)
gmx_fatal(FARGS,"Both amax and rmax should be larger than zero");
}
if (strcmp(eunit[0],"nm-3") == 0) {
nmpower = -3;
unit = "(nm^-3)";
} else if (strcmp(eunit[0],"nm-2") == 0) {
nmpower = -2;
unit = "(nm^-2)";
} else {
nmpower = 0;
unit = "count";
}
if (ftp2bSet(efTPS,NFILE,fnm) || !ftp2bSet(efNDX,NFILE,fnm))
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&x,NULL,box,
bRadial);
if (!bRadial) {
ngrps = 1;
fprintf(stderr,"\nSelect an analysis group\n");
} else {
ngrps = 3;
fprintf(stderr,
"\nSelect two groups to define the axis and an analysis group\n");
}
snew(gnx,ngrps);
snew(grpname,ngrps);
snew(ind,ngrps);
get_index(&top.atoms,ftp2fn_null(efNDX,NFILE,fnm),ngrps,gnx,ind,grpname);
anagrp = ngrps - 1;
nindex = gnx[anagrp];
index = ind[anagrp];
if (bRadial) {
if ((gnx[0]>1 || gnx[1]>1) && !ftp2bSet(efTPS,NFILE,fnm))
gmx_fatal(FARGS,"No run input file was supplied (option -s), this is required for the center of mass calculation");
}
switch (eaver[0][0]) {
case 'x':
cav = XX;
c1 = YY;
c2 = ZZ;
break;
case 'y':
cav = YY;
c1 = XX;
c2 = ZZ;
break;
case 'z':
cav = ZZ;
c1 = XX;
c2 = YY;
break;
}
natoms=read_first_x(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
if (!bRadial) {
if (n1 == 0)
n1 = (int)(box[c1][c1]/bin + 0.5);
if (n2 == 0)
n2 = (int)(box[c2][c2]/bin + 0.5);
} else {
n1 = (int)(2*amax/bin + 0.5);
nradial = (int)(rmax/bin + 0.5);
invspa = n1/(2*amax);
invspz = nradial/rmax;
if (bMirror)
n2 = 2*nradial;
else
n2 = nradial;
}
snew(grid,n1);
for(i=0; i<n1; i++)
snew(grid[i],n2);
box1 = 0;
box2 = 0;
nfr = 0;
do {
if (!bRadial) {
box1 += box[c1][c1];
box2 += box[c2][c2];
invcellvol = n1*n2;
if (nmpower == -3)
invcellvol /= det(box);
else if (nmpower == -2)
invcellvol /= box[c1][c1]*box[c2][c2];
for(i=0; i<nindex; i++) {
j = index[i];
if ((!bXmin || x[j][cav] >= xmin) &&
(!bXmax || x[j][cav] <= xmax)) {
m1 = x[j][c1]/box[c1][c1];
if (m1 >= 1)
m1 -= 1;
if (m1 < 0)
m1 += 1;
m2 = x[j][c2]/box[c2][c2];
if (m2 >= 1)
m2 -= 1;
if (m2 < 0)
m2 += 1;
grid[(int)(m1*n1)][(int)(m2*n2)] += invcellvol;
}
}
} else {
set_pbc(&pbc,ePBC,box);
for(i=0; i<2; i++) {
if (gnx[i] == 1) {
/* One atom, just copy the coordinates */
copy_rvec(x[ind[i][0]],xcom[i]);
} else {
/* Calculate the center of mass */
clear_rvec(xcom[i]);
mtot = 0;
for(j=0; j<gnx[i]; j++) {
k = ind[i][j];
m = top.atoms.atom[k].m;
for(l=0; l<DIM; l++)
xcom[i][l] += m*x[k][l];
mtot += m;
}
svmul(1/mtot,xcom[i],xcom[i]);
}
}
pbc_dx(&pbc,xcom[1],xcom[0],direction);
for(i=0; i<DIM; i++)
center[i] = xcom[0][i] + 0.5*direction[i];
unitv(direction,direction);
for(i=0; i<nindex; i++) {
j = index[i];
pbc_dx(&pbc,x[j],center,dx);
axial = iprod(dx,direction);
r = sqrt(norm2(dx) - axial*axial);
if (axial>=-amax && axial<amax && r<rmax) {
if (bMirror)
r += rmax;
grid[(int)((axial + amax)*invspa)][(int)(r*invspz)] += 1;
}
}
}
nfr++;
} while(read_next_x(oenv,status,&t,natoms,x,box));
close_trj(status);
/* normalize gridpoints */
maxgrid = 0;
if (!bRadial) {
for (i=0; i<n1; i++) {
for (j=0; j<n2; j++) {
grid[i][j] /= nfr;
if (grid[i][j] > maxgrid)
maxgrid = grid[i][j];
}
}
} else {
for (i=0; i<n1; i++) {
vol_old = 0;
for (j=0; j<nradial; j++) {
switch (nmpower) {
case -3:
vol = M_PI*(j+1)*(j+1)/(invspz*invspz*invspa);
break;
case -2:
vol = (j+1)/(invspz*invspa);
break;
default:
vol = j+1;
break;
}
if (bMirror)
k = j + nradial;
else
k = j;
grid[i][k] /= nfr*(vol - vol_old);
if (bMirror)
grid[i][nradial-1-j] = grid[i][k];
vol_old = vol;
if (grid[i][k] > maxgrid)
maxgrid = grid[i][k];
}
}
}
fprintf(stdout,"\n The maximum density is %f %s\n",maxgrid,unit);
if (dmax > 0)
maxgrid = dmax;
snew(tickx,n1+1);
snew(tickz,n2+1);
if (!bRadial) {
/* normalize box-axes */
box1 /= nfr;
box2 /= nfr;
for (i=0; i<=n1; i++)
tickx[i] = i*box1/n1;
for (i=0; i<=n2; i++)
tickz[i] = i*box2/n2;
} else {
for (i=0; i<=n1; i++)
tickx[i] = i/invspa - amax;
if (bMirror) {
for (i=0; i<=n2; i++)
tickz[i] = i/invspz - rmax;
} else {
for (i=0; i<=n2; i++)
tickz[i] = i/invspz;
}
}
if (bSums)
{
for (i=0; i<n1; ++i)
{
fprintf(stdout,"Density sums:\n");
rowsum=0;
for (j=0; j<n2; ++j)
rowsum+=grid[i][j];
fprintf(stdout,"%g\t",rowsum);
}
fprintf(stdout,"\n");
}
sprintf(buf,"%s number density",grpname[anagrp]);
if (!bRadial && (bXmin || bXmax)) {
if (!bXmax)
sprintf(buf+strlen(buf),", %c > %g nm",eaver[0][0],xmin);
else if (!bXmin)
sprintf(buf+strlen(buf),", %c < %g nm",eaver[0][0],xmax);
else
sprintf(buf+strlen(buf),", %c: %g - %g nm",eaver[0][0],xmin,xmax);
}
if (ftp2bSet(efDAT,NFILE,fnm))
{
fp = ffopen(ftp2fn(efDAT,NFILE,fnm),"w");
/*optional text form output: first row is tickz; first col is tickx */
fprintf(fp,"0\t");
for(j=0; j<n2; ++j)
fprintf(fp,"%g\t",tickz[j]);
fprintf(fp,"\n");
for (i=0; i<n1; ++i)
{
fprintf(fp,"%g\t",tickx[i]);
for (j=0; j<n2; ++j)
fprintf(fp,"%g\t",grid[i][j]);
fprintf(fp,"\n");
}
ffclose(fp);
}
else
{
fp = ffopen(ftp2fn(efXPM,NFILE,fnm),"w");
write_xpm(fp,MAT_SPATIAL_X | MAT_SPATIAL_Y,buf,unit,
bRadial ? "axial (nm)" : label[c1],bRadial ? "r (nm)" : label[c2],
n1,n2,tickx,tickz,grid,dmin,maxgrid,rlo,rhi,&nlev);
ffclose(fp);
}
thanx(stderr);
do_view(oenv,opt2fn("-o",NFILE,fnm),NULL);
return 0;
}
int gmx_genconf(int argc, char *argv[])
{
const char *desc[] = {
"[TT]genconf[tt] 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]), ",
"and interspaces the grid point with an extra space [TT]-dist[tt].[PAR]",
"When option [TT]-rot[tt] is used the program does not check for overlap",
"between molecules on grid points. It is recommended to make the box in",
"the input file at least as big as the coordinates + ",
"van der Waals radius.[PAR]",
"If the optional trajectory file is given, conformations are not",
"generated, but read from this file and translated appropriately to",
"build the grid."
};
const char *bugs[] = {
"The program should allow for random displacement of lattice points."
};
int vol;
t_atoms *atoms; /* list with all atoms */
char title[STRLEN];
rvec *x, *xx, *v; /* coordinates? */
real t;
vec4 *xrot, *vrot;
int ePBC;
matrix box, boxx; /* box length matrix */
rvec shift;
int natoms; /* number of atoms in one molecule */
int nres; /* number of molecules? */
int i, j, k, l, m, ndx, nrdx, nx, ny, nz;
t_trxstatus *status;
gmx_bool bTRX;
output_env_t oenv;
t_filenm fnm[] = {
{ efSTX, "-f", "conf", ffREAD },
{ efSTO, "-o", "out", ffWRITE },
{ efTRX, "-trj", NULL, ffOPTRD }
};
#define NFILE asize(fnm)
static rvec nrbox = {1, 1, 1};
static int seed = 0; /* seed for random number generator */
static int nmolat = 3;
static int nblock = 1;
static gmx_bool bShuffle = FALSE;
static gmx_bool bSort = FALSE;
static gmx_bool bRandom = FALSE; /* False: no random rotations */
static gmx_bool bRenum = TRUE; /* renumber residues */
static rvec dist = {0, 0, 0}; /* space added between molecules ? */
static rvec max_rot = {180, 180, 180}; /* maximum rotation */
t_pargs pa[] = {
{ "-nbox", FALSE, etRVEC, {nrbox}, "Number of boxes" },
{ "-dist", FALSE, etRVEC, {dist}, "Distance between boxes" },
{ "-seed", FALSE, etINT, {&seed},
"Random generator seed, if 0 generated from the time" },
{ "-rot", FALSE, etBOOL, {&bRandom}, "Randomly rotate conformations" },
{ "-shuffle", FALSE, etBOOL, {&bShuffle}, "Random shuffling of molecules" },
{ "-sort", FALSE, etBOOL, {&bSort}, "Sort molecules on X coord" },
{ "-block", FALSE, etINT, {&nblock},
"Divide the box in blocks on this number of cpus" },
{ "-nmolat", FALSE, etINT, {&nmolat},
"Number of atoms per molecule, assumed to start from 0. "
"If you set this wrong, it will screw up your system!" },
{ "-maxrot", FALSE, etRVEC, {max_rot}, "Maximum random rotation" },
{ "-renumber", FALSE, etBOOL, {&bRenum}, "Renumber residues" }
};
CopyRight(stderr, argv[0]);
parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, asize(bugs), bugs, &oenv);
if (bRandom && (seed == 0))
{
seed = make_seed();
}
bTRX = ftp2bSet(efTRX, NFILE, fnm);
nx = (int)(nrbox[XX]+0.5);
ny = (int)(nrbox[YY]+0.5);
nz = (int)(nrbox[ZZ]+0.5);
if ((nx <= 0) || (ny <= 0) || (nz <= 0))
{
gmx_fatal(FARGS, "Number of boxes (-nbox) should be larger than zero");
}
if ((nmolat <= 0) && bShuffle)
{
gmx_fatal(FARGS, "Can not shuffle if the molecules only have %d atoms",
nmolat);
}
vol = nx*ny*nz; /* calculate volume in grid points (= nr. molecules) */
get_stx_coordnum(opt2fn("-f", NFILE, fnm), &natoms);
snew(atoms, 1);
/* make space for all the atoms */
init_t_atoms(atoms, natoms*vol, FALSE);
snew(x, natoms*vol); /* get space for coordinates of all atoms */
snew(xrot, natoms); /* get space for rotation matrix? */
snew(v, natoms*vol); /* velocities. not really needed? */
snew(vrot, natoms);
/* set atoms->nr to the number in one box *
* to avoid complaints in read_stx_conf *
*/
atoms->nr = natoms;
read_stx_conf(opt2fn("-f", NFILE, fnm), title, atoms, x, v, &ePBC, box);
nres = atoms->nres; /* nr of residues in one element? */
if (bTRX)
{
if (!read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &xx, boxx))
{
gmx_fatal(FARGS, "No atoms in trajectory %s", ftp2fn(efTRX, NFILE, fnm));
}
}
else
{
snew(xx, natoms);
for (i = 0; i < natoms; i++)
{
copy_rvec(x[i], xx[i]);
}
}
for (k = 0; (k < nz); k++) /* loop over all gridpositions */
{
shift[ZZ] = k*(dist[ZZ]+box[ZZ][ZZ]);
for (j = 0; (j < ny); j++)
{
shift[YY] = j*(dist[YY]+box[YY][YY])+k*box[ZZ][YY];
for (i = 0; (i < nx); i++)
{
shift[XX] = i*(dist[XX]+box[XX][XX])+j*box[YY][XX]+k*box[ZZ][XX];
ndx = (i*ny*nz+j*nz+k)*natoms;
nrdx = (i*ny*nz+j*nz+k)*nres;
/* Random rotation on input coords */
if (bRandom)
{
rand_rot(natoms, xx, v, xrot, vrot, &seed, max_rot);
}
for (l = 0; (l < natoms); l++)
{
for (m = 0; (m < DIM); m++)
{
if (bRandom)
{
x[ndx+l][m] = xrot[l][m];
v[ndx+l][m] = vrot[l][m];
}
else
{
x[ndx+l][m] = xx[l][m];
v[ndx+l][m] = v[l][m];
}
}
if (ePBC == epbcSCREW && i % 2 == 1)
{
/* Rotate around x axis */
for (m = YY; m <= ZZ; m++)
{
x[ndx+l][m] = box[YY][m] + box[ZZ][m] - x[ndx+l][m];
v[ndx+l][m] = -v[ndx+l][m];
}
}
for (m = 0; (m < DIM); m++)
{
x[ndx+l][m] += shift[m];
}
atoms->atom[ndx+l].resind = nrdx + atoms->atom[l].resind;
atoms->atomname[ndx+l] = atoms->atomname[l];
}
for (l = 0; (l < nres); l++)
{
atoms->resinfo[nrdx+l] = atoms->resinfo[l];
if (bRenum)
{
atoms->resinfo[nrdx+l].nr += nrdx;
}
}
if (bTRX)
{
if (!read_next_x(oenv, status, &t, natoms, xx, boxx) &&
((i+1)*(j+1)*(k+1) < vol))
{
gmx_fatal(FARGS, "Not enough frames in trajectory");
}
}
}
}
}
if (bTRX)
{
close_trj(status);
}
/* make box bigger */
for (m = 0; (m < DIM); m++)
{
box[m][m] += dist[m];
}
svmul(nx, box[XX], box[XX]);
svmul(ny, box[YY], box[YY]);
svmul(nz, box[ZZ], box[ZZ]);
if (ePBC == epbcSCREW && nx % 2 == 0)
{
/* With an even number of boxes in x we can forgot about the screw */
ePBC = epbcXYZ;
}
/* move_x(natoms*vol,x,box); */ /* put atoms in box? */
atoms->nr *= vol;
atoms->nres *= vol;
/*depending on how you look at it, this is either a nasty hack or the way it should work*/
if (bRenum)
{
for (i = 0; i < atoms->nres; i++)
{
atoms->resinfo[i].nr = i+1;
}
}
if (bShuffle)
{
randwater(0, atoms->nr/nmolat, nmolat, x, v, &seed);
}
else if (bSort)
{
sortwater(0, atoms->nr/nmolat, nmolat, x, v);
}
else if (opt2parg_bSet("-block", asize(pa), pa))
{
mkcompact(0, atoms->nr/nmolat, nmolat, x, v, nblock, box);
}
write_sto_conf(opt2fn("-o", NFILE, fnm), title, atoms, x, v, ePBC, box);
thanx(stderr);
return 0;
}
int gmx_genbox(int argc, char *argv[])
{
const char *desc[] = {
"[TT]genbox[tt] can do one of 3 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]",
"2) Solvate a solute configuration, e.g. a protein, in a bath of solvent ",
"molecules. Specify [TT]-cp[tt] (solute) and [TT]-cs[tt] (solvent). ",
"The box specified in the solute coordinate file ([TT]-cp[tt]) is used,",
"unless [TT]-box[tt] is set.",
"If you want the solute to be centered in the box,",
"the program [TT]editconf[tt] has sophisticated options",
"to change the box dimensions and center the solute.",
"Solvent molecules are removed from the box where the ",
"distance between any atom of the solute molecule(s) and any atom of ",
"the solvent molecule is less than the sum of the van der Waals radii of ",
"both atoms. A database ([TT]vdwradii.dat[tt]) of van der Waals radii is ",
"read by the program, and atoms not in the database are ",
"assigned a default distance [TT]-vdwd[tt].",
"Note that this option will also influence the distances between",
"solvent molecules if they contain atoms that are not in the database.",
"[PAR]",
"3) Insert a number ([TT]-nmol[tt]) of extra molecules ([TT]-ci[tt]) ",
"at random positions.",
"The program iterates until [TT]nmol[tt] molecules",
"have been inserted in the box. To test whether an insertion is ",
"successful the same van der Waals criterium is used as for removal of ",
"solvent molecules. When no appropriately-sized ",
"holes (holes that can hold an extra molecule) are available, the ",
"program tries for [TT]-nmol[tt] * [TT]-try[tt] times before giving up. ",
"Increase [TT]-try[tt] if you have several small holes to fill.[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",
"you are sure of the order in which the operations occur.[PAR]",
"The default solvent is Simple Point Charge water (SPC), with coordinates ",
"from [TT]$GMXLIB/spc216.gro[tt]. These coordinates can also be used",
"for other 3-site water models, since a short equibilibration will remove",
"the small differences between the models.",
"Other solvents are also supported, as well as mixed solvents. The",
"only restriction to solvent types is that a solvent molecule consists",
"of exactly one residue. The residue information in the coordinate",
"files is used, and should therefore be more or less consistent.",
"In practice this means that two subsequent solvent molecules in the ",
"solvent coordinate file should have different residue number.",
"The box of solute is built by stacking the coordinates read from",
"the coordinate file. This means that these coordinates should be ",
"equlibrated in periodic boundary conditions to ensure a good",
"alignment of molecules on the stacking interfaces.",
"The [TT]-maxsol[tt] option simply adds only the first [TT]-maxsol[tt]",
"solvent molecules and leaves out the rest that would have fitted",
"into the box. This can create a void that can cause problems later.",
"Choose your volume wisely.[PAR]",
"The program can optionally rotate the solute molecule to align the",
"longest molecule axis along a box edge. This way the amount of solvent",
"molecules necessary is reduced.",
"It should be kept in mind that this only works for",
"short simulations, as e.g. an alpha-helical peptide in solution can ",
"rotate over 90 degrees, within 500 ps. In general it is therefore ",
"better to make a more or less cubic box.[PAR]",
"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]).",
"[PAR]",
"Finally, [TT]genbox[tt] 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."
};
const char *bugs[] = {
"Molecules must be whole in the initial configurations.",
};
/* parameter data */
gmx_bool bSol, bProt, bBox;
const char *conf_prot, *confout;
int bInsert;
real *r;
char *title_ins;
gmx_atomprop_t aps;
/* protein configuration data */
char *title = NULL;
t_atoms atoms;
rvec *x, *v = NULL;
int ePBC = -1;
matrix box;
t_pbc pbc;
/* other data types */
int atoms_added, residues_added;
t_filenm fnm[] = {
{ efSTX, "-cp", "protein", ffOPTRD },
{ efSTX, "-cs", "spc216", ffLIBOPTRD},
{ efSTX, "-ci", "insert", ffOPTRD},
{ efSTO, NULL, NULL, ffWRITE},
{ efTOP, NULL, NULL, ffOPTRW},
};
#define NFILE asize(fnm)
static int nmol_ins = 0, nmol_try = 10, seed = 1997;
static real r_distance = 0.105, r_shell = 0;
static rvec new_box = {0.0, 0.0, 0.0};
static gmx_bool bReadV = FALSE;
static int max_sol = 0;
output_env_t oenv;
t_pargs pa[] = {
{ "-box", FALSE, etRVEC, {new_box},
"Box size" },
{ "-nmol", FALSE, etINT, {&nmol_ins},
"Number of extra molecules to insert" },
{ "-try", FALSE, etINT, {&nmol_try},
"Try inserting [TT]-nmol[tt] times [TT]-try[tt] times" },
{ "-seed", FALSE, etINT, {&seed},
"Random generator seed"},
{ "-vdwd", FALSE, etREAL, {&r_distance},
"Default van der Waals distance"},
{ "-shell", FALSE, etREAL, {&r_shell},
"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" },
{ "-vel", FALSE, etBOOL, {&bReadV},
"Keep velocities from input solute and solvent" }
};
CopyRight(stderr, argv[0]);
parse_common_args(&argc, argv, PCA_BE_NICE, NFILE, fnm, asize(pa), pa,
asize(desc), desc, asize(bugs), bugs, &oenv);
bInsert = opt2bSet("-ci", NFILE, fnm) && (nmol_ins > 0);
bSol = opt2bSet("-cs", NFILE, fnm);
bProt = opt2bSet("-cp", NFILE, fnm);
bBox = opt2parg_bSet("-box", asize(pa), pa);
/* check input */
if (bInsert && nmol_ins <= 0)
{
gmx_fatal(FARGS, "When specifying inserted molecules (-ci), "
"-nmol must be larger than 0");
}
if (!bInsert && nmol_ins > 0)
{
gmx_fatal(FARGS,
"You tried to insert molecules with -nmol, but did not supply "
"a molecule to insert with -ci.");
}
if (!bProt && !bBox)
{
gmx_fatal(FARGS, "When no solute (-cp) is specified, "
"a box size (-box) must be specified");
}
aps = gmx_atomprop_init();
if (bProt)
{
/*generate a solute configuration */
conf_prot = opt2fn("-cp", NFILE, fnm);
title = read_prot(conf_prot, &atoms, &x, bReadV ? &v : NULL, &r, &ePBC, box,
aps, r_distance);
if (bReadV && !v)
{
fprintf(stderr, "Note: no velocities found\n");
}
if (atoms.nr == 0)
{
fprintf(stderr, "Note: no atoms in %s\n", conf_prot);
bProt = FALSE;
}
}
if (!bProt)
{
atoms.nr = 0;
atoms.nres = 0;
atoms.resinfo = NULL;
atoms.atomname = NULL;
atoms.atom = NULL;
atoms.pdbinfo = NULL;
x = NULL;
r = NULL;
}
if (bBox)
{
ePBC = epbcXYZ;
clear_mat(box);
box[XX][XX] = new_box[XX];
box[YY][YY] = new_box[YY];
box[ZZ][ZZ] = new_box[ZZ];
}
if (det(box) == 0)
{
gmx_fatal(FARGS, "Undefined solute box.\nCreate one with editconf "
"or give explicit -box command line option");
}
/* add nmol_ins molecules of atoms_ins
in random orientation at random place */
if (bInsert)
{
title_ins = insert_mols(opt2fn("-ci", NFILE, fnm), nmol_ins, nmol_try, seed,
&atoms, &x, &r, ePBC, box, aps, r_distance, r_shell,
oenv);
}
else
{
title_ins = strdup("Generated by genbox");
}
/* add solvent */
if (bSol)
{
add_solv(opt2fn("-cs", NFILE, fnm), &atoms, &x, v ? &v : NULL, &r, ePBC, box,
aps, r_distance, &atoms_added, &residues_added, r_shell, max_sol,
oenv);
}
/* write new configuration 1 to file confout */
confout = ftp2fn(efSTO, NFILE, fnm);
fprintf(stderr, "Writing generated configuration to %s\n", confout);
if (bProt)
{
write_sto_conf(confout, title, &atoms, x, v, ePBC, box);
/* print box sizes and box type to stderr */
fprintf(stderr, "%s\n", title);
}
else
{
write_sto_conf(confout, title_ins, &atoms, x, v, ePBC, box);
}
/* print size of generated configuration */
fprintf(stderr, "\nOutput configuration contains %d atoms in %d residues\n",
atoms.nr, atoms.nres);
update_top(&atoms, box, NFILE, fnm, aps);
gmx_atomprop_destroy(aps);
thanx(stderr);
return 0;
}
int gmx_kinetics(int argc, char *argv[])
{
const char *desc[] = {
"[TT]g_kinetics[tt] reads two [TT].xvg[tt] files, each one containing data for N replicas.",
"The first file contains the temperature of each replica at each timestep,",
"and the second contains real values that can be interpreted as",
"an indicator for folding. If the value in the file is larger than",
"the cutoff it is taken to be unfolded and the other way around.[PAR]",
"From these data an estimate of the forward and backward rate constants",
"for folding is made at a reference temperature. In addition,",
"a theoretical melting curve and free energy as a function of temperature",
"are printed in an [TT].xvg[tt] file.[PAR]",
"The user can give a max value to be regarded as intermediate",
"([TT]-ucut[tt]), which, when given will trigger the use of an intermediate state",
"in the algorithm to be defined as those structures that have",
"cutoff < DATA < ucut. Structures with DATA values larger than ucut will",
"not be regarded as potential folders. In this case 8 parameters are optimized.[PAR]",
"The average fraction foled is printed in an [TT].xvg[tt] file together with the fit to it.",
"If an intermediate is used a further file will show the build of the intermediate and the fit to that process.[PAR]",
"The program can also be used with continuous variables (by setting",
"[TT]-nodiscrete[tt]). In this case kinetics of other processes can be",
"studied. This is very much a work in progress and hence the manual",
"(this information) is lagging behind somewhat.[PAR]",
"In order to compile this program you need access to the GNU",
"scientific library."
};
static int nreplica = 1;
static real tref = 298.15;
static real cutoff = 0.2;
static real ucut = 0.0;
static real Euf = 10;
static real Efu = 30;
static real Ei = 10;
static gmx_bool bHaveT = TRUE;
static real t0 = -1;
static real t1 = -1;
static real tb = 0;
static real te = 0;
static real tol = 1e-3;
static int maxiter = 100;
static int skip = 0;
static int nmult = 1;
static gmx_bool bBack = TRUE;
static gmx_bool bSplit = TRUE;
static gmx_bool bSum = TRUE;
static gmx_bool bDiscrete = TRUE;
t_pargs pa[] = {
{ "-time", FALSE, etBOOL, {&bHaveT},
"Expect a time in the input" },
{ "-b", FALSE, etREAL, {&tb},
"First time to read from set" },
{ "-e", FALSE, etREAL, {&te},
"Last time to read from set" },
{ "-bfit", FALSE, etREAL, {&t0},
"Time to start the fit from" },
{ "-efit", FALSE, etREAL, {&t1},
"Time to end the fit" },
{ "-T", FALSE, etREAL, {&tref},
"Reference temperature for computing rate constants" },
{ "-n", FALSE, etINT, {&nreplica},
"Read data for this number of replicas. Only necessary when files are written in xmgrace format using @type and & as delimiters." },
{ "-cut", FALSE, etREAL, {&cutoff},
"Cut-off (max) value for regarding a structure as folded" },
{ "-ucut", FALSE, etREAL, {&ucut},
"Cut-off (max) value for regarding a structure as intermediate (if not folded)" },
{ "-euf", FALSE, etREAL, {&Euf},
"Initial guess for energy of activation for folding (kJ/mol)" },
{ "-efu", FALSE, etREAL, {&Efu},
"Initial guess for energy of activation for unfolding (kJ/mol)" },
{ "-ei", FALSE, etREAL, {&Ei},
"Initial guess for energy of activation for intermediates (kJ/mol)" },
{ "-maxiter", FALSE, etINT, {&maxiter},
"Max number of iterations" },
{ "-back", FALSE, etBOOL, {&bBack},
"Take the back reaction into account" },
{ "-tol", FALSE, etREAL, {&tol},
"Absolute tolerance for convergence of the Nelder and Mead simplex algorithm" },
{ "-skip", FALSE, etINT, {&skip},
"Skip points in the output [TT].xvg[tt] file" },
{ "-split", FALSE, etBOOL, {&bSplit},
"Estimate error by splitting the number of replicas in two and refitting" },
{ "-sum", FALSE, etBOOL, {&bSum},
"Average folding before computing [GRK]chi[grk]^2" },
{ "-discrete", FALSE, etBOOL, {&bDiscrete},
"Use a discrete folding criterion (F <-> U) or a continuous one" },
{ "-mult", FALSE, etINT, {&nmult},
"Factor to multiply the data with before discretization" }
};
#define NPA asize(pa)
FILE *fp;
real dt_t, dt_d, dt_d2;
int nset_t, nset_d, nset_d2, n_t, n_d, n_d2, i;
const char *tfile, *dfile, *dfile2;
t_remd_data remd;
output_env_t oenv;
t_filenm fnm[] = {
{ efXVG, "-f", "temp", ffREAD },
{ efXVG, "-d", "data", ffREAD },
{ efXVG, "-d2", "data2", ffOPTRD },
{ efXVG, "-o", "ft_all", ffWRITE },
{ efXVG, "-o2", "it_all", ffOPTWR },
{ efXVG, "-o3", "ft_repl", ffOPTWR },
{ efXVG, "-ee", "err_est", ffOPTWR },
{ efLOG, "-g", "remd", ffWRITE },
{ efXVG, "-m", "melt", ffWRITE }
};
#define NFILE asize(fnm)
parse_common_args(&argc, argv, PCA_CAN_VIEW | PCA_BE_NICE | PCA_TIME_UNIT,
NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv);
#ifdef HAVE_LIBGSL
please_cite(stdout, "Spoel2006d");
if (cutoff < 0)
{
gmx_fatal(FARGS, "cutoff should be >= 0 (rather than %f)", cutoff);
}
tfile = opt2fn("-f", NFILE, fnm);
dfile = opt2fn("-d", NFILE, fnm);
dfile2 = opt2fn_null("-d2", NFILE, fnm);
fp = ffopen(opt2fn("-g", NFILE, fnm), "w");
remd.temp = read_xvg_time(tfile, bHaveT,
opt2parg_bSet("-b", NPA, pa), tb,
opt2parg_bSet("-e", NPA, pa), te,
nreplica, &nset_t, &n_t, &dt_t, &remd.time);
printf("Read %d sets of %d points in %s, dt = %g\n\n", nset_t, n_t, tfile, dt_t);
sfree(remd.time);
remd.data = read_xvg_time(dfile, bHaveT,
opt2parg_bSet("-b", NPA, pa), tb,
opt2parg_bSet("-e", NPA, pa), te,
nreplica, &nset_d, &n_d, &dt_d, &remd.time);
printf("Read %d sets of %d points in %s, dt = %g\n\n", nset_d, n_d, dfile, dt_d);
if ((nset_t != nset_d) || (n_t != n_d) || (dt_t != dt_d))
{
gmx_fatal(FARGS, "Files %s and %s are inconsistent. Check log file",
tfile, dfile);
}
if (dfile2)
{
remd.data2 = read_xvg_time(dfile2, bHaveT,
opt2parg_bSet("-b", NPA, pa), tb,
opt2parg_bSet("-e", NPA, pa), te,
nreplica, &nset_d2, &n_d2, &dt_d2, &remd.time);
printf("Read %d sets of %d points in %s, dt = %g\n\n",
nset_d2, n_d2, dfile2, dt_d2);
if ((nset_d2 != nset_d) || (n_d != n_d2) || (dt_d != dt_d2))
{
gmx_fatal(FARGS, "Files %s and %s are inconsistent. Check log file",
dfile, dfile2);
}
}
else
{
remd.data2 = NULL;
}
remd.nreplica = nset_d;
remd.nframe = n_d;
remd.dt = 1;
preprocess_remd(fp, &remd, cutoff, tref, ucut, bBack, Euf, Efu, Ei, t0, t1,
bSum, bDiscrete, nmult);
optimize_remd_parameters(&remd, maxiter, tol);
dump_remd_parameters(fp, &remd, opt2fn("-o", NFILE, fnm),
opt2fn_null("-o2", NFILE, fnm),
opt2fn_null("-o3", NFILE, fnm),
opt2fn_null("-ee", NFILE, fnm),
opt2fn("-m", NFILE, fnm), skip, tref, oenv);
if (bSplit)
{
printf("Splitting set of replicas in two halves\n");
for (i = 0; (i < remd.nreplica); i++)
{
remd.bMask[i] = FALSE;
}
remd.nmask = 0;
for (i = 0; (i < remd.nreplica); i += 2)
{
remd.bMask[i] = TRUE;
remd.nmask++;
}
sum_ft(&remd);
optimize_remd_parameters(&remd, maxiter, tol);
dump_remd_parameters(fp, &remd, "test1.xvg", NULL, NULL, NULL, NULL, skip, tref, oenv);
for (i = 0; (i < remd.nreplica); i++)
{
remd.bMask[i] = !remd.bMask[i];
}
remd.nmask = remd.nreplica - remd.nmask;
sum_ft(&remd);
optimize_remd_parameters(&remd, maxiter, tol);
dump_remd_parameters(fp, &remd, "test2.xvg", NULL, NULL, NULL, NULL, skip, tref, oenv);
for (i = 0; (i < remd.nreplica); i++)
{
remd.bMask[i] = FALSE;
}
remd.nmask = 0;
for (i = 0; (i < remd.nreplica/2); i++)
{
remd.bMask[i] = TRUE;
remd.nmask++;
}
sum_ft(&remd);
optimize_remd_parameters(&remd, maxiter, tol);
dump_remd_parameters(fp, &remd, "test1.xvg", NULL, NULL, NULL, NULL, skip, tref, oenv);
for (i = 0; (i < remd.nreplica); i++)
{
remd.bMask[i] = FALSE;
}
remd.nmask = 0;
for (i = remd.nreplica/2; (i < remd.nreplica); i++)
{
remd.bMask[i] = TRUE;
remd.nmask++;
}
sum_ft(&remd);
optimize_remd_parameters(&remd, maxiter, tol);
dump_remd_parameters(fp, &remd, "test1.xvg", NULL, NULL, NULL, NULL, skip, tref, oenv);
}
ffclose(fp);
view_all(oenv, NFILE, fnm);
#else
fprintf(stderr, "This program should be compiled with the GNU scientific library. Please install the library and reinstall GROMACS.\n");
#endif /*HAVE_LIBGSL*/
return 0;
}