static bool step_man(t_manager *man,int *nat)
{
static int ncount=0;
static bool bWarn = FALSE;
bool bEof;
real rdum;
int dum;
char *warn;
if (!man->natom) {
fprintf(stderr,"Not initiated yet!");
exit(1);
}
bEof=read_next_x(man->status,&man->time,man->natom,man->x,man->box);
*nat=man->natom;
if (ncount == man->nSkip) {
switch (man->molw->boxtype) {
case esbTri:
put_atoms_in_triclinic_unitcell(ecenterDEF,man->box,man->natom,man->x);
break;
case esbTrunc:
warn = put_atoms_in_compact_unitcell(man->molw->ePBC,ecenterDEF,man->box,
man->natom,man->x);
if (warn && !bWarn) {
fprintf(stderr,"\n%s\n",warn);
bWarn = TRUE;
}
break;
case esbRect:
case esbNone:
default:
break;
}
if (man->bPbc) {
rm_pbc(&(man->top.idef),man->molw->ePBC,
man->natom,man->box,man->x,man->x);
reset_mols(&(man->top.mols),man->box,man->x);
}
ncount=0;
}
else {
if (man->nSkip > 0) {
ncount++;
return step_man(man,nat);
}
}
return bEof;
}
static void calc_dihs(t_xrama *xr)
{
int i;
rvec r_ij,r_kj,r_kl,m,n;
real cos_phi,sign;
t_dih *dd;
rm_pbc(xr->idef,xr->natoms,xr->box,xr->x,xr->x);
for(i=0; (i<xr->ndih); i++) {
dd=&(xr->dih[i]);
dd->ang=dih_angle(xr->box,
xr->x[dd->ai[0]],xr->x[dd->ai[1]],
xr->x[dd->ai[2]],xr->x[dd->ai[3]],
r_ij,r_kj,r_kl,m,n,&cos_phi,&sign);
}
}
int gmx_bundle(int argc,char *argv[])
{
static char *desc[] = {
"g_bundle analyzes bundles of axes. The axes can be for instance",
"helix axes. The program reads two index groups and divides both",
"of them in [TT]-na[tt] parts. The centers of mass of these parts",
"define the tops and bottoms of the axes.",
"Several quantities are written to file:",
"the axis length, the distance and the z-shift of the axis mid-points",
"with respect to the average center of all axes, the total tilt,",
"the radial tilt and the lateral tilt with respect to the average axis.",
"[PAR]",
"With options [TT]-ok[tt], [TT]-okr[tt] and [TT]-okl[tt] the total,",
"radial and lateral kinks of the axes are plotted. An extra index",
"group of kink atoms is required, which is also divided into [TT]-na[tt]",
"parts. The kink angle is defined as the angle between the kink-top and",
"the bottom-kink vectors.",
"[PAR]",
"With option [TT]-oa[tt] the top, mid (or kink when [TT]-ok[tt] is set)",
"and bottom points of each axis",
"are written to a pdb file each frame. The residue numbers correspond",
"to the axis numbers. When viewing this file with [TT]rasmol[tt], use the",
"command line option [TT]-nmrpdb[tt], and type [TT]set axis true[tt] to",
"display the reference axis."
};
static int n=0;
static bool bZ=FALSE;
t_pargs pa[] = {
{ "-na", FALSE, etINT, {&n},
"Number of axes" },
{ "-z", FALSE, etBOOL, {&bZ},
"Use the Z-axis as reference iso the average axis" }
};
FILE *out,*flen,*fdist,*fz,*ftilt,*ftiltr,*ftiltl;
FILE *fkink=NULL,*fkinkr=NULL,*fkinkl=NULL;
int status,fpdb;
t_topology top;
int ePBC;
rvec *xtop;
matrix box;
t_trxframe fr;
t_atoms outatoms;
real t,comp;
int natoms;
char *grpname[MAX_ENDS],title[256],*anm="CA",*rnm="GLY";
int i,j,gnx[MAX_ENDS];
atom_id *index[MAX_ENDS];
t_bundle bun;
bool bKink;
rvec va,vb,vc,vr,vl;
#define NLEG asize(leg)
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-ol", "bun_len", ffWRITE },
{ efXVG, "-od", "bun_dist", ffWRITE },
{ efXVG, "-oz", "bun_z", ffWRITE },
{ efXVG, "-ot", "bun_tilt", ffWRITE },
{ efXVG, "-otr", "bun_tiltr", ffWRITE },
{ efXVG, "-otl", "bun_tiltl", ffWRITE },
{ efXVG, "-ok", "bun_kink", ffOPTWR },
{ efXVG, "-okr", "bun_kinkr", ffOPTWR },
{ efXVG, "-okl", "bun_kinkl", ffOPTWR },
{ efPDB, "-oa", "axes", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_TIME_UNIT | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL);
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xtop,NULL,box,TRUE);
bKink = opt2bSet("-ok",NFILE,fnm) || opt2bSet("-okr",NFILE,fnm)
|| opt2bSet("-okl",NFILE,fnm);
if (bKink)
bun.nend = 3;
else
bun.nend = 2;
fprintf(stderr,"Select a group of top and a group of bottom ");
if (bKink)
fprintf(stderr,"and a group of kink ");
fprintf(stderr,"atoms\n");
get_index(&top.atoms,ftp2fn_null(efNDX,NFILE,fnm),bun.nend,
gnx,index,grpname);
if (n<=0 || gnx[0] % n || gnx[1] % n || (bKink && gnx[2] % n))
gmx_fatal(FARGS,
"The size of one of your index groups is not a multiple of n");
bun.n = n;
snew(bun.end[0],n);
snew(bun.end[1],n);
if (bKink)
snew(bun.end[2],n);
snew(bun.mid,n);
snew(bun.dir,n);
snew(bun.len,n);
flen = xvgropen(opt2fn("-ol",NFILE,fnm),"Axis lengths",
xvgr_tlabel(),"(nm)");
fdist = xvgropen(opt2fn("-od",NFILE,fnm),"Distance of axis centers",
xvgr_tlabel(),"(nm)");
fz = xvgropen(opt2fn("-oz",NFILE,fnm),"Z-shift of axis centers",
xvgr_tlabel(),"(nm)");
ftilt = xvgropen(opt2fn("-ot",NFILE,fnm),"Axis tilts",
xvgr_tlabel(),"(degrees)");
ftiltr = xvgropen(opt2fn("-otr",NFILE,fnm),"Radial axis tilts",
xvgr_tlabel(),"(degrees)");
ftiltl = xvgropen(opt2fn("-otl",NFILE,fnm),"Lateral axis tilts",
xvgr_tlabel(),"(degrees)");
if (bKink) {
fkink = xvgropen(opt2fn("-ok",NFILE,fnm),"Kink angles",
xvgr_tlabel(),"(degrees)");
fkinkr = xvgropen(opt2fn("-okr",NFILE,fnm),"Radial kink angles",
xvgr_tlabel(),"(degrees)");
if (bPrintXvgrCodes())
fprintf(fkinkr,"@ subtitle \"+ = ) ( - = ( )\"\n");
fkinkl = xvgropen(opt2fn("-okl",NFILE,fnm),"Lateral kink angles",
xvgr_tlabel(),"(degrees)");
}
if (opt2bSet("-oa",NFILE,fnm)) {
init_t_atoms(&outatoms,3*n,FALSE);
outatoms.nr = 3*n;
for(i=0; i<3*n; i++) {
outatoms.atomname[i] = &anm;
outatoms.atom[i].resnr = i/3;
outatoms.resname[i/3] = &rnm;
}
fpdb = open_trx(opt2fn("-oa",NFILE,fnm),"w");
} else
fpdb = -1;
read_first_frame(&status,ftp2fn(efTRX,NFILE,fnm),&fr,TRX_NEED_X);
do {
rm_pbc(&top.idef,ePBC,fr.natoms,fr.box,fr.x,fr.x);
calc_axes(fr.x,top.atoms.atom,gnx,index,!bZ,&bun);
t = convert_time(fr.time);
fprintf(flen," %10g",t);
fprintf(fdist," %10g",t);
fprintf(fz," %10g",t);
fprintf(ftilt," %10g",t);
fprintf(ftiltr," %10g",t);
fprintf(ftiltl," %10g",t);
if (bKink) {
fprintf(fkink," %10g",t);
fprintf(fkinkr," %10g",t);
fprintf(fkinkl," %10g",t);
}
for(i=0; i<bun.n; i++) {
fprintf(flen," %6g",bun.len[i]);
fprintf(fdist," %6g",norm(bun.mid[i]));
fprintf(fz," %6g",bun.mid[i][ZZ]);
fprintf(ftilt," %6g",RAD2DEG*acos(bun.dir[i][ZZ]));
comp = bun.mid[i][XX]*bun.dir[i][XX]+bun.mid[i][YY]*bun.dir[i][YY];
fprintf(ftiltr," %6g",RAD2DEG*
asin(comp/sqrt(sqr(comp)+sqr(bun.dir[i][ZZ]))));
comp = bun.mid[i][YY]*bun.dir[i][XX]-bun.mid[i][XX]*bun.dir[i][YY];
fprintf(ftiltl," %6g",RAD2DEG*
asin(comp/sqrt(sqr(comp)+sqr(bun.dir[i][ZZ]))));
if (bKink) {
rvec_sub(bun.end[0][i],bun.end[2][i],va);
rvec_sub(bun.end[2][i],bun.end[1][i],vb);
unitv_no_table(va,va);
unitv_no_table(vb,vb);
fprintf(fkink," %6g",RAD2DEG*acos(iprod(va,vb)));
cprod(va,vb,vc);
copy_rvec(bun.mid[i],vr);
vr[ZZ] = 0;
unitv_no_table(vr,vr);
fprintf(fkinkr," %6g",RAD2DEG*asin(iprod(vc,vr)));
vl[XX] = vr[YY];
vl[YY] = -vr[XX];
vl[ZZ] = 0;
fprintf(fkinkl," %6g",RAD2DEG*asin(iprod(vc,vl)));
}
}
fprintf(flen,"\n");
fprintf(fdist,"\n");
fprintf(fz,"\n");
fprintf(ftilt,"\n");
fprintf(ftiltr,"\n");
fprintf(ftiltl,"\n");
if (bKink) {
fprintf(fkink,"\n");
fprintf(fkinkr,"\n");
fprintf(fkinkl,"\n");
}
if (fpdb >= 0)
dump_axes(fpdb,&fr,&outatoms,&bun);
} while(read_next_frame(status,&fr));
close_trx(status);
if (fpdb >= 0)
close_trx(fpdb);
fclose(flen);
fclose(fdist);
fclose(fz);
fclose(ftilt);
fclose(ftiltr);
fclose(ftiltl);
if (bKink) {
fclose(fkink);
fclose(fkinkr);
fclose(fkinkl);
}
thanx(stderr);
return 0;
}
int main(int argc,char *argv[])
{
static char *desc[] = {
"do_dssp ",
"reads a trajectory file and computes the secondary structure for",
"each time frame ",
"calling the dssp program. If you do not have the dssp program,",
"get it. do_dssp assumes that the dssp executable is",
"/usr/local/bin/dssp. If this is not the case, then you should",
"set an environment variable [BB]DSSP[bb] pointing to the dssp",
"executable, e.g.: [PAR]",
"[TT]setenv DSSP /opt/dssp/bin/dssp[tt][PAR]",
"The structure assignment for each residue and time is written to an",
"[TT].xpm[tt] matrix file. This file can be visualized with for instance",
"[TT]xv[tt] and can be converted to postscript with [TT]xpm2ps[tt].",
"The number of residues with each secondary structure type and the",
"total secondary structure ([TT]-sss[tt]) count as a function of",
"time are also written to file ([TT]-sc[tt]).[PAR]",
"Solvent accessible surface (SAS) per residue can be calculated, both in",
"absolute values (A^2) and in fractions of the maximal accessible",
"surface of a residue. The maximal accessible surface is defined as",
"the accessible surface of a residue in a chain of glycines.",
"[BB]Note[bb] that the program [TT]g_sas[tt] can also compute SAS",
"and that is more efficient.[PAR]",
"Finally, this program can dump the secondary structure in a special file",
"[TT]ssdump.dat[tt] for usage in the program [TT]g_chi[tt]. Together",
"these two programs can be used to analyze dihedral properties as a",
"function of secondary structure type."
};
static bool bVerbose;
static char *ss_string="HEBT";
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"HIDDENGenerate miles of useless information" },
{ "-sss", FALSE, etSTR, {&ss_string},
"Secondary structures for structure count"}
};
int status;
FILE *tapein;
FILE *ss,*acc,*fTArea,*tmpf;
char *fnSCount,*fnArea,*fnTArea,*fnAArea;
char *leg[] = { "Phobic", "Phylic" };
t_topology top;
int ePBC;
t_atoms *atoms;
t_matrix mat;
int nres,nr0,naccr;
bool *bPhbres,bDoAccSurf;
real t;
int i,j,natoms,nframe=0;
matrix box;
int gnx;
char *grpnm,*ss_str;
atom_id *index;
rvec *xp,*x;
int *average_area;
real **accr,*av_area, *norm_av_area;
char pdbfile[32],tmpfile[32],title[256];
char dssp[256],*dptr;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efDAT, "-ssdump", "ssdump", ffOPTWR },
{ efMAP, "-map", "ss", ffLIBRD },
{ efXPM, "-o", "ss", ffWRITE },
{ efXVG, "-sc", "scount", ffWRITE },
{ efXPM, "-a", "area", ffOPTWR },
{ efXVG, "-ta", "totarea", ffOPTWR },
{ efXVG, "-aa", "averarea",ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_TIME_UNIT | PCA_BE_NICE ,
NFILE,fnm, asize(pa),pa, asize(desc),desc,0,NULL);
fnSCount= opt2fn("-sc",NFILE,fnm);
fnArea = opt2fn_null("-a", NFILE,fnm);
fnTArea = opt2fn_null("-ta",NFILE,fnm);
fnAArea = opt2fn_null("-aa",NFILE,fnm);
bDoAccSurf=(fnArea || fnTArea || fnAArea);
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xp,NULL,box,FALSE);
atoms=&(top.atoms);
check_oo(atoms);
bPhbres=bPhobics(atoms);
get_index(atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&gnx,&index,&grpnm);
nres=0;
nr0=-1;
for(i=0; (i<gnx); i++) {
if (atoms->atom[index[i]].resnr != nr0) {
nr0=atoms->atom[index[i]].resnr;
nres++;
}
}
fprintf(stderr,"There are %d residues in your selected group\n",nres);
strcpy(pdbfile,"ddXXXXXX");
gmx_tmpnam(pdbfile);
if ((tmpf = fopen(pdbfile,"w")) == NULL) {
sprintf(pdbfile,"%ctmp%cfilterXXXXXX",DIR_SEPARATOR,DIR_SEPARATOR);
gmx_tmpnam(pdbfile);
if ((tmpf = fopen(pdbfile,"w")) == NULL)
gmx_fatal(FARGS,"Can not open tmp file %s",pdbfile);
}
else
fclose(tmpf);
strcpy(tmpfile,"ddXXXXXX");
gmx_tmpnam(tmpfile);
if ((tmpf = fopen(tmpfile,"w")) == NULL) {
sprintf(tmpfile,"%ctmp%cfilterXXXXXX",DIR_SEPARATOR,DIR_SEPARATOR);
gmx_tmpnam(tmpfile);
if ((tmpf = fopen(tmpfile,"w")) == NULL)
gmx_fatal(FARGS,"Can not open tmp file %s",tmpfile);
}
else
fclose(tmpf);
if ((dptr=getenv("DSSP")) == NULL)
dptr="/usr/local/bin/dssp";
if (!fexist(dptr))
gmx_fatal(FARGS,"DSSP executable (%s) does not exist (use setenv DSSP)",
dptr);
sprintf(dssp,"%s %s %s %s > /dev/null %s",
dptr,bDoAccSurf?"":"-na",pdbfile,tmpfile,bVerbose?"":"2> /dev/null");
if (bVerbose)
fprintf(stderr,"dssp cmd='%s'\n",dssp);
if (fnTArea) {
fTArea=xvgropen(fnTArea,"Solvent Accessible Surface Area",
xvgr_tlabel(),"Area (nm\\S2\\N)");
xvgr_legend(fTArea,2,leg);
} else
fTArea=NULL;
mat.map=NULL;
mat.nmap=getcmap(libopen(opt2fn("-map",NFILE,fnm)),
opt2fn("-map",NFILE,fnm),&(mat.map));
natoms=read_first_x(&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
if (natoms > atoms->nr)
gmx_fatal(FARGS,"\nTrajectory does not match topology!");
if (gnx > natoms)
gmx_fatal(FARGS,"\nTrajectory does not match selected group!");
snew(average_area,atoms->nres+10);
snew(av_area,atoms->nres+10);
snew(norm_av_area,atoms->nres+10);
accr=NULL;
naccr=0;
do {
t = convert_time(t);
if (nframe>=naccr) {
naccr+=10;
srenew(accr,naccr);
for(i=naccr-10; i<naccr; i++)
snew(accr[i],atoms->nres+10);
}
rm_pbc(&(top.idef),ePBC,natoms,box,x,x);
tapein=ffopen(pdbfile,"w");
write_pdbfile_indexed(tapein,NULL,atoms,x,ePBC,box,0,-1,gnx,index);
fclose(tapein);
#ifdef GMX_NO_SYSTEM
printf("Warning-- No calls to system(3) supported on this platform.");
printf("Warning-- Skipping execution of 'system(\"%s\")'.", dssp);
exit(1);
#else
if(0 != system(dssp))
{
gmx_fatal(FARGS,"Failed to execute command: %s",dssp);
}
#endif
strip_dssp(tmpfile,nres,bPhbres,t,
accr[nframe],fTArea,&mat,average_area);
remove(tmpfile);
remove(pdbfile);
nframe++;
} while(read_next_x(status,&t,natoms,x,box));
fprintf(stderr,"\n");
close_trj(status);
if (fTArea)
ffclose(fTArea);
prune_ss_legend(&mat);
ss=opt2FILE("-o",NFILE,fnm,"w");
write_xpm_m(ss,mat);
ffclose(ss);
if (opt2bSet("-ssdump",NFILE,fnm)) {
snew(ss_str,nres+1);
for(i=0; (i<nres); i++)
ss_str[i] = mat.map[mat.matrix[0][i]].code.c1;
ss_str[i] = '\0';
ss = opt2FILE("-ssdump",NFILE,fnm,"w");
fprintf(ss,"%d\n%s\n",nres,ss_str);
fclose(ss);
sfree(ss_str);
}
analyse_ss(fnSCount,&mat,ss_string);
if (bDoAccSurf) {
write_sas_mat(fnArea,accr,nframe,nres,&mat);
for(i=0; i<atoms->nres; i++)
av_area[i] = (average_area[i] / (real)nframe);
norm_acc(atoms, nres, av_area, norm_av_area);
if (fnAArea) {
acc=xvgropen(fnAArea,"Average Accessible Area",
"Residue","A\\S2");
for(i=0; (i<nres); i++)
fprintf(acc,"%5d %10g %10g\n",i+1,av_area[i], norm_av_area[i]);
ffclose(acc);
}
}
view_all(NFILE, fnm);
thanx(stderr);
return 0;
}
int gmx_rmsf(int argc,char *argv[])
{
static char *desc[] = {
"g_rmsf computes the root mean square fluctuation (RMSF, i.e. standard ",
"deviation) of atomic positions ",
"after (optionally) fitting to a reference frame.[PAR]",
"With option [TT]-oq[tt] the RMSF values are converted to B-factor",
"values, which are written to a pdb file with the coordinates, of the",
"structure file, or of a pdb file when [TT]-q[tt] is specified.",
"Option [TT]-ox[tt] writes the B-factors to a file with the average",
"coordinates.[PAR]",
"With the option [TT]-od[tt] the root mean square deviation with",
"respect to the reference structure is calculated.[PAR]",
"With the option [TT]aniso[tt] g_rmsf will compute anisotropic",
"temperature factors and then it will also output average coordinates",
"and a pdb file with ANISOU records (corresonding to the [TT]-oq[tt]",
"or [TT]-ox[tt] option). Please note that the U values",
"are orientation dependent, so before comparison with experimental data",
"you should verify that you fit to the experimental coordinates.[PAR]",
"When a pdb input file is passed to the program and the [TT]-aniso[tt]",
"flag is set",
"a correlation plot of the Uij will be created, if any anisotropic",
"temperature factors are present in the pdb file.[PAR]",
"With option [TT]-dir[tt] the average MSF (3x3) matrix is diagonalized.",
"This shows the directions in which the atoms fluctuate the most and",
"the least."
};
static bool bRes=FALSE,bAniso=FALSE,bdevX=FALSE,bFit=TRUE;
t_pargs pargs[] = {
{ "-res", FALSE, etBOOL, {&bRes},
"Calculate averages for each residue" },
{ "-aniso",FALSE, etBOOL, {&bAniso},
"Compute anisotropic termperature factors" },
{ "-fit", FALSE, etBOOL, {&bFit},
"Do a least squares superposition before computing RMSF. Without this you must make sure that the reference structure and the trajectory match." }
};
int step,nre,natom,natoms,i,g,m,teller=0;
real t,lambda,*w_rls,*w_rms;
t_tpxheader header;
t_inputrec ir;
t_topology top;
int ePBC;
t_atoms *pdbatoms,*refatoms;
bool bCont;
matrix box,pdbbox;
rvec *x,*pdbx,*xref;
int status,npdbatoms,res0;
char buf[256],*label;
char title[STRLEN];
FILE *fp; /* the graphics file */
char *devfn,*dirfn;
int resnr;
bool bReadPDB;
atom_id *index;
int isize;
char *grpnames;
real bfac,pdb_bfac,*Uaver;
double **U,*xav;
atom_id aid;
rvec *rmsd_x=NULL;
real *rmsf,invcount,totmass;
int d;
real count=0;
rvec xcm;
char *leg[2] = { "MD", "X-Ray" };
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efPDB, "-q", NULL, ffOPTRD },
{ efPDB, "-oq", "bfac", ffOPTWR },
{ efPDB, "-ox", "xaver", ffOPTWR },
{ efXVG, "-o", "rmsf", ffWRITE },
{ efXVG, "-od", "rmsdev", ffOPTWR },
{ efXVG, "-oc", "correl", ffOPTWR },
{ efLOG, "-dir", "rmsf", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_BE_NICE ,
NFILE,fnm,asize(pargs),pargs,asize(desc),desc,0,NULL);
bReadPDB = ftp2bSet(efPDB,NFILE,fnm);
devfn = opt2fn_null("-od",NFILE,fnm);
dirfn = opt2fn_null("-dir",NFILE,fnm);
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xref,NULL,box,TRUE);
snew(w_rls,top.atoms.nr);
fprintf(stderr,"Select group(s) for root mean square calculation\n");
get_index(&top.atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&isize,&index,&grpnames);
/* Set the weight */
for(i=0; i<isize; i++)
w_rls[index[i]]=top.atoms.atom[index[i]].m;
/* Malloc the rmsf arrays */
snew(xav,isize*DIM);
snew(U,isize);
for(i=0; i<isize; i++)
snew(U[i],DIM*DIM);
snew(rmsf,isize);
if (devfn)
snew(rmsd_x, isize);
if (bReadPDB) {
get_stx_coordnum(opt2fn("-q",NFILE,fnm),&npdbatoms);
snew(pdbatoms,1);
snew(refatoms,1);
init_t_atoms(pdbatoms,npdbatoms,TRUE);
init_t_atoms(refatoms,npdbatoms,TRUE);
snew(pdbx,npdbatoms);
/* Read coordinates twice */
read_stx_conf(opt2fn("-q",NFILE,fnm),title,pdbatoms,pdbx,NULL,NULL,pdbbox);
read_stx_conf(opt2fn("-q",NFILE,fnm),title,refatoms,pdbx,NULL,NULL,pdbbox);
} else {
pdbatoms = &top.atoms;
refatoms = &top.atoms;
pdbx = xref;
npdbatoms = pdbatoms->nr;
snew(pdbatoms->pdbinfo,npdbatoms);
copy_mat(box,pdbbox);
}
if (bFit)
sub_xcm(xref,isize,index,top.atoms.atom,xcm,FALSE);
natom = read_first_x(&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
/* Now read the trj again to compute fluctuations */
teller = 0;
do {
if (bFit) {
/* Remove periodic boundary */
rm_pbc(&(top.idef),ePBC,natom,box,x,x);
/* Set center of mass to zero */
sub_xcm(x,isize,index,top.atoms.atom,xcm,FALSE);
/* Fit to reference structure */
do_fit(natom,w_rls,xref,x);
}
/* Calculate Anisotropic U Tensor */
for(i=0; i<isize; i++) {
aid = index[i];
for(d=0; d<DIM; d++) {
xav[i*DIM + d] += x[aid][d];
for(m=0; m<DIM; m++)
U[i][d*DIM + m] += x[aid][d]*x[aid][m];
}
}
if (devfn) {
/* Calculate RMS Deviation */
for(i=0;(i<isize);i++) {
aid = index[i];
for(d=0;(d<DIM);d++) {
rmsd_x[i][d] += sqr(x[aid][d]-xref[aid][d]);
}
}
}
count += 1.0;
teller++;
} while(read_next_x(status,&t,natom,x,box));
close_trj(status);
invcount = 1.0/count;
snew(Uaver,DIM*DIM);
totmass = 0;
for(i=0; i<isize; i++) {
for(d=0; d<DIM; d++)
xav[i*DIM + d] *= invcount;
for(d=0; d<DIM; d++)
for(m=0; m<DIM; m++) {
U[i][d*DIM + m] = U[i][d*DIM + m]*invcount
- xav[i*DIM + d]*xav[i*DIM + m];
Uaver[3*d+m] += top.atoms.atom[index[i]].m*U[i][d*DIM + m];
}
totmass += top.atoms.atom[index[i]].m;
}
for(d=0; d<DIM*DIM; d++)
Uaver[d] /= totmass;
if (bAniso) {
for(i=0; i<isize; i++) {
aid = index[i];
pdbatoms->pdbinfo[aid].bAnisotropic = TRUE;
pdbatoms->pdbinfo[aid].uij[U11] = 1e6*U[i][XX*DIM + XX];
pdbatoms->pdbinfo[aid].uij[U22] = 1e6*U[i][YY*DIM + YY];
pdbatoms->pdbinfo[aid].uij[U33] = 1e6*U[i][ZZ*DIM + ZZ];
pdbatoms->pdbinfo[aid].uij[U12] = 1e6*U[i][XX*DIM + YY];
pdbatoms->pdbinfo[aid].uij[U13] = 1e6*U[i][XX*DIM + ZZ];
pdbatoms->pdbinfo[aid].uij[U23] = 1e6*U[i][YY*DIM + ZZ];
}
}
if (bRes) {
average_residues(rmsf,isize,index,w_rls,&top.atoms);
label = "Residue";
} else
label = "Atom";
for(i=0; i<isize; i++)
rmsf[i] = U[i][XX*DIM + XX] + U[i][YY*DIM + YY] + U[i][ZZ*DIM + ZZ];
if (dirfn) {
fprintf(stdout,"\n");
print_dir(stdout,Uaver);
fp = ffopen(dirfn,"w");
print_dir(fp,Uaver);
fclose(fp);
}
for(i=0; i<isize; i++)
sfree(U[i]);
sfree(U);
/* Write RMSF output */
if (bReadPDB) {
bfac = 8.0*M_PI*M_PI/3.0*100;
fp = xvgropen(ftp2fn(efXVG,NFILE,fnm),"B-Factors",
label,"(A\\b\\S\\So\\N\\S2\\N)");
xvgr_legend(fp,2,leg);
for(i=0;(i<isize);i++) {
if (!bRes || i+1==isize ||
top.atoms.atom[index[i]].resnr!=top.atoms.atom[index[i+1]].resnr) {
resnr = top.atoms.atom[index[i]].resnr;
pdb_bfac = find_pdb_bfac(pdbatoms,*(top.atoms.resname[resnr]),resnr,
*(top.atoms.atomname[index[i]]));
fprintf(fp,"%5d %10.5f %10.5f\n",
bRes ? top.atoms.atom[index[i]].resnr+1 : i+1,rmsf[i]*bfac,
pdb_bfac);
}
}
fclose(fp);
} else {
fp = xvgropen(ftp2fn(efXVG,NFILE,fnm),"RMS fluctuation",label,"(nm)");
for(i=0; i<isize; i++)
if (!bRes || i+1==isize ||
top.atoms.atom[index[i]].resnr!=top.atoms.atom[index[i+1]].resnr)
fprintf(fp,"%5d %8.4f\n",
bRes ? top.atoms.atom[index[i]].resnr+1 : i+1,sqrt(rmsf[i]));
fclose(fp);
}
for(i=0; i<isize; i++)
pdbatoms->pdbinfo[index[i]].bfac = 800*M_PI*M_PI/3.0*rmsf[i];
if (devfn) {
for(i=0; i<isize; i++)
rmsf[i] = (rmsd_x[i][XX]+rmsd_x[i][YY]+rmsd_x[i][ZZ])/count;
if (bRes)
average_residues(rmsf,isize,index,w_rls,&top.atoms);
/* Write RMSD output */
fp = xvgropen(devfn,"RMS Deviation",label,"(nm)");
for(i=0; i<isize; i++)
if (!bRes || i+1==isize ||
top.atoms.atom[index[i]].resnr!=top.atoms.atom[index[i+1]].resnr)
fprintf(fp,"%5d %8.4f\n",
bRes ? top.atoms.atom[index[i]].resnr+1 : i+1,sqrt(rmsf[i]));
fclose(fp);
}
if (opt2bSet("-oq",NFILE,fnm)) {
/* Write a pdb file with B-factors and optionally anisou records */
for(i=0; i<isize; i++)
rvec_inc(xref[index[i]],xcm);
write_sto_conf_indexed(opt2fn("-oq",NFILE,fnm),title,pdbatoms,pdbx,
NULL,ePBC,pdbbox,isize,index);
}
if (opt2bSet("-ox",NFILE,fnm)) {
/* Misuse xref as a temporary array */
for(i=0; i<isize; i++)
for(d=0; d<DIM; d++)
xref[index[i]][d] = xcm[d] + xav[i*DIM + d];
/* Write a pdb file with B-factors and optionally anisou records */
write_sto_conf_indexed(opt2fn("-ox",NFILE,fnm),title,pdbatoms,xref,NULL,
ePBC,pdbbox,isize,index);
}
if (bAniso) {
correlate_aniso(opt2fn("-oc",NFILE,fnm),refatoms,pdbatoms);
do_view(opt2fn("-oc",NFILE,fnm),"-nxy");
}
do_view(opt2fn("-o",NFILE,fnm),"-nxy");
if (devfn)
do_view(opt2fn("-od",NFILE,fnm),"-nxy");
thanx(stderr);
return 0;
}
int gmx_covar(int argc,char *argv[])
{
static char *desc[] = {
"[TT]g_covar[tt] calculates and diagonalizes the (mass-weighted)",
"covariance matrix.",
"All structures are fitted to the structure in the structure file.",
"When this is not a run input file periodicity will not be taken into",
"account. When the fit and analysis groups are identical and the analysis",
"is non mass-weighted, the fit will also be non mass-weighted.",
"[PAR]",
"The eigenvectors are written to a trajectory file ([TT]-v[tt]).",
"When the same atoms are used for the fit and the covariance analysis,",
"the reference structure for the fit is written first with t=-1.",
"The average (or reference when [TT]-ref[tt] is used) structure is",
"written with t=0, the eigenvectors",
"are written as frames with the eigenvector number as timestamp.",
"[PAR]",
"The eigenvectors can be analyzed with [TT]g_anaeig[tt].",
"[PAR]",
"Option [TT]-ascii[tt] writes the whole covariance matrix to",
"an ASCII file. The order of the elements is: x1x1, x1y1, x1z1, x1x2, ...",
"[PAR]",
"Option [TT]-xpm[tt] writes the whole covariance matrix to an xpm file.",
"[PAR]",
"Option [TT]-xpma[tt] writes the atomic covariance matrix to an xpm file,",
"i.e. for each atom pair the sum of the xx, yy and zz covariances is",
"written."
};
static bool bFit=TRUE,bRef=FALSE,bM=FALSE,bPBC=TRUE;
static int end=-1;
t_pargs pa[] = {
{ "-fit", FALSE, etBOOL, {&bFit},
"Fit to a reference structure"},
{ "-ref", FALSE, etBOOL, {&bRef},
"Use the deviation from the conformation in the structure file instead of from the average" },
{ "-mwa", FALSE, etBOOL, {&bM},
"Mass-weighted covariance analysis"},
{ "-last", FALSE, etINT, {&end},
"Last eigenvector to write away (-1 is till the last)" },
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Apply corrections for periodic boundary conditions" }
};
FILE *out;
int status,trjout;
t_topology top;
int ePBC;
t_atoms *atoms;
rvec *x,*xread,*xref,*xav,*xproj;
matrix box,zerobox;
real *sqrtm,*mat,*eigval,sum,trace,inv_nframes;
real t,tstart,tend,**mat2;
real xj,*w_rls=NULL;
real min,max,*axis;
int ntopatoms,step;
int natoms,nat,ndim,count,nframes0,nframes,nlevels;
int WriteXref;
char *fitfile,*trxfile,*ndxfile;
char *eigvalfile,*eigvecfile,*averfile,*logfile;
char *asciifile,*xpmfile,*xpmafile;
char str[STRLEN],*fitname,*ananame;
int i,j,k,l,d,dj,nfit;
atom_id *index,*ifit;
bool bDiffMass1,bDiffMass2;
time_t now;
t_rgb rlo,rmi,rhi;
real *tmp;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "eigenval", ffWRITE },
{ efTRN, "-v", "eigenvec", ffWRITE },
{ efSTO, "-av", "average.pdb", ffWRITE },
{ efLOG, NULL, "covar", ffWRITE },
{ efDAT, "-ascii","covar", ffOPTWR },
{ efXPM, "-xpm","covar", ffOPTWR },
{ efXPM, "-xpma","covara", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_TIME_UNIT | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL);
clear_mat(zerobox);
fitfile = ftp2fn(efTPS,NFILE,fnm);
trxfile = ftp2fn(efTRX,NFILE,fnm);
ndxfile = ftp2fn_null(efNDX,NFILE,fnm);
eigvalfile = ftp2fn(efXVG,NFILE,fnm);
eigvecfile = ftp2fn(efTRN,NFILE,fnm);
averfile = ftp2fn(efSTO,NFILE,fnm);
logfile = ftp2fn(efLOG,NFILE,fnm);
asciifile = opt2fn_null("-ascii",NFILE,fnm);
xpmfile = opt2fn_null("-xpm",NFILE,fnm);
xpmafile = opt2fn_null("-xpma",NFILE,fnm);
read_tps_conf(fitfile,str,&top,&ePBC,&xref,NULL,box,TRUE);
atoms=&top.atoms;
if (bFit) {
printf("\nChoose a group for the least squares fit\n");
get_index(atoms,ndxfile,1,&nfit,&ifit,&fitname);
if (nfit < 3)
gmx_fatal(FARGS,"Need >= 3 points to fit!\n");
} else
nfit=0;
printf("\nChoose a group for the covariance analysis\n");
get_index(atoms,ndxfile,1,&natoms,&index,&ananame);
bDiffMass1=FALSE;
if (bFit) {
snew(w_rls,atoms->nr);
for(i=0; (i<nfit); i++) {
w_rls[ifit[i]]=atoms->atom[ifit[i]].m;
if (i)
bDiffMass1 = bDiffMass1 || (w_rls[ifit[i]]!=w_rls[ifit[i-1]]);
}
}
bDiffMass2=FALSE;
snew(sqrtm,natoms);
for(i=0; (i<natoms); i++)
if (bM) {
sqrtm[i]=sqrt(atoms->atom[index[i]].m);
if (i)
bDiffMass2 = bDiffMass2 || (sqrtm[i]!=sqrtm[i-1]);
}
else
sqrtm[i]=1.0;
if (bFit && bDiffMass1 && !bDiffMass2) {
bDiffMass1 = natoms != nfit;
i=0;
for (i=0; (i<natoms) && !bDiffMass1; i++)
bDiffMass1 = index[i] != ifit[i];
if (!bDiffMass1) {
fprintf(stderr,"\n"
"Note: the fit and analysis group are identical,\n"
" while the fit is mass weighted and the analysis is not.\n"
" Making the fit non mass weighted.\n\n");
for(i=0; (i<nfit); i++)
w_rls[ifit[i]]=1.0;
}
}
/* Prepare reference frame */
if (bPBC)
rm_pbc(&(top.idef),ePBC,atoms->nr,box,xref,xref);
if (bFit)
reset_x(nfit,ifit,atoms->nr,NULL,xref,w_rls);
snew(x,natoms);
snew(xav,natoms);
ndim=natoms*DIM;
snew(mat,ndim*ndim);
fprintf(stderr,"Calculating the average structure ...\n");
nframes0 = 0;
nat=read_first_x(&status,trxfile,&t,&xread,box);
if (nat != atoms->nr)
fprintf(stderr,"\nWARNING: number of atoms in tpx (%d) and trajectory (%d) do not match\n",natoms,nat);
do {
nframes0++;
/* calculate x: a fitted struture of the selected atoms */
if (bPBC)
rm_pbc(&(top.idef),ePBC,nat,box,xread,xread);
if (bFit) {
reset_x(nfit,ifit,nat,NULL,xread,w_rls);
do_fit(nat,w_rls,xref,xread);
}
for (i=0; i<natoms; i++)
rvec_inc(xav[i],xread[index[i]]);
} while (read_next_x(status,&t,nat,xread,box));
close_trj(status);
inv_nframes = 1.0/nframes0;
for(i=0; i<natoms; i++)
for(d=0; d<DIM; d++) {
xav[i][d] *= inv_nframes;
xread[index[i]][d] = xav[i][d];
}
write_sto_conf_indexed(opt2fn("-av",NFILE,fnm),"Average structure",
atoms,xread,NULL,epbcNONE,zerobox,natoms,index);
sfree(xread);
fprintf(stderr,"Constructing covariance matrix (%dx%d) ...\n",ndim,ndim);
nframes=0;
nat=read_first_x(&status,trxfile,&t,&xread,box);
tstart = t;
do {
nframes++;
tend = t;
/* calculate x: a (fitted) structure of the selected atoms */
if (bPBC)
rm_pbc(&(top.idef),ePBC,nat,box,xread,xread);
if (bFit) {
reset_x(nfit,ifit,nat,NULL,xread,w_rls);
do_fit(nat,w_rls,xref,xread);
}
if (bRef)
for (i=0; i<natoms; i++)
rvec_sub(xread[index[i]],xref[index[i]],x[i]);
else
for (i=0; i<natoms; i++)
rvec_sub(xread[index[i]],xav[i],x[i]);
for (j=0; j<natoms; j++) {
for (dj=0; dj<DIM; dj++) {
k=ndim*(DIM*j+dj);
xj=x[j][dj];
for (i=j; i<natoms; i++) {
l=k+DIM*i;
for(d=0; d<DIM; d++)
mat[l+d] += x[i][d]*xj;
}
}
}
} while (read_next_x(status,&t,nat,xread,box) &&
(bRef || nframes < nframes0));
close_trj(status);
fprintf(stderr,"Read %d frames\n",nframes);
if (bRef) {
/* copy the reference structure to the ouput array x */
snew(xproj,natoms);
for (i=0; i<natoms; i++)
copy_rvec(xref[index[i]],xproj[i]);
} else {
xproj = xav;
}
/* correct the covariance matrix for the mass */
inv_nframes = 1.0/nframes;
for (j=0; j<natoms; j++)
for (dj=0; dj<DIM; dj++)
for (i=j; i<natoms; i++) {
k = ndim*(DIM*j+dj)+DIM*i;
for (d=0; d<DIM; d++)
mat[k+d] = mat[k+d]*inv_nframes*sqrtm[i]*sqrtm[j];
}
/* symmetrize the matrix */
for (j=0; j<ndim; j++)
for (i=j; i<ndim; i++)
mat[ndim*i+j]=mat[ndim*j+i];
trace=0;
for(i=0; i<ndim; i++)
trace+=mat[i*ndim+i];
fprintf(stderr,"\nTrace of the covariance matrix: %g (%snm^2)\n",
trace,bM ? "u " : "");
if (asciifile) {
out = ffopen(asciifile,"w");
for (j=0; j<ndim; j++) {
for (i=0; i<ndim; i+=3)
fprintf(out,"%g %g %g\n",
mat[ndim*j+i],mat[ndim*j+i+1],mat[ndim*j+i+2]);
}
fclose(out);
}
if (xpmfile) {
min = 0;
max = 0;
snew(mat2,ndim);
for (j=0; j<ndim; j++) {
mat2[j] = &(mat[ndim*j]);
for (i=0; i<=j; i++) {
if (mat2[j][i] < min)
min = mat2[j][i];
if (mat2[j][j] > max)
max = mat2[j][i];
}
}
snew(axis,ndim);
for(i=0; i<ndim; i++)
axis[i] = i+1;
rlo.r = 0; rlo.g = 0; rlo.b = 1;
rmi.r = 1; rmi.g = 1; rmi.b = 1;
rhi.r = 1; rhi.g = 0; rhi.b = 0;
out = ffopen(xpmfile,"w");
nlevels = 80;
write_xpm3(out,0,"Covariance",bM ? "u nm^2" : "nm^2",
"dim","dim",ndim,ndim,axis,axis,
mat2,min,0.0,max,rlo,rmi,rhi,&nlevels);
fclose(out);
sfree(axis);
sfree(mat2);
}
if (xpmafile) {
min = 0;
max = 0;
snew(mat2,ndim/DIM);
for (i=0; i<ndim/DIM; i++)
snew(mat2[i],ndim/DIM);
for (j=0; j<ndim/DIM; j++) {
for (i=0; i<=j; i++) {
mat2[j][i] = 0;
for(d=0; d<DIM; d++)
mat2[j][i] += mat[ndim*(DIM*j+d)+DIM*i+d];
if (mat2[j][i] < min)
min = mat2[j][i];
if (mat2[j][j] > max)
max = mat2[j][i];
mat2[i][j] = mat2[j][i];
}
}
snew(axis,ndim/DIM);
for(i=0; i<ndim/DIM; i++)
axis[i] = i+1;
rlo.r = 0; rlo.g = 0; rlo.b = 1;
rmi.r = 1; rmi.g = 1; rmi.b = 1;
rhi.r = 1; rhi.g = 0; rhi.b = 0;
out = ffopen(xpmafile,"w");
nlevels = 80;
write_xpm3(out,0,"Covariance",bM ? "u nm^2" : "nm^2",
"atom","atom",ndim/DIM,ndim/DIM,axis,axis,
mat2,min,0.0,max,rlo,rmi,rhi,&nlevels);
fclose(out);
sfree(axis);
for (i=0; i<ndim/DIM; i++)
sfree(mat2[i]);
sfree(mat2);
}
/* call diagonalization routine */
fprintf(stderr,"\nDiagonalizing ...\n");
fflush(stderr);
snew(eigval,ndim);
snew(tmp,ndim*ndim);
memcpy(tmp,mat,ndim*ndim*sizeof(real));
eigensolver(tmp,ndim,0,ndim,eigval,mat);
sfree(tmp);
/* now write the output */
sum=0;
for(i=0; i<ndim; i++)
sum+=eigval[i];
fprintf(stderr,"\nSum of the eigenvalues: %g (%snm^2)\n",
sum,bM ? "u " : "");
if (fabs(trace-sum)>0.01*trace)
fprintf(stderr,"\nWARNING: eigenvalue sum deviates from the trace of the covariance matrix\n");
fprintf(stderr,"\nWriting eigenvalues to %s\n",eigvalfile);
sprintf(str,"(%snm\\S2\\N)",bM ? "u " : "");
out=xvgropen(eigvalfile,
"Eigenvalues of the covariance matrix",
"Eigenvector index",str);
for (i=0; (i<ndim); i++)
fprintf (out,"%10d %g\n",i+1,eigval[ndim-1-i]);
fclose(out);
if (end==-1) {
if (nframes-1 < ndim)
end=nframes-1;
else
end=ndim;
}
if (bFit) {
/* misuse lambda: 0/1 mass weighted analysis no/yes */
if (nfit==natoms) {
WriteXref = eWXR_YES;
for(i=0; i<nfit; i++)
copy_rvec(xref[ifit[i]],x[i]);
} else
WriteXref = eWXR_NO;
} else {
/* misuse lambda: -1 for no fit */
WriteXref = eWXR_NOFIT;
}
write_eigenvectors(eigvecfile,natoms,mat,TRUE,1,end,
WriteXref,x,bDiffMass1,xproj,bM,eigval);
out = ffopen(logfile,"w");
now = time(NULL);
fprintf(out,"Covariance analysis log, written %s\n",
ctime(&now));
fprintf(out,"Program: %s\n",argv[0]);
if(NULL==getcwd(str,STRLEN))
{
gmx_fatal(FARGS,"Current working directory is undefined");
}
fprintf(out,"Working directory: %s\n\n",str);
fprintf(out,"Read %d frames from %s (time %g to %g %s)\n",nframes,trxfile,
convert_time(tstart),convert_time(tend),time_unit());
if (bFit)
fprintf(out,"Read reference structure for fit from %s\n",fitfile);
if (ndxfile)
fprintf(out,"Read index groups from %s\n",ndxfile);
fprintf(out,"\n");
fprintf(out,"Analysis group is '%s' (%d atoms)\n",ananame,natoms);
if (bFit)
fprintf(out,"Fit group is '%s' (%d atoms)\n",fitname,nfit);
else
fprintf(out,"No fit was used\n");
fprintf(out,"Analysis is %smass weighted\n", bDiffMass2 ? "":"non-");
if (bFit)
fprintf(out,"Fit is %smass weighted\n", bDiffMass1 ? "":"non-");
fprintf(out,"Diagonalized the %dx%d covariance matrix\n",ndim,ndim);
fprintf(out,"Trace of the covariance matrix before diagonalizing: %g\n",
trace);
fprintf(out,"Trace of the covariance matrix after diagonalizing: %g\n\n",
sum);
fprintf(out,"Wrote %d eigenvalues to %s\n",ndim,eigvalfile);
if (WriteXref == eWXR_YES)
fprintf(out,"Wrote reference structure to %s\n",eigvecfile);
fprintf(out,"Wrote average structure to %s and %s\n",averfile,eigvecfile);
fprintf(out,"Wrote eigenvectors %d to %d to %s\n",1,end,eigvecfile);
fclose(out);
fprintf(stderr,"Wrote the log to %s\n",logfile);
thanx(stderr);
return 0;
}
int main(int argc,char *argv[])
{
static char *desc[] = {
"The [TT]pmetest[tt] program tests the scaling of the PME code. When only given",
"a [TT].tpr[tt] file it will compute PME for one frame. When given a trajectory",
"it will do so for all the frames in the trajectory. Before the PME",
"routine is called the coordinates are sorted along the X-axis.[PAR]",
"As an extra service to the public the program can also compute",
"long-range Coulomb energies for components of the system. When the",
"[TT]-groups[tt] flag is given to the program the energy groups",
"from the [TT].tpr[tt] file will be read, and half an energy matrix computed."
};
t_commrec *cr,*mcr;
static t_filenm fnm[] = {
{ efTPX, NULL, NULL, ffREAD },
{ efTRN, "-o", NULL, ffWRITE },
{ efLOG, "-g", "pme", ffWRITE },
{ efTRX, "-f", NULL, ffOPTRD },
{ efXVG, "-x", "ener-pme", ffWRITE }
};
#define NFILE asize(fnm)
/* Command line options ! */
static gmx_bool bVerbose=FALSE;
static gmx_bool bOptFFT=FALSE;
static gmx_bool bSort=FALSE;
static int ewald_geometry=eewg3D;
static int nnodes=1;
static int pme_order=0;
static rvec grid = { -1, -1, -1 };
static real rc = 0.0;
static real dtol = 0.0;
static gmx_bool bGroups = FALSE;
static t_pargs pa[] = {
{ "-np", FALSE, etINT, {&nnodes},
"Number of nodes, must be the same as used for [TT]grompp[tt]" },
{ "-v", FALSE, etBOOL,{&bVerbose},
"Be loud and noisy" },
{ "-sort", FALSE, etBOOL,{&bSort},
"Sort coordinates. Crucial for domain decomposition." },
{ "-grid", FALSE, etRVEC,{&grid},
"Number of grid cells in X, Y, Z dimension (if -1 use from [TT].tpr[tt])" },
{ "-order", FALSE, etINT, {&pme_order},
"Order of the PME spreading algorithm" },
{ "-groups", FALSE, etBOOL, {&bGroups},
"Compute half an energy matrix based on the energy groups in your [TT].tpr[tt] file" },
{ "-rc", FALSE, etREAL, {&rc},
"Rcoulomb for Ewald summation" },
{ "-tol", FALSE, etREAL, {&dtol},
"Tolerance for Ewald summation" }
};
FILE *fp;
t_inputrec *ir;
t_topology top;
t_tpxheader tpx;
t_nrnb nrnb;
t_nsborder *nsb;
t_forcerec *fr;
t_mdatoms *mdatoms;
char title[STRLEN];
int natoms,step,status,i,ncg,root;
real t,lambda,ewaldcoeff,qtot;
rvec *x,*f,*xbuf;
int *index;
gmx_bool bCont;
real *charge,*qbuf,*qqbuf;
matrix box;
/* Start the actual parallel code if necessary */
cr = init_par(&argc,&argv);
root = 0;
if (MASTER(cr))
CopyRight(stderr,argv[0]);
/* Parse command line on all processors, arguments are passed on in
* init_par (see above)
*/
parse_common_args(&argc,argv,
PCA_KEEP_ARGS | PCA_NOEXIT_ON_ARGS | PCA_BE_NICE |
PCA_CAN_SET_DEFFNM | (MASTER(cr) ? 0 : PCA_QUIET),
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL);
#ifndef GMX_MPI
if (nnodes > 1)
gmx_fatal(FARGS,"GROMACS compiled without MPI support - can't do parallel runs");
#endif
/* Open log files on all processors */
open_log(ftp2fn(efLOG,NFILE,fnm),cr);
snew(ir,1);
if (MASTER(cr)) {
/* Read tpr file etc. */
read_tpxheader(ftp2fn(efTPX,NFILE,fnm),&tpx,FALSE,NULL,NULL);
snew(x,tpx.natoms);
read_tpx(ftp2fn(efTPX,NFILE,fnm),&step,&t,&lambda,ir,
box,&natoms,x,NULL,NULL,&top);
/* Charges */
qtot = 0;
snew(charge,natoms);
for(i=0; (i<natoms); i++) {
charge[i] = top.atoms.atom[i].q;
qtot += charge[i];
}
/* Grid stuff */
if (opt2parg_bSet("-grid",asize(pa),pa)) {
ir->nkx = grid[XX];
ir->nky = grid[YY];
ir->nkz = grid[ZZ];
}
/* Check command line parameters for consistency */
if ((ir->nkx <= 0) || (ir->nky <= 0) || (ir->nkz <= 0))
gmx_fatal(FARGS,"PME grid = %d %d %d",ir->nkx,ir->nky,ir->nkz);
if (opt2parg_bSet("-rc",asize(pa),pa))
ir->rcoulomb = rc;
if (ir->rcoulomb <= 0)
gmx_fatal(FARGS,"rcoulomb should be > 0 (not %f)",ir->rcoulomb);
if (opt2parg_bSet("-order",asize(pa),pa))
ir->pme_order = pme_order;
if (ir->pme_order <= 0)
gmx_fatal(FARGS,"pme_order should be > 0 (not %d)",ir->pme_order);
if (opt2parg_bSet("-tol",asize(pa),pa))
ir->ewald_rtol = dtol;
if (ir->ewald_rtol <= 0)
gmx_fatal(FARGS,"ewald_tol should be > 0 (not %f)",ir->ewald_rtol);
}
else {
init_top(&top);
}
/* Add parallellization code here */
snew(nsb,1);
if (MASTER(cr)) {
ncg = top.blocks[ebCGS].multinr[0];
for(i=0; (i<cr->nnodes-1); i++)
top.blocks[ebCGS].multinr[i] = min(ncg,(ncg*(i+1))/cr->nnodes);
for( ; (i<MAXNODES); i++)
top.blocks[ebCGS].multinr[i] = ncg;
}
if (PAR(cr)) {
/* Set some variables to zero to avoid core dumps */
ir->opts.ngtc = ir->opts.ngacc = ir->opts.ngfrz = ir->opts.ngener = 0;
#ifdef GMX_MPI
/* Distribute the data over processors */
MPI_Bcast(&natoms,1,MPI_INT,root,MPI_COMM_WORLD);
MPI_Bcast(ir,sizeof(*ir),MPI_BYTE,root,MPI_COMM_WORLD);
MPI_Bcast(&qtot,1,GMX_MPI_REAL,root,MPI_COMM_WORLD);
#endif
/* Call some dedicated communication routines, master sends n-1 times */
if (MASTER(cr)) {
for(i=1; (i<cr->nnodes); i++) {
mv_block(i,&(top.blocks[ebCGS]));
mv_block(i,&(top.atoms.excl));
}
}
else {
ld_block(root,&(top.blocks[ebCGS]));
ld_block(root,&(top.atoms.excl));
}
if (!MASTER(cr)) {
snew(charge,natoms);
snew(x,natoms);
}
#ifdef GMX_MPI
MPI_Bcast(charge,natoms,GMX_MPI_REAL,root,MPI_COMM_WORLD);
#endif
}
ewaldcoeff = calc_ewaldcoeff(ir->rcoulomb,ir->ewald_rtol);
if (bVerbose)
pr_inputrec(stdlog,0,"Inputrec",ir);
/* Allocate memory for temp arrays etc. */
snew(xbuf,natoms);
snew(f,natoms);
snew(qbuf,natoms);
snew(qqbuf,natoms);
snew(index,natoms);
/* Initialize the PME code */
init_pme(stdlog,cr,ir->nkx,ir->nky,ir->nkz,ir->pme_order,
natoms,FALSE,bOptFFT,ewald_geometry);
/* MFlops accounting */
init_nrnb(&nrnb);
/* Initialize the work division */
calc_nsb(stdlog,&(top.blocks[ebCGS]),cr->nnodes,nsb,0);
nsb->nodeid = cr->nodeid;
print_nsb(stdlog,"pmetest",nsb);
/* Initiate forcerec */
mdatoms = atoms2md(stdlog,&top.atoms,ir->opts.nFreeze,ir->eI,
ir->delta_t,0,ir->opts.tau_t,FALSE,FALSE);
snew(fr,1);
init_forcerec(stdlog,fr,ir,&top,cr,mdatoms,nsb,box,FALSE,NULL,NULL,FALSE);
/* First do PME based on coordinates in tpr file, send them to
* other processors if needed.
*/
if (MASTER(cr))
fprintf(stdlog,"-----\n"
"Results based on tpr file %s\n",ftp2fn(efTPX,NFILE,fnm));
#ifdef GMX_MPI
if (PAR(cr)) {
MPI_Bcast(x[0],natoms*DIM,GMX_MPI_REAL,root,MPI_COMM_WORLD);
MPI_Bcast(box[0],DIM*DIM,GMX_MPI_REAL,root,MPI_COMM_WORLD);
MPI_Bcast(&t,1,GMX_MPI_REAL,root,MPI_COMM_WORLD);
}
#endif
do_my_pme(stdlog,0,bVerbose,ir,x,xbuf,f,charge,qbuf,qqbuf,box,bSort,
cr,nsb,&nrnb,&(top.atoms.excl),qtot,fr,index,NULL,
bGroups ? ir->opts.ngener : 1,mdatoms->cENER);
/* If we have a trajectry file, we will read the frames in it and compute
* the PME energy.
*/
if (ftp2bSet(efTRX,NFILE,fnm)) {
fprintf(stdlog,"-----\n"
"Results based on trx file %s\n",ftp2fn(efTRX,NFILE,fnm));
if (MASTER(cr)) {
sfree(x);
natoms = read_first_x(&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
if (natoms != top.atoms.nr)
gmx_fatal(FARGS,"natoms in trx = %d, in tpr = %d",natoms,top.atoms.nr);
fp = xvgropen(ftp2fn(efXVG,NFILE,fnm),"PME Energy","Time (ps)","E (kJ/mol)");
}
else
fp = NULL;
do {
/* Send coordinates, box and time to the other nodes */
#ifdef GMX_MPI
if (PAR(cr)) {
MPI_Bcast(x[0],natoms*DIM,GMX_MPI_REAL,root,MPI_COMM_WORLD);
MPI_Bcast(box[0],DIM*DIM,GMX_MPI_REAL,root,MPI_COMM_WORLD);
MPI_Bcast(&t,1,GMX_MPI_REAL,root,MPI_COMM_WORLD);
}
#endif
rm_pbc(&top.idef,nsb->natoms,box,x,x);
/* Call the PME wrapper function */
do_my_pme(stdlog,t,bVerbose,ir,x,xbuf,f,charge,qbuf,qqbuf,box,bSort,cr,
nsb,&nrnb,&(top.atoms.excl),qtot,fr,index,fp,
bGroups ? ir->opts.ngener : 1,mdatoms->cENER);
/* Only the master processor reads more data */
if (MASTER(cr))
bCont = read_next_x(status,&t,natoms,x,box);
/* Check whether we need to continue */
#ifdef GMX_MPI
if (PAR(cr))
MPI_Bcast(&bCont,1,MPI_INT,root,MPI_COMM_WORLD);
#endif
} while (bCont);
/* Finish I/O, close files */
if (MASTER(cr)) {
close_trx(status);
ffclose(fp);
}
}
if (bVerbose) {
/* Do some final I/O about performance, might be useful in debugging */
fprintf(stdlog,"-----\n");
print_nrnb(stdlog,&nrnb);
}
/* Finish the parallel stuff */
if (gmx_parallel_env_initialized())
gmx_finalize(cr);
/* Thank the audience, as usual */
if (MASTER(cr))
thanx(stderr);
return 0;
}
void spectrum(bool bVerbose,
char *trj,char *shifts,bool bAbInitio,
char *corrfn,char *noefn,
int maxframes,bool bFour,bool bFit,int nrestart,
int npair,t_pair pair[],int nat,real chem_shifts[],
real taum,real maxdist,
real w_rls[],rvec xp[],t_idef *idef)
{
FILE *fp;
int i,j,m,ii,jj,natoms,status,nframes;
rvec *x,dx;
matrix box;
real t0,t1,t,dt;
real r2,r6,r_3,r_6,tauc;
rvec **corr;
real **Corr;
t_sij *spec;
snew(spec,npair);
fprintf(stderr,"There is no kill like overkill! Going to malloc %d bytes\n",
npair*maxframes*sizeof(corr[0][0]));
snew(corr,npair);
for(i=0; (i<npair); i++)
snew(corr[i],maxframes);
nframes = 0;
natoms = read_first_x(&status,trj,&t0,&x,box);
if (natoms > nat)
gmx_fatal(FARGS,"Not enough atoms in trajectory");
do {
if (nframes >= maxframes) {
fprintf(stderr,"\nThere are more than the %d frames you told me!",
maxframes);
break;
}
t1 = t;
if (bVerbose)
fprintf(stderr,"\rframe: %d",nframes);
rm_pbc(idef,natoms,box,x,x);
if (bFit)
do_fit(natoms,w_rls,xp,x);
for(i=0; (i<npair); i++) {
ii = pair[i].ai;
jj = pair[i].aj;
rvec_sub(x[ii],x[jj],dx);
copy_rvec(dx,corr[i][nframes]);
r2 = iprod(dx,dx);
r6 = r2*r2*r2;
r_3 = invsqrt(r6);
r_6 = r_3*r_3;
spec[i].rij_3 += r_3;
spec[i].rij_6 += r_6;
for(m=0; (m<5); m++) {
spec[i].Ylm[m] = c_add(spec[i].Ylm[m],
calc_ylm(m-2,dx,r2,r_3,r_6));
}
}
nframes++;
} while (read_next_x(status,&t,natoms,x,box));
close_trj(status);
if (bVerbose)
fprintf(stderr,"\n");
fp=ffopen("ylm.out","w");
calc_aver(fp,nframes,npair,pair,spec,maxdist);
fclose(fp);
/* Select out the pairs that have to be correlated */
snew(Corr,npair);
for(i=j=0; (i<npair); i++) {
if (spec[i].bNOE) {
Corr[j] = &(corr[i][0][0]);
j++;
}
}
fprintf(stderr,"There are %d NOEs in your simulation\n",j);
if (nframes > 1)
dt = (t1-t0)/(nframes-1);
else
dt = 1;
do_autocorr(corrfn,"Correlation Function for Interproton Vectors",
nframes,j,Corr,dt,eacP2,nrestart,FALSE,FALSE,bFour,TRUE);
calc_tauc(bVerbose,npair,pair,dt,nframes/2,spec,(real **)corr);
plot_spectrum(noefn,npair,pair,spec,taum);
}
int gmx_relax(int argc,char *argv[])
{
const char *desc[] = {
"g_noe calculates a NOE spectrum"
};
int status;
t_topology *top;
int i,j,k,natoms,nprot,*prot_ind;
int ifit;
char *gn_fit;
atom_id *ind_fit,*all_at;
real *w_rls;
rvec *xp;
t_pair *pair;
matrix box;
int step,nre;
real t,lambda;
real *shifts=NULL;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPX, "-s", NULL, ffREAD },
{ efNDX, NULL, NULL, ffREAD },
{ efDAT, "-d", "shifts", ffREAD },
{ efOUT, "-o","spec", ffWRITE },
{ efXVG, "-corr", "rij-corr", ffWRITE },
{ efXVG, "-noe", "noesy", ffWRITE }
};
#define NFILE asize(fnm)
static real taum = 0.0, maxdist = 0.6;
static int nlevels = 15;
static int nrestart = 1;
static int maxframes = 100;
static bool bFFT = TRUE,bFit = TRUE, bVerbose = TRUE;
t_pargs pa[] = {
{ "-taum", FALSE, etREAL, &taum,
"Rotational correlation time for your molecule. It is obligatory to pass this option" },
{ "-maxdist", FALSE, etREAL, &maxdist,
"Maximum distance to be plotted" },
{ "-nlevels", FALSE, etINT, &nlevels,
"Number of levels for plotting" },
{ "-nframes", FALSE, etINT, &maxframes,
"Number of frames in your trajectory. Will stop analysis after this" },
{ "-fft", FALSE, etBOOL, &bFFT,
"Use FFT for correlation function" },
{ "-nrestart", FALSE, etINT, &nrestart,
"Number of frames between starting point for computation of ACF without FFT" },
{ "-fit", FALSE, etBOOL, &bFit,
"Do an optimal superposition on reference structure in tpx file" },
{ "-v", FALSE, etBOOL, &bVerbose,
"Tell you what I am about to do" }
};
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);
if (taum <= 0)
gmx_fatal(FARGS,"Please give me a sensible taum!\n");
if (nlevels > 50) {
nlevels = 50;
fprintf(stderr,"Warning: too many levels, setting to %d\n",nlevels);
}
top = read_top(ftp2fn(efTPX,NFILE,fnm));
natoms = top->atoms.nr;
snew(xp,natoms);
read_tpx(ftp2fn(efTPX,NFILE,fnm),&step,&t,&lambda,NULL,box,
&natoms,xp,NULL,NULL,NULL);
/* Determine the number of protons, and their index numbers
* by checking the mass
*/
nprot = 0;
snew(prot_ind,natoms);
for(i=0; (i<natoms); i++)
if (top->atoms.atom[i].m < 2) {
prot_ind[nprot++] = i;
}
fprintf(stderr,"There %d protons in your topology\n",nprot);
snew(pair,(nprot*(nprot-1)/2));
for(i=k=0; (i<nprot); i++) {
for(j=i+1; (j<nprot); j++,k++) {
pair[k].ai = prot_ind[i];
pair[k].aj = prot_ind[j];
}
}
sfree(prot_ind);
fprintf(stderr,"Select group for root least squares fit\n");
rd_index(ftp2fn(efNDX,NFILE,fnm),1,&ifit,&ind_fit,&gn_fit);
if (ifit < 3)
gmx_fatal(FARGS,"Need >= 3 points to fit!\n");
/* Make an array with weights for fitting */
snew(w_rls,natoms);
for(i=0; (i<ifit); i++)
w_rls[ind_fit[i]]=top->atoms.atom[ind_fit[i]].m;
/* Prepare reference frame */
snew(all_at,natoms);
for(j=0; (j<natoms); j++)
all_at[j]=j;
rm_pbc(&(top->idef),natoms,box,xp,xp);
reset_x(ifit,ind_fit,natoms,all_at,xp,w_rls);
sfree(all_at);
spectrum(bVerbose,
ftp2fn(efTRX,NFILE,fnm),ftp2fn(efDAT,NFILE,fnm),
ftp2bSet(efDAT,NFILE,fnm),opt2fn("-corr",NFILE,fnm),
opt2fn("-noe",NFILE,fnm),
maxframes,bFFT,bFit,nrestart,
k,pair,natoms,shifts,
taum,maxdist,w_rls,xp,&(top->idef));
thanx(stderr);
return 0;
}
int main(int argc,char *argv[])
{
static char *desc[] = {
"[TT]do_shift[tt] reads a trajectory file and computes the chemical",
"shift for each time frame (or every [BB]dt[bb] ps) by",
"calling the 'total' program. If you do not have the total program,",
"get it. do_shift assumes that the total executable is in",
"[TT]/home/mdgroup/total/total[tt]. If that is not the case, then you should",
"set an environment variable [BB]TOTAL[bb] as in: [PAR]",
"[TT]setenv TOTAL /usr/local/bin/total[tt][PAR]",
"where the right hand side should point to the total executable.[PAR]",
"Output is printed in files [TT]shift.out[tt] where t is the time of the frame.[PAR]",
"The program also needs an input file called [BB]random.dat[bb] which",
"contains the random coil chemical shifts of all protons."
};
static real dt=0.0;
t_pargs pa[] = {
{ "-dt", FALSE, etREAL, { &dt }, "Time interval between frames." }
};
static char *bugs[] = {
"The program is very slow"
};
static char *OXYGEN="O";
FILE *out,*tot,*fp;
t_topology *top;
t_atoms *atoms;
int status,nres;
real t,nt;
int i,natoms,nframe=0;
matrix box;
int gnx;
char *grpnm,*randf;
atom_id *index;
rvec *x,*x_s;
char pdbfile[32],tmpfile[32];
char total[256],*dptr;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPX, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffREAD },
{ efOUT, "-o", "shift", ffWRITE },
{ efDAT, "-d", "random", ffREAD }
};
char *leg[] = { "shift","ring","anisCO","anisCN","sigmaE","sum" };
#define NFILE asize(fnm)
CopyRight(stdout,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_BE_NICE ,NFILE,fnm,
asize(pa),pa,asize(desc),desc,asize(bugs),bugs);
top=read_top(ftp2fn(efTPX,NFILE,fnm));
atoms=&(top->atoms);
nres=atoms->nres;
for(i=0; (i<atoms->nr); i++)
if ((strcmp(*atoms->atomname[i],"O1") == 0) ||
(strcmp(*atoms->atomname[i],"O2") == 0) ||
(strcmp(*atoms->atomname[i],"OXT") == 0) ||
(strcmp(*atoms->atomname[i],"OT") == 0))
atoms->atomname[i]=&OXYGEN;
rd_index(ftp2fn(efNDX,NFILE,fnm),1,&gnx,&index,&grpnm);
snew(x_s,atoms->nr);
strcpy(pdbfile,"dsXXXXXX");
gmx_tmpnam(pdbfile);
strcpy(tmpfile,"dsXXXXXX");
gmx_tmpnam(tmpfile);
fprintf(stderr,"pdbfile = %s\ntmpfile = %s\n",pdbfile,tmpfile);
if ((dptr=getenv("TOTAL")) == NULL)
dptr="/home/mdgroup/total/total";
sprintf(total,"%s > /dev/null",dptr);
fprintf(stderr,"total cmd='%s'\n",total);
randf=ftp2fn(efDAT,NFILE,fnm);
natoms=read_first_x(&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
if (natoms != atoms->nr)
gmx_fatal(FARGS,"Trajectory does not match topology!");
out=ftp2FILE(efOUT,NFILE,fnm,"w");
xvgr_legend(out,asize(leg),leg);
nt=t;
do {
if (t >= nt) {
rm_pbc(&(top->idef),top->atoms.nr,box,x,x_s);
fp=gmx_ffopen(pdbfile,"w");
write_pdbfile_indexed(fp,"Generated by do_shift",
atoms,x_s,box,0,-1,gnx,index);
gmx_ffclose(fp);
if ((tot=popen(total,"w")) == NULL)
perror("opening pipe to total");
fprintf(tot,"%s\n",pdbfile);
fprintf(tot,"%s\n",tmpfile);
fprintf(tot,"3\n");
fprintf(tot,"N\n");
fprintf(tot,"%s\n",randf);
fprintf(tot,"N\n");
fprintf(tot,"N\n");
if (pclose(tot) != 0)
perror("closing pipe to total");
cat(out,tmpfile,t);
remove(pdbfile);
remove(tmpfile);
nt+=dt;
nframe++;
}
} while(read_next_x(status,&t,natoms,x,box));
close_trj(status);
gmx_ffclose(out);
gmx_thanx(stderr);
return 0;
}
int gmx_gyrate(int argc,char *argv[])
{
const char *desc[] = {
"g_gyrate computes the radius of gyration of a group of atoms",
"and the radii of gyration about the x, y and z axes,",
"as a function of time. The atoms are explicitly mass weighted.[PAR]",
"With the [TT]-nmol[tt] option the radius of gyration will be calculated",
"for multiple molecules by splitting the analysis group in equally",
"sized parts.[PAR]",
"With the option [TT]-nz[tt] 2D radii of gyration in the x-y plane",
"of slices along the z-axis are calculated."
};
static int nmol=1,nz=0;
static bool bQ=FALSE,bRot=FALSE,bMOI=FALSE;
t_pargs pa[] = {
{ "-nmol", FALSE, etINT, {&nmol},
"The number of molecules to analyze" },
{ "-q", FALSE, etBOOL, {&bQ},
"Use absolute value of the charge of an atom as weighting factor instead of mass" },
{ "-p", FALSE, etBOOL, {&bRot},
"Calculate the radii of gyration about the principal axes." },
{ "-moi", FALSE, etBOOL, {&bMOI},
"Calculate the moments of inertia (defined by the principal axes)." },
{ "-nz", FALSE, etINT, {&nz},
"Calculate the 2D radii of gyration of # slices along the z-axis" },
};
FILE *out;
int status;
t_topology top;
int ePBC;
rvec *x,*x_s;
rvec xcm,gvec,gvec1;
matrix box,trans;
bool bACF;
real **moi_trans=NULL;
int max_moi=0,delta_moi=100;
rvec d,d1; /* eigenvalues of inertia tensor */
real t,t0,tm,gyro;
int natoms;
char *grpname,title[256];
int i,j,m,gnx,nam,mol;
atom_id *index;
char *leg[] = { "Rg", "RgX", "RgY", "RgZ" };
char *legI[] = { "Itot", "I1", "I2", "I3" };
#define NLEG asize(leg)
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "gyrate", ffWRITE },
{ efXVG, "-acf", "moi-acf", ffOPTWR },
};
#define NFILE asize(fnm)
int npargs;
t_pargs *ppa;
CopyRight(stderr,argv[0]);
npargs = asize(pa);
ppa = add_acf_pargs(&npargs,pa);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_BE_NICE,
NFILE,fnm,npargs,ppa,asize(desc),desc,0,NULL);
bACF = opt2bSet("-acf",NFILE,fnm);
if (bACF && nmol!=1)
gmx_fatal(FARGS,"Can only do acf with nmol=1");
bRot = bRot || bMOI || bACF;
/*
if (nz > 0)
bMOI = TRUE;
*/
if (bRot) {
printf("Will rotate system along principal axes\n");
snew(moi_trans,DIM);
}
if (bMOI) {
printf("Will print moments of inertia\n");
bQ = FALSE;
}
if (bQ)
printf("Will print radius normalised by charge\n");
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&x,NULL,box,TRUE);
get_index(&top.atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&gnx,&index,&grpname);
if (nmol > gnx || gnx % nmol != 0) {
gmx_fatal(FARGS,"The number of atoms in the group (%d) is not a multiple of nmol (%d)",gnx,nmol);
}
nam = gnx/nmol;
natoms=read_first_x(&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
snew(x_s,natoms);
j = 0;
t0 = t;
if (bQ)
out=xvgropen(ftp2fn(efXVG,NFILE,fnm),
"Radius of Charge","Time (ps)","Rg (nm)");
else if (bMOI)
out=xvgropen(ftp2fn(efXVG,NFILE,fnm),
"Moments of inertia","Time (ps)","I (a.m.u. nm\\S2\\N)");
else
out=xvgropen(ftp2fn(efXVG,NFILE,fnm),
"Radius of gyration","Time (ps)","Rg (nm)");
if (bMOI)
xvgr_legend(out,NLEG,legI);
else {
if (bRot)
if (bPrintXvgrCodes())
fprintf(out,"@ subtitle \"Axes are principal component axes\"\n");
xvgr_legend(out,NLEG,leg);
}
do {
if (nz == 0)
rm_pbc(&top.idef,ePBC,natoms,box,x,x_s);
gyro = 0;
clear_rvec(gvec);
clear_rvec(d);
for(mol=0; mol<nmol; mol++) {
tm = sub_xcm(nz==0?x_s:x,nam,index+mol*nam,top.atoms.atom,xcm,bQ);
if (nz == 0)
gyro += calc_gyro(x_s,nam,index+mol*nam,top.atoms.atom,
tm,gvec1,d1,bQ,bRot,bMOI,trans);
else
calc_gyro_z(x,box,nam,index+mol*nam,top.atoms.atom,nz,t,out);
rvec_inc(gvec,gvec1);
rvec_inc(d,d1);
}
if (nmol > 0) {
gyro /= nmol;
svmul(1.0/nmol,gvec,gvec);
svmul(1.0/nmol,d,d);
}
if (nz == 0) {
if (bRot) {
if (j >= max_moi) {
max_moi += delta_moi;
for(m=0; (m<DIM); m++)
srenew(moi_trans[m],max_moi*DIM);
}
for(m=0; (m<DIM); m++)
copy_rvec(trans[m],moi_trans[m]+DIM*j);
fprintf(out,"%10g %10g %10g %10g %10g\n",
t,gyro,d[XX],d[YY],d[ZZ]); }
else {
fprintf(out,"%10g %10g %10g %10g %10g\n",
t,gyro,gvec[XX],gvec[YY],gvec[ZZ]); }
}
j++;
} while(read_next_x(status,&t,natoms,x,box));
close_trj(status);
fclose(out);
if (bACF) {
int mode = eacVector;
do_autocorr(opt2fn("-acf",NFILE,fnm),
"Moment of inertia vector ACF",
j,3,moi_trans,(t-t0)/j,mode,FALSE);
do_view(opt2fn("-acf",NFILE,fnm),"-nxy");
}
do_view(ftp2fn(efXVG,NFILE,fnm),"-nxy");
thanx(stderr);
return 0;
}
int gmx_traj(int argc,char *argv[])
{
static char *desc[] = {
"g_traj plots coordinates, velocities, forces and/or the box.",
"With [TT]-com[tt] the coordinates, velocities and forces are",
"calculated for the center of mass of each group.",
"When [TT]-mol[tt] is set, the numbers in the index file are",
"interpreted as molecule numbers and the same procedure as with",
"[TT]-com[tt] is used for each molecule.[PAR]",
"Option [TT]-ot[tt] plots the temperature of each group,",
"provided velocities are present in the trajectory file.",
"No corrections are made for constrained degrees of freedom!",
"This implies [TT]-com[tt].[PAR]",
"Options [TT]-ekt[tt] and [TT]-ekr[tt] plot the translational and",
"rotational kinetic energy of each group,",
"provided velocities are present in the trajectory file.",
"This implies [TT]-com[tt].[PAR]",
"Options [TT]-cv[tt] and [TT]-cf[tt] write the average velocities",
"and average forces as temperature factors to a pdb file with",
"the average coordinates. The temperature factors are scaled such",
"that the maximum is 10. The scaling can be changed with the option",
"[TT]-scale[tt]. To get the velocities or forces of one",
"frame set both [TT]-b[tt] and [TT]-e[tt] to the time of",
"desired frame. When averaging over frames you might need to use",
"the [TT]-nojump[tt] option to obtain the correct average coordinates.",
"If you select either of these option the average force and velocity",
"for each atom are written to an xvg file as well",
"(specified with [TT]-av[tt] or [TT]-af[tt]).[PAR]",
"Option [TT]-vd[tt] computes a velocity distribution, i.e. the",
"norm of the vector is plotted. In addition in the same graph",
"the kinetic energy distribution is given."
};
static bool bMol=FALSE,bCom=FALSE,bNoJump=FALSE;
static bool bX=TRUE,bY=TRUE,bZ=TRUE,bNorm=FALSE;
static int ngroups=1;
static real scale=0,binwidth=1;
t_pargs pa[] = {
{ "-com", FALSE, etBOOL, {&bCom},
"Plot data for the com of each group" },
{ "-mol", FALSE, etBOOL, {&bMol},
"Index contains molecule numbers iso atom numbers" },
{ "-nojump", FALSE, etBOOL, {&bNoJump},
"Remove jumps of atoms across the box" },
{ "-x", FALSE, etBOOL, {&bX},
"Plot X-component" },
{ "-y", FALSE, etBOOL, {&bY},
"Plot Y-component" },
{ "-z", FALSE, etBOOL, {&bZ},
"Plot Z-component" },
{ "-ng", FALSE, etINT, {&ngroups},
"Number of groups to consider" },
{ "-len", FALSE, etBOOL, {&bNorm},
"Plot vector length" },
{ "-bin", FALSE, etREAL, {&binwidth},
"Binwidth for velocity histogram (nm/ps)" },
{ "-scale", FALSE, etREAL, {&scale},
"Scale factor for pdb output, 0 is autoscale" }
};
FILE *outx=NULL,*outv=NULL,*outf=NULL,*outb=NULL,*outt=NULL;
FILE *outekt=NULL,*outekr=NULL;
t_topology top;
int ePBC;
real *mass,time;
char title[STRLEN],*indexfn;
t_trxframe fr,frout;
int flags,nvhisto=0,*vhisto=NULL;
rvec *xtop,*xp=NULL;
rvec *sumxv=NULL,*sumv=NULL,*sumxf=NULL,*sumf=NULL;
matrix topbox;
int status,status_out=-1;
int i,j,n;
int nr_xfr,nr_vfr,nr_ffr;
char **grpname;
int *isize0,*isize;
atom_id **index0,**index;
atom_id *atndx;
t_block *mols;
bool bTop,bOX,bOXT,bOV,bOF,bOB,bOT,bEKT,bEKR,bCV,bCF;
bool bDim[4],bDum[4],bVD;
char *box_leg[6] = { "XX", "YY", "ZZ", "YX", "ZX", "ZY" };
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-ox", "coord.xvg", ffOPTWR },
{ efTRX, "-oxt","coord.xtc", ffOPTWR },
{ efXVG, "-ov", "veloc.xvg", ffOPTWR },
{ efXVG, "-of", "force.xvg", ffOPTWR },
{ efXVG, "-ob", "box.xvg", ffOPTWR },
{ efXVG, "-ot", "temp.xvg", ffOPTWR },
{ efXVG, "-ekt","ektrans.xvg", ffOPTWR },
{ efXVG, "-ekr","ekrot.xvg", ffOPTWR },
{ efXVG, "-vd", "veldist.xvg", ffOPTWR },
{ efPDB, "-cv", "veloc.pdb", ffOPTWR },
{ efPDB, "-cf", "force.pdb", ffOPTWR },
{ efXVG, "-av", "all_veloc.xvg", ffOPTWR },
{ efXVG, "-af", "all_force.xvg", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
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);
if (bMol)
fprintf(stderr,"Interpreting indexfile entries as molecules.\n"
"Using center of mass.\n");
bOX = opt2bSet("-ox",NFILE,fnm);
bOXT = opt2bSet("-oxt",NFILE,fnm);
bOV = opt2bSet("-ov",NFILE,fnm);
bOF = opt2bSet("-of",NFILE,fnm);
bOB = opt2bSet("-ob",NFILE,fnm);
bOT = opt2bSet("-ot",NFILE,fnm);
bEKT = opt2bSet("-ekt",NFILE,fnm);
bEKR = opt2bSet("-ekr",NFILE,fnm);
bCV = opt2bSet("-cv",NFILE,fnm) || opt2bSet("-av",NFILE,fnm);
bCF = opt2bSet("-cf",NFILE,fnm) || opt2bSet("-af",NFILE,fnm);
bVD = opt2bSet("-vd",NFILE,fnm) || opt2parg_bSet("-bin",asize(pa),pa);
if (bMol || bOT || bEKT || bEKR)
bCom = TRUE;
bDim[XX] = bX;
bDim[YY] = bY;
bDim[ZZ] = bZ;
bDim[DIM] = bNorm;
bTop = read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,
&xtop,NULL,topbox,
bCom && (bOX || bOXT || bOV || bOT || bEKT || bEKR));
sfree(xtop);
if ((bMol || bCV || bCF) && !bTop)
gmx_fatal(FARGS,"Need a run input file for option -mol, -cv or -cf");
if (bMol)
indexfn = ftp2fn(efNDX,NFILE,fnm);
else
indexfn = ftp2fn_null(efNDX,NFILE,fnm);
if (!(bCom && !bMol))
ngroups = 1;
snew(grpname,ngroups);
snew(isize0,ngroups);
snew(index0,ngroups);
get_index(&(top.atoms),indexfn,ngroups,isize0,index0,grpname);
if (bMol) {
mols=&(top.mols);
atndx = mols->index;
ngroups = isize0[0];
snew(isize,ngroups);
snew(index,ngroups);
for (i=0; i<ngroups; i++) {
if (index0[0][i] < 0 || index0[0][i] >= mols->nr)
gmx_fatal(FARGS,"Molecule index (%d) is out of range (%d-%d)",
index0[0][i]+1,1,mols->nr);
isize[i] = atndx[index0[0][i]+1] - atndx[index0[0][i]];
snew(index[i],isize[i]);
for(j=0; j<isize[i]; j++)
index[i][j] = atndx[index0[0][i]] + j;
}
} else {
isize = isize0;
index = index0;
}
if (bCom) {
snew(mass,top.atoms.nr);
for(i=0; i<top.atoms.nr; i++)
mass[i] = top.atoms.atom[i].m;
} else
mass = NULL;
flags = 0;
if (bOX) {
flags = flags | TRX_READ_X;
outx = xvgropen(opt2fn("-ox",NFILE,fnm),
bCom ? "Center of mass" : "Coordinate",
xvgr_tlabel(),"Coordinate (nm)");
make_legend(outx,ngroups,isize0[0],index0[0],grpname,bCom,bMol,bDim);
}
if (bOXT) {
flags = flags | TRX_READ_X;
status_out = open_trx(opt2fn("-oxt",NFILE,fnm),"w");
}
if (bOV) {
flags = flags | TRX_READ_V;
outv = xvgropen(opt2fn("-ov",NFILE,fnm),
bCom ? "Center of mass velocity" : "Velocity",
xvgr_tlabel(),"Velocity (nm/ps)");
make_legend(outv,ngroups,isize0[0],index0[0],grpname,bCom,bMol,bDim);
}
if (bOF) {
flags = flags | TRX_READ_F;
outf = xvgropen(opt2fn("-of",NFILE,fnm),"Force",
xvgr_tlabel(),"Force (kJ mol\\S-1\\N nm\\S-1\\N)");
make_legend(outf,ngroups,isize0[0],index0[0],grpname,bCom,bMol,bDim);
}
if (bOB) {
outb = xvgropen(opt2fn("-ob",NFILE,fnm),"Box vector elements",
xvgr_tlabel(),"(nm)");
xvgr_legend(outb,6,box_leg);
}
if (bOT) {
bDum[XX] = FALSE;
bDum[YY] = FALSE;
bDum[ZZ] = FALSE;
bDum[DIM] = TRUE;
flags = flags | TRX_READ_V;
outt = xvgropen(opt2fn("-ot",NFILE,fnm),"Temperature",xvgr_tlabel(),"(K)");
make_legend(outt,ngroups,isize[0],index[0],grpname,bCom,bMol,bDum);
}
if (bEKT) {
bDum[XX] = FALSE;
bDum[YY] = FALSE;
bDum[ZZ] = FALSE;
bDum[DIM] = TRUE;
flags = flags | TRX_READ_V;
outekt = xvgropen(opt2fn("-ekt",NFILE,fnm),"Center of mass translation",
xvgr_tlabel(),"Energy (kJ mol\\S-1\\N)");
make_legend(outekt,ngroups,isize[0],index[0],grpname,bCom,bMol,bDum);
}
if (bEKR) {
bDum[XX] = FALSE;
bDum[YY] = FALSE;
bDum[ZZ] = FALSE;
bDum[DIM] = TRUE;
flags = flags | TRX_READ_X | TRX_READ_V;
outekr = xvgropen(opt2fn("-ekr",NFILE,fnm),"Center of mass rotation",
xvgr_tlabel(),"Energy (kJ mol\\S-1\\N)");
make_legend(outekr,ngroups,isize[0],index[0],grpname,bCom,bMol,bDum);
}
if (bVD)
flags = flags | TRX_READ_V;
if (bCV)
flags = flags | TRX_READ_X | TRX_READ_V;
if (bCF)
flags = flags | TRX_READ_X | TRX_READ_F;
if ((flags == 0) && !bOB) {
fprintf(stderr,"Please select one or more output file options\n");
exit(0);
}
read_first_frame(&status,ftp2fn(efTRX,NFILE,fnm),&fr,flags);
if (bCV) {
snew(sumxv,fr.natoms);
snew(sumv,fr.natoms);
}
if (bCF) {
snew(sumxf,fr.natoms);
snew(sumf,fr.natoms);
}
nr_xfr = 0;
nr_vfr = 0;
nr_ffr = 0;
do {
time = convert_time(fr.time);
if (fr.bX && bNoJump && fr.bBox) {
if (xp)
remove_jump(fr.box,fr.natoms,xp,fr.x);
else
snew(xp,fr.natoms);
for(i=0; i<fr.natoms; i++)
copy_rvec(fr.x[i],xp[i]);
}
if (fr.bX && bCom)
rm_pbc(&(top.idef),ePBC,fr.natoms,fr.box,fr.x,fr.x);
if (bVD && fr.bV)
update_histo(isize[0],index[0],fr.v,&nvhisto,&vhisto,binwidth);
if (bOX && fr.bX)
print_data(outx,time,fr.x,mass,bCom,ngroups,isize,index,bDim);
if (bOXT && fr.bX) {
frout = fr;
if (!frout.bAtoms) {
frout.atoms = &top.atoms;
frout.bAtoms = TRUE;
}
write_trx_x(status_out,&frout,mass,bCom,ngroups,isize,index);
}
if (bOV && fr.bV)
print_data(outv,time,fr.v,mass,bCom,ngroups,isize,index,bDim);
if (bOF && fr.bF)
print_data(outf,time,fr.f,NULL,bCom,ngroups,isize,index,bDim);
if (bOB && fr.bBox)
fprintf(outb,"\t%g\t%g\t%g\t%g\t%g\t%g\t%g\n",fr.time,
fr.box[XX][XX],fr.box[YY][YY],fr.box[ZZ][ZZ],
fr.box[YY][XX],fr.box[ZZ][XX],fr.box[ZZ][YY]);
if (bOT && fr.bV) {
fprintf(outt," %g",time);
for(i=0; i<ngroups; i++)
fprintf(outt,"\t%g",temp(fr.v,mass,isize[i],index[i]));
fprintf(outt,"\n");
}
if (bEKT && fr.bV) {
fprintf(outekt," %g",time);
for(i=0; i<ngroups; i++)
fprintf(outekt,"\t%g",ektrans(fr.v,mass,isize[i],index[i]));
fprintf(outekt,"\n");
}
if (bEKR && fr.bX && fr.bV) {
fprintf(outekr," %g",time);
for(i=0; i<ngroups; i++)
fprintf(outekr,"\t%g",ekrot(fr.x,fr.v,mass,isize[i],index[i]));
fprintf(outekr,"\n");
}
if (bCV) {
if (fr.bX) {
for(i=0; i<fr.natoms; i++)
rvec_inc(sumxv[i],fr.x[i]);
nr_xfr++;
}
if (fr.bV) {
for(i=0; i<fr.natoms; i++)
rvec_inc(sumv[i],fr.v[i]);
nr_vfr++;
}
}
if (bCF) {
if (fr.bX) {
for(i=0; i<fr.natoms; i++)
rvec_inc(sumxf[i],fr.x[i]);
nr_xfr++;
}
if (fr.bF) {
for(i=0; i<fr.natoms; i++)
rvec_inc(sumf[i],fr.f[i]);
nr_ffr++;
}
}
} while(read_next_frame(status,&fr));
/* clean up a bit */
close_trj(status);
if (bOX) fclose(outx);
if (bOXT) close_trx(status_out);
if (bOV) fclose(outv);
if (bOF) fclose(outf);
if (bOB) fclose(outb);
if (bOT) fclose(outt);
if (bEKT) fclose(outekt);
if (bEKR) fclose(outekr);
if (bVD)
print_histo(opt2fn("-vd",NFILE,fnm),nvhisto,vhisto,binwidth);
if ((bCV || bCF) && (nr_vfr>1 || nr_ffr>1) && !bNoJump)
fprintf(stderr,"WARNING: More than one frame was used for option -cv or -cf\n"
"If atoms jump across the box you should use the -nojump option\n");
if (bCV)
write_pdb_bfac(opt2fn("-cv",NFILE,fnm),
opt2fn("-av",NFILE,fnm),"average velocity",&(top.atoms),
ePBC,topbox,isize[0],index[0],nr_xfr,sumxv,
nr_vfr,sumv,bDim,scale);
if (bCF)
write_pdb_bfac(opt2fn("-cf",NFILE,fnm),
opt2fn("-af",NFILE,fnm),"average force",&(top.atoms),
ePBC,topbox,isize[0],index[0],nr_xfr,sumxf,
nr_ffr,sumf,bDim,scale);
/* view it */
view_all(NFILE, fnm);
thanx(stderr);
return 0;
}
int gmx_mdmat(int argc,char *argv[])
{
static char *desc[] = {
"g_mdmat makes distance matrices consisting of the smallest distance",
"between residue pairs. With -frames these distance matrices can be",
"stored as a function",
"of time, to be able to see differences in tertiary structure as a",
"funcion of time. If you choose your options unwise, this may generate",
"a large output file. 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 xpm2ps to make a PostScript (tm) plot."
};
static real truncate=1.5;
static bool bAtom=FALSE;
static int nlevels=40;
t_pargs pa[] = {
{ "-t", FALSE, etREAL, {&truncate},
"trunc distance" },
{ "-nlevels", FALSE, etINT, {&nlevels},
"Discretize distance in # 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,status,nres,natoms,nframes,it,trxnat;
int nr0;
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;
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);
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.resname,natoms);
prevres = top.atoms.atom[index[0]].resnr;
newres = 0;
for(i=0;(i<isize);i++) {
int ii = index[i];
useatoms.atomname[i]=top.atoms.atomname[ii];
if (top.atoms.atom[ii].resnr != prevres) {
prevres = top.atoms.atom[ii].resnr;
newres++;
useatoms.resname[i] = top.atoms.resname[prevres];
if (debug) {
fprintf(debug,"New residue: atom %5s %5s %6d, index entry %5d, newres %5d\n",
*(top.atoms.resname[top.atoms.atom[ii].resnr]),
*(top.atoms.atomname[ii]),
ii,i,newres);
}
}
useatoms.atom[i].resnr = 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(&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;
if (bFrames)
out=opt2FILE("-frames",NFILE,fnm,"w");
do {
rm_pbc(&top.idef,ePBC,trxnat,box,x,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(status,&t,trxnat,x,box));
fprintf(stderr,"\n");
close_trj(status);
if (bFrames)
fclose(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");
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]);
}
fclose(fp);
}
thanx(stderr);
return 0;
}
/*!
* \param[in,out] d Trajectory analysis data structure.
* \param[in] flags Combination of flags
* (currently, there are no flags defined).
* \param[in] analyze Pointer to frame analysis function.
* \param data User data to be passed to \p analyze.
* \returns 0 on success, a non-zero error code on error.
*
* This function performs the actual analysis of the trajectory.
* It loops through all the frames in the trajectory, and calls
* \p analyze for each frame to perform the actual analysis.
* Before calling \p analyze, selections are updated (if there are any).
* See gmx_analysisfunc() for description of \p analyze parameters.
*
* This function also calculates the number of frames during the run.
*/
int
gmx_ana_do(gmx_ana_traj_t *d, int flags, gmx_analysisfunc analyze, void *data)
{
t_pbc pbc;
t_pbc *ppbc;
int rc;
rc = init_first_frame(d);
if (rc != 0)
{
return rc;
}
ppbc = d->bPBC ? &pbc : 0;
if (!d->top)
{
d->bRmPBC = FALSE;
}
d->nframes = 0;
do
{
if (d->bRmPBC)
{
rm_pbc(&d->top->idef, d->ePBC, d->fr->natoms, d->fr->box,
d->fr->x, d->fr->x);
}
if (ppbc)
{
set_pbc(&pbc, d->ePBC, d->fr->box);
}
gmx_ana_poscalc_init_frame(d->pcc);
rc = gmx_ana_selcollection_evaluate(d->sc, d->fr, ppbc);
if (rc != 0)
{
close_trj(d->status);
gmx_fatal(FARGS, "selection evaluation failed");
return rc;
}
rc = analyze(d->top, d->fr, ppbc, d->ngrps, d->sel, data);
if (rc != 0)
{
close_trj(d->status);
return rc;
}
d->nframes++;
}
while (read_next_frame(d->status, d->fr));
close_trj(d->status);
fprintf(stderr, "Analyzed %d frames, last time %.3f\n",
d->nframes, d->fr->time);
/* Restore the maximal groups for dynamic selections */
rc = gmx_ana_selcollection_evaluate_fin(d->sc, d->nframes);
if (rc != 0)
{
gmx_fatal(FARGS, "selection evaluation failed");
}
return rc;
}
static void do_sdf(char *fnNDX,char *fnTPS,char *fnTRX, char *fnSDF,
char *fnREF, bool bRef, rvec cutoff, real binwidth,
int mode, rvec triangle, rvec dtri)
{
FILE *fp;
int status;
int ng,natoms,i,j,k,l,X,Y,Z,lc,dest;
ivec nbin;
int ***count;
/* real ***sdf; */
real sdf,min_sdf=1e10,max_sdf=0;
char **grpname;
int *isize;
int isize_cg=0;
int isize_ref=3;
int ref_resind[3];
int nrefmol=0,refc=0;
atom_id **index;
atom_id *index_cg=NULL;
atom_id *index_ref=NULL;
real t,boxmin,hbox,normfac;
real invbinw;
rvec tri_upper,tri_lower;
rvec *x,xcog,dx,*x_i1,xi,*x_refmol;
matrix box;
matrix rot; /* rotation matrix := unit vectors for the molecule frame */
rvec k_mol,i1_mol,i2_mol,dx_mol;
real delta;
atom_id ix,jx;
t_topology top;
int ePBC=-1;
t_pbc pbc;
bool bTop=FALSE,bRefDone=FALSE,bInGroup=FALSE;
char title[STRLEN];
/* Read Topology */
if (fnTPS) {
bTop=read_tps_conf(fnTPS,title,&top,&ePBC,&x,NULL,box,TRUE);
}
if ( !bTop ) {
fprintf(stderr,"\nNeed tpr-file to make a reference structure.\n");
fprintf(stderr,"Option -r will be ignored!\n");
bRef = FALSE;
}
/* Allocate memory for 4 groups, 3 dummy groups and a group for the ref
structure if needed */
ng = 4;
snew(grpname,ng);
/* the dummy groups are used to dynamically store triples of atoms */
/* for molecular coordinate systems */
if ( bRef )
{
snew(isize,ng+4);
snew(index,ng+4);
}
else
{
snew(isize,ng+3);
snew(index,ng+3);
}
/* Read the index groups */
fprintf(stderr,"\nSelect the 3 reference groups and the SDF group:\n");
if (fnTPS)
get_index(&top.atoms,fnNDX,ng,isize,index,grpname);
else
rd_index(fnNDX,ng,isize,index,grpname);
isize[NDX_REF1]=isize[G_REF1];
for (i=NDX_REF1; i<=NDX_REF3; i++)
snew(index[i],isize[NDX_REF1]);
/* Read first frame and check it */
natoms=read_first_x(&status,fnTRX,&t,&x,box);
if ( !natoms )
gmx_fatal(FARGS,"Could not read coordinates from statusfile!\n");
/* check with topology */
if (fnTPS)
if ( natoms > top.atoms.nr )
gmx_fatal(FARGS,"Trajectory (%d atoms) does not match topology (%d atoms)!\n",
natoms,top.atoms.nr);
/* check with index groups */
for (i=0; i<ng; i++)
for (j=0; j<isize[i]; j++)
if ( index[i][j] >= natoms )
gmx_fatal(FARGS,"Atom index (%d) in index group %s (%d atoms) larger "
"than number of atoms in trajectory (%d atoms)!\n",
index[i][j],grpname[i],isize[i],natoms);
/* check reference groups */
if ( mode == 1 )
{
if ( isize[G_REF1] != isize[G_REF2] || isize[G_REF1] != isize[G_REF3] ||
isize[G_REF2] != isize[G_REF3] )
gmx_fatal(FARGS,"For single particle SDF, all reference groups"
"must have the same size.\n");
/* for single particle SDF dynamic triples are not needed */
/* so we build them right here */
/* copy all triples from G_REFx to NDX_REFx */
for (i=0; i<isize[G_REF1]; i++)
{
/* check if all three atoms come from the same molecule */
for (j=G_REF1; j<=G_REF3; j++)
ref_resind[j] = top.atoms.atom[index[j][i]].resind;
if ( ref_resind[G_REF1] != ref_resind[G_REF2] ||
ref_resind[G_REF2] != ref_resind[G_REF3] ||
ref_resind[G_REF3] != ref_resind[G_REF1] )
{
fprintf(stderr,"\nWarning: reference triple (%d) will be skipped.\n",i);
fprintf(stderr, " resnr[1]: %d, resnr[2]: %d, resnr[3]: %d\n",
ref_resind[G_REF1],ref_resind[G_REF2], ref_resind[G_REF3]);
isize[NDX_REF1]--;
for (j=NDX_REF1; j<=NDX_REF3; j++)
srenew(index[j],isize[NDX_REF1]);
continue;
}
else
/* check if all entries are unique*/
if ( index[G_REF1][i] == index[G_REF2][i] ||
index[G_REF2][i] == index[G_REF3][i] ||
index[G_REF3][i] == index[G_REF1][i] )
{
fprintf(stderr,"Warning: reference triple (%d) will be skipped.\n",i);
fprintf(stderr, " index[1]: %d, index[2]: %d, index[3]: %d\n",
index[G_REF1][i],index[G_REF2][i],index[G_REF3][i]);
isize[NDX_REF1]--;
for (j=NDX_REF1; j<=NDX_REF3; j++)
srenew(index[j],isize[NDX_REF1]);
continue;
}
else /* everythings fine, copy that one */
for (j=G_REF1; j<=G_REF3; j++)
index[j+4][i] = index[j][i];
}
}
else if ( mode == 2 )
{
if ( isize[G_REF1] != isize[G_REF2] )
gmx_fatal(FARGS,"For two particle SDF, reference groups 1 and 2"
"must have the same size.\n");
for (i=0; i<isize[G_REF1]; i++)
{
/* check consistency for atoms 1 and 2 */
for (j=G_REF1; j<=G_REF2; j++)
ref_resind[j] = top.atoms.atom[index[j][i]].resind;
if ( ref_resind[G_REF1] != ref_resind[G_REF2] ||
index[G_REF1][i] == index[G_REF2][i] )
{
if ( ref_resind[G_REF1] != ref_resind[G_REF2] )
{
fprintf(stderr,"\nWarning: bond (%d) not from one molecule."
"Will not be used for SDF.\n",i);
fprintf(stderr, " resnr[1]: %d, resnr[2]: %d\n",
ref_resind[G_REF1],ref_resind[G_REF2]);
}
else
{
fprintf(stderr,"\nWarning: atom1 and atom2 are identical."
"Bond (%d) will not be used for SDF.\n",i);
fprintf(stderr, " index[1]: %d, index[2]: %d\n",
index[G_REF1][i],index[G_REF2][i]);
}
for (j=NDX_REF1; j<=NDX_REF2; j++)
{
for (k=i; k<isize[G_REF1]-1; k++)
index[j][k]=index[j][k+1];
isize[j]--;
srenew(index[j],isize[j]);
}
}
}
}
/* Read Atoms for refmol group */
if ( bRef )
{
snew(index[G_REFMOL],1);
for (i=G_REF1; i<=G_REF3; i++)
ref_resind[i] = top.atoms.atom[index[i][0]].resind;
for (i=0; i<natoms; i++)
{
if ( ref_resind[G_REF1] == top.atoms.atom[i].resind ||
ref_resind[G_REF2] == top.atoms.atom[i].resind ||
ref_resind[G_REF3] == top.atoms.atom[i].resind )
nrefmol++;
}
srenew(index[G_REFMOL],nrefmol);
isize[G_REFMOL] = nrefmol;
nrefmol = 0;
for (i=0; i<natoms; i++)
{
if ( ref_resind[G_REF1] == top.atoms.atom[i].resind ||
ref_resind[G_REF2] == top.atoms.atom[i].resind ||
ref_resind[G_REF3] == top.atoms.atom[i].resind )
{
index[G_REFMOL][nrefmol] = i;
nrefmol++;
}
}
}
/* initialize some stuff */
boxmin = min( norm(box[XX]), min( norm(box[YY]), norm(box[ZZ]) ) );
hbox = boxmin / 2.0;
for (i=0; i<DIM; i++)
{
cutoff[i] = cutoff[i] / 2;
nbin[i] = (int)(2 * cutoff[i] / binwidth) + 1;
invbinw = 1.0 / binwidth;
tri_upper[i] = triangle[i] + dtri[i];
tri_upper[i] = sqr(tri_upper[i]);
tri_lower[i] = triangle[i] - dtri[i];
tri_lower[i] = sqr(tri_lower[i]);
}
/* Allocate the array's for sdf */
snew(count,nbin[0]+1);
for(i=0; i<nbin[0]+1; i++)
{
snew(count[i],nbin[1]+1);
for (j=0; j<nbin[1]+1; j++)
snew(count[i][j],nbin[2]+1);
}
/* Allocate space for the coordinates */
snew(x_i1,isize[G_SDF]);
snew(x_refmol,isize[G_REFMOL]);
for (i=0; i<isize[G_REFMOL]; i++)
for (j=XX; j<=ZZ; j++)
x_refmol[i][j] = 0;
normfac = 0;
do {
/* Must init pbc every step because of pressure coupling */
set_pbc(&pbc,ePBC,box);
rm_pbc(&top.idef,ePBC,natoms,box,x,x);
/* Dynamically build the ref tripels */
if ( mode == 2 )
{
isize[NDX_REF1]=0;
for (j=NDX_REF1; j<=NDX_REF3; j++)
srenew(index[j],isize[NDX_REF1]+1);
/* consistancy of G_REF[1,2] has already been check */
/* hence we can look for the third atom right away */
for (i=0; i<isize[G_REF1]; i++)
{
for (j=0; j<isize[G_REF3]; j++)
{
/* Avoid expensive stuff if possible */
if ( top.atoms.atom[index[G_REF1][i]].resind !=
top.atoms.atom[index[G_REF3][j]].resind &&
index[G_REF1][i] != index[G_REF3][j] &&
index[G_REF2][i] != index[G_REF3][j] )
{
pbc_dx(&pbc,x[index[G_REF1][i]],x[index[G_REF3][j]],dx);
delta = norm2(dx);
if ( delta < tri_upper[G_REF1] &&
delta > tri_lower[G_REF1] )
{
pbc_dx(&pbc,x[index[G_REF2][i]],x[index[G_REF3][j]],dx);
delta = norm2(dx);
if ( delta < tri_upper[G_REF2] &&
delta > tri_lower[G_REF2] )
{
/* found triple */
index[NDX_REF1][isize[NDX_REF1]]=index[G_REF1][i];
index[NDX_REF2][isize[NDX_REF1]]=index[G_REF2][i];
index[NDX_REF3][isize[NDX_REF1]]=index[G_REF3][j];
/* resize groups */
isize[NDX_REF1]++;
for (k=NDX_REF1; k<=NDX_REF3; k++)
srenew(index[k],isize[NDX_REF1]+1);
}
}
}
}
}
}
else if ( mode ==3 )
{
isize[NDX_REF1]=0;
for (j=NDX_REF1; j<=NDX_REF3; j++)
srenew(index[j],isize[NDX_REF1]+1);
/* consistancy will be checked while searching */
for (i=0; i<isize[G_REF1]; i++)
{
for (j=0; j<isize[G_REF2]; j++)
{
/* Avoid expensive stuff if possible */
if ( top.atoms.atom[index[G_REF1][i]].resind !=
top.atoms.atom[index[G_REF2][j]].resind &&
index[G_REF1][i] != index[G_REF2][j] )
{
pbc_dx(&pbc,x[index[G_REF1][i]],x[index[G_REF2][j]],dx);
delta = norm2(dx);
if ( delta < tri_upper[G_REF3] &&
delta > tri_lower[G_REF3] )
{
for (k=0; k<isize[G_REF3]; k++)
{
if ( top.atoms.atom[index[G_REF1][i]].resind !=
top.atoms.atom[index[G_REF3][k]].resind &&
top.atoms.atom[index[G_REF2][j]].resind !=
top.atoms.atom[index[G_REF3][k]].resind &&
index[G_REF1][i] != index[G_REF3][k] &&
index[G_REF2][j] != index[G_REF3][k])
{
pbc_dx(&pbc,x[index[G_REF1][i]],x[index[G_REF3][k]],dx);
delta = norm2(dx);
if ( delta < tri_upper[G_REF1] &&
delta > tri_lower[G_REF1] )
{
pbc_dx(&pbc,x[index[G_REF2][j]],x[index[G_REF3][k]],dx);
delta = norm2(dx);
if ( delta < tri_upper[G_REF2] &&
delta > tri_lower[G_REF2] )
{
/* found triple */
index[NDX_REF1][isize[NDX_REF1]]=index[G_REF1][i];
index[NDX_REF2][isize[NDX_REF1]]=index[G_REF2][j];
index[NDX_REF3][isize[NDX_REF1]]=index[G_REF3][k];
/* resize groups */
isize[NDX_REF1]++;
for (l=NDX_REF1; l<=NDX_REF3; l++)
srenew(index[l],isize[NDX_REF1]+1);
}
}
}
}
}
}
}
}
}
for (i=0; i<isize[NDX_REF1]; i++)
{
/* setup the molecular coordinate system (i',j',k') */
/* because the coodinate system of the box forms a unit matrix */
/* (i',j',k') is identical with the rotation matrix */
clear_mat(rot);
/* k' = unitv(r(atom0) - r(atom1)) */
pbc_dx(&pbc,x[index[NDX_REF1][i]],x[index[NDX_REF2][i]],k_mol);
unitv(k_mol,rot[2]);
/* i' = unitv(k' x (r(atom2) - r(atom1))) */
pbc_dx(&pbc,x[index[NDX_REF3][i]],x[index[NDX_REF2][i]],i1_mol);
cprod(i1_mol,rot[2],i2_mol);
unitv(i2_mol,rot[0]);
/* j' = k' x i' */
cprod(rot[2],rot[0],rot[1]);
/* set the point of reference */
if ( mode == 2 )
copy_rvec(x[index[NDX_REF3][i]],xi);
else
copy_rvec(x[index[NDX_REF1][i]],xi);
/* make the reference */
if ( bRef )
{
for (j=0; j<isize[G_REFMOL]; j++)
{
pbc_dx(&pbc,xi,x[index[G_REFMOL][j]],dx);
mvmul(rot,dx,dx_mol);
rvec_inc(x_refmol[j],dx_mol);
for(k=XX; k<=ZZ; k++)
x_refmol[j][k] = x_refmol[j][k] / 2;
}
}
/* Copy the indexed coordinates to a continuous array */
for(j=0; j<isize[G_SDF]; j++)
copy_rvec(x[index[G_SDF][j]],x_i1[j]);
/* count the SDF */
for(j=0; j<isize[G_SDF]; j++)
{
/* Exclude peaks from the reference set */
bInGroup=FALSE;
for (k=NDX_REF1; k<=NDX_REF3; k++)
if ( index[G_SDF][j] == index[k][i] )
bInGroup=TRUE;
if ( !bInGroup )
{
pbc_dx(&pbc,xi,x_i1[j],dx);
/* transfer dx to the molecular coordinate system */
mvmul(rot,dx,dx_mol);
/* check cutoff's and count */
if ( dx_mol[XX] > -cutoff[XX] && dx_mol[XX] < cutoff[XX] )
if ( dx_mol[YY] > -cutoff[YY] && dx_mol[YY] < cutoff[YY] )
if ( dx_mol[ZZ] > -cutoff[ZZ] && dx_mol[ZZ] < cutoff[ZZ] )
{
X = (int)(floor(dx_mol[XX]*invbinw)) + (nbin[XX]-1)/2
+1;
Y = (int)(floor(dx_mol[YY]*invbinw)) + (nbin[YY]-1)/2
+1;
Z = (int)(floor(dx_mol[ZZ]*invbinw)) + (nbin[ZZ]-1)/2
+1;
count[X][Y][Z]++;
normfac++;
}
}
}
}
} while (read_next_x(status,&t,natoms,x,box));
fprintf(stderr,"\n");
close_trj(status);
sfree(x);
/* write the reference strcture*/
if ( bRef )
{
fp=ffopen(fnREF,"w");
fprintf(fp,"%s\n",title);
fprintf(fp," %d\n",isize[G_REFMOL]);
for (i=0; i<isize[G_REFMOL]; i++)
fprintf(fp,"%5d%5s%5s%5d%8.3f%8.3f%8.3f\n",
top.atoms.resinfo[top.atoms.atom[index[G_REFMOL][i]].resind].nr,
*(top.atoms.resinfo[top.atoms.atom[index[G_REFMOL][i]].resind].name),
*(top.atoms.atomname[index[G_REFMOL][i]]),i+1,
-1*x_refmol[i][XX],-1*x_refmol[i][YY],-1*x_refmol[i][ZZ]);
/* Inserted -1* on the line above three times */
fprintf(fp," 10.00000 10.00000 10.00000\n");
ffclose(fp);
fprintf(stderr,"\nWrote reference structure. (%d Atoms)\n",isize[G_REFMOL]);
}
/* Calculate the mean probability density */
fprintf(stderr,"\nNumber of configuations used for SDF: %d\n",(int)normfac);
normfac = nbin[0]*nbin[1]*nbin[2] / normfac;
fprintf(stderr,"\nMean probability density: %f\n",1/normfac);
/* normalize the SDF and write output */
/* see http://www.csc.fi/gopenmol/index.phtml for documentation */
fp=ffopen(fnSDF,"wb");
/* rank */
i_write(fp,3);
/* Type of surface */
i_write(fp,42);
/* Zdim, Ydim, Xdim */
for (i=ZZ; i>=XX; i--)
i_write(fp,nbin[i]);
/* [Z,Y,X][min,max] (box corners in Angstroem)*/
for (i=ZZ; i>=XX; i--)
{
f_write(fp,-cutoff[i]*10);
f_write(fp,cutoff[i]*10);
}
/* Original Code
for (i=1; i<nbin[2]+1; i++)
for (j=1; j<nbin[1]+1; j++)
for (k=1; k<nbin[0]+1; k++)
{
sdf = normfac * count[k][j][i];
if ( sdf < min_sdf ) min_sdf = sdf;
if ( sdf > max_sdf ) max_sdf = sdf;
f_write(fp,sdf);
}*/
/* Changed Code to Mirror SDF to correct coordinates */
for (i=nbin[2]; i>0; i--)
for (j=nbin[1]; j>0; j--)
for (k=nbin[0]; k>0; k--)
{
sdf = normfac * count[k][j][i];
if ( sdf < min_sdf ) min_sdf = sdf;
if ( sdf > max_sdf ) max_sdf = sdf;
f_write(fp,sdf);
}
fprintf(stderr,"\nMin: %f Max: %f\n",min_sdf,max_sdf);
ffclose(fp);
/* Give back the mem */
for(i=0; i<nbin[0]+1; i++)
{
for (j=0; j<nbin[1]+1; j++)
{
sfree(count[i][j]);
}
sfree(count[i]);
}
sfree(count);
}
int gmx_disre(int argc,char *argv[])
{
const char *desc[] = {
"g_disre computes violations of distance restraints.",
"If necessary all protons can be added to a protein molecule ",
"using the protonate program.[PAR]",
"The program always",
"computes the instantaneous violations rather than time-averaged,",
"because this analysis is done from a trajectory file afterwards",
"it does not make sense to use time averaging. However,",
"the time averaged values per restraint are given in the log file.[PAR]",
"An index file may be used to select specific restraints for",
"printing.[PAR]",
"When the optional[TT]-q[tt] flag is given a pdb file coloured by the",
"amount of average violations.[PAR]",
"When the [TT]-c[tt] option is given, an index file will be read",
"containing the frames in your trajectory corresponding to the clusters",
"(defined in another manner) that you want to analyze. For these clusters",
"the program will compute average violations using the third power",
"averaging algorithm and print them in the log file."
};
static int ntop = 0;
static int nlevels = 20;
static real max_dr = 0;
static bool bThird = TRUE;
t_pargs pa[] = {
{ "-ntop", FALSE, etINT, {&ntop},
"Number of large violations that are stored in the log file every step" },
{ "-maxdr", FALSE, etREAL, {&max_dr},
"Maximum distance violation in matrix output. If less than or equal to 0 the maximum will be determined by the data." },
{ "-nlevels", FALSE, etINT, {&nlevels},
"Number of levels in the matrix output" },
{ "-third", FALSE, etBOOL, {&bThird},
"Use inverse third power averaging or linear for matrix output" }
};
FILE *out=NULL,*aver=NULL,*numv=NULL,*maxxv=NULL,*xvg=NULL;
t_tpxheader header;
t_inputrec ir;
gmx_mtop_t mtop;
rvec *xtop;
gmx_localtop_t *top;
t_atoms *atoms=NULL;
t_forcerec *fr;
t_fcdata fcd;
t_nrnb nrnb;
t_commrec *cr;
t_graph *g;
int status,ntopatoms,natoms,i,j,kkk;
real t;
rvec *x,*f,*xav=NULL;
matrix box;
bool bPDB;
int isize;
atom_id *index=NULL,*ind_fit=NULL;
char *grpname;
t_cluster_ndx *clust=NULL;
t_dr_result dr,*dr_clust=NULL;
char **leg;
real *vvindex=NULL,*w_rls=NULL;
t_mdatoms *mdatoms;
t_pbc pbc,*pbc_null;
int my_clust;
FILE *fplog;
t_filenm fnm[] = {
{ efTPX, NULL, NULL, ffREAD },
{ efTRX, "-f", NULL, ffREAD },
{ efXVG, "-ds", "drsum", ffWRITE },
{ efXVG, "-da", "draver", ffWRITE },
{ efXVG, "-dn", "drnum", ffWRITE },
{ efXVG, "-dm", "drmax", ffWRITE },
{ efXVG, "-dr", "restr", ffWRITE },
{ efLOG, "-l", "disres", ffWRITE },
{ efNDX, NULL, "viol", ffOPTRD },
{ efPDB, "-q", "viol", ffOPTWR },
{ efNDX, "-c", "clust", ffOPTRD },
{ efXPM, "-x", "matrix", ffOPTWR }
};
#define NFILE asize(fnm)
cr = init_par(&argc,&argv);
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL);
fplog = gmx_log_open(ftp2fn(efLOG,NFILE,fnm),cr,FALSE,0);
if (ntop)
init5(ntop);
read_tpxheader(ftp2fn(efTPX,NFILE,fnm),&header,FALSE,NULL,NULL);
snew(xtop,header.natoms);
read_tpx(ftp2fn(efTPX,NFILE,fnm),&ir,box,&ntopatoms,xtop,NULL,NULL,&mtop);
bPDB = opt2bSet("-q",NFILE,fnm);
if (bPDB) {
snew(xav,ntopatoms);
snew(ind_fit,ntopatoms);
snew(w_rls,ntopatoms);
for(kkk=0; (kkk<ntopatoms); kkk++) {
w_rls[kkk] = 1;
ind_fit[kkk] = kkk;
}
snew(atoms,1);
*atoms = gmx_mtop_global_atoms(&mtop);
if (atoms->pdbinfo == NULL) {
snew(atoms->pdbinfo,atoms->nr);
}
}
top = gmx_mtop_generate_local_top(&mtop,&ir);
g = NULL;
pbc_null = NULL;
if (ir.ePBC != epbcNONE) {
if (ir.bPeriodicMols)
pbc_null = &pbc;
else
g = mk_graph(fplog,&top->idef,0,mtop.natoms,FALSE,FALSE);
}
if (ftp2bSet(efNDX,NFILE,fnm)) {
rd_index(ftp2fn(efNDX,NFILE,fnm),1,&isize,&index,&grpname);
xvg=xvgropen(opt2fn("-dr",NFILE,fnm),"Inidividual Restraints","Time (ps)",
"nm");
snew(vvindex,isize);
snew(leg,isize);
for(i=0; (i<isize); i++) {
index[i]++;
snew(leg[i],12);
sprintf(leg[i],"index %d",index[i]);
}
xvgr_legend(xvg,isize,leg);
}
else
isize=0;
ir.dr_tau=0.0;
init_disres(fplog,&mtop,&ir,NULL,FALSE,&fcd,NULL);
natoms=read_first_x(&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
snew(f,5*natoms);
init_dr_res(&dr,fcd.disres.nres);
if (opt2bSet("-c",NFILE,fnm)) {
clust = cluster_index(fplog,opt2fn("-c",NFILE,fnm));
snew(dr_clust,clust->clust->nr+1);
for(i=0; (i<=clust->clust->nr); i++)
init_dr_res(&dr_clust[i],fcd.disres.nres);
}
else {
out =xvgropen(opt2fn("-ds",NFILE,fnm),
"Sum of Violations","Time (ps)","nm");
aver=xvgropen(opt2fn("-da",NFILE,fnm),
"Average Violation","Time (ps)","nm");
numv=xvgropen(opt2fn("-dn",NFILE,fnm),
"# Violations","Time (ps)","#");
maxxv=xvgropen(opt2fn("-dm",NFILE,fnm),
"Largest Violation","Time (ps)","nm");
}
mdatoms = init_mdatoms(fplog,&mtop,ir.efep!=efepNO);
atoms2md(&mtop,&ir,0,NULL,0,mtop.natoms,mdatoms);
update_mdatoms(mdatoms,ir.init_lambda);
fr = mk_forcerec();
fprintf(fplog,"Made forcerec\n");
init_forcerec(fplog,fr,NULL,&ir,&mtop,cr,box,FALSE,NULL,NULL,NULL,FALSE,-1);
init_nrnb(&nrnb);
j=0;
do {
if (ir.ePBC != epbcNONE) {
if (ir.bPeriodicMols)
set_pbc(&pbc,ir.ePBC,box);
else
rm_pbc(&top->idef,ir.ePBC,natoms,box,x,x);
}
if (clust) {
if (j > clust->maxframe)
gmx_fatal(FARGS,"There are more frames in the trajectory than in the cluster index file. t = %8f\n",t);
my_clust = clust->inv_clust[j];
range_check(my_clust,0,clust->clust->nr);
check_viol(fplog,cr,&(top->idef.il[F_DISRES]),
top->idef.iparams,top->idef.functype,
x,f,fr,pbc_null,g,dr_clust,my_clust,isize,index,vvindex,&fcd);
}
else
check_viol(fplog,cr,&(top->idef.il[F_DISRES]),
top->idef.iparams,top->idef.functype,
x,f,fr,pbc_null,g,&dr,0,isize,index,vvindex,&fcd);
if (bPDB) {
reset_x(atoms->nr,ind_fit,atoms->nr,NULL,x,w_rls);
do_fit(atoms->nr,w_rls,x,x);
if (j == 0) {
/* Store the first frame of the trajectory as 'characteristic'
* for colouring with violations.
*/
for(kkk=0; (kkk<atoms->nr); kkk++)
copy_rvec(x[kkk],xav[kkk]);
}
}
if (!clust) {
if (isize > 0) {
fprintf(xvg,"%10g",t);
for(i=0; (i<isize); i++)
fprintf(xvg," %10g",vvindex[i]);
fprintf(xvg,"\n");
}
fprintf(out, "%10g %10g\n",t,dr.sumv);
fprintf(aver, "%10g %10g\n",t,dr.averv);
fprintf(maxxv,"%10g %10g\n",t,dr.maxv);
fprintf(numv, "%10g %10d\n",t,dr.nv);
}
j++;
} while (read_next_x(status,&t,natoms,x,box));
close_trj(status);
if (clust) {
dump_clust_stats(fplog,fcd.disres.nres,&(top->idef.il[F_DISRES]),
top->idef.iparams,clust->clust,dr_clust,
clust->grpname,isize,index);
}
else {
dump_stats(fplog,j,fcd.disres.nres,&(top->idef.il[F_DISRES]),
top->idef.iparams,&dr,isize,index,
bPDB ? atoms : NULL);
if (bPDB) {
write_sto_conf(opt2fn("-q",NFILE,fnm),
"Coloured by average violation in Angstrom",
atoms,xav,NULL,ir.ePBC,box);
}
dump_disre_matrix(opt2fn_null("-x",NFILE,fnm),&dr,fcd.disres.nres,
j,&top->idef,&mtop,max_dr,nlevels,bThird);
fclose(out);
fclose(aver);
fclose(numv);
fclose(maxxv);
if (isize > 0) {
fclose(xvg);
do_view(opt2fn("-dr",NFILE,fnm),"-nxy");
}
do_view(opt2fn("-dn",NFILE,fnm),"-nxy");
do_view(opt2fn("-da",NFILE,fnm),"-nxy");
do_view(opt2fn("-ds",NFILE,fnm),"-nxy");
do_view(opt2fn("-dm",NFILE,fnm),"-nxy");
}
thanx(stderr);
if (gmx_parallel_env)
gmx_finalize();
gmx_log_close(fplog);
return 0;
}
void sgangle_plot_single(char *fn,char *afile,char *dfile,
char *d1file, char *d2file,
atom_id index1[], int gnx1, char *grpn1,
atom_id index2[], int gnx2, char *grpn2,
t_topology *top,int ePBC)
{
FILE
*sg_angle, /* xvgr file with angles */
*sg_distance = NULL, /* xvgr file with distances */
*sg_distance1 = NULL,/* xvgr file with distance between plane and atom */
*sg_distance2 = NULL;/* xvgr file with distance between plane and atom2 */
real
t, /* time */
angle, /* cosine of angle between two groups */
distance, /* distance between two groups. */
distance1, /* distance between plane and one of two atoms */
distance2; /* same for second of two atoms */
int status,natoms,teller=0;
int i;
rvec *x0; /* coordinates, and coordinates corrected for pb */
rvec *xzero;
matrix box;
char buf[256]; /* for xvgr title */
if ((natoms = read_first_x(&status,fn,&t,&x0,box)) == 0)
gmx_fatal(FARGS,"Could not read coordinates from statusfile\n");
sprintf(buf,"Angle between %s and %s",grpn1,grpn2);
sg_angle = xvgropen(afile,buf,"Time (ps)","Cos(angle) ");
if (dfile) {
sprintf(buf,"Distance between %s and %s",grpn1,grpn2);
sg_distance = xvgropen(dfile,buf,"Time (ps)","Distance (nm)");
}
if (d1file) {
sprintf(buf,"Distance between plane and first atom of vector");
sg_distance1 = xvgropen(d1file,buf,"Time (ps)","Distance (nm)");
}
if (d2file) {
sprintf(buf,"Distance between plane and second atom of vector");
sg_distance2 = xvgropen(d2file,buf,"Time (ps","Distance (nm)");
}
snew(xzero,natoms);
do {
teller++;
rm_pbc(&(top->idef),ePBC,natoms,box,x0,x0);
if (teller==1) {
for(i=0;i<natoms;i++)
copy_rvec(x0[i],xzero[i]);
}
calc_angle_single(ePBC,box,
xzero,x0,index1,index2,gnx1,gnx2,&angle,
&distance,&distance1,&distance2);
fprintf(sg_angle,"%12g %12g %12g\n",t,angle,acos(angle)*180.0/M_PI);
if (dfile)
fprintf(sg_distance,"%12g %12g\n",t,distance);
if (d1file)
fprintf(sg_distance1,"%12g %12g\n",t,distance1);
if (d2file)
fprintf(sg_distance2,"%12g %12g\n",t,distance1);
} while (read_next_x(status,&t,natoms,x0,box));
fprintf(stderr,"\n");
close_trj(status);
fclose(sg_angle);
if (dfile)
fclose(sg_distance);
if (d1file)
fclose(sg_distance1);
if (d2file)
fclose(sg_distance2);
sfree(x0);
}
int main(int argc,char *argv[])
{
static char *desc[] = {
"g_mydist is g_dist with periodic boundary conditions disabled completely.",
"g_mydist does not output the dx,dy,dz components of the coordinate displacement vector.",
"see g_dist -h for other usage"
};
t_topology *top=NULL;
real t,cut2,dist2;
rvec *x=NULL,*v=NULL,dx;
matrix box;
int status;
int natoms;
int g,d,i,j,res,teller=0;
atom_id aid;
int ngrps; /* the number of index groups */
atom_id **index,max; /* the index for the atom numbers */
int *isize; /* the size of each group */
char **grpname; /* the name of each group */
rvec *com;
real *mass;
FILE *fp=NULL;
bool bCutoff;
t_pbc pbc;
char *leg[4] = { "|d|","d\\sx\\N","d\\sy\\N","d\\sz\\N" };
static real cut=0;
static t_pargs pa[] = {
{ "-dist", FALSE, etREAL, {&cut},
"Print all atoms in group 2 closer than dist to the center of mass of group 1" },
};
#define NPA asize(pa)
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPX, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "dist", ffOPTWR },
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_BE_NICE,
NFILE,fnm,NPA,pa,asize(desc),desc,0,NULL);
bCutoff=opt2parg_bSet("-dist",NPA,pa);
cut2=cut*cut;
top=read_top(ftp2fn(efTPX,NFILE,fnm));
/* read index files */
ngrps = 2;
snew(com,ngrps);
snew(grpname,ngrps);
snew(index,ngrps);
snew(isize,ngrps);
get_index(&top->atoms,ftp2fn(efNDX,NFILE,fnm),ngrps,isize,index,grpname);
/* calculate mass */
max=0;
snew(mass,ngrps);
for(g=0;(g<ngrps);g++) {
mass[g]=0;
for(i=0;(i<isize[g]);i++) {
if (index[g][i]>max)
max=index[g][i];
if (index[g][i] >= top->atoms.nr)
gmx_fatal(FARGS,"Atom number %d, item %d of group %d, is larger than number of atoms in the topolgy (%d)\n",index[g][i]+1,i+1,g+1,top->atoms.nr+1);
mass[g]+=top->atoms.atom[index[g][i]].m;
}
}
natoms=read_first_x(&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
if (max>=natoms)
gmx_fatal(FARGS,"Atom number %d in an index group is larger than number of atoms in the trajectory (%d)\n",(int)max+1,natoms);
if (!bCutoff) {
/* open output file */
fp = xvgropen(ftp2fn(efXVG,NFILE,fnm),
"Distance","Time (ps)","Distance (nm)");
xvgr_legend(fp,4,leg);
} else
ngrps=1;
do {
/* initialisation for correct distance calculations */
/* GL : set box diagonal to zero to avoid pbc distance calculations
* note that set_pbc do not use pbc to calc. distances if one of
* the diagonal entries for box is 0
*/
/* GL: comment out this line to get PBC back */
box[XX][XX]=box[YY][YY]=box[ZZ][ZZ]=0;
/* end comment */
set_pbc(&pbc,box);
/* make molecules whole again */
/*GL: rm_pbc transforms the molecules' coordinates to make them whole.
* Not sure if rm_pbc needs to be called here..but I think it was put here
* in case a user used an input trajectory with non-whole molecule(s)
*/
rm_pbc(&top->idef,natoms,box,x,x);
/* calculate center of masses */
for(g=0;(g<ngrps);g++) {
for(d=0;(d<DIM);d++) {
com[g][d]=0;
for(i=0;(i<isize[g]);i++) {
com[g][d] += x[index[g][i]][d] * top->atoms.atom[index[g][i]].m;
}
com[g][d] /= mass[g];
}
}
if (!bCutoff) {
/* write to output */
fprintf(fp,"%12.7f ",t);
for(g=0;(g<ngrps/2);g++) {
pbc_dx(&pbc,com[2*g],com[2*g+1],dx);
/*fprintf(fp,"%12.7f %12.7f %12.7f %12.7f",
norm(dx),dx[XX],dx[YY],dx[ZZ]);*/
/*GL: prints only the distance*/
fprintf(fp,"%12.7f",norm(dx));
}
fprintf(fp,"\n");
} else {
for(i=0;(i<isize[1]);i++) {
j=index[1][i];
pbc_dx(&pbc,x[j],com[0],dx);
dist2 = norm2(dx);
if (dist2<cut2) {
res=top->atoms.atom[j].resnr;
fprintf(stdout,"\rt: %g %d %s %d %s %g (nm)\n",
t,res+1,*top->atoms.resname[res],
j+1,*top->atoms.atomname[j],sqrt(dist2));
}
}
}
teller++;
} while (read_next_x(status,&t,natoms,x,box));
if (!bCutoff)
fclose(fp);
close_trj(status);
thanx(stderr);
return 0;
}
int gmx_principal(int argc,char *argv[])
{
const char *desc[] = {
"g_principal calculates the three principal axes of inertia for a group",
"of atoms.",
};
static bool foo = FALSE;
t_pargs pa[] = {
{ "-foo", FALSE, etBOOL, {&foo}, "Dummy option to avoid empty array" }
};
int status;
t_topology top;
int ePBC;
real t;
rvec * x;
int natoms;
char *grpname,title[256];
int i,j,m,gnx,nam,mol;
atom_id *index;
rvec a1,a2,a3,moi;
FILE * axis1;
FILE * axis2;
FILE * axis3;
FILE * fmoi;
matrix axes,box;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efDAT, "-a1", "axis1", ffWRITE },
{ efDAT, "-a2", "axis2", ffWRITE },
{ efDAT, "-a3", "axis3", ffWRITE },
{ efDAT, "-om", "moi", ffWRITE }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
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);
axis1=fopen(opt2fn("-a1",NFILE,fnm),"w");
axis2=fopen(opt2fn("-a2",NFILE,fnm),"w");
axis3=fopen(opt2fn("-a3",NFILE,fnm),"w");
fmoi =fopen(opt2fn("-om",NFILE,fnm),"w");
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,NULL,NULL,box,TRUE);
get_index(&top.atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&gnx,&index,&grpname);
natoms=read_first_x(&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
do
{
rm_pbc(&(top.idef),ePBC,natoms,box,x,x);
calc_principal_axes(&top,x,index,gnx,axes,moi);
fprintf(axis1,"%15.10f %15.10f %15.10f %15.10f\n",t,axes[XX][XX],axes[YY][XX],axes[ZZ][XX]);
fprintf(axis2,"%15.10f %15.10f %15.10f %15.10f\n",t,axes[XX][YY],axes[YY][YY],axes[ZZ][YY]);
fprintf(axis3,"%15.10f %15.10f %15.10f %15.10f\n",t,axes[XX][ZZ],axes[YY][ZZ],axes[ZZ][ZZ]);
fprintf(fmoi, "%15.10f %15.10f %15.10f %15.10f\n",t,moi[XX],moi[YY],moi[ZZ]);
}
while(read_next_x(status,&t,natoms,x,box));
close_trj(status);
fclose(axis1);
fclose(axis2);
fclose(axis3);
fclose(fmoi);
thanx(stderr);
return 0;
}
static void do_rdf(char *fnNDX,char *fnTPS,char *fnTRX,
char *fnRDF,char *fnCNRDF, char *fnHQ,
bool bCM,char **rdft,bool bXY,bool bPBC,bool bNormalize,
real cutoff,real binwidth,real fade,int ng)
{
FILE *fp;
int status;
char outf1[STRLEN],outf2[STRLEN];
char title[STRLEN],gtitle[STRLEN];
int g,natoms,i,j,k,nbin,j0,j1,n,nframes;
int **count;
char **grpname;
int *isize,isize_cm=0,nrdf=0,max_i,isize0,isize_g;
atom_id **index,*index_cm=NULL;
#if (defined SIZEOF_LONG_LONG_INT) && (SIZEOF_LONG_LONG_INT >= 8)
long long int *sum;
#else
double *sum;
#endif
real t,rmax2,cut2,r,r2,invhbinw,normfac;
real segvol,spherevol,prev_spherevol,**rdf;
rvec *x,dx,*x0=NULL,*x_i1,xi;
real *inv_segvol,invvol,invvol_sum,rho;
bool *bExcl,bTop,bNonSelfExcl;
matrix box,box_pbc;
int **npairs;
atom_id ix,jx,***pairs;
t_topology *top=NULL;
int ePBC=-1;
t_block *mols=NULL;
t_blocka *excl;
t_atom *atom=NULL;
t_pbc pbc;
int *is=NULL,**coi=NULL,cur,mol,i1,res,a;
excl=NULL;
if (fnTPS) {
snew(top,1);
bTop=read_tps_conf(fnTPS,title,top,&ePBC,&x,NULL,box,TRUE);
if (bTop && !bCM)
/* get exclusions from topology */
excl = &(top->excls);
}
snew(grpname,ng+1);
snew(isize,ng+1);
snew(index,ng+1);
fprintf(stderr,"\nSelect a reference group and %d group%s\n",
ng,ng==1?"":"s");
if (fnTPS) {
get_index(&(top->atoms),fnNDX,ng+1,isize,index,grpname);
atom = top->atoms.atom;
} else {
rd_index(fnNDX,ng+1,isize,index,grpname);
}
if (rdft[0][0] != 'a') {
/* Split up all the groups in molecules or residues */
switch (rdft[0][0]) {
case 'm':
mols = &top->mols;
break;
case 'r':
atom = top->atoms.atom;
break;
default:
gmx_fatal(FARGS,"Unknown rdf option '%s'",rdft[0]);
}
snew(is,ng+1);
snew(coi,ng+1);
for(g=(bCM ? 1 : 0); g<ng+1; g++) {
snew(coi[g],isize[g]+1);
is[g] = 0;
cur = -1;
mol = 0;
for(i=0; i<isize[g]; i++) {
a = index[g][i];
if (rdft[0][0] == 'm') {
/* Check if the molecule number has changed */
i1 = mols->index[mol+1];
while(a >= i1) {
mol++;
i1 = mols->index[mol+1];
}
if (mol != cur) {
coi[g][is[g]++] = i;
cur = mol;
}
} else if (rdft[0][0] == 'r') {
/* Check if the residue number has changed */
res = atom[a].resnr;
if (res != cur) {
coi[g][is[g]++] = i;
cur = res;
}
}
}
coi[g][is[g]] = i;
srenew(coi[g],is[g]+1);
printf("Group '%s' of %d atoms consists of %d %s\n",
grpname[g],isize[g],is[g],
(rdft[0][0]=='m' ? "molecules" : "residues"));
}
} else if (bCM) {
snew(is,1);
snew(coi,1);
}
if (bCM) {
is[0] = 1;
snew(coi[0],is[0]+1);
coi[0][0] = 0;
coi[0][1] = isize[0];
isize0 = is[0];
snew(x0,isize0);
} else if (rdft[0][0] != 'a') {
isize0 = is[0];
snew(x0,isize0);
} else {
isize0 = isize[0];
}
natoms=read_first_x(&status,fnTRX,&t,&x,box);
if ( !natoms )
gmx_fatal(FARGS,"Could not read coordinates from statusfile\n");
if (fnTPS)
/* check with topology */
if ( natoms > top->atoms.nr )
gmx_fatal(FARGS,"Trajectory (%d atoms) does not match topology (%d atoms)",
natoms,top->atoms.nr);
/* check with index groups */
for (i=0; i<ng+1; i++)
for (j=0; j<isize[i]; j++)
if ( index[i][j] >= natoms )
gmx_fatal(FARGS,"Atom index (%d) in index group %s (%d atoms) larger "
"than number of atoms in trajectory (%d atoms)",
index[i][j],grpname[i],isize[i],natoms);
/* initialize some handy things */
copy_mat(box,box_pbc);
if (bXY) {
check_box_c(box);
/* Make sure the z-height does not influence the cut-off */
box_pbc[ZZ][ZZ] = 2*max(box[XX][XX],box[YY][YY]);
}
if (bPBC)
rmax2 = 0.99*0.99*max_cutoff2(bXY ? epbcXY : epbcXYZ,box_pbc);
else
rmax2 = sqr(3*max(box[XX][XX],max(box[YY][YY],box[ZZ][ZZ])));
if (debug)
fprintf(debug,"rmax2 = %g\n",rmax2);
/* We use the double amount of bins, so we can correctly
* write the rdf and rdf_cn output at i*binwidth values.
*/
nbin = (int)(sqrt(rmax2) * 2 / binwidth);
invhbinw = 2.0 / binwidth;
cut2 = sqr(cutoff);
snew(count,ng);
snew(pairs,ng);
snew(npairs,ng);
snew(bExcl,natoms);
max_i = 0;
for(g=0; g<ng; g++) {
if (isize[g+1] > max_i)
max_i = isize[g+1];
/* this is THE array */
snew(count[g],nbin+1);
/* make pairlist array for groups and exclusions */
snew(pairs[g],isize[0]);
snew(npairs[g],isize[0]);
for(i=0; i<isize[0]; i++) {
/* We can only have exclusions with atomic rdfs */
if (!(bCM || rdft[0][0] != 'a')) {
ix = index[0][i];
for(j=0; j < natoms; j++)
bExcl[j] = FALSE;
/* exclusions? */
if (excl)
for( j = excl->index[ix]; j < excl->index[ix+1]; j++)
bExcl[excl->a[j]]=TRUE;
k = 0;
snew(pairs[g][i], isize[g+1]);
bNonSelfExcl = FALSE;
for(j=0; j<isize[g+1]; j++) {
jx = index[g+1][j];
if (!bExcl[jx])
pairs[g][i][k++]=jx;
else if (ix != jx)
/* Check if we have exclusions other than self exclusions */
bNonSelfExcl = TRUE;
}
if (bNonSelfExcl) {
npairs[g][i]=k;
srenew(pairs[g][i],npairs[g][i]);
} else {
/* Save a LOT of memory and some cpu cycles */
npairs[g][i]=-1;
sfree(pairs[g][i]);
}
} else {
npairs[g][i]=-1;
}
}
}
sfree(bExcl);
snew(x_i1,max_i);
nframes = 0;
invvol_sum = 0;
do {
/* Must init pbc every step because of pressure coupling */
copy_mat(box,box_pbc);
if (bPBC) {
if (top != NULL)
rm_pbc(&top->idef,ePBC,natoms,box,x,x);
if (bXY) {
check_box_c(box);
clear_rvec(box_pbc[ZZ]);
}
set_pbc(&pbc,ePBC,box_pbc);
if (bXY)
/* Set z-size to 1 so we get the surface iso the volume */
box_pbc[ZZ][ZZ] = 1;
}
invvol = 1/det(box_pbc);
invvol_sum += invvol;
if (bCM) {
/* Calculate center of mass of the whole group */
calc_comg(is[0],coi[0],index[0],TRUE ,atom,x,x0);
} else if (rdft[0][0] != 'a') {
calc_comg(is[0],coi[0],index[0],rdft[0][6]=='m',atom,x,x0);
}
for(g=0; g<ng; g++) {
if (rdft[0][0] == 'a') {
/* Copy the indexed coordinates to a continuous array */
for(i=0; i<isize[g+1]; i++)
copy_rvec(x[index[g+1][i]],x_i1[i]);
} else {
/* Calculate the COMs/COGs and store in x_i1 */
calc_comg(is[g+1],coi[g+1],index[g+1],rdft[0][6]=='m',atom,x,x_i1);
}
for(i=0; i<isize0; i++) {
if (bCM || rdft[0][0] != 'a') {
copy_rvec(x0[i],xi);
} else {
copy_rvec(x[index[0][i]],xi);
}
if (rdft[0][0] == 'a' && npairs[g][i] >= 0) {
/* Expensive loop, because of indexing */
for(j=0; j<npairs[g][i]; j++) {
jx=pairs[g][i][j];
if (bPBC)
pbc_dx(&pbc,xi,x[jx],dx);
else
rvec_sub(xi,x[jx],dx);
if (bXY)
r2 = dx[XX]*dx[XX] + dx[YY]*dx[YY];
else
r2=iprod(dx,dx);
if (r2>cut2 && r2<=rmax2)
count[g][(int)(sqrt(r2)*invhbinw)]++;
}
} else {
/* Cheaper loop, no exclusions */
if (rdft[0][0] == 'a')
isize_g = isize[g+1];
else
isize_g = is[g+1];
for(j=0; j<isize_g; j++) {
if (bPBC)
pbc_dx(&pbc,xi,x_i1[j],dx);
else
rvec_sub(xi,x_i1[j],dx);
if (bXY)
r2 = dx[XX]*dx[XX] + dx[YY]*dx[YY];
else
r2=iprod(dx,dx);
if (r2>cut2 && r2<=rmax2)
count[g][(int)(sqrt(r2)*invhbinw)]++;
}
}
}
}
nframes++;
} while (read_next_x(status,&t,natoms,x,box));
fprintf(stderr,"\n");
close_trj(status);
sfree(x);
/* Average volume */
invvol = invvol_sum/nframes;
/* Calculate volume of sphere segments or length of circle segments */
snew(inv_segvol,(nbin+1)/2);
prev_spherevol=0;
for(i=0; (i<(nbin+1)/2); i++) {
r = (i + 0.5)*binwidth;
if (bXY) {
spherevol=M_PI*r*r;
} else {
spherevol=(4.0/3.0)*M_PI*r*r*r;
}
segvol=spherevol-prev_spherevol;
inv_segvol[i]=1.0/segvol;
prev_spherevol=spherevol;
}
snew(rdf,ng);
for(g=0; g<ng; g++) {
/* We have to normalize by dividing by the number of frames */
if (rdft[0][0] == 'a')
normfac = 1.0/(nframes*invvol*isize0*isize[g+1]);
else
normfac = 1.0/(nframes*invvol*isize0*is[g+1]);
/* Do the normalization */
nrdf = max((nbin+1)/2,1+2*fade/binwidth);
snew(rdf[g],nrdf);
for(i=0; i<(nbin+1)/2; i++) {
r = i*binwidth;
if (i == 0)
j = count[g][0];
else
j = count[g][i*2-1] + count[g][i*2];
if ((fade > 0) && (r >= fade))
rdf[g][i] = 1 + (j*inv_segvol[i]*normfac-1)*exp(-16*sqr(r/fade-1));
else {
if (bNormalize)
rdf[g][i] = j*inv_segvol[i]*normfac;
else
rdf[g][i] = j/(binwidth*isize0*nframes);
}
}
for( ; (i<nrdf); i++)
rdf[g][i] = 1.0;
}
if (rdft[0][0] == 'a') {
sprintf(gtitle,"Radial distribution");
} else {
sprintf(gtitle,"Radial distribution of %s %s",
rdft[0][0]=='m' ? "molecule" : "residue",
rdft[0][6]=='m' ? "COM" : "COG");
}
fp=xvgropen(fnRDF,gtitle,"r","");
if (ng==1) {
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"%s%s - %s\"\n",
grpname[0],bCM ? " COM" : "",grpname[1]);
}
else {
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"reference %s%s\"\n",
grpname[0],bCM ? " COM" : "");
xvgr_legend(fp,ng,grpname+1);
}
for(i=0; (i<nrdf); i++) {
fprintf(fp,"%10g",i*binwidth);
for(g=0; g<ng; g++)
fprintf(fp," %10g",rdf[g][i]);
fprintf(fp,"\n");
}
ffclose(fp);
do_view(fnRDF,NULL);
/* h(Q) function: fourier transform of rdf */
if (fnHQ) {
int nhq = 401;
real *hq,*integrand,Q;
/* Get a better number density later! */
rho = isize[1]*invvol;
snew(hq,nhq);
snew(integrand,nrdf);
for(i=0; (i<nhq); i++) {
Q = i*0.5;
integrand[0] = 0;
for(j=1; (j<nrdf); j++) {
r = j*binwidth;
integrand[j] = (Q == 0) ? 1.0 : sin(Q*r)/(Q*r);
integrand[j] *= 4.0*M_PI*rho*r*r*(rdf[0][j]-1.0);
}
hq[i] = print_and_integrate(debug,nrdf,binwidth,integrand,NULL,0);
}
fp=xvgropen(fnHQ,"h(Q)","Q(/nm)","h(Q)");
for(i=0; (i<nhq); i++)
fprintf(fp,"%10g %10g\n",i*0.5,hq[i]);
ffclose(fp);
do_view(fnHQ,NULL);
sfree(hq);
sfree(integrand);
}
if (fnCNRDF) {
normfac = 1.0/(isize0*nframes);
fp=xvgropen(fnCNRDF,"Cumulative Number RDF","r","number");
if (ng==1) {
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"%s-%s\"\n",grpname[0],grpname[1]);
}
else {
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"reference %s\"\n",grpname[0]);
xvgr_legend(fp,ng,grpname+1);
}
snew(sum,ng);
for(i=0; (i<=nbin/2); i++) {
fprintf(fp,"%10g",i*binwidth);
for(g=0; g<ng; g++) {
fprintf(fp," %10g",(real)((double)sum[g]*normfac));
if (i*2+1 < nbin)
sum[g] += count[g][i*2] + count[g][i*2+1];
}
fprintf(fp,"\n");
}
ffclose(fp);
sfree(sum);
do_view(fnCNRDF,NULL);
}
for(g=0; g<ng; g++)
sfree(rdf[g]);
sfree(rdf);
}
int gmx_rotacf(int argc,char *argv[])
{
static char *desc[] = {
"g_rotacf calculates the rotational correlation function",
"for molecules. Three atoms (i,j,k) must be given in the index",
"file, defining two vectors ij and jk. The rotational acf",
"is calculated as the autocorrelation function of the vector",
"n = ij x jk, i.e. the cross product of the two vectors.",
"Since three atoms span a plane, the order of the three atoms",
"does not matter. Optionally, controlled by the -d switch, you can",
"calculate the rotational correlation function for linear molecules",
"by specifying two atoms (i,j) in the index file.",
"[PAR]",
"EXAMPLES[PAR]",
"g_rotacf -P 1 -nparm 2 -fft -n index -o rotacf-x-P1",
"-fa expfit-x-P1 -beginfit 2.5 -endfit 20.0[PAR]",
"This will calculate the rotational correlation function using a first",
"order Legendre polynomial of the angle of a vector defined by the index",
"file. The correlation function will be fitted from 2.5 ps till 20.0 ps",
"to a two parameter exponential",
""
};
static bool bVec = FALSE,bAver=TRUE;
t_pargs pa[] = {
{ "-d", FALSE, etBOOL, {&bVec},
"Use index doublets (vectors) for correlation function instead of triplets (planes)" },
{ "-aver",FALSE, etBOOL, {&bAver},
"Average over molecules" }
};
int status,isize;
atom_id *index;
char *grpname;
rvec *x,*x_s;
matrix box;
real **c1;
rvec xij,xjk,n;
int i,m,teller,n_alloc,natoms,nvec,ai,aj,ak;
unsigned long mode;
real t,t0,t1,dt;
t_topology *top;
int ePBC;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPX, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffREAD },
{ efXVG, "-o", "rotacf", ffWRITE }
};
#define NFILE asize(fnm)
int npargs;
t_pargs *ppa;
CopyRight(stderr,argv[0]);
npargs = asize(pa);
ppa = add_acf_pargs(&npargs,pa);
parse_common_args(&argc,argv,PCA_CAN_VIEW | PCA_CAN_TIME | PCA_BE_NICE,
NFILE,fnm,npargs,ppa,asize(desc),desc,0,NULL);
rd_index(ftp2fn(efNDX,NFILE,fnm),1,&isize,&index,&grpname);
if (bVec)
nvec = isize/2;
else
nvec = isize/3;
if (((isize % 3) != 0) && !bVec)
gmx_fatal(FARGS,"number of index elements not multiple of 3, "
"these can not be atom triplets\n");
if (((isize % 2) != 0) && bVec)
gmx_fatal(FARGS,"number of index elements not multiple of 2, "
"these can not be atom doublets\n");
top=read_top(ftp2fn(efTPX,NFILE,fnm),&ePBC);
snew(c1,nvec);
for (i=0; (i<nvec); i++)
c1[i]=NULL;
n_alloc=0;
natoms=read_first_x(&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
snew(x_s,natoms);
/* Start the loop over frames */
t1 = t0 = t;
teller = 0;
do {
if (teller >= n_alloc) {
n_alloc+=100;
for (i=0; (i<nvec); i++)
srenew(c1[i],DIM*n_alloc);
}
t1 = t;
/* Remove periodicity */
rm_pbc(&(top->idef),ePBC,natoms,box,x,x_s);
/* Compute crossproducts for all vectors, if triplets.
* else, just get the vectors in case of doublets.
*/
if (bVec == FALSE) {
for (i=0; (i<nvec); i++) {
ai=index[3*i];
aj=index[3*i+1];
ak=index[3*i+2];
rvec_sub(x_s[ai],x_s[aj],xij);
rvec_sub(x_s[aj],x_s[ak],xjk);
cprod(xij,xjk,n);
for(m=0; (m<DIM); m++)
c1[i][DIM*teller+m]=n[m];
}
}
else {
for (i=0; (i<nvec); i++) {
ai=index[2*i];
aj=index[2*i+1];
rvec_sub(x_s[ai],x_s[aj],n);
for(m=0; (m<DIM); m++)
c1[i][DIM*teller+m]=n[m];
}
}
/* Increment loop counter */
teller++;
} while (read_next_x(status,&t,natoms,x,box));
close_trj(status);
fprintf(stderr,"\nDone with trajectory\n");
/* Autocorrelation function */
if (teller < 2)
fprintf(stderr,"Not enough frames for correlation function\n");
else {
dt=(t1 - t0)/(teller-1);
mode = eacVector;
do_autocorr(ftp2fn(efXVG,NFILE,fnm),"Rotational Correlation Function",
teller,nvec,c1,dt,mode,bAver);
}
do_view(ftp2fn(efXVG,NFILE,fnm),NULL);
thanx(stderr);
return 0;
}
int gmx_sorient(int argc,char *argv[])
{
t_topology top;
int ePBC;
char title[STRLEN];
int status;
int natoms;
real t;
rvec *xtop,*x;
matrix box;
FILE *fp;
int i,j,p,sa0,sa1,sa2,n,ntot,nf,m,*hist1,*hist2,*histn,nbin1,nbin2,nrbin;
real *histi1,*histi2,invbw,invrbw;
double sum1,sum2;
int *isize,nrefgrp,nrefat;
atom_id **index;
char **grpname;
real inp,outp,two_pi,nav,normfac,rmin2,rmax2,rcut,rcut2,r2,r,mass,mtot;
real c1,c2;
char str[STRLEN];
bool bTPS;
rvec xref,dx,dxh1,dxh2,outer;
t_pbc pbc;
char *legr[] = { "<cos(\\8q\\4\\s1\\N)>",
"<3cos\\S2\\N(\\8q\\4\\s2\\N)-1>" };
char *legc[] = { "cos(\\8q\\4\\s1\\N)",
"3cos\\S2\\N(\\8q\\4\\s2\\N)-1" };
static char *desc[] = {
"g_sorient analyzes solvent orientation around solutes.",
"It calculates two angles between the vector from one or more",
"reference positions to the first atom of each solvent molecule:[BR]"
"theta1: the angle with the vector from the first atom of the solvent",
"molecule to the midpoint between atoms 2 and 3.[BR]",
"theta2: the angle with the normal of the solvent plane, defined by the",
"same three atoms, or when the option [TT]-v23[tt] is set",
"the angle with the vector between atoms 2 and 3.[BR]",
"The reference can be a set of atoms or",
"the center of mass of a set of atoms. The group of solvent atoms should",
"consist of 3 atoms per solvent molecule.",
"Only solvent molecules between [TT]-rmin[tt] and [TT]-rmax[tt] are",
"considered for [TT]-o[tt] and [TT]-no[tt] each frame.[PAR]",
"[TT]-o[tt]: distribtion of cos(theta1) for rmin<=r<=rmax.[PAR]",
"[TT]-no[tt]: distribution of cos(theta2) for rmin<=r<=rmax.[PAR]",
"[TT]-ro[tt]: <cos(theta1)> and <3cos^2(theta2)-1> as a function of the",
"distance.[PAR]",
"[TT]-co[tt]: the sum over all solvent molecules within distance r",
"of cos(theta1) and 3cos^2(theta2)-1 as a function of r.[PAR]",
"[TT]-rc[tt]: the distribution of the solvent molecules as a function of r"
};
static bool bCom = FALSE,bVec23=FALSE,bPBC = FALSE;
static real rmin=0.0,rmax=0.5,binwidth=0.02,rbinw=0.02;
t_pargs pa[] = {
{ "-com", FALSE, etBOOL, {&bCom},
"Use the center of mass as the reference postion" },
{ "-v23", FALSE, etBOOL, {&bVec23},
"Use the vector between atoms 2 and 3" },
{ "-rmin", FALSE, etREAL, {&rmin}, "Minimum distance (nm)" },
{ "-rmax", FALSE, etREAL, {&rmax}, "Maximum distance (nm)" },
{ "-cbin", FALSE, etREAL, {&binwidth}, "Binwidth for the cosine" },
{ "-rbin", FALSE, etREAL, {&rbinw}, "Binwidth for r (nm)" },
{ "-pbc", FALSE, etBOOL, {&bPBC}, "Check PBC for the center of mass calculation. Only necessary when your reference group consists of several molecules." }
};
t_filenm fnm[] = {
{ efTRX, NULL, NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "sori.xvg", ffWRITE },
{ efXVG, "-no", "snor.xvg", ffWRITE },
{ efXVG, "-ro", "sord.xvg", ffWRITE },
{ efXVG, "-co", "scum.xvg", ffWRITE },
{ efXVG, "-rc", "scount.xvg", ffWRITE }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL);
two_pi = 2/M_PI;
bTPS = (opt2bSet("-s",NFILE,fnm) || !opt2bSet("-n",NFILE,fnm) || bCom);
if (bTPS) {
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xtop,NULL,box,
bCom);
}
/* get index groups */
printf("Select a group of reference particles and a solvent group:\n");
snew(grpname,2);
snew(index,2);
snew(isize,2);
if (bTPS) {
get_index(&top.atoms,ftp2fn_null(efNDX,NFILE,fnm),2,isize,index,grpname);
} else {
get_index(NULL,ftp2fn(efNDX,NFILE,fnm),2,isize,index,grpname);
}
if (bCom) {
nrefgrp = 1;
nrefat = isize[0];
} else {
nrefgrp = isize[0];
nrefat = 1;
}
if (isize[1] % 3)
gmx_fatal(FARGS,"The number of solvent atoms (%d) is not a multiple of 3",
isize[1]);
/* initialize reading trajectory: */
natoms=read_first_x(&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
rmin2 = sqr(rmin);
rmax2 = sqr(rmax);
rcut = 0.99*sqrt(max_cutoff2(guess_ePBC(box),box));
if (rcut == 0)
rcut = 10*rmax;
rcut2 = sqr(rcut);
invbw = 1/binwidth;
nbin1 = (int)(2*invbw + 0.5);
nbin2 = (int)(invbw + 0.5);
invrbw = 1/rbinw;
snew(hist1,nbin1+1);
snew(hist2,nbin2+1);
nrbin = rcut/rbinw;
if (nrbin == 0)
nrbin = 1;
snew(histi1,nrbin);
snew(histi2,nrbin);
snew(histn,nrbin);
ntot = 0;
nf = 0;
sum1 = 0;
sum2 = 0;
/* start analysis of trajectory */
do {
if (bTPS) {
/* make molecules whole again */
rm_pbc(&top.idef,ePBC,natoms,box,x,x);
}
set_pbc(&pbc,ePBC,box);
n = 0;
inp = 0;
outp = 0;
for(p=0; (p<nrefgrp); p++) {
if (bCom)
calc_com_pbc(nrefat,&top,x,&pbc,index[0],xref,bPBC,box);
else
copy_rvec(x[index[0][p]],xref);
for(m=0; m<isize[1]; m+=3) {
sa0 = index[1][m];
sa1 = index[1][m+1];
sa2 = index[1][m+2];
pbc_dx(&pbc,x[sa0],xref,dx);
r2 = norm2(dx);
if (r2 < rcut2) {
r = sqrt(r2);
if (!bVec23) {
/* Determine the normal to the plain */
rvec_sub(x[sa1],x[sa0],dxh1);
rvec_sub(x[sa2],x[sa0],dxh2);
rvec_inc(dxh1,dxh2);
svmul(1/r,dx,dx);
unitv(dxh1,dxh1);
inp = iprod(dx,dxh1);
cprod(dxh1,dxh2,outer);
unitv(outer,outer);
outp = iprod(dx,outer);
} else {
/* Use the vector between the 2nd and 3rd atom */
rvec_sub(x[sa2],x[sa1],dxh2);
unitv(dxh2,dxh2);
outp = iprod(dx,dxh2)/r;
}
(histi1[(int)(invrbw*r)]) += inp;
(histi2[(int)(invrbw*r)]) += 3*sqr(outp) - 1;
(histn[(int)(invrbw*r)])++;
if (r2>=rmin2 && r2<rmax2) {
(hist1[(int)(invbw*(inp + 1))])++;
(hist2[(int)(invbw*fabs(outp))])++;
sum1 += inp;
sum2 += outp;
n++;
}
}
}
}
ntot += n;
nf++;
} while (read_next_x(status,&t,natoms,x,box));
/* clean up */
sfree(x);
close_trj(status);
/* Add the bin for the exact maximum to the previous bin */
hist1[nbin1-1] += hist1[nbin1];
hist2[nbin2-1] += hist2[nbin2];
nav = (real)ntot/(nrefgrp*nf);
normfac = invbw/ntot;
fprintf(stderr, "Average nr of molecules between %g and %g nm: %.1f\n",
rmin,rmax,nav);
if (ntot > 0) {
sum1 /= ntot;
sum2 /= ntot;
fprintf(stderr,"Average cos(theta1) between %g and %g nm: %6.3f\n",
rmin,rmax,sum1);
fprintf(stderr,"Average 3cos2(theta2)-1 between %g and %g nm: %6.3f\n",
rmin,rmax,sum2);
}
sprintf(str,"Solvent orientation between %g and %g nm",rmin,rmax);
fp=xvgropen(opt2fn("-o",NFILE,fnm),
str,"cos(\\8q\\4\\s1\\N)","");
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"average shell size %.1f molecules\"\n",nav);
for(i=0; i<nbin1; i++) {
fprintf(fp,"%g %g\n",(i+0.5)*binwidth-1,2*normfac*hist1[i]);
}
fclose(fp);
sprintf(str,"Solvent normal orientation between %g and %g nm",rmin,rmax);
fp=xvgropen(opt2fn("-no",NFILE,fnm),
str,"cos(\\8q\\4\\s2\\N)","");
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"average shell size %.1f molecules\"\n",nav);
for(i=0; i<nbin2; i++) {
fprintf(fp,"%g %g\n",(i+0.5)*binwidth,normfac*hist2[i]);
}
fclose(fp);
sprintf(str,"Solvent orientation");
fp=xvgropen(opt2fn("-ro",NFILE,fnm),str,"r (nm)","");
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"as a function of distance\"\n");
xvgr_legend(fp,2,legr);
for(i=0; i<nrbin; i++)
fprintf(fp,"%g %g %g\n",(i+0.5)*rbinw,
histn[i] ? histi1[i]/histn[i] : 0,
histn[i] ? histi2[i]/histn[i] : 0);
fclose(fp);
sprintf(str,"Cumulative solvent orientation");
fp=xvgropen(opt2fn("-co",NFILE,fnm),str,"r (nm)","");
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"as a function of distance\"\n");
xvgr_legend(fp,2,legc);
normfac = 1.0/(nrefgrp*nf);
c1 = 0;
c2 = 0;
fprintf(fp,"%g %g %g\n",0.0,c1,c2);
for(i=0; i<nrbin; i++) {
c1 += histi1[i]*normfac;
c2 += histi2[i]*normfac;
fprintf(fp,"%g %g %g\n",(i+1)*rbinw,c1,c2);
}
fclose(fp);
sprintf(str,"Solvent distribution");
fp=xvgropen(opt2fn("-rc",NFILE,fnm),str,"r (nm)","molecules/nm");
if (bPrintXvgrCodes())
fprintf(fp,"@ subtitle \"as a function of distance\"\n");
normfac = 1.0/(rbinw*nf);
for(i=0; i<nrbin; i++) {
fprintf(fp,"%g %g\n",(i+0.5)*rbinw,histn[i]*normfac);
}
fclose(fp);
do_view(opt2fn("-o",NFILE,fnm),NULL);
do_view(opt2fn("-no",NFILE,fnm),NULL);
do_view(opt2fn("-ro",NFILE,fnm),"-nxy");
do_view(opt2fn("-co",NFILE,fnm),"-nxy");
thanx(stderr);
return 0;
}
