int gmx_covar(int argc,char *argv[])
{
const char *desc[] = {
"[TT]g_covar[tt] calculates and diagonalizes the (mass-weighted)",
"covariance matrix.",
"All structures are fitted to the structure in the structure file.",
"When this is not a run input file periodicity will not be taken into",
"account. When the fit and analysis groups are identical and the analysis",
"is non mass-weighted, the fit will also be non mass-weighted.",
"[PAR]",
"The eigenvectors are written to a trajectory file ([TT]-v[tt]).",
"When the same atoms are used for the fit and the covariance analysis,",
"the reference structure for the fit is written first with t=-1.",
"The average (or reference when [TT]-ref[tt] is used) structure is",
"written with t=0, the eigenvectors",
"are written as frames with the eigenvector number as timestamp.",
"[PAR]",
"The eigenvectors can be analyzed with [TT]g_anaeig[tt].",
"[PAR]",
"Option [TT]-ascii[tt] writes the whole covariance matrix to",
"an ASCII file. The order of the elements is: x1x1, x1y1, x1z1, x1x2, ...",
"[PAR]",
"Option [TT]-xpm[tt] writes the whole covariance matrix to an [TT].xpm[tt] file.",
"[PAR]",
"Option [TT]-xpma[tt] writes the atomic covariance matrix to an [TT].xpm[tt] file,",
"i.e. for each atom pair the sum of the xx, yy and zz covariances is",
"written.",
"[PAR]",
"Note that the diagonalization of a matrix requires memory and time",
"that will increase at least as fast as than the square of the number",
"of atoms involved. It is easy to run out of memory, in which",
"case this tool will probably exit with a 'Segmentation fault'. You",
"should consider carefully whether a reduced set of atoms will meet",
"your needs for lower costs."
};
static gmx_bool bFit=TRUE,bRef=FALSE,bM=FALSE,bPBC=TRUE;
static int end=-1;
t_pargs pa[] = {
{ "-fit", FALSE, etBOOL, {&bFit},
"Fit to a reference structure"},
{ "-ref", FALSE, etBOOL, {&bRef},
"Use the deviation from the conformation in the structure file instead of from the average" },
{ "-mwa", FALSE, etBOOL, {&bM},
"Mass-weighted covariance analysis"},
{ "-last", FALSE, etINT, {&end},
"Last eigenvector to write away (-1 is till the last)" },
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Apply corrections for periodic boundary conditions" }
};
FILE *out;
t_trxstatus *status;
t_trxstatus *trjout;
t_topology top;
int ePBC;
t_atoms *atoms;
rvec *x,*xread,*xref,*xav,*xproj;
matrix box,zerobox;
real *sqrtm,*mat,*eigval,sum,trace,inv_nframes;
real t,tstart,tend,**mat2;
real xj,*w_rls=NULL;
real min,max,*axis;
int ntopatoms,step;
int natoms,nat,count,nframes0,nframes,nlevels;
gmx_large_int_t ndim,i,j,k,l;
int WriteXref;
const char *fitfile,*trxfile,*ndxfile;
const char *eigvalfile,*eigvecfile,*averfile,*logfile;
const char *asciifile,*xpmfile,*xpmafile;
char str[STRLEN],*fitname,*ananame,*pcwd;
int d,dj,nfit;
atom_id *index,*ifit;
gmx_bool bDiffMass1,bDiffMass2;
time_t now;
char timebuf[STRLEN];
t_rgb rlo,rmi,rhi;
real *tmp;
output_env_t oenv;
gmx_rmpbc_t gpbc=NULL;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "eigenval", ffWRITE },
{ efTRN, "-v", "eigenvec", ffWRITE },
{ efSTO, "-av", "average.pdb", ffWRITE },
{ efLOG, NULL, "covar", ffWRITE },
{ efDAT, "-ascii","covar", ffOPTWR },
{ efXPM, "-xpm","covar", ffOPTWR },
{ efXPM, "-xpma","covara", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_TIME_UNIT | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL,&oenv);
clear_mat(zerobox);
fitfile = ftp2fn(efTPS,NFILE,fnm);
trxfile = ftp2fn(efTRX,NFILE,fnm);
ndxfile = ftp2fn_null(efNDX,NFILE,fnm);
eigvalfile = ftp2fn(efXVG,NFILE,fnm);
eigvecfile = ftp2fn(efTRN,NFILE,fnm);
averfile = ftp2fn(efSTO,NFILE,fnm);
logfile = ftp2fn(efLOG,NFILE,fnm);
asciifile = opt2fn_null("-ascii",NFILE,fnm);
xpmfile = opt2fn_null("-xpm",NFILE,fnm);
xpmafile = opt2fn_null("-xpma",NFILE,fnm);
read_tps_conf(fitfile,str,&top,&ePBC,&xref,NULL,box,TRUE);
atoms=&top.atoms;
if (bFit) {
printf("\nChoose a group for the least squares fit\n");
get_index(atoms,ndxfile,1,&nfit,&ifit,&fitname);
if (nfit < 3)
gmx_fatal(FARGS,"Need >= 3 points to fit!\n");
} else
nfit=0;
printf("\nChoose a group for the covariance analysis\n");
get_index(atoms,ndxfile,1,&natoms,&index,&ananame);
bDiffMass1=FALSE;
if (bFit) {
snew(w_rls,atoms->nr);
for(i=0; (i<nfit); i++) {
w_rls[ifit[i]]=atoms->atom[ifit[i]].m;
if (i)
bDiffMass1 = bDiffMass1 || (w_rls[ifit[i]]!=w_rls[ifit[i-1]]);
}
}
bDiffMass2=FALSE;
snew(sqrtm,natoms);
for(i=0; (i<natoms); i++)
if (bM) {
sqrtm[i]=sqrt(atoms->atom[index[i]].m);
if (i)
bDiffMass2 = bDiffMass2 || (sqrtm[i]!=sqrtm[i-1]);
}
else
sqrtm[i]=1.0;
if (bFit && bDiffMass1 && !bDiffMass2) {
bDiffMass1 = natoms != nfit;
i=0;
for (i=0; (i<natoms) && !bDiffMass1; i++)
bDiffMass1 = index[i] != ifit[i];
if (!bDiffMass1) {
fprintf(stderr,"\n"
"Note: the fit and analysis group are identical,\n"
" while the fit is mass weighted and the analysis is not.\n"
" Making the fit non mass weighted.\n\n");
for(i=0; (i<nfit); i++)
w_rls[ifit[i]]=1.0;
}
}
/* Prepare reference frame */
if (bPBC) {
gpbc = gmx_rmpbc_init(&top.idef,ePBC,atoms->nr,box);
gmx_rmpbc(gpbc,atoms->nr,box,xref);
}
if (bFit)
reset_x(nfit,ifit,atoms->nr,NULL,xref,w_rls);
snew(x,natoms);
snew(xav,natoms);
ndim=natoms*DIM;
if (sqrt(GMX_LARGE_INT_MAX)<ndim) {
gmx_fatal(FARGS,"Number of degrees of freedoms to large for matrix.\n");
}
snew(mat,ndim*ndim);
fprintf(stderr,"Calculating the average structure ...\n");
nframes0 = 0;
nat=read_first_x(oenv,&status,trxfile,&t,&xread,box);
if (nat != atoms->nr)
fprintf(stderr,"\nWARNING: number of atoms in tpx (%d) and trajectory (%d) do not match\n",natoms,nat);
do {
nframes0++;
/* calculate x: a fitted struture of the selected atoms */
if (bPBC)
gmx_rmpbc(gpbc,nat,box,xread);
if (bFit) {
reset_x(nfit,ifit,nat,NULL,xread,w_rls);
do_fit(nat,w_rls,xref,xread);
}
for (i=0; i<natoms; i++)
rvec_inc(xav[i],xread[index[i]]);
} while (read_next_x(oenv,status,&t,nat,xread,box));
close_trj(status);
inv_nframes = 1.0/nframes0;
for(i=0; i<natoms; i++)
for(d=0; d<DIM; d++) {
xav[i][d] *= inv_nframes;
xread[index[i]][d] = xav[i][d];
}
write_sto_conf_indexed(opt2fn("-av",NFILE,fnm),"Average structure",
atoms,xread,NULL,epbcNONE,zerobox,natoms,index);
sfree(xread);
fprintf(stderr,"Constructing covariance matrix (%dx%d) ...\n",(int)ndim,(int)ndim);
nframes=0;
nat=read_first_x(oenv,&status,trxfile,&t,&xread,box);
tstart = t;
do {
nframes++;
tend = t;
/* calculate x: a (fitted) structure of the selected atoms */
if (bPBC)
gmx_rmpbc(gpbc,nat,box,xread);
if (bFit) {
reset_x(nfit,ifit,nat,NULL,xread,w_rls);
do_fit(nat,w_rls,xref,xread);
}
if (bRef)
for (i=0; i<natoms; i++)
rvec_sub(xread[index[i]],xref[index[i]],x[i]);
else
for (i=0; i<natoms; i++)
rvec_sub(xread[index[i]],xav[i],x[i]);
for (j=0; j<natoms; j++) {
for (dj=0; dj<DIM; dj++) {
k=ndim*(DIM*j+dj);
xj=x[j][dj];
for (i=j; i<natoms; i++) {
l=k+DIM*i;
for(d=0; d<DIM; d++)
mat[l+d] += x[i][d]*xj;
}
}
}
} while (read_next_x(oenv,status,&t,nat,xread,box) &&
(bRef || nframes < nframes0));
close_trj(status);
gmx_rmpbc_done(gpbc);
fprintf(stderr,"Read %d frames\n",nframes);
if (bRef) {
/* copy the reference structure to the ouput array x */
snew(xproj,natoms);
for (i=0; i<natoms; i++)
copy_rvec(xref[index[i]],xproj[i]);
} else {
xproj = xav;
}
/* correct the covariance matrix for the mass */
inv_nframes = 1.0/nframes;
for (j=0; j<natoms; j++)
for (dj=0; dj<DIM; dj++)
for (i=j; i<natoms; i++) {
k = ndim*(DIM*j+dj)+DIM*i;
for (d=0; d<DIM; d++)
mat[k+d] = mat[k+d]*inv_nframes*sqrtm[i]*sqrtm[j];
}
/* symmetrize the matrix */
for (j=0; j<ndim; j++)
for (i=j; i<ndim; i++)
mat[ndim*i+j]=mat[ndim*j+i];
trace=0;
for(i=0; i<ndim; i++)
trace+=mat[i*ndim+i];
fprintf(stderr,"\nTrace of the covariance matrix: %g (%snm^2)\n",
trace,bM ? "u " : "");
if (asciifile) {
out = ffopen(asciifile,"w");
for (j=0; j<ndim; j++) {
for (i=0; i<ndim; i+=3)
fprintf(out,"%g %g %g\n",
mat[ndim*j+i],mat[ndim*j+i+1],mat[ndim*j+i+2]);
}
ffclose(out);
}
if (xpmfile) {
min = 0;
max = 0;
snew(mat2,ndim);
for (j=0; j<ndim; j++) {
mat2[j] = &(mat[ndim*j]);
for (i=0; i<=j; i++) {
if (mat2[j][i] < min)
min = mat2[j][i];
if (mat2[j][j] > max)
max = mat2[j][i];
}
}
snew(axis,ndim);
for(i=0; i<ndim; i++)
axis[i] = i+1;
rlo.r = 0; rlo.g = 0; rlo.b = 1;
rmi.r = 1; rmi.g = 1; rmi.b = 1;
rhi.r = 1; rhi.g = 0; rhi.b = 0;
out = ffopen(xpmfile,"w");
nlevels = 80;
write_xpm3(out,0,"Covariance",bM ? "u nm^2" : "nm^2",
"dim","dim",ndim,ndim,axis,axis,
mat2,min,0.0,max,rlo,rmi,rhi,&nlevels);
ffclose(out);
sfree(axis);
sfree(mat2);
}
if (xpmafile) {
min = 0;
max = 0;
snew(mat2,ndim/DIM);
for (i=0; i<ndim/DIM; i++)
snew(mat2[i],ndim/DIM);
for (j=0; j<ndim/DIM; j++) {
for (i=0; i<=j; i++) {
mat2[j][i] = 0;
for(d=0; d<DIM; d++)
mat2[j][i] += mat[ndim*(DIM*j+d)+DIM*i+d];
if (mat2[j][i] < min)
min = mat2[j][i];
if (mat2[j][j] > max)
max = mat2[j][i];
mat2[i][j] = mat2[j][i];
}
}
snew(axis,ndim/DIM);
for(i=0; i<ndim/DIM; i++)
axis[i] = i+1;
rlo.r = 0; rlo.g = 0; rlo.b = 1;
rmi.r = 1; rmi.g = 1; rmi.b = 1;
rhi.r = 1; rhi.g = 0; rhi.b = 0;
out = ffopen(xpmafile,"w");
nlevels = 80;
write_xpm3(out,0,"Covariance",bM ? "u nm^2" : "nm^2",
"atom","atom",ndim/DIM,ndim/DIM,axis,axis,
mat2,min,0.0,max,rlo,rmi,rhi,&nlevels);
ffclose(out);
sfree(axis);
for (i=0; i<ndim/DIM; i++)
sfree(mat2[i]);
sfree(mat2);
}
/* call diagonalization routine */
fprintf(stderr,"\nDiagonalizing ...\n");
fflush(stderr);
snew(eigval,ndim);
snew(tmp,ndim*ndim);
memcpy(tmp,mat,ndim*ndim*sizeof(real));
eigensolver(tmp,ndim,0,ndim,eigval,mat);
sfree(tmp);
/* now write the output */
sum=0;
for(i=0; i<ndim; i++)
sum+=eigval[i];
fprintf(stderr,"\nSum of the eigenvalues: %g (%snm^2)\n",
sum,bM ? "u " : "");
if (fabs(trace-sum)>0.01*trace)
fprintf(stderr,"\nWARNING: eigenvalue sum deviates from the trace of the covariance matrix\n");
fprintf(stderr,"\nWriting eigenvalues to %s\n",eigvalfile);
sprintf(str,"(%snm\\S2\\N)",bM ? "u " : "");
out=xvgropen(eigvalfile,
"Eigenvalues of the covariance matrix",
"Eigenvector index",str,oenv);
for (i=0; (i<ndim); i++)
fprintf (out,"%10d %g\n",(int)i+1,eigval[ndim-1-i]);
ffclose(out);
if (end==-1) {
if (nframes-1 < ndim)
end=nframes-1;
else
end=ndim;
}
if (bFit) {
/* misuse lambda: 0/1 mass weighted analysis no/yes */
if (nfit==natoms) {
WriteXref = eWXR_YES;
for(i=0; i<nfit; i++)
copy_rvec(xref[ifit[i]],x[i]);
} else
WriteXref = eWXR_NO;
} else {
/* misuse lambda: -1 for no fit */
WriteXref = eWXR_NOFIT;
}
write_eigenvectors(eigvecfile,natoms,mat,TRUE,1,end,
WriteXref,x,bDiffMass1,xproj,bM,eigval);
out = ffopen(logfile,"w");
time(&now);
gmx_ctime_r(&now,timebuf,STRLEN);
fprintf(out,"Covariance analysis log, written %s\n",timebuf);
fprintf(out,"Program: %s\n",argv[0]);
#if ((defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64) && !defined __CYGWIN__ && !defined __CYGWIN32__)
pcwd=_getcwd(str,STRLEN);
#else
pcwd=getcwd(str,STRLEN);
#endif
if(NULL==pcwd)
{
gmx_fatal(FARGS,"Current working directory is undefined");
}
fprintf(out,"Working directory: %s\n\n",str);
fprintf(out,"Read %d frames from %s (time %g to %g %s)\n",nframes,trxfile,
output_env_conv_time(oenv,tstart),output_env_conv_time(oenv,tend),output_env_get_time_unit(oenv));
if (bFit)
fprintf(out,"Read reference structure for fit from %s\n",fitfile);
if (ndxfile)
fprintf(out,"Read index groups from %s\n",ndxfile);
fprintf(out,"\n");
fprintf(out,"Analysis group is '%s' (%d atoms)\n",ananame,natoms);
if (bFit)
fprintf(out,"Fit group is '%s' (%d atoms)\n",fitname,nfit);
else
fprintf(out,"No fit was used\n");
fprintf(out,"Analysis is %smass weighted\n", bDiffMass2 ? "":"non-");
if (bFit)
fprintf(out,"Fit is %smass weighted\n", bDiffMass1 ? "":"non-");
fprintf(out,"Diagonalized the %dx%d covariance matrix\n",(int)ndim,(int)ndim);
fprintf(out,"Trace of the covariance matrix before diagonalizing: %g\n",
trace);
fprintf(out,"Trace of the covariance matrix after diagonalizing: %g\n\n",
sum);
fprintf(out,"Wrote %d eigenvalues to %s\n",(int)ndim,eigvalfile);
if (WriteXref == eWXR_YES)
fprintf(out,"Wrote reference structure to %s\n",eigvecfile);
fprintf(out,"Wrote average structure to %s and %s\n",averfile,eigvecfile);
fprintf(out,"Wrote eigenvectors %d to %d to %s\n",1,end,eigvecfile);
ffclose(out);
fprintf(stderr,"Wrote the log to %s\n",logfile);
thanx(stderr);
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;
}
static void clust_size(const char *ndx, const char *trx, const char *xpm,
const char *xpmw, const char *ncl, const char *acl,
const char *mcl, const char *histo, const char *tempf,
const char *mcn, gmx_bool bMol, gmx_bool bPBC, const char *tpr,
real cut, int nskip, int nlevels,
t_rgb rmid, t_rgb rhi, int ndf,
const output_env_t oenv)
{
FILE *fp, *gp, *hp, *tp;
atom_id *index = NULL;
int nindex, natoms;
t_trxstatus *status;
rvec *x = NULL, *v = NULL, dx;
t_pbc pbc;
char *gname;
char timebuf[32];
gmx_bool bSame, bTPRwarn = TRUE;
/* Topology stuff */
t_trxframe fr;
t_tpxheader tpxh;
gmx_mtop_t *mtop = NULL;
int ePBC = -1;
t_block *mols = NULL;
gmx_mtop_atomlookup_t alook;
t_atom *atom;
int version, generation, ii, jj;
real temp, tfac;
/* Cluster size distribution (matrix) */
real **cs_dist = NULL;
real tf, dx2, cut2, *t_x = NULL, *t_y, cmid, cmax, cav, ekin;
int i, j, k, ai, aj, ci, cj, nframe, nclust, n_x, max_size = 0;
int *clust_index, *clust_size, max_clust_size, max_clust_ind, nav, nhisto;
t_rgb rlo = { 1.0, 1.0, 1.0 };
clear_trxframe(&fr, TRUE);
sprintf(timebuf, "Time (%s)", output_env_get_time_unit(oenv));
tf = output_env_get_time_factor(oenv);
fp = xvgropen(ncl, "Number of clusters", timebuf, "N", oenv);
gp = xvgropen(acl, "Average cluster size", timebuf, "#molecules", oenv);
hp = xvgropen(mcl, "Max cluster size", timebuf, "#molecules", oenv);
tp = xvgropen(tempf, "Temperature of largest cluster", timebuf, "T (K)",
oenv);
if (!read_first_frame(oenv, &status, trx, &fr, TRX_NEED_X | TRX_READ_V))
{
gmx_file(trx);
}
natoms = fr.natoms;
x = fr.x;
if (tpr)
{
snew(mtop, 1);
read_tpxheader(tpr, &tpxh, TRUE, &version, &generation);
if (tpxh.natoms != natoms)
{
gmx_fatal(FARGS, "tpr (%d atoms) and trajectory (%d atoms) do not match!",
tpxh.natoms, natoms);
}
ePBC = read_tpx(tpr, NULL, NULL, &natoms, NULL, NULL, mtop);
}
if (ndf <= -1)
{
tfac = 1;
}
else
{
tfac = ndf/(3.0*natoms);
}
if (bMol)
{
if (ndx)
{
printf("Using molecules rather than atoms. Not reading index file %s\n",
ndx);
}
GMX_RELEASE_ASSERT(mtop != NULL, "Trying to access mtop->mols from NULL mtop pointer");
mols = &(mtop->mols);
/* Make dummy index */
nindex = mols->nr;
snew(index, nindex);
for (i = 0; (i < nindex); i++)
{
index[i] = i;
}
gname = gmx_strdup("mols");
}
else
{
rd_index(ndx, 1, &nindex, &index, &gname);
}
alook = gmx_mtop_atomlookup_init(mtop);
snew(clust_index, nindex);
snew(clust_size, nindex);
cut2 = cut*cut;
nframe = 0;
n_x = 0;
snew(t_y, nindex);
for (i = 0; (i < nindex); i++)
{
t_y[i] = i+1;
}
max_clust_size = 1;
max_clust_ind = -1;
do
{
if ((nskip == 0) || ((nskip > 0) && ((nframe % nskip) == 0)))
{
if (bPBC)
{
set_pbc(&pbc, ePBC, fr.box);
}
max_clust_size = 1;
max_clust_ind = -1;
/* Put all atoms/molecules in their own cluster, with size 1 */
for (i = 0; (i < nindex); i++)
{
/* Cluster index is indexed with atom index number */
clust_index[i] = i;
/* Cluster size is indexed with cluster number */
clust_size[i] = 1;
}
/* Loop over atoms */
for (i = 0; (i < nindex); i++)
{
ai = index[i];
ci = clust_index[i];
/* Loop over atoms (only half a matrix) */
for (j = i+1; (j < nindex); j++)
{
cj = clust_index[j];
/* If they are not in the same cluster already */
if (ci != cj)
{
aj = index[j];
/* Compute distance */
if (bMol)
{
GMX_RELEASE_ASSERT(mols != NULL, "Cannot access index[] from NULL mols pointer");
bSame = FALSE;
for (ii = mols->index[ai]; !bSame && (ii < mols->index[ai+1]); ii++)
{
for (jj = mols->index[aj]; !bSame && (jj < mols->index[aj+1]); jj++)
{
if (bPBC)
{
pbc_dx(&pbc, x[ii], x[jj], dx);
}
else
{
rvec_sub(x[ii], x[jj], dx);
}
dx2 = iprod(dx, dx);
bSame = (dx2 < cut2);
}
}
}
else
{
if (bPBC)
{
pbc_dx(&pbc, x[ai], x[aj], dx);
}
else
{
rvec_sub(x[ai], x[aj], dx);
}
dx2 = iprod(dx, dx);
bSame = (dx2 < cut2);
}
/* If distance less than cut-off */
if (bSame)
{
/* Merge clusters: check for all atoms whether they are in
* cluster cj and if so, put them in ci
*/
for (k = 0; (k < nindex); k++)
{
if (clust_index[k] == cj)
{
if (clust_size[cj] <= 0)
{
gmx_fatal(FARGS, "negative cluster size %d for element %d",
clust_size[cj], cj);
}
clust_size[cj]--;
clust_index[k] = ci;
clust_size[ci]++;
}
}
}
}
}
}
n_x++;
srenew(t_x, n_x);
t_x[n_x-1] = fr.time*tf;
srenew(cs_dist, n_x);
snew(cs_dist[n_x-1], nindex);
nclust = 0;
cav = 0;
nav = 0;
for (i = 0; (i < nindex); i++)
{
ci = clust_size[i];
if (ci > max_clust_size)
{
max_clust_size = ci;
max_clust_ind = i;
}
if (ci > 0)
{
nclust++;
cs_dist[n_x-1][ci-1] += 1.0;
max_size = std::max(max_size, ci);
if (ci > 1)
{
cav += ci;
nav++;
}
}
}
fprintf(fp, "%14.6e %10d\n", fr.time, nclust);
if (nav > 0)
{
fprintf(gp, "%14.6e %10.3f\n", fr.time, cav/nav);
}
fprintf(hp, "%14.6e %10d\n", fr.time, max_clust_size);
}
/* Analyse velocities, if present */
if (fr.bV)
{
if (!tpr)
{
if (bTPRwarn)
{
printf("You need a [REF].tpr[ref] file to analyse temperatures\n");
bTPRwarn = FALSE;
}
}
else
{
v = fr.v;
/* Loop over clusters and for each cluster compute 1/2 m v^2 */
if (max_clust_ind >= 0)
{
ekin = 0;
for (i = 0; (i < nindex); i++)
{
if (clust_index[i] == max_clust_ind)
{
ai = index[i];
gmx_mtop_atomnr_to_atom(alook, ai, &atom);
ekin += 0.5*atom->m*iprod(v[ai], v[ai]);
}
}
temp = (ekin*2.0)/(3.0*tfac*max_clust_size*BOLTZ);
fprintf(tp, "%10.3f %10.3f\n", fr.time, temp);
}
}
}
nframe++;
}
while (read_next_frame(oenv, status, &fr));
close_trx(status);
xvgrclose(fp);
xvgrclose(gp);
xvgrclose(hp);
xvgrclose(tp);
gmx_mtop_atomlookup_destroy(alook);
if (max_clust_ind >= 0)
{
fp = gmx_ffopen(mcn, "w");
fprintf(fp, "[ max_clust ]\n");
for (i = 0; (i < nindex); i++)
{
if (clust_index[i] == max_clust_ind)
{
if (bMol)
{
GMX_RELEASE_ASSERT(mols != NULL, "Cannot access index[] from NULL mols pointer");
for (j = mols->index[i]; (j < mols->index[i+1]); j++)
{
fprintf(fp, "%d\n", j+1);
}
}
else
{
fprintf(fp, "%d\n", index[i]+1);
}
}
}
gmx_ffclose(fp);
}
/* Print the real distribution cluster-size/numer, averaged over the trajectory. */
fp = xvgropen(histo, "Cluster size distribution", "Cluster size", "()", oenv);
nhisto = 0;
fprintf(fp, "%5d %8.3f\n", 0, 0.0);
for (j = 0; (j < max_size); j++)
{
real nelem = 0;
for (i = 0; (i < n_x); i++)
{
nelem += cs_dist[i][j];
}
fprintf(fp, "%5d %8.3f\n", j+1, nelem/n_x);
nhisto += static_cast<int>((j+1)*nelem/n_x);
}
fprintf(fp, "%5d %8.3f\n", j+1, 0.0);
xvgrclose(fp);
fprintf(stderr, "Total number of atoms in clusters = %d\n", nhisto);
/* Look for the smallest entry that is not zero
* This will make that zero is white, and not zero is coloured.
*/
cmid = 100.0;
cmax = 0.0;
for (i = 0; (i < n_x); i++)
{
for (j = 0; (j < max_size); j++)
{
if ((cs_dist[i][j] > 0) && (cs_dist[i][j] < cmid))
{
cmid = cs_dist[i][j];
}
cmax = std::max(cs_dist[i][j], cmax);
}
}
fprintf(stderr, "cmid: %g, cmax: %g, max_size: %d\n", cmid, cmax, max_size);
cmid = 1;
fp = gmx_ffopen(xpm, "w");
write_xpm3(fp, 0, "Cluster size distribution", "# clusters", timebuf, "Size",
n_x, max_size, t_x, t_y, cs_dist, 0, cmid, cmax,
rlo, rmid, rhi, &nlevels);
gmx_ffclose(fp);
cmid = 100.0;
cmax = 0.0;
for (i = 0; (i < n_x); i++)
{
for (j = 0; (j < max_size); j++)
{
cs_dist[i][j] *= (j+1);
if ((cs_dist[i][j] > 0) && (cs_dist[i][j] < cmid))
{
cmid = cs_dist[i][j];
}
cmax = std::max(cs_dist[i][j], cmax);
}
}
fprintf(stderr, "cmid: %g, cmax: %g, max_size: %d\n", cmid, cmax, max_size);
fp = gmx_ffopen(xpmw, "w");
write_xpm3(fp, 0, "Weighted cluster size distribution", "Fraction", timebuf,
"Size", n_x, max_size, t_x, t_y, cs_dist, 0, cmid, cmax,
rlo, rmid, rhi, &nlevels);
gmx_ffclose(fp);
sfree(clust_index);
sfree(clust_size);
sfree(index);
}
static void do_rama(int nf,int nlist,t_dlist dlist[],real **dih,
gmx_bool bViol,gmx_bool bRamOmega,const output_env_t oenv)
{
FILE *fp,*gp=NULL;
gmx_bool bOm;
char fn[256];
int i,j,k,Xi1,Xi2,Phi,Psi,Om=0,nlevels;
#define NMAT 120
real **mat=NULL,phi,psi,omega,axis[NMAT],lo,hi;
t_rgb rlo = { 1.0, 0.0, 0.0 };
t_rgb rmid= { 1.0, 1.0, 1.0 };
t_rgb rhi = { 0.0, 0.0, 1.0 };
for(i=0; (i<nlist); i++) {
if ((has_dihedral(edPhi,&(dlist[i]))) &&
(has_dihedral(edPsi,&(dlist[i])))) {
sprintf(fn,"ramaPhiPsi%s.xvg",dlist[i].name);
fp = rama_file(fn,"Ramachandran Plot",
"\\8f\\4 (deg)","\\8y\\4 (deg)",oenv);
bOm = bRamOmega && has_dihedral(edOmega,&(dlist[i]));
if (bOm) {
Om = dlist[i].j0[edOmega];
snew(mat,NMAT);
for(j=0; (j<NMAT); j++) {
snew(mat[j],NMAT);
axis[j] = -180+(360*j)/NMAT;
}
}
if (bViol) {
sprintf(fn,"violPhiPsi%s.xvg",dlist[i].name);
gp = ffopen(fn,"w");
}
Phi = dlist[i].j0[edPhi];
Psi = dlist[i].j0[edPsi];
for(j=0; (j<nf); j++) {
phi = RAD2DEG*dih[Phi][j];
psi = RAD2DEG*dih[Psi][j];
fprintf(fp,"%10g %10g\n",phi,psi);
if (bViol)
fprintf(gp,"%d\n",!bAllowed(dih[Phi][j],RAD2DEG*dih[Psi][j]));
if (bOm) {
omega = RAD2DEG*dih[Om][j];
mat[(int)((phi*NMAT)/360)+NMAT/2][(int)((psi*NMAT)/360)+NMAT/2]
+= omega;
}
}
if (bViol)
ffclose(gp);
ffclose(fp);
if (bOm) {
sprintf(fn,"ramomega%s.xpm",dlist[i].name);
fp = ffopen(fn,"w");
lo = hi = 0;
for(j=0; (j<NMAT); j++)
for(k=0; (k<NMAT); k++) {
mat[j][k] /= nf;
lo=min(mat[j][k],lo);
hi=max(mat[j][k],hi);
}
/* Symmetrise */
if (fabs(lo) > fabs(hi))
hi = -lo;
else
lo = -hi;
/* Add 180 */
for(j=0; (j<NMAT); j++)
for(k=0; (k<NMAT); k++)
mat[j][k] += 180;
lo += 180;
hi += 180;
nlevels = 20;
write_xpm3(fp,0,"Omega/Ramachandran Plot","Deg","Phi","Psi",
NMAT,NMAT,axis,axis,mat,lo,180.0,hi,rlo,rmid,rhi,&nlevels);
ffclose(fp);
for(j=0; (j<NMAT); j++)
sfree(mat[j]);
sfree(mat);
}
}
if ((has_dihedral(edChi1,&(dlist[i]))) &&
(has_dihedral(edChi2,&(dlist[i])))) {
sprintf(fn,"ramaX1X2%s.xvg",dlist[i].name);
fp = rama_file(fn,"\\8c\\4\\s1\\N-\\8c\\4\\s2\\N Ramachandran Plot",
"\\8c\\4\\s1\\N (deg)","\\8c\\4\\s2\\N (deg)",oenv);
Xi1 = dlist[i].j0[edChi1];
Xi2 = dlist[i].j0[edChi2];
for(j=0; (j<nf); j++)
fprintf(fp,"%10g %10g\n",RAD2DEG*dih[Xi1][j],RAD2DEG*dih[Xi2][j]);
ffclose(fp);
}
else
fprintf(stderr,"No chi1 & chi2 angle for %s\n",dlist[i].name);
}
}
