static void writesurftoxpms(t_interf ***surf1,t_interf ***surf2, int tblocks,int xbins, int ybins, int zbins, real bw,real bwz, char **outfiles,int maplevels )
{
char numbuf[12];
int n, i, j;
real **profile1, **profile2;
real max1, max2, min1, min2, *xticks, *yticks;
t_rgb lo={0,0,0};
t_rgb hi={1,1,1};
FILE *xpmfile1, *xpmfile2;
/*Prepare xpm structures for output*/
/*Allocate memory to tick's and matrices*/
snew (xticks,xbins+1);
snew (yticks,ybins+1);
profile1=mk_matrix(xbins,ybins,FALSE);
profile2=mk_matrix(xbins,ybins,FALSE);
for (i=0;i<xbins+1;i++) xticks[i]+=bw;
for (j=0;j<ybins+1;j++) yticks[j]+=bw;
xpmfile1 = ffopen(outfiles[0],"w");
xpmfile2 = ffopen(outfiles[1],"w");
max1=max2=0.0;
min1=min2=zbins*bwz;
for(n=0;n<tblocks;n++)
{
sprintf(numbuf,"tblock: %4i",n);
/*Filling matrices for inclusion in xpm-files*/
for(i=0;i<xbins;i++)
{
for(j=0;j<ybins;j++)
{
profile1[i][j]=(surf1[n][j+ybins*i])->Z;
profile2[i][j]=(surf2[n][j+ybins*i])->Z;
/*Finding max and min values*/
if(profile1[i][j]>max1) max1=profile1[i][j];
if(profile1[i][j]<min1) min1=profile1[i][j];
if(profile2[i][j]>max2) max2=profile2[i][j];
if(profile2[i][j]<min2) min2=profile2[i][j];
}
}
write_xpm(xpmfile1,3,numbuf,"Height","x[nm]","y[nm]",xbins,ybins,xticks,yticks,profile1,min1,max1,lo,hi,&maplevels);
write_xpm(xpmfile2,3,numbuf,"Height","x[nm]","y[nm]",xbins,ybins,xticks,yticks,profile2,min2,max2,lo,hi,&maplevels);
}
ffclose(xpmfile1);
ffclose(xpmfile2);
sfree(profile1);
sfree(profile2);
sfree(xticks);
sfree(yticks);
}
void write_sas_mat(const char *fn, real **accr, int nframe, int nres, t_matrix *mat)
{
real lo, hi;
int i, j, nlev;
t_rgb rlo = {1, 1, 1}, rhi = {0, 0, 0};
FILE *fp;
if (fn)
{
hi = lo = accr[0][0];
for (i = 0; i < nframe; i++)
{
for (j = 0; j < nres; j++)
{
lo = min(lo, accr[i][j]);
hi = max(hi, accr[i][j]);
}
}
fp = gmx_ffopen(fn, "w");
nlev = hi-lo+1;
write_xpm(fp, 0, "Solvent Accessible Surface", "Surface (A^2)",
"Time", "Residue Index", nframe, nres,
mat->axis_x, mat->axis_y, accr, lo, hi, rlo, rhi, &nlev);
gmx_ffclose(fp);
}
}
static void print_cmap(const char *cmap,t_gkrbin *gb,int *nlevels)
{
FILE *out;
int i,j;
real hi;
real *xaxis,*yaxis;
t_rgb rlo = { 1, 1, 1 };
t_rgb rhi = { 0, 0, 0 };
hi = normalize_cmap(gb);
snew(xaxis,gb->nx+1);
for(i=0; (i<gb->nx+1); i++)
xaxis[i] = i*gb->spacing;
snew(yaxis,gb->ny);
for(j=0; (j<gb->ny); j++) {
if (gb->bPhi)
yaxis[j] = (360.0*j)/(gb->ny-1.0)-180;
else
yaxis[j] = (180.0*j)/(gb->ny-1.0);
/*2.0*j/(gb->ny-1.0)-1.0;*/
}
out = ffopen(cmap,"w");
write_xpm(out,0,
"Dipole Orientation Distribution","Fraction","r (nm)",
gb->bPhi ? "Phi" : "Alpha",
gb->nx,gb->ny,xaxis,yaxis,
gb->cmap,0,hi,rlo,rhi,nlevels);
ffclose(out);
sfree(xaxis);
sfree(yaxis);
}
static void ana_trans(t_clusters *clust, int nf,
char *transfn, char *ntransfn, FILE *log,
t_rgb rlo,t_rgb rhi)
{
FILE *fp;
real **trans,*axis;
int *ntrans;
int i,ntranst,maxtrans;
char buf[STRLEN];
snew(ntrans,clust->ncl);
snew(trans,clust->ncl);
snew(axis,clust->ncl);
for(i=0; i<clust->ncl; i++) {
axis[i]=i+1;
snew(trans[i],clust->ncl);
}
ntranst=0;
maxtrans=0;
for(i=1; i<nf; i++)
if(clust->cl[i] != clust->cl[i-1]) {
ntranst++;
ntrans[clust->cl[i-1]-1]++;
ntrans[clust->cl[i]-1]++;
trans[clust->cl[i-1]-1][clust->cl[i]-1]++;
maxtrans = max(maxtrans, trans[clust->cl[i]-1][clust->cl[i-1]-1]);
}
ffprintf2(stderr,log,buf,"Counted %d transitions in total, "
"max %d between two specific clusters\n",ntranst,maxtrans);
if (transfn) {
fp=ffopen(transfn,"w");
i = min(maxtrans+1, 80);
write_xpm(fp,0,"Cluster Transitions","# transitions",
"from cluster","to cluster",
clust->ncl, clust->ncl, axis, axis, trans,
0, maxtrans, rlo, rhi, &i);
ffclose(fp);
}
if (ntransfn) {
fp=xvgropen(ntransfn,"Cluster Transitions","Cluster #","# transitions");
for(i=0; i<clust->ncl; i++)
fprintf(fp,"%5d %5d\n",i+1,ntrans[i]);
ffclose(fp);
}
sfree(ntrans);
for(i=0; i<clust->ncl; i++)
sfree(trans[i]);
sfree(trans);
sfree(axis);
}
static void dump_sd(const char *fn, t_shiftdata *sd)
{
FILE *fp;
int i, j;
char buf[256];
int nnx, nny, nfac = 4, nlevels = 20;
real phi, psi, *x_phi, *y_psi, **newdata;
real lo, hi;
t_rgb rlo = { 1, 0, 0 }, rhi = { 0, 0, 1 };
nnx = sd->nx*nfac+1;
nny = sd->ny*nfac+1;
snew(x_phi, nnx);
snew(y_psi, nny);
snew(newdata, nnx);
lo = 100000;
hi = -100000;
for (i = 0; (i < nnx); i++)
{
snew(newdata[i], nny);
phi = i*2*M_PI/(nnx-1);
x_phi[i] = phi*RAD2DEG-180;
for (j = 0; (j < nny); j++)
{
psi = j*2*M_PI/(nny-1);
if (i == 0)
{
y_psi[j] = psi*RAD2DEG-180;
}
/*if (((i % nfac) == 0) && ((j % nfac) == 0))
newdata[i][j] = sd->data[i/nfac][j/nfac];
else*/
newdata[i][j] = interpolate(phi, psi, sd);
lo = min(lo, newdata[i][j]);
hi = max(hi, newdata[i][j]);
}
}
sprintf(buf, "%s.xpm", fn);
fp = ffopen(buf, "w");
write_xpm(fp, 0, fn, fn, "Phi", "Psi", nnx, nny,
x_phi, y_psi, newdata, lo, hi, rlo, rhi, &nlevels);
for (i = 0; (i < nnx); i++)
{
sfree(newdata[i]);
}
sfree(newdata);
sfree(x_phi);
sfree(y_psi);
}
int main(int argc,char *argv[])
{
static char *desc[] = {
"[TT]g_anavel[tt] computes temperature profiles in a sample. The sample",
"can be analysed radial, i.e. the temperature as a function of",
"distance from the center, cylindrical, i.e. as a function of distance",
"from the vector (0,0,1) through the center of the box, or otherwise",
"(will be specified later)"
};
t_filenm fnm[] = {
{ efTRN, "-f", NULL, ffREAD },
{ efTPX, "-s", NULL, ffREAD },
{ efXPM, "-o", "xcm", ffWRITE }
};
#define NFILE asize(fnm)
static int mode = 0, nlevels = 10;
static real tmax = 300, xmax = -1;
t_pargs pa[] = {
{ "-mode", FALSE, etINT, {&mode}, "mode" },
{ "-nlevels", FALSE, etINT, {&nlevels}, "number of levels" },
{ "-tmax", FALSE, etREAL, {&tmax}, "max temperature in output" },
{ "-xmax", FALSE, etREAL, {&xmax}, "max distance from center" }
};
FILE *fp;
int *npts,nmax;
int status;
int i,j,idum,step,nframe=0,index;
real temp,rdum,hboxx,hboxy,scale,xnorm=0;
real **profile=NULL;
real *t_x=NULL,*t_y,hi=0;
t_topology *top;
int d,m,n;
matrix box;
atom_id *sysindex;
gmx_bool bHaveV,bReadV;
t_rgb rgblo = { 0, 0, 1 },rgbhi = { 1, 0, 0 };
int flags = TRX_READ_X | TRX_READ_V;
t_trxframe fr;
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_BE_NICE ,NFILE,fnm,
asize(pa),pa,asize(desc),desc,0,NULL);
top = read_top(ftp2fn(efTPX,NFILE,fnm));
read_first_frame(&status,ftp2fn(efTRX,NFILE,fnm),&fr,flags);
if (xmax > 0) {
scale = 5;
nmax = xmax*scale;
}
else {
scale = 5;
nmax = (0.5*sqrt(sqr(box[XX][XX])+sqr(box[YY][YY])))*scale;
}
snew(npts,nmax+1);
snew(t_y,nmax+1);
for(i=0; (i<=nmax); i++) {
npts[i] = 0;
t_y[i] = i/scale;
}
do {
srenew(profile,++nframe);
snew(profile[nframe-1],nmax+1);
srenew(t_x,nframe);
t_x[nframe-1] = fr.time*1000;
hboxx = box[XX][XX]/2;
hboxy = box[YY][YY]/2;
for(i=0; (i<fr.natoms); i++) {
/* determine position dependent on mode */
switch (mode) {
case 0:
xnorm = sqrt(sqr(fr.x[i][XX]-hboxx) + sqr(fr.x[i][YY]-hboxy));
break;
default:
gmx_fatal(FARGS,"Unknown mode %d",mode);
}
index = xnorm*scale;
if (index <= nmax) {
temp = top->atoms.atom[i].m*iprod(fr.v[i],fr.v[i])/(2*BOLTZ);
if (temp > hi)
hi = temp;
npts[index]++;
profile[nframe-1][index] += temp;
}
}
for(i=0; (i<=nmax); i++) {
if (npts[i] != 0)
profile[nframe-1][i] /= npts[i];
npts[i] = 0;
}
} while (read_next_frame(status,&fr));
close_trx(status);
fp = ftp2FILE(efXPM,NFILE,fnm,"w");
write_xpm(fp,0,"Temp. profile","T (a.u.)",
"t (fs)","R (nm)",
nframe,nmax+1,t_x,t_y,profile,0,tmax,
rgblo,rgbhi,&nlevels);
gmx_thanx(stderr);
return 0;
}
static void inprod_matrix(const char *matfile,int natoms,
int nvec1,int *eignr1,rvec **eigvec1,
int nvec2,int *eignr2,rvec **eigvec2,
gmx_bool bSelect,int noutvec,int *outvec)
{
FILE *out;
real **mat;
int i,x1,y1,x,y,nlevels;
int nx,ny;
real inp,*t_x,*t_y,max;
t_rgb rlo,rhi;
snew(t_y,nvec2);
if (bSelect) {
nx = noutvec;
ny = 0;
for(y1=0; y1<nx; y1++)
if (outvec[y1] < nvec2) {
t_y[ny] = eignr2[outvec[y1]]+1;
ny++;
}
} else {
nx = nvec1;
ny = nvec2;
for(y=0; y<ny; y++)
t_y[y] = eignr2[y]+1;
}
fprintf(stderr,"Calculating inner-product matrix of %dx%d eigenvectors\n",
nx,nvec2);
snew(mat,nx);
snew(t_x,nx);
max = 0;
for(x1=0; x1<nx; x1++) {
snew(mat[x1],ny);
if (bSelect)
x = outvec[x1];
else
x = x1;
t_x[x1] = eignr1[x]+1;
fprintf(stderr," %d",eignr1[x]+1);
for(y1=0; y1<ny; y1++) {
inp = 0;
if (bSelect) {
while (outvec[y1] >= nvec2)
y1++;
y= outvec[y1];
} else
y = y1;
for(i=0; i<natoms; i++)
inp += iprod(eigvec1[x][i],eigvec2[y][i]);
mat[x1][y1] = fabs(inp);
if (mat[x1][y1]>max)
max = mat[x1][y1];
}
}
fprintf(stderr,"\n");
rlo.r = 1; rlo.g = 1; rlo.b = 1;
rhi.r = 0; rhi.g = 0; rhi.b = 0;
nlevels = 41;
out = ffopen(matfile,"w");
write_xpm(out,0,"Eigenvector inner-products","in.prod.","run 1","run 2",
nx,ny,t_x,t_y,mat,0.0,max,rlo,rhi,&nlevels);
ffclose(out);
}
void write_combined_matrix(int ecombine, char *fn,
int nmat, t_matrix *mat1, t_matrix *mat2,
real *cmin,real *cmax)
{
int i, j, k, nlevels;
t_mapping *map=NULL;
FILE *out;
real **rmat1, **rmat2;
real rhi, rlo;
out = ffopen(fn, "w");
for(k=0; k<nmat; k++) {
if ( mat2[k].nx!=mat1[k].nx || mat2[k].ny!=mat1[k].ny )
gmx_fatal(FARGS,"Size of frame %d in 1st (%dx%d) and 2nd matrix (%dx%d) do"
" not match.\n",k,mat1[k].nx,mat1[k].ny,mat2[k].nx,mat2[k].ny);
printf("Combining two %dx%d matrices\n",mat1[k].nx,mat1[k].ny);
rmat1 = matrix2real(&mat1[k], NULL);
rmat2 = matrix2real(&mat2[k], NULL);
rlo=1e38;
rhi=-1e38;
for(j=0; j<mat1[k].ny; j++)
for(i=0; i<mat1[k].nx; i++) {
switch (ecombine) {
case ecAdd: rmat1[i][j] += rmat2[i][j]; break;
case ecSub: rmat1[i][j] -= rmat2[i][j]; break;
case ecMult: rmat1[i][j] *= rmat2[i][j]; break;
case ecDiv: rmat1[i][j] /= rmat2[i][j]; break;
default:
gmx_fatal(FARGS,"No such combination rule %d for matrices",ecombine);
}
rlo = min(rlo, rmat1[i][j]);
rhi = max(rhi, rmat1[i][j]);
}
if (cmin)
rlo = *cmin;
if (cmax)
rhi = *cmax;
nlevels = max(mat1[k].nmap,mat2[k].nmap);
if (rhi==rlo)
fprintf(stderr,
"combination results in uniform matrix (%g), no output\n",rhi);
/*
else if (rlo>=0 || rhi<=0)
write_xpm(out, mat1[k].flags, mat1[k].title, mat1[k].legend,
mat1[k].label_x, mat1[k].label_y,
mat1[k].nx, mat1[k].ny, mat1[k].axis_x, mat1[k].axis_y,
rmat1, rlo, rhi, rhi<=0?red:white, rhi<=0?white:blue,
&nlevels);
else
write_xpm3(out, mat2[k].flags, mat1[k].title, mat1[k].legend,
mat1[k].label_x, mat1[k].label_y,
mat1[k].nx, mat1[k].ny, mat1[k].axis_x, mat1[k].axis_y,
rmat1, rlo, 0, rhi, red, white, blue, &nlevels);
*/
else
write_xpm(out, mat1[k].flags, mat1[k].title, mat1[k].legend,
mat1[k].label_x, mat1[k].label_y,
mat1[k].nx, mat1[k].ny, mat1[k].axis_x, mat1[k].axis_y,
rmat1, rlo, rhi, white, black, &nlevels);
}
fclose(out);
}
int gmx_rms(int argc, char *argv[])
{
const char *desc[] =
{
"[THISMODULE] compares two structures by computing the root mean square",
"deviation (RMSD), the size-independent [GRK]rho[grk] similarity parameter",
"([TT]rho[tt]) or the scaled [GRK]rho[grk] ([TT]rhosc[tt]), ",
"see Maiorov & Crippen, Proteins [BB]22[bb], 273 (1995).",
"This is selected by [TT]-what[tt].[PAR]"
"Each structure from a trajectory ([TT]-f[tt]) is compared to a",
"reference structure. The reference structure",
"is taken from the structure file ([TT]-s[tt]).[PAR]",
"With option [TT]-mir[tt] also a comparison with the mirror image of",
"the reference structure is calculated.",
"This is useful as a reference for 'significant' values, see",
"Maiorov & Crippen, Proteins [BB]22[bb], 273 (1995).[PAR]",
"Option [TT]-prev[tt] produces the comparison with a previous frame",
"the specified number of frames ago.[PAR]",
"Option [TT]-m[tt] produces a matrix in [TT].xpm[tt] format of",
"comparison values of each structure in the trajectory with respect to",
"each other structure. This file can be visualized with for instance",
"[TT]xv[tt] and can be converted to postscript with [gmx-xpm2ps].[PAR]",
"Option [TT]-fit[tt] controls the least-squares fitting of",
"the structures on top of each other: complete fit (rotation and",
"translation), translation only, or no fitting at all.[PAR]",
"Option [TT]-mw[tt] controls whether mass weighting is done or not.",
"If you select the option (default) and ",
"supply a valid [TT].tpr[tt] file masses will be taken from there, ",
"otherwise the masses will be deduced from the [TT]atommass.dat[tt] file in",
"[TT]GMXLIB[tt]. This is fine for proteins, but not",
"necessarily for other molecules. A default mass of 12.011 amu (carbon)",
"is assigned to unknown atoms. You can check whether this happend by",
"turning on the [TT]-debug[tt] flag and inspecting the log file.[PAR]",
"With [TT]-f2[tt], the 'other structures' are taken from a second",
"trajectory, this generates a comparison matrix of one trajectory",
"versus the other.[PAR]",
"Option [TT]-bin[tt] does a binary dump of the comparison matrix.[PAR]",
"Option [TT]-bm[tt] produces a matrix of average bond angle deviations",
"analogously to the [TT]-m[tt] option. Only bonds between atoms in the",
"comparison group are considered."
};
static gmx_bool bPBC = TRUE, bFitAll = TRUE, bSplit = FALSE;
static gmx_bool bDeltaLog = FALSE;
static int prev = 0, freq = 1, freq2 = 1, nlevels = 80, avl = 0;
static real rmsd_user_max = -1, rmsd_user_min = -1, bond_user_max = -1,
bond_user_min = -1, delta_maxy = 0.0;
/* strings and things for selecting difference method */
enum
{
ewSel, ewRMSD, ewRho, ewRhoSc, ewNR
};
int ewhat;
const char *what[ewNR + 1] =
{ NULL, "rmsd", "rho", "rhosc", NULL };
const char *whatname[ewNR] =
{ NULL, "RMSD", "Rho", "Rho sc" };
const char *whatlabel[ewNR] =
{ NULL, "RMSD (nm)", "Rho", "Rho sc" };
const char *whatxvgname[ewNR] =
{ NULL, "RMSD", "\\8r\\4", "\\8r\\4\\ssc\\N" };
const char *whatxvglabel[ewNR] =
{ NULL, "RMSD (nm)", "\\8r\\4", "\\8r\\4\\ssc\\N" };
/* strings and things for fitting methods */
enum
{
efSel, efFit, efReset, efNone, efNR
};
int efit;
const char *fit[efNR + 1] =
{ NULL, "rot+trans", "translation", "none", NULL };
const char *fitgraphlabel[efNR + 1] =
{ NULL, "lsq fit", "translational fit", "no fit" };
static int nrms = 1;
static gmx_bool bMassWeighted = TRUE;
t_pargs pa[] =
{
{ "-what", FALSE, etENUM,
{ what }, "Structural difference measure" },
{ "-pbc", FALSE, etBOOL,
{ &bPBC }, "PBC check" },
{ "-fit", FALSE, etENUM,
{ fit }, "Fit to reference structure" },
{ "-prev", FALSE, etINT,
{ &prev }, "Compare with previous frame" },
{ "-split", FALSE, etBOOL,
{ &bSplit }, "Split graph where time is zero" },
{ "-fitall", FALSE, etBOOL,
{ &bFitAll }, "HIDDENFit all pairs of structures in matrix" },
{ "-skip", FALSE, etINT,
{ &freq }, "Only write every nr-th frame to matrix" },
{ "-skip2", FALSE, etINT,
{ &freq2 }, "Only write every nr-th frame to matrix" },
{ "-max", FALSE, etREAL,
{ &rmsd_user_max }, "Maximum level in comparison matrix" },
{ "-min", FALSE, etREAL,
{ &rmsd_user_min }, "Minimum level in comparison matrix" },
{ "-bmax", FALSE, etREAL,
{ &bond_user_max }, "Maximum level in bond angle matrix" },
{ "-bmin", FALSE, etREAL,
{ &bond_user_min }, "Minimum level in bond angle matrix" },
{ "-mw", FALSE, etBOOL,
{ &bMassWeighted }, "Use mass weighting for superposition" },
{ "-nlevels", FALSE, etINT,
{ &nlevels }, "Number of levels in the matrices" },
{ "-ng", FALSE, etINT,
{ &nrms }, "Number of groups to compute RMS between" },
{ "-dlog", FALSE, etBOOL,
{ &bDeltaLog },
"HIDDENUse a log x-axis in the delta t matrix" },
{ "-dmax", FALSE, etREAL,
{ &delta_maxy }, "HIDDENMaximum level in delta matrix" },
{ "-aver", FALSE, etINT,
{ &avl },
"HIDDENAverage over this distance in the RMSD matrix" }
};
int natoms_trx, natoms_trx2, natoms;
int i, j, k, m, teller, teller2, tel_mat, tel_mat2;
#define NFRAME 5000
int maxframe = NFRAME, maxframe2 = NFRAME;
real t, *w_rls, *w_rms, *w_rls_m = NULL, *w_rms_m = NULL;
gmx_bool bNorm, bAv, bFreq2, bFile2, bMat, bBond, bDelta, bMirror, bMass;
gmx_bool bFit, bReset;
t_topology top;
int ePBC;
t_iatom *iatom = NULL;
matrix box;
rvec *x, *xp, *xm = NULL, **mat_x = NULL, **mat_x2, *mat_x2_j = NULL, vec1,
vec2;
t_trxstatus *status;
char buf[256], buf2[256];
int ncons = 0;
FILE *fp;
real rlstot = 0, **rls, **rlsm = NULL, *time, *time2, *rlsnorm = NULL,
**rmsd_mat = NULL, **bond_mat = NULL, *axis, *axis2, *del_xaxis,
*del_yaxis, rmsd_max, rmsd_min, rmsd_avg, bond_max, bond_min, ang;
real **rmsdav_mat = NULL, av_tot, weight, weight_tot;
real **delta = NULL, delta_max, delta_scalex = 0, delta_scaley = 0,
*delta_tot;
int delta_xsize = 0, del_lev = 100, mx, my, abs_my;
gmx_bool bA1, bA2, bPrev, bTop, *bInMat = NULL;
int ifit, *irms, ibond = 0, *ind_bond1 = NULL, *ind_bond2 = NULL, n_ind_m =
0;
atom_id *ind_fit, **ind_rms, *ind_m = NULL, *rev_ind_m = NULL, *ind_rms_m =
NULL;
char *gn_fit, **gn_rms;
t_rgb rlo, rhi;
output_env_t oenv;
gmx_rmpbc_t gpbc = NULL;
t_filenm fnm[] =
{
{ efTPS, NULL, NULL, ffREAD },
{ efTRX, "-f", NULL, ffREAD },
{ efTRX, "-f2", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "rmsd", ffWRITE },
{ efXVG, "-mir", "rmsdmir", ffOPTWR },
{ efXVG, "-a", "avgrp", ffOPTWR },
{ efXVG, "-dist", "rmsd-dist", ffOPTWR },
{ efXPM, "-m", "rmsd", ffOPTWR },
{ efDAT, "-bin", "rmsd", ffOPTWR },
{ efXPM, "-bm", "bond", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_TIME_UNIT | PCA_CAN_VIEW
| PCA_BE_NICE, NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL,
&oenv))
{
return 0;
}
/* parse enumerated options: */
ewhat = nenum(what);
if (ewhat == ewRho || ewhat == ewRhoSc)
{
please_cite(stdout, "Maiorov95");
}
efit = nenum(fit);
bFit = efit == efFit;
bReset = efit == efReset;
if (bFit)
{
bReset = TRUE; /* for fit, reset *must* be set */
}
else
{
bFitAll = FALSE;
}
/* mark active cmdline options */
bMirror = opt2bSet("-mir", NFILE, fnm); /* calc RMSD vs mirror of ref. */
bFile2 = opt2bSet("-f2", NFILE, fnm);
bMat = opt2bSet("-m", NFILE, fnm);
bBond = opt2bSet("-bm", NFILE, fnm);
bDelta = (delta_maxy > 0); /* calculate rmsd vs delta t matrix from *
* your RMSD matrix (hidden option */
bNorm = opt2bSet("-a", NFILE, fnm);
bFreq2 = opt2parg_bSet("-skip2", asize(pa), pa);
if (freq <= 0)
{
fprintf(stderr, "The number of frames to skip is <= 0. "
"Writing out all frames.\n\n");
freq = 1;
}
if (!bFreq2)
{
freq2 = freq;
}
else if (bFile2 && freq2 <= 0)
{
fprintf(stderr,
"The number of frames to skip in second trajectory is <= 0.\n"
" Writing out all frames.\n\n");
freq2 = 1;
}
bPrev = (prev > 0);
if (bPrev)
{
prev = abs(prev);
if (freq != 1)
{
fprintf(stderr, "WARNING: option -skip also applies to -prev\n");
}
}
if (bFile2 && !bMat && !bBond)
{
fprintf(
stderr,
"WARNING: second trajectory (-f2) useless when not calculating matrix (-m/-bm),\n"
" will not read from %s\n", opt2fn("-f2", NFILE,
fnm));
bFile2 = FALSE;
}
if (bDelta)
{
bMat = TRUE;
if (bFile2)
{
fprintf(stderr,
"WARNING: second trajectory (-f2) useless when making delta matrix,\n"
" will not read from %s\n", opt2fn("-f2",
NFILE, fnm));
bFile2 = FALSE;
}
}
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm), buf, &top, &ePBC, &xp,
NULL, box, TRUE);
snew(w_rls, top.atoms.nr);
snew(w_rms, top.atoms.nr);
if (!bTop && bBond)
{
fprintf(stderr,
"WARNING: Need a run input file for bond angle matrix,\n"
" will not calculate bond angle matrix.\n");
bBond = FALSE;
}
if (bReset)
{
fprintf(stderr, "Select group for %s fit\n", bFit ? "least squares"
: "translational");
get_index(&(top.atoms), ftp2fn_null(efNDX, NFILE, fnm), 1, &ifit,
&ind_fit, &gn_fit);
}
else
{
ifit = 0;
}
if (bReset)
{
if (bFit && ifit < 3)
{
gmx_fatal(FARGS, "Need >= 3 points to fit!\n" );
}
bMass = FALSE;
for (i = 0; i < ifit; i++)
{
if (bMassWeighted)
{
w_rls[ind_fit[i]] = top.atoms.atom[ind_fit[i]].m;
}
else
{
w_rls[ind_fit[i]] = 1;
}
bMass = bMass || (top.atoms.atom[ind_fit[i]].m != 0);
}
if (!bMass)
{
fprintf(stderr, "All masses in the fit group are 0, using masses of 1\n");
for (i = 0; i < ifit; i++)
{
w_rls[ind_fit[i]] = 1;
}
}
}
if (bMat || bBond)
{
nrms = 1;
}
snew(gn_rms, nrms);
snew(ind_rms, nrms);
snew(irms, nrms);
fprintf(stderr, "Select group%s for %s calculation\n",
(nrms > 1) ? "s" : "", whatname[ewhat]);
get_index(&(top.atoms), ftp2fn_null(efNDX, NFILE, fnm),
nrms, irms, ind_rms, gn_rms);
if (bNorm)
{
snew(rlsnorm, irms[0]);
}
snew(rls, nrms);
for (j = 0; j < nrms; j++)
{
snew(rls[j], maxframe);
}
if (bMirror)
{
snew(rlsm, nrms);
for (j = 0; j < nrms; j++)
{
snew(rlsm[j], maxframe);
}
}
snew(time, maxframe);
for (j = 0; j < nrms; j++)
{
bMass = FALSE;
for (i = 0; i < irms[j]; i++)
{
if (bMassWeighted)
{
w_rms[ind_rms[j][i]] = top.atoms.atom[ind_rms[j][i]].m;
}
else
{
w_rms[ind_rms[j][i]] = 1.0;
}
bMass = bMass || (top.atoms.atom[ind_rms[j][i]].m != 0);
}
if (!bMass)
{
fprintf(stderr, "All masses in group %d are 0, using masses of 1\n", j);
for (i = 0; i < irms[j]; i++)
{
w_rms[ind_rms[j][i]] = 1;
}
}
}
/* Prepare reference frame */
if (bPBC)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr);
gmx_rmpbc(gpbc, top.atoms.nr, box, xp);
}
if (bReset)
{
reset_x(ifit, ind_fit, top.atoms.nr, NULL, xp, w_rls);
}
if (bMirror)
{
/* generate reference structure mirror image: */
snew(xm, top.atoms.nr);
for (i = 0; i < top.atoms.nr; i++)
{
copy_rvec(xp[i], xm[i]);
xm[i][XX] = -xm[i][XX];
}
}
if (ewhat == ewRhoSc)
{
norm_princ(&top.atoms, ifit, ind_fit, top.atoms.nr, xp);
}
/* read first frame */
natoms_trx = read_first_x(oenv, &status, opt2fn("-f", NFILE, fnm), &t, &x, box);
if (natoms_trx != top.atoms.nr)
{
fprintf(stderr,
"\nWARNING: topology has %d atoms, whereas trajectory has %d\n",
top.atoms.nr, natoms_trx);
}
natoms = min(top.atoms.nr, natoms_trx);
if (bMat || bBond || bPrev)
{
snew(mat_x, NFRAME);
if (bPrev)
{
/* With -prev we use all atoms for simplicity */
n_ind_m = natoms;
}
else
{
/* Check which atoms we need (fit/rms) */
snew(bInMat, natoms);
for (i = 0; i < ifit; i++)
{
bInMat[ind_fit[i]] = TRUE;
}
n_ind_m = ifit;
for (i = 0; i < irms[0]; i++)
{
if (!bInMat[ind_rms[0][i]])
{
bInMat[ind_rms[0][i]] = TRUE;
n_ind_m++;
}
}
}
/* Make an index of needed atoms */
snew(ind_m, n_ind_m);
snew(rev_ind_m, natoms);
j = 0;
for (i = 0; i < natoms; i++)
{
if (bPrev || bInMat[i])
{
ind_m[j] = i;
rev_ind_m[i] = j;
j++;
}
}
snew(w_rls_m, n_ind_m);
snew(ind_rms_m, irms[0]);
snew(w_rms_m, n_ind_m);
for (i = 0; i < ifit; i++)
{
w_rls_m[rev_ind_m[ind_fit[i]]] = w_rls[ind_fit[i]];
}
for (i = 0; i < irms[0]; i++)
{
ind_rms_m[i] = rev_ind_m[ind_rms[0][i]];
w_rms_m[ind_rms_m[i]] = w_rms[ind_rms[0][i]];
}
sfree(bInMat);
}
if (bBond)
{
ncons = 0;
for (k = 0; k < F_NRE; k++)
{
if (IS_CHEMBOND(k))
{
iatom = top.idef.il[k].iatoms;
ncons += top.idef.il[k].nr/3;
}
}
fprintf(stderr, "Found %d bonds in topology\n", ncons);
snew(ind_bond1, ncons);
snew(ind_bond2, ncons);
ibond = 0;
for (k = 0; k < F_NRE; k++)
{
if (IS_CHEMBOND(k))
{
iatom = top.idef.il[k].iatoms;
ncons = top.idef.il[k].nr/3;
for (i = 0; i < ncons; i++)
{
bA1 = FALSE;
bA2 = FALSE;
for (j = 0; j < irms[0]; j++)
{
if (iatom[3*i+1] == ind_rms[0][j])
{
bA1 = TRUE;
}
if (iatom[3*i+2] == ind_rms[0][j])
{
bA2 = TRUE;
}
}
if (bA1 && bA2)
{
ind_bond1[ibond] = rev_ind_m[iatom[3*i+1]];
ind_bond2[ibond] = rev_ind_m[iatom[3*i+2]];
ibond++;
}
}
}
}
fprintf(stderr, "Using %d bonds for bond angle matrix\n", ibond);
if (ibond == 0)
{
gmx_fatal(FARGS, "0 bonds found");
}
}
/* start looping over frames: */
tel_mat = 0;
teller = 0;
do
{
if (bPBC)
{
gmx_rmpbc(gpbc, natoms, box, x);
}
if (bReset)
{
reset_x(ifit, ind_fit, natoms, NULL, x, w_rls);
}
if (ewhat == ewRhoSc)
{
norm_princ(&top.atoms, ifit, ind_fit, natoms, x);
}
if (bFit)
{
/*do the least squares fit to original structure*/
do_fit(natoms, w_rls, xp, x);
}
if (teller % freq == 0)
{
/* keep frame for matrix calculation */
if (bMat || bBond || bPrev)
{
if (tel_mat >= NFRAME)
{
srenew(mat_x, tel_mat+1);
}
snew(mat_x[tel_mat], n_ind_m);
for (i = 0; i < n_ind_m; i++)
{
copy_rvec(x[ind_m[i]], mat_x[tel_mat][i]);
}
}
tel_mat++;
}
/*calculate energy of root_least_squares*/
if (bPrev)
{
j = tel_mat-prev-1;
if (j < 0)
{
j = 0;
}
for (i = 0; i < n_ind_m; i++)
{
copy_rvec(mat_x[j][i], xp[ind_m[i]]);
}
if (bReset)
{
reset_x(ifit, ind_fit, natoms, NULL, xp, w_rls);
}
if (bFit)
{
do_fit(natoms, w_rls, x, xp);
}
}
for (j = 0; (j < nrms); j++)
{
rls[j][teller] =
calc_similar_ind(ewhat != ewRMSD, irms[j], ind_rms[j], w_rms, x, xp);
}
if (bNorm)
{
for (j = 0; (j < irms[0]); j++)
{
rlsnorm[j] +=
calc_similar_ind(ewhat != ewRMSD, 1, &(ind_rms[0][j]), w_rms, x, xp);
}
}
if (bMirror)
{
if (bFit)
{
/*do the least squares fit to mirror of original structure*/
do_fit(natoms, w_rls, xm, x);
}
for (j = 0; j < nrms; j++)
{
rlsm[j][teller] =
calc_similar_ind(ewhat != ewRMSD, irms[j], ind_rms[j], w_rms, x, xm);
}
}
time[teller] = output_env_conv_time(oenv, t);
teller++;
if (teller >= maxframe)
{
maxframe += NFRAME;
srenew(time, maxframe);
for (j = 0; (j < nrms); j++)
{
srenew(rls[j], maxframe);
}
if (bMirror)
{
for (j = 0; (j < nrms); j++)
{
srenew(rlsm[j], maxframe);
}
}
}
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (bFile2)
{
snew(time2, maxframe2);
fprintf(stderr, "\nWill read second trajectory file\n");
snew(mat_x2, NFRAME);
natoms_trx2 =
read_first_x(oenv, &status, opt2fn("-f2", NFILE, fnm), &t, &x, box);
if (natoms_trx2 != natoms_trx)
{
gmx_fatal(FARGS,
"Second trajectory (%d atoms) does not match the first one"
" (%d atoms)", natoms_trx2, natoms_trx);
}
tel_mat2 = 0;
teller2 = 0;
do
{
if (bPBC)
{
gmx_rmpbc(gpbc, natoms, box, x);
}
if (bReset)
{
reset_x(ifit, ind_fit, natoms, NULL, x, w_rls);
}
if (ewhat == ewRhoSc)
{
norm_princ(&top.atoms, ifit, ind_fit, natoms, x);
}
if (bFit)
{
/*do the least squares fit to original structure*/
do_fit(natoms, w_rls, xp, x);
}
if (teller2 % freq2 == 0)
{
/* keep frame for matrix calculation */
if (bMat)
{
if (tel_mat2 >= NFRAME)
{
srenew(mat_x2, tel_mat2+1);
}
snew(mat_x2[tel_mat2], n_ind_m);
for (i = 0; i < n_ind_m; i++)
{
copy_rvec(x[ind_m[i]], mat_x2[tel_mat2][i]);
}
}
tel_mat2++;
}
time2[teller2] = output_env_conv_time(oenv, t);
teller2++;
if (teller2 >= maxframe2)
{
maxframe2 += NFRAME;
srenew(time2, maxframe2);
}
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
}
else
{
mat_x2 = mat_x;
time2 = time;
tel_mat2 = tel_mat;
freq2 = freq;
}
gmx_rmpbc_done(gpbc);
if (bMat || bBond)
{
/* calculate RMS matrix */
fprintf(stderr, "\n");
if (bMat)
{
fprintf(stderr, "Building %s matrix, %dx%d elements\n",
whatname[ewhat], tel_mat, tel_mat2);
snew(rmsd_mat, tel_mat);
}
if (bBond)
{
fprintf(stderr, "Building bond angle matrix, %dx%d elements\n",
tel_mat, tel_mat2);
snew(bond_mat, tel_mat);
}
snew(axis, tel_mat);
snew(axis2, tel_mat2);
rmsd_max = 0;
if (bFile2)
{
rmsd_min = 1e10;
}
else
{
rmsd_min = 0;
}
rmsd_avg = 0;
bond_max = 0;
bond_min = 1e10;
for (j = 0; j < tel_mat2; j++)
{
axis2[j] = time2[freq2*j];
}
if (bDelta)
{
if (bDeltaLog)
{
delta_scalex = 8.0/log(2.0);
delta_xsize = (int)(log(tel_mat/2)*delta_scalex+0.5)+1;
}
else
{
delta_xsize = tel_mat/2;
}
delta_scaley = 1.0/delta_maxy;
snew(delta, delta_xsize);
for (j = 0; j < delta_xsize; j++)
{
snew(delta[j], del_lev+1);
}
if (avl > 0)
{
snew(rmsdav_mat, tel_mat);
for (j = 0; j < tel_mat; j++)
{
snew(rmsdav_mat[j], tel_mat);
}
}
}
if (bFitAll)
{
snew(mat_x2_j, natoms);
}
for (i = 0; i < tel_mat; i++)
{
axis[i] = time[freq*i];
fprintf(stderr, "\r element %5d; time %5.2f ", i, axis[i]);
if (bMat)
{
snew(rmsd_mat[i], tel_mat2);
}
if (bBond)
{
snew(bond_mat[i], tel_mat2);
}
for (j = 0; j < tel_mat2; j++)
{
if (bFitAll)
{
for (k = 0; k < n_ind_m; k++)
{
copy_rvec(mat_x2[j][k], mat_x2_j[k]);
}
do_fit(n_ind_m, w_rls_m, mat_x[i], mat_x2_j);
}
else
{
mat_x2_j = mat_x2[j];
}
if (bMat)
{
if (bFile2 || (i < j))
{
rmsd_mat[i][j] =
calc_similar_ind(ewhat != ewRMSD, irms[0], ind_rms_m,
w_rms_m, mat_x[i], mat_x2_j);
if (rmsd_mat[i][j] > rmsd_max)
{
rmsd_max = rmsd_mat[i][j];
}
if (rmsd_mat[i][j] < rmsd_min)
{
rmsd_min = rmsd_mat[i][j];
}
rmsd_avg += rmsd_mat[i][j];
}
else
{
rmsd_mat[i][j] = rmsd_mat[j][i];
}
}
if (bBond)
{
if (bFile2 || (i <= j))
{
ang = 0.0;
for (m = 0; m < ibond; m++)
{
rvec_sub(mat_x[i][ind_bond1[m]], mat_x[i][ind_bond2[m]], vec1);
rvec_sub(mat_x2_j[ind_bond1[m]], mat_x2_j[ind_bond2[m]], vec2);
ang += acos(cos_angle(vec1, vec2));
}
bond_mat[i][j] = ang*180.0/(M_PI*ibond);
if (bond_mat[i][j] > bond_max)
{
bond_max = bond_mat[i][j];
}
if (bond_mat[i][j] < bond_min)
{
bond_min = bond_mat[i][j];
}
}
else
{
bond_mat[i][j] = bond_mat[j][i];
}
}
}
}
if (bFile2)
{
rmsd_avg /= tel_mat*tel_mat2;
}
else
{
rmsd_avg /= tel_mat*(tel_mat - 1)/2;
}
if (bMat && (avl > 0))
{
rmsd_max = 0.0;
rmsd_min = 0.0;
rmsd_avg = 0.0;
for (j = 0; j < tel_mat-1; j++)
{
for (i = j+1; i < tel_mat; i++)
{
av_tot = 0;
weight_tot = 0;
for (my = -avl; my <= avl; my++)
{
if ((j+my >= 0) && (j+my < tel_mat))
{
abs_my = abs(my);
for (mx = -avl; mx <= avl; mx++)
{
if ((i+mx >= 0) && (i+mx < tel_mat))
{
weight = (real)(avl+1-max(abs(mx), abs_my));
av_tot += weight*rmsd_mat[i+mx][j+my];
weight_tot += weight;
}
}
}
}
rmsdav_mat[i][j] = av_tot/weight_tot;
rmsdav_mat[j][i] = rmsdav_mat[i][j];
if (rmsdav_mat[i][j] > rmsd_max)
{
rmsd_max = rmsdav_mat[i][j];
}
}
}
rmsd_mat = rmsdav_mat;
}
if (bMat)
{
fprintf(stderr, "\n%s: Min %f, Max %f, Avg %f\n",
whatname[ewhat], rmsd_min, rmsd_max, rmsd_avg);
rlo.r = 1; rlo.g = 1; rlo.b = 1;
rhi.r = 0; rhi.g = 0; rhi.b = 0;
if (rmsd_user_max != -1)
{
rmsd_max = rmsd_user_max;
}
if (rmsd_user_min != -1)
{
rmsd_min = rmsd_user_min;
}
if ((rmsd_user_max != -1) || (rmsd_user_min != -1))
{
fprintf(stderr, "Min and Max value set to resp. %f and %f\n",
rmsd_min, rmsd_max);
}
sprintf(buf, "%s %s matrix", gn_rms[0], whatname[ewhat]);
write_xpm(opt2FILE("-m", NFILE, fnm, "w"), 0, buf, whatlabel[ewhat],
output_env_get_time_label(oenv), output_env_get_time_label(oenv), tel_mat, tel_mat2,
axis, axis2, rmsd_mat, rmsd_min, rmsd_max, rlo, rhi, &nlevels);
/* Print the distribution of RMSD values */
if (opt2bSet("-dist", NFILE, fnm))
{
low_rmsd_dist(opt2fn("-dist", NFILE, fnm), rmsd_max, tel_mat, rmsd_mat, oenv);
}
if (bDelta)
{
snew(delta_tot, delta_xsize);
for (j = 0; j < tel_mat-1; j++)
{
for (i = j+1; i < tel_mat; i++)
{
mx = i-j;
if (mx < tel_mat/2)
{
if (bDeltaLog)
{
mx = (int)(log(mx)*delta_scalex+0.5);
}
my = (int)(rmsd_mat[i][j]*delta_scaley*del_lev+0.5);
delta_tot[mx] += 1.0;
if ((rmsd_mat[i][j] >= 0) && (rmsd_mat[i][j] <= delta_maxy))
{
delta[mx][my] += 1.0;
}
}
}
}
delta_max = 0;
for (i = 0; i < delta_xsize; i++)
{
if (delta_tot[i] > 0.0)
{
delta_tot[i] = 1.0/delta_tot[i];
for (j = 0; j <= del_lev; j++)
{
delta[i][j] *= delta_tot[i];
if (delta[i][j] > delta_max)
{
delta_max = delta[i][j];
}
}
}
}
fprintf(stderr, "Maximum in delta matrix: %f\n", delta_max);
snew(del_xaxis, delta_xsize);
snew(del_yaxis, del_lev+1);
for (i = 0; i < delta_xsize; i++)
{
del_xaxis[i] = axis[i]-axis[0];
}
for (i = 0; i < del_lev+1; i++)
{
del_yaxis[i] = delta_maxy*i/del_lev;
}
sprintf(buf, "%s %s vs. delta t", gn_rms[0], whatname[ewhat]);
fp = gmx_ffopen("delta.xpm", "w");
write_xpm(fp, 0, buf, "density", output_env_get_time_label(oenv), whatlabel[ewhat],
delta_xsize, del_lev+1, del_xaxis, del_yaxis,
delta, 0.0, delta_max, rlo, rhi, &nlevels);
gmx_ffclose(fp);
}
if (opt2bSet("-bin", NFILE, fnm))
{
/* NB: File must be binary if we use fwrite */
fp = ftp2FILE(efDAT, NFILE, fnm, "wb");
for (i = 0; i < tel_mat; i++)
{
if (fwrite(rmsd_mat[i], sizeof(**rmsd_mat), tel_mat2, fp) != tel_mat2)
{
gmx_fatal(FARGS, "Error writing to output file");
}
}
gmx_ffclose(fp);
}
}
if (bBond)
{
fprintf(stderr, "\nMin. angle: %f, Max. angle: %f\n", bond_min, bond_max);
if (bond_user_max != -1)
{
bond_max = bond_user_max;
}
if (bond_user_min != -1)
{
bond_min = bond_user_min;
}
if ((bond_user_max != -1) || (bond_user_min != -1))
{
fprintf(stderr, "Bond angle Min and Max set to:\n"
"Min. angle: %f, Max. angle: %f\n", bond_min, bond_max);
}
rlo.r = 1; rlo.g = 1; rlo.b = 1;
rhi.r = 0; rhi.g = 0; rhi.b = 0;
sprintf(buf, "%s av. bond angle deviation", gn_rms[0]);
write_xpm(opt2FILE("-bm", NFILE, fnm, "w"), 0, buf, "degrees",
output_env_get_time_label(oenv), output_env_get_time_label(oenv), tel_mat, tel_mat2,
axis, axis2, bond_mat, bond_min, bond_max, rlo, rhi, &nlevels);
}
}
bAv = opt2bSet("-a", NFILE, fnm);
/* Write the RMSD's to file */
if (!bPrev)
{
sprintf(buf, "%s", whatxvgname[ewhat]);
}
else
{
sprintf(buf, "%s with frame %g %s ago", whatxvgname[ewhat],
time[prev*freq]-time[0], output_env_get_time_label(oenv));
}
fp = xvgropen(opt2fn("-o", NFILE, fnm), buf, output_env_get_xvgr_tlabel(oenv),
whatxvglabel[ewhat], oenv);
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"%s%s after %s%s%s\"\n",
(nrms == 1) ? "" : "of ", gn_rms[0], fitgraphlabel[efit],
bFit ? " to " : "", bFit ? gn_fit : "");
}
if (nrms != 1)
{
xvgr_legend(fp, nrms, (const char**)gn_rms, oenv);
}
for (i = 0; (i < teller); i++)
{
if (bSplit && i > 0 &&
abs(time[bPrev ? freq*i : i]/output_env_get_time_factor(oenv)) < 1e-5)
{
fprintf(fp, "&\n");
}
fprintf(fp, "%12.7f", time[bPrev ? freq*i : i]);
for (j = 0; (j < nrms); j++)
{
fprintf(fp, " %12.7f", rls[j][i]);
if (bAv)
{
rlstot += rls[j][i];
}
}
fprintf(fp, "\n");
}
gmx_ffclose(fp);
if (bMirror)
{
/* Write the mirror RMSD's to file */
sprintf(buf, "%s with Mirror", whatxvgname[ewhat]);
sprintf(buf2, "Mirror %s", whatxvglabel[ewhat]);
fp = xvgropen(opt2fn("-mir", NFILE, fnm), buf, output_env_get_xvgr_tlabel(oenv),
buf2, oenv);
if (nrms == 1)
{
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"of %s after lsq fit to mirror of %s\"\n",
gn_rms[0], gn_fit);
}
}
else
{
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"after lsq fit to mirror %s\"\n", gn_fit);
}
xvgr_legend(fp, nrms, (const char**)gn_rms, oenv);
}
for (i = 0; (i < teller); i++)
{
if (bSplit && i > 0 && abs(time[i]) < 1e-5)
{
fprintf(fp, "&\n");
}
fprintf(fp, "%12.7f", time[i]);
for (j = 0; (j < nrms); j++)
{
fprintf(fp, " %12.7f", rlsm[j][i]);
}
fprintf(fp, "\n");
}
gmx_ffclose(fp);
}
if (bAv)
{
sprintf(buf, "Average %s", whatxvgname[ewhat]);
sprintf(buf2, "Average %s", whatxvglabel[ewhat]);
fp = xvgropen(opt2fn("-a", NFILE, fnm), buf, "Residue", buf2, oenv);
for (j = 0; (j < nrms); j++)
{
fprintf(fp, "%10d %10g\n", j, rlstot/teller);
}
gmx_ffclose(fp);
}
if (bNorm)
{
fp = xvgropen("aver.xvg", gn_rms[0], "Residue", whatxvglabel[ewhat], oenv);
for (j = 0; (j < irms[0]); j++)
{
fprintf(fp, "%10d %10g\n", j, rlsnorm[j]/teller);
}
gmx_ffclose(fp);
}
do_view(oenv, opt2fn_null("-a", NFILE, fnm), "-graphtype bar");
do_view(oenv, opt2fn("-o", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-mir", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-m", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-bm", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-dist", NFILE, fnm), NULL);
return 0;
}
int main(int argc,char *argv[])
{
const char *desc[] = {
"g_zcoord can output the z(t) coordinates of atoms which are located in a "
"cylindrical region. "
"This region is defined by its radius R, the axis, and a point on this axis."
"It takes an index file with atom, ",
"and generates an output file with the ",
"z coordinates for each entry in the index file. Coordinates of particles "
"that are NOT in the cylinder are set to a special value, which is set "
"with the [TT]-nan[TT] option.",
"[PAR]For quicker visualisation the [TT]-mat[tt] option is useful. It creates ",
"an xpm matrix file. The boundaries of the graph in z are taken from "
"z1 and z2; the spacing can be set with the hidden option "
"[TT]-matspacing[TT]. Its default is " xstr(XPM_Z_SPACING) " nm.",
"[PAR]Due to the huge amount of diskspace that the .dat and .xvg file can "
"take up these options have been all made optional. YOU NEED TO SET AT LEAST "
"ONE OF [TT]-dat[TT], [TT]-o[TT], or [TT]-mat[TT] to generate any output."
};
t_cavity cavity = { /* define volume to count mols in */
{0, 0, 1}, /* axis */
{0, 0, 0}, /* cpoint */
-1, /* radius */
-1, /* z1 < z2 */
-1,
0 /* volume - calculate later */
};
real spacing = XPM_Z_SPACING; /* spacing in nm (!) for conversion to xpm */
int ngroups = 1; /* not used yet >1 */
real invalid = 9999.0; /* mark coordinates of particles not in cylinder */
t_pargs pa[] = {
{ "-axis", FALSE, etRVEC, {&(cavity.axis)},
"Vector pointing parallel to the pore axis"},
{ "-cpoint", FALSE, etRVEC, {&(cavity.cpoint)},
"Point on the pore axis"},
{ "-R", FALSE, etREAL, {&(cavity.radius)},
"Radius of the cylindrical pore cavity"},
{ "-z1", FALSE, etREAL, {&(cavity.z1)},
"Confine waters to have a z coordinate larger than z1, and"},
{ "-z2", FALSE, etREAL, {&(cavity.z2)},
"smaller than z2 (in nm). Also the z-boundaries for the xpm matrix."},
{ "-nan", FALSE, etREAL, {&invalid},
"number that is used in output files for coordinates when the particle "
"is not in the cylinder"},
{ "-matspacing", FALSE, etREAL, {&spacing},
"HIDDENz spacing (in nm) for the xpm matrix"},
{ "-ng", FALSE, etINT, {&ngroups},
"HIDDENNumber of groups to consider" },
};
FILE *out = NULL; /* xmgr file with coordinates */
FILE *fData= NULL; /* simple data file: t z */
t_topology top; /* topology */
rvec *xtop;
int ePBC;
char title[STRLEN];
gmx_bool bTop;
rvec *x,*x_s; /* coord, with and without pbc*/
rvec xcm; /* center of mass of molecule */
matrix box; /* box matrix (3x3) */
real t,tm; /* time, total mass molecule */
int natoms; /* number of atoms in system */
t_trxstatus *status;
int i,j; /* loopcounters */
int k_frame; /* counts frames */
const char *indexfn;
char **grpname; /* groupnames for all groups */
int *isize;
atom_id **index; /* molecule numbers in index for each group */
atom_id *atndx = NULL; /* indices from block. */
t_block *mols= NULL; /* all molecules in system */
char *ggrpname; /* name of the FIRST group */
int gnx = 0; /* number of atoms in FIRST group*/
atom_id *gindex = NULL; /* index of FIRST group */
real maxzval = MINZVAL_DEFAULT; /* max z in nm (!) for conversion to xpm */
real minzval = MAXZVAL_DEFAULT; /* min z in nm (!) for conversion to xpm */
int nbins = 0; /* number of bins for conv to xpm */
real **zbins = NULL; /* bins for conversion to xpm */
FILE *xpmOut = NULL; /* xpm matrix file */
t_rgb rlo, rhi; /* low and high colors for matrix */
int nlevels = 2;
int max_frames = XPM_INITIAL_FRAMES;
/* current max number of frames in xpm matrix */
real *x_axis = NULL;/* x-axis labels */
real *y_axis = NULL;/* y-axis labels */
gmx_bool bXPM = FALSE; /* produce XPM matrix ?*/
gmx_bool bXVG = FALSE; /* no output generated by default */
gmx_bool bDAT = FALSE;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efXVG, "-o", "zcoord", ffOPTWR },
{ efXPM, "-mat", "zcoord", ffOPTWR }, /* this is for xpm output */
{ efDAT, "-dat", "zcoord", ffOPTWR },
{ efNDX, NULL, NULL, ffOPTRD }
};
output_env_t oenv;
#define NFILE asize(fnm)
#define NPA asize(pa)
#define NDFILES 2
FILE *dfiles[NDFILES+1]; /* output files to dump data to
terminate with NULL */
const char *bugs[] = {
"Even if the cylinder axis is not (0,0,1), the top and bottom of the cylinder are"
"still determined by the z-coordinates z1 and z2.",
"ATTENTION: no data is generated by default !!!",
"xpm graph: If no proper (i.e. |z| < " xstr(Z_SANITY) "nm) z-limits are "
"given they are set to "
"the arbitrary values z_min=" xstr(MINZVAL_DEFAULT) " and "
"z_max=" xstr(MAXZVAL_DEFAULT),
};
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW,
NFILE,fnm,asize(pa),pa,asize(desc),desc,asize(bugs),bugs,
&oenv);
bDAT = (opt2fn_null("-dat", NFILE, fnm)) ? TRUE : FALSE;
bXVG = (opt2fn_null("-o", NFILE, fnm)) ? TRUE : FALSE;
bXPM = (opt2fn_null("-mat", NFILE, fnm)) ? TRUE : FALSE;
if (! (bXPM || bXVG || bDAT)) {
/* check if this is a pointless run */
msg("No output selected. I stop here.\n");
return (1);
}
bTop = read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xtop,NULL,box,TRUE);
sfree(xtop);
if (!bTop) {
gmx_fatal(FARGS, "Need a run input file");
}
indexfn = ftp2fn_null(efNDX,NFILE,fnm);
if (ngroups != 1) {
gmx_fatal(FARGS, "Sorry, only a single group currently allowed.");
}
snew(grpname,ngroups);
snew(isize,ngroups);
snew(index,ngroups);
get_index(&(top.atoms),indexfn,ngroups,isize,index,grpname);
/* ngroups == 1 at moment */
gnx = isize[0];
gindex = index[0];
ggrpname = grpname[0];
mols = &(top.mols);
atndx = mols->index;
natoms=read_first_x(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
snew(x_s,natoms);
/* look at cavity */
if (cavity.z1 >= cavity.z2) {
gmx_fatal(FARGS, "z-boundaries have worng values: They must be z1 < z2.");
}
/* look at cavity
set defaults from the simulation box size
*/
msg("\n");
autoset_cavity(&cavity,box,NPA,pa);
cavity.vol = sqr(cavity.radius) * PI * (cavity.z2 - cavity.z1); // not needed, just for completeness
if (bXPM) {
/* for xpm output: set limits to z1 and z2 */
/* mild sanity check */
minzval = cavity.z1 < -Z_SANITY ? MINZVAL_DEFAULT : cavity.z1;
maxzval = cavity.z2 > Z_SANITY ? MAXZVAL_DEFAULT : cavity.z2;
/* xpm graphics: initialize bins */
nbins = (int)ceill((maxzval - minzval) / spacing);
snew(zbins,max_frames);
snew(x_axis,max_frames);
msg("Limits for xpm matrix: %g nm < z < %g nm\n", minzval, maxzval);
}
/* initialize dfiles: use it to dump data to different files simultanously */
for (i = 0; i < NDFILES+1; i++) dfiles[i] = NULL;
i = 0; /* use to count how many output files are open */
if (bXVG) {
out = xmgropen(opt2fn("-o",NFILE,fnm),
"z coordinate",
"Coordinate",
"Time (ps)","z (nm)");
dfiles[i++] = out;
}
if (bDAT) {
fData = ffopen (opt2fn("-dat", NFILE, fnm), "w");
dfiles[i++] = fData;
}
k_frame = 0; /*! counts the frames */
do {
dump_data (dfiles, "%10g", t);
if (bXPM) {
// new timeframe
// check if we need more memory
if (k_frame >= max_frames) {
max_frames += XPM_INITIAL_FRAMES;
if (!(srenew(zbins,max_frames)) ||
!(srenew(x_axis,max_frames)) ) {
msg("Out of memory for xpm graph: I abort and try to process what "
"I have got so far (frame = %g).\n", k_frame);
break;
}
}
snew(zbins[k_frame],nbins);
x_axis[k_frame]=t/1000; // in ns
// initialize bins to zero
for (i=0; i<nbins; i++)
zbins[k_frame][i] = 0.0;
}
/* We are not interested in molecules, just in the z-coordinates
of atoms */
for(i=0; i<gnx; i++) {
if ( bInCavity (x[gindex[i]], &cavity) ) { // only look at cylinder
if (bXPM) {
if ( (x[gindex[i]][ZZ] >= minzval) && (x[gindex[i]][ZZ] <= maxzval))
zbins[k_frame][(int)floorl((x[gindex[i]][ZZ] - minzval) / spacing)]=1.0;
}
}
else {
/* particle OUTSIDE cylinder: mark coordinates as 'invalid'
but keep them in the output file */
for(j=0; j<3; j++) {
x[gindex[i]][j] = invalid;
}
}
dump_data (dfiles,"\t%10g", x[gindex[i]][ZZ]);
}
/* some printout for debugging/development - MB
for (i=0; i<nbins; i++)
for (i=0; i<10; i++)
printf("%1d",(int)zbins[k_frame][i]);
printf("\n");
*/
dump_data (dfiles, "\n");
k_frame++;
} while(read_next_x(oenv,status,&t,natoms,x,box));
close_trj(status);
if (bXPM) {
/* colors for matrix */
rlo.r = 1.0, rlo.g = 1.0, rlo.b = 1.0; // no water color
rhi.r = 0.4, rhi.g = 0.4, rhi.b = 1.0; // water color
/* create labels */
snew(y_axis,nbins+1);
for(i=0; i<=nbins; i++) { // n+1 labels with MAT_SPATIAL_Y
y_axis[i]=10 * (minzval + (i * spacing)); // Yes, I WANT Angstroms !!!
}
/* write xpm matrix */
xpmOut = fopen(opt2fn("-mat", NFILE, fnm),"w");
write_xpm(xpmOut,
MAT_SPATIAL_Y,
"g_zcoord matrix", // title
"existence", // label for the continuous legend
"timeframe / ns", // label for the x-axis
"z coordinate / A", // label for the y-axis - where the F**k is the
// bloody Angstrom
k_frame, nbins, // size of the matrix
x_axis, // the x-ticklabels
// would be nice to have the times here
y_axis, // the y-ticklabels
// would be nice to have the zcoordinate label in nm or A
zbins, // element x,y is matrix[x][y]
0.0, // output lower than lo is set to lo
1.0, // output higher than hi is set to hi
rlo, // rgb value for level lo
rhi, // rgb value for level hi
&nlevels); // number of color levels for the output
fclose(xpmOut);
};
/* clean up a bit */
fprintf(stderr,"\n");
if (bDAT) fclose(fData);
if (bXVG) fclose(out);
if (bXPM) {
// free memory from xpm matrix data
for (i=0; i<k_frame; i++)
sfree(zbins[i]);
sfree(zbins);
sfree(x_axis);
}
thanx(stdout);
return 0;
}
static void dump_disre_matrix(const char *fn,t_dr_result *dr,int ndr,
int nsteps,t_idef *idef,gmx_mtop_t *mtop,
real max_dr,int nlevels,gmx_bool bThird)
{
FILE *fp;
int *resnr;
int n_res,a_offset,mb,mol,a;
t_atoms *atoms;
int iii,i,j,nra,nratoms,tp,ri,rj,index,nlabel,label;
atom_id ai,aj,*ptr;
real **matrix,*t_res,hi,*w_dr,rav,rviol;
t_rgb rlo = { 1, 1, 1 };
t_rgb rhi = { 0, 0, 0 };
if (fn == NULL)
return;
snew(resnr,mtop->natoms);
n_res = 0;
a_offset = 0;
for(mb=0; mb<mtop->nmolblock; mb++) {
atoms = &mtop->moltype[mtop->molblock[mb].type].atoms;
for(mol=0; mol<mtop->molblock[mb].nmol; mol++) {
for(a=0; a<atoms->nr; a++) {
resnr[a_offset+a] = n_res + atoms->atom[a].resind;
}
n_res += atoms->nres;
a_offset += atoms->nr;
}
}
snew(t_res,n_res);
for(i=0; (i<n_res); i++)
t_res[i] = i+1;
snew(matrix,n_res);
for(i=0; (i<n_res); i++)
snew(matrix[i],n_res);
nratoms = interaction_function[F_DISRES].nratoms;
nra = (idef->il[F_DISRES].nr/(nratoms+1));
snew(ptr,nra+1);
index = 0;
nlabel = 0;
ptr[0] = 0;
snew(w_dr,ndr);
for(i=0; (i<idef->il[F_DISRES].nr); i+=nratoms+1) {
tp = idef->il[F_DISRES].iatoms[i];
label = idef->iparams[tp].disres.label;
if (label != index) {
/* Set index pointer */
ptr[index+1] = i;
if (nlabel <= 0)
gmx_fatal(FARGS,"nlabel is %d, label = %d",nlabel,label);
if (index >= ndr)
gmx_fatal(FARGS,"ndr = %d, index = %d",ndr,index);
/* Update the weight */
w_dr[index] = 1.0/nlabel;
index = label;
nlabel = 1;
}
else {
nlabel++;
}
}
printf("nlabel = %d, index = %d, ndr = %d\n",nlabel,index,ndr);
hi = 0;
for(i=0; (i<ndr); i++) {
for(j=ptr[i]; (j<ptr[i+1]); j+=nratoms+1) {
tp = idef->il[F_DISRES].iatoms[j];
ai = idef->il[F_DISRES].iatoms[j+1];
aj = idef->il[F_DISRES].iatoms[j+2];
ri = resnr[ai];
rj = resnr[aj];
if (bThird)
rav = pow(dr->aver_3[i]/nsteps,-1.0/3.0);
else
rav = dr->aver1[i]/nsteps;
if (debug)
fprintf(debug,"DR %d, atoms %d, %d, distance %g\n",i,ai,aj,rav);
rviol = max(0,rav-idef->iparams[tp].disres.up1);
matrix[ri][rj] += w_dr[i]*rviol;
matrix[rj][ri] += w_dr[i]*rviol;
hi = max(hi,matrix[ri][rj]);
hi = max(hi,matrix[rj][ri]);
}
}
sfree(resnr);
if (max_dr > 0) {
if (hi > max_dr)
printf("Warning: the maxdr that you have specified (%g) is smaller than\nthe largest value in your simulation (%g)\n",max_dr,hi);
hi = max_dr;
}
printf("Highest level in the matrix will be %g\n",hi);
fp = ffopen(fn,"w");
write_xpm(fp,0,"Distance Violations","<V> (nm)","Residue","Residue",
n_res,n_res,t_res,t_res,matrix,0,hi,rlo,rhi,&nlevels);
ffclose(fp);
}
void write_combined_matrix(int ecombine, const char *fn,
int nmat, t_matrix *mat1, t_matrix *mat2,
real *cmin, real *cmax)
{
int i, j, k, nlevels;
t_mapping *map = NULL;
FILE *out;
real **rmat1, **rmat2;
real rhi, rlo;
out = ffopen(fn, "w");
for (k = 0; k < nmat; k++)
{
if (mat2[k].nx != mat1[k].nx || mat2[k].ny != mat1[k].ny)
{
gmx_fatal(FARGS, "Size of frame %d in 1st (%dx%d) and 2nd matrix (%dx%d) do"
" not match.\n", k, mat1[k].nx, mat1[k].ny, mat2[k].nx, mat2[k].ny);
}
printf("Combining two %dx%d matrices\n", mat1[k].nx, mat1[k].ny);
rmat1 = matrix2real(&mat1[k], NULL);
rmat2 = matrix2real(&mat2[k], NULL);
if (NULL == rmat1 || NULL == rmat2)
{
gmx_fatal(FARGS, "Could not extract real data from %s xpm matrices. Note that, e.g.,\n"
"g_rms and g_mdmat provide such data, but not do_dssp.\n",
(NULL == rmat1 && NULL == rmat2) ? "both" : "one of the" );
}
rlo = 1e38;
rhi = -1e38;
for (j = 0; j < mat1[k].ny; j++)
{
for (i = 0; i < mat1[k].nx; i++)
{
switch (ecombine)
{
case ecAdd: rmat1[i][j] += rmat2[i][j]; break;
case ecSub: rmat1[i][j] -= rmat2[i][j]; break;
case ecMult: rmat1[i][j] *= rmat2[i][j]; break;
case ecDiv: rmat1[i][j] /= rmat2[i][j]; break;
default:
gmx_fatal(FARGS, "No such combination rule %d for matrices", ecombine);
}
rlo = min(rlo, rmat1[i][j]);
rhi = max(rhi, rmat1[i][j]);
}
}
if (cmin)
{
rlo = *cmin;
}
if (cmax)
{
rhi = *cmax;
}
nlevels = max(mat1[k].nmap, mat2[k].nmap);
if (rhi == rlo)
{
fprintf(stderr,
"combination results in uniform matrix (%g), no output\n", rhi);
}
/*
else if (rlo>=0 || rhi<=0)
write_xpm(out, mat1[k].flags, mat1[k].title, mat1[k].legend,
mat1[k].label_x, mat1[k].label_y,
mat1[k].nx, mat1[k].ny, mat1[k].axis_x, mat1[k].axis_y,
rmat1, rlo, rhi, rhi<=0?red:white, rhi<=0?white:blue,
&nlevels);
else
write_xpm3(out, mat2[k].flags, mat1[k].title, mat1[k].legend,
mat1[k].label_x, mat1[k].label_y,
mat1[k].nx, mat1[k].ny, mat1[k].axis_x, mat1[k].axis_y,
rmat1, rlo, 0, rhi, red, white, blue, &nlevels);
*/
else
{
write_xpm(out, mat1[k].flags, mat1[k].title, mat1[k].legend,
mat1[k].label_x, mat1[k].label_y,
mat1[k].nx, mat1[k].ny, mat1[k].axis_x, mat1[k].axis_y,
rmat1, rlo, rhi, white, black, &nlevels);
}
}
ffclose(out);
}
int main(int argc,char *argv[])
{
const char *desc[] = {
"sas2mat converts matrix data in [IT]raw[it] format to X PixMap format,",
"which can be digested by xpm2ps to make nice plots.",
"These [IT]raw[it] data may be generated by g_rms, do_dssp or your",
"own program.[PAR]",
"The program prompts the user for some parameters:[PAR]",
"[TT]Enter nres, res0, nframes, dt, t0, nlevels:[tt][PAR]",
"In this context nres is the number of residues, res0 the starting residue",
"dt is the time step, t0 is the starting time, nlevels is the number",
"of levels for coloring. By default a greyscale colormap is generated."
};
static bool bCol=FALSE;
static char *title="Area (nm^2)";
static real ssmin=-1,ssmax=-1,t0=0,dt=1;
static int nres=1,nframes=1,r0=0,nlevels=20,nskip=0;
t_pargs pa[] = {
{ "-col", FALSE, etBOOL, &bCol,
"The user is prompted for rgb lower and upper values" },
{ "-min", FALSE, etREAL, &ssmin,
"Lower values for the data, calculated from the data by default" },
{ "-max", FALSE, etREAL, &ssmax,
"Upper values for the data, see above" },
{ "-title", FALSE, etSTR, &title,
"Title for the graph" },
{ "-nlevel", FALSE, etINT, &nlevels,
"Number of levels in graph" },
{ "-nres", FALSE, etINT, &nres,
"Number of residues (Y-axis)" },
{ "-nframes", FALSE, etINT, &nframes,
"Number of frames (Y-axis)" },
{ "-res0", FALSE, etINT, &r0,
"Number of first residue" },
{ "-nskip", FALSE, etINT, &nskip,
"Number of frames to skip after every frame" },
{ "-dt", FALSE, etREAL, &dt,
"Time between time frames" },
{ "-t0", FALSE, etREAL, &t0,
"Time of first time frame" }
};
FILE *in,*out;
int i,j,k,ihi;
double s;
real **ss,lo,hi,s1min,s1max;
real *resnr,*t;
bool bCheck=TRUE;
t_rgb rlo,rhi;
t_filenm fnm[] = {
{ efOUT, "-f", "area", ffREAD },
{ efXPM, "-o", "sas", ffWRITE }
};
#define NFILE asize(fnm)
/* If we want to read all frames nskip must be greater than zero */
nskip += 1;
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_BE_NICE,NFILE,fnm,asize(pa),pa,asize(desc),desc,
0,NULL);
snew(ss,nres);
snew(resnr,nres);
snew(t,nframes);
for(i=0; (i<nframes); i++)
t[i]=t0+i*dt;
for(i=0; (i<nres); i++) {
snew(ss[i],nframes);
}
in=ftp2FILE(efOUT,NFILE,fnm,"r");
for(i=k=0; (i<nframes); i++) {
for(j=0; (j<nres); j++) {
fscanf(in,"%lf",&s);
ss[j][k]=s;
}
if (!nskip || ((i % nskip) == 0))
k++;
}
fclose(in);
nframes=k;
lo=10000;
hi=0;
for(j=0; (j<nres); j++) {
/* Find lowest SAS value and subtract that from all occurrences */
s1min=10000;
s1max=0;
for(i=0; (i<nframes); i++) {
s1min=min(s1min,ss[j][i]);
s1max=max(s1max,ss[j][i]);
}
printf("res %d: ssmin=%g, ssmax=%g, diff=%g\n",j,s1min,s1max,s1max-s1min);
hi=max(hi,s1max);
lo=min(lo,s1min);
}
printf("Lowest and Highest SAS value: %g %g\n",lo,hi);
if (ssmin == -1)
ssmin=lo;
if (ssmax == -1)
ssmax=hi;
/*
hi=ssmax-ssmin;
for(j=0; (j<nres); j++) {
for(i=0; (i<nframes); i++)
ss[j][i]-=ssmin;
}
*/
/* ihi=hi; */
rhi.r=0,rhi.g=0,rhi.b=0;
rlo.r=1,rlo.g=1,rlo.b=1;
if (bCol) {
printf("Color entries:\n""drlo glo blo rhi ghi bhi\n");
scanf("%f%f%f%f%f%f",&rlo.r,&rlo.g,&rlo.b,&rhi.r,&rhi.g,&rhi.b);
}
/*
write_mapfile(ftp2fn(efMAP,NFILE,fnm),&nlevels,rlo,rhi,ssmin,ssmax);
*/
for(i=0;i<nres;i++)
resnr[i]=i+1;
out=ftp2FILE(efXPM,NFILE,fnm,"w");
/*
write_matrix(out,nres,nframes,resnr,t,ss,NULL,title,0,hi,nlevels);
*/
write_xpm(out,0,"????","????","Time (ps)","Residue",
nres,nframes,resnr,t,ss,ssmin,ssmax,rlo,rhi,&nlevels);
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 do_sham(const char *fn, const char *ndx,
const char *xpmP, const char *xpm, const char *xpm2,
const char *xpm3, const char *pdb,
const char *logf,
int n, int neig, real **eig,
gmx_bool bGE, int nenerT, real **enerT,
real Tref,
real pmax, real gmax,
real *emin, real *emax, int nlevels, real pmin,
int *idim, int *ibox,
gmx_bool bXmin, real *xmin, gmx_bool bXmax, real *xmax)
{
FILE *fp;
real *min_eig, *max_eig;
real *axis_x, *axis_y, *axis_z, *axis = NULL;
double *P;
real **PP, *W, *E, **WW, **EE, *S, **SS, *M, *bE;
rvec xxx;
char *buf;
double *bfac, efac, bref, Pmax, Wmin, Wmax, Winf, Emin, Emax, Einf, Smin, Smax, Sinf, Mmin, Mmax;
real *delta;
int i, j, k, imin, len, index, d, *nbin, *bindex, bi;
int *nxyz, maxbox;
t_blocka *b;
gmx_bool bOutside;
unsigned int flags;
t_rgb rlo = { 0, 0, 0 };
t_rgb rhi = { 1, 1, 1 };
/* Determine extremes for the eigenvectors */
snew(min_eig, neig);
snew(max_eig, neig);
snew(nxyz, neig);
snew(bfac, neig);
snew(delta, neig);
for (i = 0; (i < neig); i++)
{
/* Check for input constraints */
min_eig[i] = max_eig[i] = eig[i][0];
for (j = 0; (j < n); j++)
{
min_eig[i] = min(min_eig[i], eig[i][j]);
max_eig[i] = max(max_eig[i], eig[i][j]);
delta[i] = (max_eig[i]-min_eig[i])/(2.0*ibox[i]);
}
/* Add some extra space, half a bin on each side, unless the
* user has set the limits.
*/
if (bXmax)
{
if (max_eig[i] > xmax[i])
{
gmx_warning("Your xmax[%d] value %f is smaller than the largest data point %f", i, xmax[i], max_eig[i]);
}
max_eig[i] = xmax[i];
}
else
{
max_eig[i] += delta[i];
}
if (bXmin)
{
if (min_eig[i] < xmin[i])
{
gmx_warning("Your xmin[%d] value %f is larger than the smallest data point %f", i, xmin[i], min_eig[i]);
}
min_eig[i] = xmin[i];
}
else
{
min_eig[i] -= delta[i];
}
bfac[i] = ibox[i]/(max_eig[i]-min_eig[i]);
}
/* Do the binning */
bref = 1/(BOLTZ*Tref);
snew(bE, n);
if (bGE || nenerT == 2)
{
Emin = 1e8;
for (j = 0; (j < n); j++)
{
if (bGE)
{
bE[j] = bref*enerT[0][j];
}
else
{
bE[j] = (bref - 1/(BOLTZ*enerT[1][j]))*enerT[0][j];
}
Emin = min(Emin, bE[j]);
}
}
else
{
Emin = 0;
}
len = 1;
for (i = 0; (i < neig); i++)
{
len = len*ibox[i];
}
printf("There are %d bins in the %d-dimensional histogram. Beta-Emin = %g\n",
len, neig, Emin);
snew(P, len);
snew(W, len);
snew(E, len);
snew(S, len);
snew(M, len);
snew(nbin, len);
snew(bindex, n);
/* Loop over projections */
for (j = 0; (j < n); j++)
{
/* Loop over dimensions */
bOutside = FALSE;
for (i = 0; (i < neig); i++)
{
nxyz[i] = bfac[i]*(eig[i][j]-min_eig[i]);
if (nxyz[i] < 0 || nxyz[i] >= ibox[i])
{
bOutside = TRUE;
}
}
if (!bOutside)
{
index = indexn(neig, ibox, nxyz);
range_check(index, 0, len);
/* Compute the exponential factor */
if (enerT)
{
efac = exp(-bE[j]+Emin);
}
else
{
efac = 1;
}
/* Apply the bin volume correction for a multi-dimensional distance */
for (i = 0; i < neig; i++)
{
if (idim[i] == 2)
{
efac /= eig[i][j];
}
else if (idim[i] == 3)
{
efac /= sqr(eig[i][j]);
}
else if (idim[i] == -1)
{
efac /= sin(DEG2RAD*eig[i][j]);
}
}
/* Update the probability */
P[index] += efac;
/* Update the energy */
if (enerT)
{
E[index] += enerT[0][j];
}
/* Statistics: which "structure" in which bin */
nbin[index]++;
bindex[j] = index;
}
}
/* Normalize probability */
normalize_p_e(len, P, nbin, E, pmin);
Pmax = 0;
/* Compute boundaries for the Free energy */
Wmin = 1e8;
imin = -1;
Wmax = -1e8;
/* Recompute Emin: it may have changed due to averaging */
Emin = 1e8;
Emax = -1e8;
for (i = 0; (i < len); i++)
{
if (P[i] != 0)
{
Pmax = max(P[i], Pmax);
W[i] = -BOLTZ*Tref*log(P[i]);
if (W[i] < Wmin)
{
Wmin = W[i];
imin = i;
}
Emin = min(E[i], Emin);
Emax = max(E[i], Emax);
Wmax = max(W[i], Wmax);
}
}
if (pmax > 0)
{
Pmax = pmax;
}
if (gmax > 0)
{
Wmax = gmax;
}
else
{
Wmax -= Wmin;
}
Winf = Wmax+1;
Einf = Emax+1;
Smin = Emin-Wmax;
Smax = Emax-Smin;
Sinf = Smax+1;
/* Write out the free energy as a function of bin index */
fp = gmx_ffopen(fn, "w");
for (i = 0; (i < len); i++)
{
if (P[i] != 0)
{
W[i] -= Wmin;
S[i] = E[i]-W[i]-Smin;
fprintf(fp, "%5d %10.5e %10.5e %10.5e\n", i, W[i], E[i], S[i]);
}
else
{
W[i] = Winf;
E[i] = Einf;
S[i] = Sinf;
}
}
gmx_ffclose(fp);
/* Organize the structures in the bins */
snew(b, 1);
snew(b->index, len+1);
snew(b->a, n);
b->index[0] = 0;
for (i = 0; (i < len); i++)
{
b->index[i+1] = b->index[i]+nbin[i];
nbin[i] = 0;
}
for (i = 0; (i < n); i++)
{
bi = bindex[i];
b->a[b->index[bi]+nbin[bi]] = i;
nbin[bi]++;
}
/* Consistency check */
/* This no longer applies when we allow the plot to be smaller
than the sampled space.
for(i=0; (i<len); i++) {
if (nbin[i] != (b->index[i+1] - b->index[i]))
gmx_fatal(FARGS,"nbin[%d] = %d, should be %d",i,nbin[i],
b->index[i+1] - b->index[i]);
}
*/
/* Write the index file */
fp = gmx_ffopen(ndx, "w");
for (i = 0; (i < len); i++)
{
if (nbin[i] > 0)
{
fprintf(fp, "[ %d ]\n", i);
for (j = b->index[i]; (j < b->index[i+1]); j++)
{
fprintf(fp, "%d\n", b->a[j]+1);
}
}
}
gmx_ffclose(fp);
snew(axis_x, ibox[0]+1);
snew(axis_y, ibox[1]+1);
snew(axis_z, ibox[2]+1);
maxbox = max(ibox[0], max(ibox[1], ibox[2]));
snew(PP, maxbox*maxbox);
snew(WW, maxbox*maxbox);
snew(EE, maxbox*maxbox);
snew(SS, maxbox*maxbox);
for (i = 0; (i < min(neig, 3)); i++)
{
switch (i)
{
case 0: axis = axis_x; break;
case 1: axis = axis_y; break;
case 2: axis = axis_z; break;
default: break;
}
for (j = 0; j <= ibox[i]; j++)
{
axis[j] = min_eig[i] + j/bfac[i];
}
}
pick_minima(logf, ibox, neig, len, W);
if (gmax <= 0)
{
gmax = Winf;
}
flags = MAT_SPATIAL_X | MAT_SPATIAL_Y;
if (neig == 2)
{
/* Dump to XPM file */
snew(PP, ibox[0]);
for (i = 0; (i < ibox[0]); i++)
{
snew(PP[i], ibox[1]);
for (j = 0; j < ibox[1]; j++)
{
PP[i][j] = P[i*ibox[1]+j];
}
WW[i] = &(W[i*ibox[1]]);
EE[i] = &(E[i*ibox[1]]);
SS[i] = &(S[i*ibox[1]]);
}
fp = gmx_ffopen(xpmP, "w");
write_xpm(fp, flags, "Probability Distribution", "", "PC1", "PC2",
ibox[0], ibox[1], axis_x, axis_y, PP, 0, Pmax, rlo, rhi, &nlevels);
gmx_ffclose(fp);
fp = gmx_ffopen(xpm, "w");
write_xpm(fp, flags, "Gibbs Energy Landscape", "G (kJ/mol)", "PC1", "PC2",
ibox[0], ibox[1], axis_x, axis_y, WW, 0, gmax, rlo, rhi, &nlevels);
gmx_ffclose(fp);
fp = gmx_ffopen(xpm2, "w");
write_xpm(fp, flags, "Enthalpy Landscape", "H (kJ/mol)", "PC1", "PC2",
ibox[0], ibox[1], axis_x, axis_y, EE,
emin ? *emin : Emin, emax ? *emax : Einf, rlo, rhi, &nlevels);
gmx_ffclose(fp);
fp = gmx_ffopen(xpm3, "w");
write_xpm(fp, flags, "Entropy Landscape", "TDS (kJ/mol)", "PC1", "PC2",
ibox[0], ibox[1], axis_x, axis_y, SS, 0, Sinf, rlo, rhi, &nlevels);
gmx_ffclose(fp);
}
else if (neig == 3)
{
/* Dump to PDB file */
fp = gmx_ffopen(pdb, "w");
for (i = 0; (i < ibox[0]); i++)
{
xxx[XX] = 3*(i+0.5-ibox[0]/2);
for (j = 0; (j < ibox[1]); j++)
{
xxx[YY] = 3*(j+0.5-ibox[1]/2);
for (k = 0; (k < ibox[2]); k++)
{
xxx[ZZ] = 3*(k+0.5-ibox[2]/2);
index = index3(ibox, i, j, k);
if (P[index] > 0)
{
fprintf(fp, "%-6s%5u %-4.4s%3.3s %4d %8.3f%8.3f%8.3f%6.2f%6.2f\n",
"ATOM", (index+1) %10000, "H", "H", (index+1)%10000,
xxx[XX], xxx[YY], xxx[ZZ], 1.0, W[index]);
}
}
}
}
gmx_ffclose(fp);
write_xplor("out.xplor", W, ibox, min_eig, max_eig);
nxyz[XX] = imin/(ibox[1]*ibox[2]);
nxyz[YY] = (imin-nxyz[XX]*ibox[1]*ibox[2])/ibox[2];
nxyz[ZZ] = imin % ibox[2];
for (i = 0; (i < ibox[0]); i++)
{
snew(WW[i], maxbox);
for (j = 0; (j < ibox[1]); j++)
{
WW[i][j] = W[index3(ibox, i, j, nxyz[ZZ])];
}
}
snew(buf, strlen(xpm)+4);
sprintf(buf, "%s", xpm);
sprintf(&buf[strlen(xpm)-4], "12.xpm");
fp = gmx_ffopen(buf, "w");
write_xpm(fp, flags, "Gibbs Energy Landscape", "W (kJ/mol)", "PC1", "PC2",
ibox[0], ibox[1], axis_x, axis_y, WW, 0, gmax, rlo, rhi, &nlevels);
gmx_ffclose(fp);
for (i = 0; (i < ibox[0]); i++)
{
for (j = 0; (j < ibox[2]); j++)
{
WW[i][j] = W[index3(ibox, i, nxyz[YY], j)];
}
}
sprintf(&buf[strlen(xpm)-4], "13.xpm");
fp = gmx_ffopen(buf, "w");
write_xpm(fp, flags, "SHAM Energy Landscape", "kJ/mol", "PC1", "PC3",
ibox[0], ibox[2], axis_x, axis_z, WW, 0, gmax, rlo, rhi, &nlevels);
gmx_ffclose(fp);
for (i = 0; (i < ibox[1]); i++)
{
for (j = 0; (j < ibox[2]); j++)
{
WW[i][j] = W[index3(ibox, nxyz[XX], i, j)];
}
}
sprintf(&buf[strlen(xpm)-4], "23.xpm");
fp = gmx_ffopen(buf, "w");
write_xpm(fp, flags, "SHAM Energy Landscape", "kJ/mol", "PC2", "PC3",
ibox[1], ibox[2], axis_y, axis_z, WW, 0, gmax, rlo, rhi, &nlevels);
gmx_ffclose(fp);
sfree(buf);
}
}
int gmx_rmsdist(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes the root mean square deviation of atom distances,",
"which has the advantage that no fit is needed like in standard RMS",
"deviation as computed by [gmx-rms].",
"The reference structure is taken from the structure file.",
"The RMSD at time t is calculated as the RMS",
"of the differences in distance between atom-pairs in the reference",
"structure and the structure at time t.[PAR]",
"[THISMODULE] can also produce matrices of the rms distances, rms distances",
"scaled with the mean distance and the mean distances and matrices with",
"NMR averaged distances (1/r^3 and 1/r^6 averaging). Finally, lists",
"of atom pairs with 1/r^3 and 1/r^6 averaged distance below the",
"maximum distance ([TT]-max[tt], which will default to 0.6 in this case)",
"can be generated, by default averaging over equivalent hydrogens",
"(all triplets of hydrogens named \\*[123]). Additionally a list of",
"equivalent atoms can be supplied ([TT]-equiv[tt]), each line containing",
"a set of equivalent atoms specified as residue number and name and",
"atom name; e.g.:[PAR]",
"[TT]HB* 3 SER HB1 3 SER HB2[tt][PAR]",
"Residue and atom names must exactly match those in the structure",
"file, including case. Specifying non-sequential atoms is undefined."
};
int i, teller;
real t;
t_topology top;
int ePBC;
t_atoms *atoms;
matrix box;
rvec *x;
FILE *fp;
t_trxstatus *status;
int isize, gnr = 0;
atom_id *index, *noe_index;
char *grpname;
real **d_r, **d, **dtot, **dtot2, **mean, **rms, **rmsc, *resnr;
real **dtot1_3 = NULL, **dtot1_6 = NULL;
real rmsnow, meanmax, rmsmax, rmscmax;
real max1_3, max1_6;
t_noe_gr *noe_gr = NULL;
t_noe **noe = NULL;
t_rgb rlo, rhi;
gmx_bool bRMS, bScale, bMean, bNOE, bNMR3, bNMR6, bNMR;
static int nlevels = 40;
static real scalemax = -1.0;
static gmx_bool bSumH = TRUE;
static gmx_bool bPBC = TRUE;
output_env_t oenv;
t_pargs pa[] = {
{ "-nlevels", FALSE, etINT, {&nlevels},
"Discretize RMS in this number of levels" },
{ "-max", FALSE, etREAL, {&scalemax},
"Maximum level in matrices" },
{ "-sumh", FALSE, etBOOL, {&bSumH},
"Average distance over equivalent hydrogens" },
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Use periodic boundary conditions when computing distances" }
};
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efDAT, "-equiv", "equiv", ffOPTRD },
{ efXVG, NULL, "distrmsd", ffWRITE },
{ efXPM, "-rms", "rmsdist", ffOPTWR },
{ efXPM, "-scl", "rmsscale", ffOPTWR },
{ efXPM, "-mean", "rmsmean", ffOPTWR },
{ efXPM, "-nmr3", "nmr3", ffOPTWR },
{ efXPM, "-nmr6", "nmr6", ffOPTWR },
{ efDAT, "-noe", "noe", ffOPTWR },
};
#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;
}
bRMS = opt2bSet("-rms", NFILE, fnm);
bScale = opt2bSet("-scl", NFILE, fnm);
bMean = opt2bSet("-mean", NFILE, fnm);
bNOE = opt2bSet("-noe", NFILE, fnm);
bNMR3 = opt2bSet("-nmr3", NFILE, fnm);
bNMR6 = opt2bSet("-nmr6", NFILE, fnm);
bNMR = bNMR3 || bNMR6 || bNOE;
max1_3 = 0;
max1_6 = 0;
/* check input */
if (bNOE && scalemax < 0)
{
scalemax = 0.6;
fprintf(stderr, "WARNING: using -noe without -max "
"makes no sense, setting -max to %g\n\n", scalemax);
}
/* get topology and index */
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, &x, NULL, box, FALSE);
if (!bPBC)
{
ePBC = epbcNONE;
}
atoms = &(top.atoms);
get_index(atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &isize, &index, &grpname);
/* initialize arrays */
snew(d, isize);
snew(dtot, isize);
snew(dtot2, isize);
if (bNMR)
{
snew(dtot1_3, isize);
snew(dtot1_6, isize);
}
snew(mean, isize);
snew(rms, isize);
snew(rmsc, isize);
snew(d_r, isize);
snew(resnr, isize);
for (i = 0; (i < isize); i++)
{
snew(d[i], isize);
snew(dtot[i], isize);
snew(dtot2[i], isize);
if (bNMR)
{
snew(dtot1_3[i], isize);
snew(dtot1_6[i], isize);
}
snew(mean[i], isize);
snew(rms[i], isize);
snew(rmsc[i], isize);
snew(d_r[i], isize);
resnr[i] = i+1;
}
/*set box type*/
calc_dist(isize, index, x, ePBC, box, d_r);
sfree(x);
/*open output files*/
fp = xvgropen(ftp2fn(efXVG, NFILE, fnm), "RMS Deviation", "Time (ps)", "RMSD (nm)",
oenv);
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"of distances between %s atoms\"\n", grpname);
}
/*do a first step*/
read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
teller = 0;
do
{
calc_dist_tot(isize, index, x, ePBC, box, d, dtot, dtot2, bNMR, dtot1_3, dtot1_6);
rmsnow = rms_diff(isize, d, d_r);
fprintf(fp, "%g %g\n", t, rmsnow);
teller++;
}
while (read_next_x(oenv, status, &t, x, box));
fprintf(stderr, "\n");
xvgrclose(fp);
close_trj(status);
calc_rms(isize, teller, dtot, dtot2, rms, &rmsmax, rmsc, &rmscmax, mean, &meanmax);
fprintf(stderr, "rmsmax = %g, rmscmax = %g\n", rmsmax, rmscmax);
if (bNMR)
{
calc_nmr(isize, teller, dtot1_3, dtot1_6, &max1_3, &max1_6);
}
if (scalemax > -1.0)
{
rmsmax = scalemax;
rmscmax = scalemax;
meanmax = scalemax;
max1_3 = scalemax;
max1_6 = scalemax;
}
if (bNOE)
{
/* make list of noe atom groups */
snew(noe_index, isize+1);
snew(noe_gr, isize);
gnr = analyze_noe_equivalent(opt2fn_null("-equiv", NFILE, fnm),
atoms, isize, index, bSumH, noe_index, noe_gr);
fprintf(stdout, "Found %d non-equivalent atom-groups in %d atoms\n",
gnr, isize);
/* make half matrix of of noe-group distances from atom distances */
snew(noe, gnr);
for (i = 0; i < gnr; i++)
{
snew(noe[i], gnr);
}
calc_noe(isize, noe_index, dtot1_3, dtot1_6, gnr, noe);
}
rlo.r = 1.0, rlo.g = 1.0, rlo.b = 1.0;
rhi.r = 0.0, rhi.g = 0.0, rhi.b = 0.0;
if (bRMS)
{
write_xpm(opt2FILE("-rms", NFILE, fnm, "w"), 0,
"RMS of distance", "RMS (nm)", "Atom Index", "Atom Index",
isize, isize, resnr, resnr, rms, 0.0, rmsmax, rlo, rhi, &nlevels);
}
if (bScale)
{
write_xpm(opt2FILE("-scl", NFILE, fnm, "w"), 0,
"Relative RMS", "RMS", "Atom Index", "Atom Index",
isize, isize, resnr, resnr, rmsc, 0.0, rmscmax, rlo, rhi, &nlevels);
}
if (bMean)
{
write_xpm(opt2FILE("-mean", NFILE, fnm, "w"), 0,
"Mean Distance", "Distance (nm)", "Atom Index", "Atom Index",
isize, isize, resnr, resnr, mean, 0.0, meanmax, rlo, rhi, &nlevels);
}
if (bNMR3)
{
write_xpm(opt2FILE("-nmr3", NFILE, fnm, "w"), 0, "1/r^3 averaged distances",
"Distance (nm)", "Atom Index", "Atom Index",
isize, isize, resnr, resnr, dtot1_3, 0.0, max1_3, rlo, rhi, &nlevels);
}
if (bNMR6)
{
write_xpm(opt2FILE("-nmr6", NFILE, fnm, "w"), 0, "1/r^6 averaged distances",
"Distance (nm)", "Atom Index", "Atom Index",
isize, isize, resnr, resnr, dtot1_6, 0.0, max1_6, rlo, rhi, &nlevels);
}
if (bNOE)
{
write_noe(opt2FILE("-noe", NFILE, fnm, "w"), gnr, noe, noe_gr, scalemax);
}
do_view(oenv, ftp2fn(efXVG, NFILE, fnm), NULL);
return 0;
}
int gmx_mdmat(int argc, char *argv[])
{
const char *desc[] = {
"[TT]g_mdmat[tt] makes distance matrices consisting of the smallest distance",
"between residue pairs. With [TT]-frames[tt], these distance matrices can be",
"stored in order to see differences in tertiary structure as a",
"function of time. If you choose your options unwisely, this may generate",
"a large output file. By default, only an averaged matrix over the whole",
"trajectory is output.",
"Also a count of the number of different atomic contacts between",
"residues over the whole trajectory can be made.",
"The output can be processed with [TT]xpm2ps[tt] to make a PostScript (tm) plot."
};
static real truncate = 1.5;
static gmx_bool bAtom = FALSE;
static int nlevels = 40;
t_pargs pa[] = {
{ "-t", FALSE, etREAL, {&truncate},
"trunc distance" },
{ "-nlevels", FALSE, etINT, {&nlevels},
"Discretize distance in this number of levels" }
};
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXPM, "-mean", "dm", ffWRITE },
{ efXPM, "-frames", "dmf", ffOPTWR },
{ efXVG, "-no", "num", ffOPTWR },
};
#define NFILE asize(fnm)
FILE *out = NULL, *fp;
t_topology top;
int ePBC;
t_atoms useatoms;
int isize;
atom_id *index;
char *grpname;
int *rndx, *natm, prevres, newres;
int i, j, nres, natoms, nframes, it, trxnat;
t_trxstatus *status;
int nr0;
gmx_bool bCalcN, bFrames;
real t, ratio;
char title[256], label[234];
t_rgb rlo, rhi;
rvec *x;
real **mdmat, *resnr, **totmdmat;
int **nmat, **totnmat;
real *mean_n;
int *tot_n;
matrix box;
output_env_t oenv;
gmx_rmpbc_t gpbc = NULL;
CopyRight(stderr, argv[0]);
parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_BE_NICE, NFILE, fnm,
asize(pa), pa, asize(desc), desc, 0, NULL, &oenv);
fprintf(stderr, "Will truncate at %f nm\n", truncate);
bCalcN = opt2bSet("-no", NFILE, fnm);
bFrames = opt2bSet("-frames", NFILE, fnm);
if (bCalcN)
{
fprintf(stderr, "Will calculate number of different contacts\n");
}
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC, &x, NULL, box, FALSE);
fprintf(stderr, "Select group for analysis\n");
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &isize, &index, &grpname);
natoms = isize;
snew(useatoms.atom, natoms);
snew(useatoms.atomname, natoms);
useatoms.nres = 0;
snew(useatoms.resinfo, natoms);
prevres = top.atoms.atom[index[0]].resind;
newres = 0;
for (i = 0; (i < isize); i++)
{
int ii = index[i];
useatoms.atomname[i] = top.atoms.atomname[ii];
if (top.atoms.atom[ii].resind != prevres)
{
prevres = top.atoms.atom[ii].resind;
newres++;
useatoms.resinfo[i] = top.atoms.resinfo[prevres];
if (debug)
{
fprintf(debug, "New residue: atom %5s %5s %6d, index entry %5d, newres %5d\n",
*(top.atoms.resinfo[top.atoms.atom[ii].resind].name),
*(top.atoms.atomname[ii]),
ii, i, newres);
}
}
useatoms.atom[i].resind = newres;
}
useatoms.nres = newres+1;
useatoms.nr = isize;
rndx = res_ndx(&(useatoms));
natm = res_natm(&(useatoms));
nres = useatoms.nres;
fprintf(stderr, "There are %d residues with %d atoms\n", nres, natoms);
snew(resnr, nres);
snew(mdmat, nres);
snew(nmat, nres);
snew(totnmat, nres);
snew(mean_n, nres);
snew(tot_n, nres);
for (i = 0; (i < nres); i++)
{
snew(mdmat[i], nres);
snew(nmat[i], natoms);
snew(totnmat[i], natoms);
resnr[i] = i+1;
}
snew(totmdmat, nres);
for (i = 0; (i < nres); i++)
{
snew(totmdmat[i], nres);
}
trxnat = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
nframes = 0;
rlo.r = 1.0, rlo.g = 1.0, rlo.b = 1.0;
rhi.r = 0.0, rhi.g = 0.0, rhi.b = 0.0;
gpbc = gmx_rmpbc_init(&top.idef, ePBC, trxnat, box);
if (bFrames)
{
out = opt2FILE("-frames", NFILE, fnm, "w");
}
do
{
gmx_rmpbc(gpbc, trxnat, box, x);
nframes++;
calc_mat(nres, natoms, rndx, x, index, truncate, mdmat, nmat, ePBC, box);
for (i = 0; (i < nres); i++)
{
for (j = 0; (j < natoms); j++)
{
if (nmat[i][j])
{
totnmat[i][j]++;
}
}
}
for (i = 0; (i < nres); i++)
{
for (j = 0; (j < nres); j++)
{
totmdmat[i][j] += mdmat[i][j];
}
}
if (bFrames)
{
sprintf(label, "t=%.0f ps", t);
write_xpm(out, 0, label, "Distance (nm)", "Residue Index", "Residue Index",
nres, nres, resnr, resnr, mdmat, 0, truncate, rlo, rhi, &nlevels);
}
}
while (read_next_x(oenv, status, &t, trxnat, x, box));
fprintf(stderr, "\n");
close_trj(status);
gmx_rmpbc_done(gpbc);
if (bFrames)
{
ffclose(out);
}
fprintf(stderr, "Processed %d frames\n", nframes);
for (i = 0; (i < nres); i++)
{
for (j = 0; (j < nres); j++)
{
totmdmat[i][j] /= nframes;
}
}
write_xpm(opt2FILE("-mean", NFILE, fnm, "w"), 0, "Mean smallest distance",
"Distance (nm)", "Residue Index", "Residue Index",
nres, nres, resnr, resnr, totmdmat, 0, truncate, rlo, rhi, &nlevels);
if (bCalcN)
{
tot_nmat(nres, natoms, nframes, totnmat, tot_n, mean_n);
fp = xvgropen(ftp2fn(efXVG, NFILE, fnm),
"Increase in number of contacts", "Residue", "Ratio", oenv);
fprintf(fp, "@ legend on\n");
fprintf(fp, "@ legend box on\n");
fprintf(fp, "@ legend loctype view\n");
fprintf(fp, "@ legend 0.75, 0.8\n");
fprintf(fp, "@ legend string 0 \"Total/mean\"\n");
fprintf(fp, "@ legend string 1 \"Total\"\n");
fprintf(fp, "@ legend string 2 \"Mean\"\n");
fprintf(fp, "@ legend string 3 \"# atoms\"\n");
fprintf(fp, "@ legend string 4 \"Mean/# atoms\"\n");
fprintf(fp, "#%3s %8s %3s %8s %3s %8s\n",
"res", "ratio", "tot", "mean", "natm", "mean/atm");
for (i = 0; (i < nres); i++)
{
if (mean_n[i] == 0)
{
ratio = 1;
}
else
{
ratio = tot_n[i]/mean_n[i];
}
fprintf(fp, "%3d %8.3f %3d %8.3f %3d %8.3f\n",
i+1, ratio, tot_n[i], mean_n[i], natm[i], mean_n[i]/natm[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_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_cluster(int argc,char *argv[])
{
static char *desc[] = {
"g_cluster can cluster structures with several different methods.",
"Distances between structures can be determined from a trajectory",
"or read from an XPM matrix file with the [TT]-dm[tt] option.",
"RMS deviation after fitting or RMS deviation of atom-pair distances",
"can be used to define the distance between structures.[PAR]",
"single linkage: add a structure to a cluster when its distance to any",
"element of the cluster is less than [TT]cutoff[tt].[PAR]",
"Jarvis Patrick: add a structure to a cluster when this structure",
"and a structure in the cluster have each other as neighbors and",
"they have a least [TT]P[tt] neighbors in common. The neighbors",
"of a structure are the M closest structures or all structures within",
"[TT]cutoff[tt].[PAR]",
"Monte Carlo: reorder the RMSD matrix using Monte Carlo.[PAR]",
"diagonalization: diagonalize the RMSD matrix.[PAR]"
"gromos: use algorithm as described in Daura [IT]et al.[it]",
"([IT]Angew. Chem. Int. Ed.[it] [BB]1999[bb], [IT]38[it], pp 236-240).",
"Count number of neighbors using cut-off, take structure with",
"largest number of neighbors with all its neighbors as cluster",
"and eleminate it from the pool of clusters. Repeat for remaining",
"structures in pool.[PAR]",
"When the clustering algorithm assigns each structure to exactly one",
"cluster (single linkage, Jarvis Patrick and gromos) and a trajectory",
"file is supplied, the structure with",
"the smallest average distance to the others or the average structure",
"or all structures for each cluster will be written to a trajectory",
"file. When writing all structures, separate numbered files are made",
"for each cluster.[PAR]"
"Two output files are always written:[BR]",
"[TT]-o[tt] writes the RMSD values in the upper left half of the matrix",
"and a graphical depiction of the clusters in the lower right half",
"When [TT]-minstruct[tt] = 1 the graphical depiction is black",
"when two structures are in the same cluster.",
"When [TT]-minstruct[tt] > 1 different colors will be used for each",
"cluster.[BR]",
"[TT]-g[tt] writes information on the options used and a detailed list",
"of all clusters and their members.[PAR]",
"Additionally, a number of optional output files can be written:[BR]",
"[TT]-dist[tt] writes the RMSD distribution.[BR]",
"[TT]-ev[tt] writes the eigenvectors of the RMSD matrix",
"diagonalization.[BR]",
"[TT]-sz[tt] writes the cluster sizes.[BR]",
"[TT]-tr[tt] writes a matrix of the number transitions between",
"cluster pairs.[BR]",
"[TT]-ntr[tt] writes the total number of transitions to or from",
"each cluster.[BR]",
"[TT]-clid[tt] writes the cluster number as a function of time.[BR]",
"[TT]-cl[tt] writes average (with option [TT]-av[tt]) or central",
"structure of each cluster or writes numbered files with cluster members",
"for a selected set of clusters (with option [TT]-wcl[tt], depends on",
"[TT]-nst[tt] and [TT]-rmsmin[tt]).[BR]",
};
FILE *fp,*log;
int i,i1,i2,j,nf,nrms;
matrix box;
rvec *xtps,*usextps,*x1,**xx=NULL;
char *fn,*trx_out_fn;
t_clusters clust;
t_mat *rms;
real *eigval;
t_topology top;
int ePBC;
t_atoms useatoms;
t_matrix *readmat;
real *tmp;
int isize=0,ifsize=0,iosize=0;
atom_id *index=NULL, *fitidx, *outidx;
char *grpname;
real rmsd,**d1,**d2,*time,time_invfac,*mass=NULL;
char buf[STRLEN],buf1[80],title[STRLEN];
bool bAnalyze,bUseRmsdCut,bJP_RMSD=FALSE,bReadMat,bReadTraj;
int method,ncluster=0;
static char *methodname[] = {
NULL, "linkage", "jarvis-patrick","monte-carlo",
"diagonalization", "gromos", NULL
};
enum { m_null, m_linkage, m_jarvis_patrick,
m_monte_carlo, m_diagonalize, m_gromos, m_nr };
/* Set colors for plotting: white = zero RMS, black = maximum */
static t_rgb rlo_top = { 1.0, 1.0, 1.0 };
static t_rgb rhi_top = { 0.0, 0.0, 0.0 };
static t_rgb rlo_bot = { 1.0, 1.0, 1.0 };
static t_rgb rhi_bot = { 0.0, 0.0, 1.0 };
static int nlevels=40,skip=1;
static real scalemax=-1.0,rmsdcut=0.1,rmsmin=0.0;
static bool bRMSdist=FALSE,bBinary=FALSE,bAverage=FALSE,bFit=TRUE;
static int niter=10000,seed=1993,write_ncl=0,write_nst=1,minstruct=1;
static real kT=1e-3;
static int M=10,P=3;
t_pargs pa[] = {
{ "-dista", FALSE, etBOOL, {&bRMSdist},
"Use RMSD of distances instead of RMS deviation" },
{ "-nlevels",FALSE,etINT, {&nlevels},
"Discretize RMSD matrix in # levels" },
{ "-cutoff",FALSE, etREAL, {&rmsdcut},
"RMSD cut-off (nm) for two structures to be neighbor" },
{ "-fit", FALSE, etBOOL, {&bFit},
"Use least squares fitting before RMSD calculation" },
{ "-max", FALSE, etREAL, {&scalemax},
"Maximum level in RMSD matrix" },
{ "-skip", FALSE, etINT, {&skip},
"Only analyze every nr-th frame" },
{ "-av", FALSE, etBOOL, {&bAverage},
"Write average iso middle structure for each cluster" },
{ "-wcl", FALSE, etINT, {&write_ncl},
"Write all structures for first # clusters to numbered files" },
{ "-nst", FALSE, etINT, {&write_nst},
"Only write all structures if more than # per cluster" },
{ "-rmsmin",FALSE, etREAL, {&rmsmin},
"minimum rms difference with rest of cluster for writing structures" },
{ "-method",FALSE, etENUM, {methodname},
"Method for cluster determination" },
{ "-minstruct", FALSE, etINT, {&minstruct},
"Minimum number of structures in cluster for coloring in the xpm file" },
{ "-binary",FALSE, etBOOL, {&bBinary},
"Treat the RMSD matrix as consisting of 0 and 1, where the cut-off "
"is given by -cutoff" },
{ "-M", FALSE, etINT, {&M},
"Number of nearest neighbors considered for Jarvis-Patrick algorithm, "
"0 is use cutoff" },
{ "-P", FALSE, etINT, {&P},
"Number of identical nearest neighbors required to form a cluster" },
{ "-seed", FALSE, etINT, {&seed},
"Random number seed for Monte Carlo clustering algorithm" },
{ "-niter", FALSE, etINT, {&niter},
"Number of iterations for MC" },
{ "-kT", FALSE, etREAL, {&kT},
"Boltzmann weighting factor for Monte Carlo optimization "
"(zero turns off uphill steps)" }
};
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffOPTRD },
{ efTPS, "-s", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXPM, "-dm", "rmsd", ffOPTRD },
{ efXPM, "-o", "rmsd-clust", ffWRITE },
{ efLOG, "-g", "cluster", ffWRITE },
{ efXVG, "-dist", "rmsd-dist", ffOPTWR },
{ efXVG, "-ev", "rmsd-eig", ffOPTWR },
{ efXVG, "-sz", "clust-size", ffOPTWR},
{ efXPM, "-tr", "clust-trans",ffOPTWR},
{ efXVG, "-ntr", "clust-trans",ffOPTWR},
{ efXVG, "-clid", "clust-id.xvg",ffOPTWR},
{ efTRX, "-cl", "clusters.pdb", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_VIEW | PCA_CAN_TIME | PCA_TIME_UNIT | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL);
/* parse options */
bReadMat = opt2bSet("-dm",NFILE,fnm);
bReadTraj = opt2bSet("-f",NFILE,fnm) || !bReadMat;
if ( opt2parg_bSet("-av",asize(pa),pa) ||
opt2parg_bSet("-wcl",asize(pa),pa) ||
opt2parg_bSet("-nst",asize(pa),pa) ||
opt2parg_bSet("-rmsmin",asize(pa),pa) ||
opt2bSet("-cl",NFILE,fnm) )
trx_out_fn = opt2fn("-cl",NFILE,fnm);
else
trx_out_fn = NULL;
if (bReadMat && time_factor()!=1) {
fprintf(stderr,
"\nWarning: assuming the time unit in %s is %s\n",
opt2fn("-dm",NFILE,fnm),time_unit());
}
if (trx_out_fn && !bReadTraj)
fprintf(stderr,"\nWarning: "
"cannot write cluster structures without reading trajectory\n"
" ignoring option -cl %s\n", trx_out_fn);
method=1;
while ( method < m_nr && strcasecmp(methodname[0], methodname[method])!=0 )
method++;
if (method == m_nr)
gmx_fatal(FARGS,"Invalid method");
bAnalyze = (method == m_linkage || method == m_jarvis_patrick ||
method == m_gromos );
/* Open log file */
log = ftp2FILE(efLOG,NFILE,fnm,"w");
fprintf(stderr,"Using %s method for clustering\n",methodname[0]);
fprintf(log,"Using %s method for clustering\n",methodname[0]);
/* check input and write parameters to log file */
bUseRmsdCut = FALSE;
if (method == m_jarvis_patrick) {
bJP_RMSD = (M == 0) || opt2parg_bSet("-cutoff",asize(pa),pa);
if ((M<0) || (M == 1))
gmx_fatal(FARGS,"M (%d) must be 0 or larger than 1",M);
if (M < 2) {
sprintf(buf1,"Will use P=%d and RMSD cutoff (%g)",P,rmsdcut);
bUseRmsdCut = TRUE;
} else {
if (P >= M)
gmx_fatal(FARGS,"Number of neighbors required (P) must be less than M");
if (bJP_RMSD) {
sprintf(buf1,"Will use P=%d, M=%d and RMSD cutoff (%g)",P,M,rmsdcut);
bUseRmsdCut = TRUE;
} else
sprintf(buf1,"Will use P=%d, M=%d",P,M);
}
ffprintf1(stderr,log,buf,"%s for determining the neighbors\n\n",buf1);
} else /* method != m_jarvis */
bUseRmsdCut = ( bBinary || method == m_linkage || method == m_gromos );
if (bUseRmsdCut && method != m_jarvis_patrick)
fprintf(log,"Using RMSD cutoff %g nm\n",rmsdcut);
if ( method==m_monte_carlo )
fprintf(log,"Using %d iterations\n",niter);
if (skip < 1)
gmx_fatal(FARGS,"skip (%d) should be >= 1",skip);
/* get input */
if (bReadTraj) {
/* don't read mass-database as masses (and top) are not used */
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),buf,&top,&ePBC,&xtps,NULL,box,
bAnalyze);
fprintf(stderr,"\nSelect group for least squares fit%s:\n",
bReadMat?"":" and RMSD calculation");
get_index(&(top.atoms),ftp2fn_null(efNDX,NFILE,fnm),
1,&ifsize,&fitidx,&grpname);
if (trx_out_fn) {
fprintf(stderr,"\nSelect group for output:\n");
get_index(&(top.atoms),ftp2fn_null(efNDX,NFILE,fnm),
1,&iosize,&outidx,&grpname);
/* merge and convert both index groups: */
/* first copy outidx to index. let outidx refer to elements in index */
snew(index,iosize);
isize = iosize;
for(i=0; i<iosize; i++) {
index[i]=outidx[i];
outidx[i]=i;
}
/* now lookup elements from fitidx in index, add them if necessary
and also let fitidx refer to elements in index */
for(i=0; i<ifsize; i++) {
j=0;
while (j<isize && index[j]!=fitidx[i])
j++;
if (j>=isize) {
/* slow this way, but doesn't matter much */
isize++;
srenew(index,isize);
}
index[j]=fitidx[i];
fitidx[i]=j;
}
} else { /* !trx_out_fn */
isize = ifsize;
snew(index, isize);
for(i=0; i<ifsize; i++) {
index[i]=fitidx[i];
fitidx[i]=i;
}
}
}
/* Initiate arrays */
snew(d1,isize);
snew(d2,isize);
for(i=0; (i<isize); i++) {
snew(d1[i],isize);
snew(d2[i],isize);
}
if (bReadTraj) {
/* Loop over first coordinate file */
fn = opt2fn("-f",NFILE,fnm);
xx = read_whole_trj(fn,isize,index,skip,&nf,&time);
convert_times(nf, time);
if (!bRMSdist || bAnalyze) {
/* Center all frames on zero */
snew(mass,isize);
for(i=0; i<ifsize; i++)
mass[fitidx[i]] = top.atoms.atom[index[fitidx[i]]].m;
if (bFit)
for(i=0; i<nf; i++)
reset_x(ifsize,fitidx,isize,NULL,xx[i],mass);
}
}
if (bReadMat) {
fprintf(stderr,"Reading rms distance matrix ");
read_xpm_matrix(opt2fn("-dm",NFILE,fnm),&readmat);
fprintf(stderr,"\n");
if (readmat[0].nx != readmat[0].ny)
gmx_fatal(FARGS,"Matrix (%dx%d) is not square",
readmat[0].nx,readmat[0].ny);
if (bReadTraj && bAnalyze && (readmat[0].nx != nf))
gmx_fatal(FARGS,"Matrix size (%dx%d) does not match the number of "
"frames (%d)",readmat[0].nx,readmat[0].ny,nf);
nf = readmat[0].nx;
sfree(time);
time = readmat[0].axis_x;
time_invfac = time_invfactor();
for(i=0; i<nf; i++)
time[i] *= time_invfac;
rms = init_mat(readmat[0].nx,method == m_diagonalize);
convert_mat(&(readmat[0]),rms);
nlevels = readmat[0].nmap;
} else { /* !bReadMat */
rms = init_mat(nf,method == m_diagonalize);
nrms = (nf*(nf-1))/2;
if (!bRMSdist) {
fprintf(stderr,"Computing %dx%d RMS deviation matrix\n",nf,nf);
snew(x1,isize);
for(i1=0; (i1<nf); i1++) {
for(i2=i1+1; (i2<nf); i2++) {
for(i=0; i<isize; i++)
copy_rvec(xx[i1][i],x1[i]);
if (bFit)
do_fit(isize,mass,xx[i2],x1);
rmsd = rmsdev(isize,mass,xx[i2],x1);
set_mat_entry(rms,i1,i2,rmsd);
}
nrms -= (nf-i1-1);
fprintf(stderr,"\r# RMSD calculations left: %d ",nrms);
}
} else { /* bRMSdist */
fprintf(stderr,"Computing %dx%d RMS distance deviation matrix\n",nf,nf);
for(i1=0; (i1<nf); i1++) {
calc_dist(isize,xx[i1],d1);
for(i2=i1+1; (i2<nf); i2++) {
calc_dist(isize,xx[i2],d2);
set_mat_entry(rms,i1,i2,rms_dist(isize,d1,d2));
}
nrms -= (nf-i1-1);
fprintf(stderr,"\r# RMSD calculations left: %d ",nrms);
}
}
fprintf(stderr,"\n\n");
}
ffprintf2(stderr,log,buf,"The RMSD ranges from %g to %g nm\n",
rms->minrms,rms->maxrms);
ffprintf1(stderr,log,buf,"Average RMSD is %g\n",2*rms->sumrms/(nf*(nf-1)));
ffprintf1(stderr,log,buf,"Number of structures for matrix %d\n",nf);
ffprintf1(stderr,log,buf,"Energy of the matrix is %g nm\n",mat_energy(rms));
if (bUseRmsdCut && (rmsdcut < rms->minrms || rmsdcut > rms->maxrms) )
fprintf(stderr,"WARNING: rmsd cutoff %g is outside range of rmsd values "
"%g to %g\n",rmsdcut,rms->minrms,rms->maxrms);
if (bAnalyze && (rmsmin < rms->minrms) )
fprintf(stderr,"WARNING: rmsd minimum %g is below lowest rmsd value %g\n",
rmsmin,rms->minrms);
if (bAnalyze && (rmsmin > rmsdcut) )
fprintf(stderr,"WARNING: rmsd minimum %g is above rmsd cutoff %g\n",
rmsmin,rmsdcut);
/* Plot the rmsd distribution */
rmsd_distribution(opt2fn("-dist",NFILE,fnm),rms);
if (bBinary) {
for(i1=0; (i1 < nf); i1++)
for(i2=0; (i2 < nf); i2++)
if (rms->mat[i1][i2] < rmsdcut)
rms->mat[i1][i2] = 0;
else
rms->mat[i1][i2] = 1;
}
snew(clust.cl,nf);
switch (method) {
case m_linkage:
/* Now sort the matrix and write it out again */
gather(rms,rmsdcut,&clust);
break;
case m_diagonalize:
/* Do a diagonalization */
snew(eigval,nf);
snew(tmp,nf*nf);
memcpy(tmp,rms->mat[0],nf*nf*sizeof(real));
eigensolver(tmp,nf,0,nf,eigval,rms->mat[0]);
sfree(tmp);
fp = xvgropen(opt2fn("-ev",NFILE,fnm),"RMSD matrix Eigenvalues",
"Eigenvector index","Eigenvalues (nm\\S2\\N)");
for(i=0; (i<nf); i++)
fprintf(fp,"%10d %10g\n",i,eigval[i]);
ffclose(fp);
break;
case m_monte_carlo:
mc_optimize(log,rms,niter,&seed,kT);
swap_mat(rms);
reset_index(rms);
break;
case m_jarvis_patrick:
jarvis_patrick(rms->nn,rms->mat,M,P,bJP_RMSD ? rmsdcut : -1,&clust);
break;
case m_gromos:
gromos(rms->nn,rms->mat,rmsdcut,&clust);
break;
default:
gmx_fatal(FARGS,"DEATH HORROR unknown method \"%s\"",methodname[0]);
}
if (method == m_monte_carlo || method == m_diagonalize)
fprintf(stderr,"Energy of the matrix after clustering is %g nm\n",
mat_energy(rms));
if (bAnalyze) {
if (minstruct > 1) {
ncluster = plot_clusters(nf,rms->mat,&clust,nlevels,minstruct);
} else {
mark_clusters(nf,rms->mat,rms->maxrms,&clust);
}
init_t_atoms(&useatoms,isize,FALSE);
snew(usextps, isize);
useatoms.resname=top.atoms.resname;
for(i=0; i<isize; i++) {
useatoms.atomname[i]=top.atoms.atomname[index[i]];
useatoms.atom[i].resnr=top.atoms.atom[index[i]].resnr;
useatoms.nres=max(useatoms.nres,useatoms.atom[i].resnr+1);
copy_rvec(xtps[index[i]],usextps[i]);
}
useatoms.nr=isize;
analyze_clusters(nf,&clust,rms->mat,isize,&useatoms,usextps,mass,xx,time,
ifsize,fitidx,iosize,outidx,
bReadTraj?trx_out_fn:NULL,
opt2fn_null("-sz",NFILE,fnm),
opt2fn_null("-tr",NFILE,fnm),
opt2fn_null("-ntr",NFILE,fnm),
opt2fn_null("-clid",NFILE,fnm),
bAverage, write_ncl, write_nst, rmsmin, bFit, log,
rlo_bot,rhi_bot);
}
ffclose(log);
if (bBinary && !bAnalyze)
/* Make the clustering visible */
for(i2=0; (i2 < nf); i2++)
for(i1=i2+1; (i1 < nf); i1++)
if (rms->mat[i1][i2])
rms->mat[i1][i2] = rms->maxrms;
fp = opt2FILE("-o",NFILE,fnm,"w");
fprintf(stderr,"Writing rms distance/clustering matrix ");
if (bReadMat) {
write_xpm(fp,0,readmat[0].title,readmat[0].legend,readmat[0].label_x,
readmat[0].label_y,nf,nf,readmat[0].axis_x,readmat[0].axis_y,
rms->mat,0.0,rms->maxrms,rlo_top,rhi_top,&nlevels);
}
else {
sprintf(buf,"Time (%s)",time_unit());
sprintf(title,"RMS%sDeviation / Cluster Index",
bRMSdist ? " Distance " : " ");
if (minstruct > 1) {
write_xpm_split(fp,0,title,"RMSD (nm)",buf,buf,
nf,nf,time,time,rms->mat,0.0,rms->maxrms,&nlevels,
rlo_top,rhi_top,0.0,(real) ncluster,
&ncluster,TRUE,rlo_bot,rhi_bot);
} else {
write_xpm(fp,0,title,"RMSD (nm)",buf,buf,
nf,nf,time,time,rms->mat,0.0,rms->maxrms,
rlo_top,rhi_top,&nlevels);
}
}
fprintf(stderr,"\n");
ffclose(fp);
/* now show what we've done */
do_view(opt2fn("-o",NFILE,fnm),"-nxy");
do_view(opt2fn_null("-sz",NFILE,fnm),"-nxy");
if (method == m_diagonalize)
do_view(opt2fn_null("-ev",NFILE,fnm),"-nxy");
do_view(opt2fn("-dist",NFILE,fnm),"-nxy");
if (bAnalyze) {
do_view(opt2fn_null("-tr",NFILE,fnm),"-nxy");
do_view(opt2fn_null("-ntr",NFILE,fnm),"-nxy");
do_view(opt2fn_null("-clid",NFILE,fnm),"-nxy");
}
/* Thank the user for her patience */
thanx(stderr);
return 0;
}
