void write_sto_conf_indexed(const char *outfile, const char *title,
t_atoms *atoms,
rvec x[], rvec *v, int ePBC, matrix box,
atom_id nindex, atom_id index[])
{
FILE *out;
int ftp;
t_trxframe fr;
ftp = fn2ftp(outfile);
switch (ftp)
{
case efGRO:
out = gmx_fio_fopen(outfile, "w");
write_hconf_indexed_p(out, title, atoms, nindex, index, 3, x, v, box);
gmx_fio_fclose(out);
break;
case efG96:
clear_trxframe(&fr, TRUE);
fr.bTitle = TRUE;
fr.title = title;
fr.natoms = atoms->nr;
fr.bAtoms = TRUE;
fr.atoms = atoms;
fr.bX = TRUE;
fr.x = x;
if (v)
{
fr.bV = TRUE;
fr.v = v;
}
fr.bBox = TRUE;
copy_mat(box, fr.box);
out = gmx_fio_fopen(outfile, "w");
write_g96_conf(out, &fr, nindex, index);
gmx_fio_fclose(out);
break;
case efPDB:
case efBRK:
case efENT:
case efPQR:
out = gmx_fio_fopen(outfile, "w");
write_pdbfile_indexed(out, title, atoms, x, ePBC, box, ' ', -1, nindex, index, NULL, TRUE);
gmx_fio_fclose(out);
break;
case efESP:
out = gmx_fio_fopen(outfile, "w");
write_espresso_conf_indexed(out, title, atoms, nindex, index, x, v, box);
gmx_fio_fclose(out);
break;
case efTPR:
case efTPB:
case efTPA:
gmx_fatal(FARGS, "Sorry, can not write a topology to %s", outfile);
break;
default:
gmx_incons("Not supported in write_sto_conf_indexed");
}
}
void write_pdbfile(FILE *out,char *title, t_atoms *atoms,rvec x[],
int ePBC,matrix box,char chain,int model_nr)
{
atom_id i,*index;
snew(index,atoms->nr);
for(i=0; i<atoms->nr; i++)
index[i]=i;
write_pdbfile_indexed(out,title,atoms,x,ePBC,box,chain,model_nr,
atoms->nr,index);
sfree(index);
}
void write_pdbfile(FILE *out,const char *title, t_atoms *atoms,rvec x[],
int ePBC,matrix box,char chainid,int model_nr,gmx_conect conect,gmx_bool bTerSepChains)
{
atom_id i,*index;
snew(index,atoms->nr);
for(i=0; i<atoms->nr; i++)
index[i]=i;
write_pdbfile_indexed(out,title,atoms,x,ePBC,box,chainid,model_nr,
atoms->nr,index,conect,bTerSepChains);
sfree(index);
}
int write_trxframe_indexed(t_trxstatus *status, const t_trxframe *fr, int nind,
const int *ind, gmx_conect gc)
{
char title[STRLEN];
rvec *xout = nullptr, *vout = nullptr, *fout = nullptr;
int i, ftp = -1;
real prec;
if (fr->bPrec)
{
prec = fr->prec;
}
else
{
prec = 1000.0;
}
if (status->tng)
{
ftp = efTNG;
}
else if (status->fio)
{
ftp = gmx_fio_getftp(status->fio);
}
else
{
gmx_incons("No input file available");
}
switch (ftp)
{
case efTRR:
case efTNG:
break;
default:
if (!fr->bX)
{
gmx_fatal(FARGS, "Need coordinates to write a %s trajectory",
ftp2ext(ftp));
}
break;
}
switch (ftp)
{
case efTRR:
case efTNG:
if (fr->bV)
{
snew(vout, nind);
for (i = 0; i < nind; i++)
{
copy_rvec(fr->v[ind[i]], vout[i]);
}
}
if (fr->bF)
{
snew(fout, nind);
for (i = 0; i < nind; i++)
{
copy_rvec(fr->f[ind[i]], fout[i]);
}
}
// fallthrough
case efXTC:
if (fr->bX)
{
snew(xout, nind);
for (i = 0; i < nind; i++)
{
copy_rvec(fr->x[ind[i]], xout[i]);
}
}
break;
default:
break;
}
switch (ftp)
{
case efTNG:
gmx_write_tng_from_trxframe(status->tng, fr, nind);
break;
case efXTC:
write_xtc(status->fio, nind, fr->step, fr->time, fr->box, xout, prec);
break;
case efTRR:
gmx_trr_write_frame(status->fio, nframes_read(status),
fr->time, fr->step, fr->box, nind, xout, vout, fout);
break;
case efGRO:
case efPDB:
case efBRK:
case efENT:
if (!fr->bAtoms)
{
gmx_fatal(FARGS, "Can not write a %s file without atom names",
ftp2ext(ftp));
}
sprintf(title, "frame t= %.3f", fr->time);
if (ftp == efGRO)
{
write_hconf_indexed_p(gmx_fio_getfp(status->fio), title, fr->atoms, nind, ind,
fr->x, fr->bV ? fr->v : nullptr, fr->box);
}
else
{
write_pdbfile_indexed(gmx_fio_getfp(status->fio), title, fr->atoms,
fr->x, -1, fr->box, ' ', fr->step, nind, ind, gc, TRUE);
}
break;
case efG96:
sprintf(title, "frame t= %.3f", fr->time);
write_g96_conf(gmx_fio_getfp(status->fio), title, fr, nind, ind);
break;
default:
gmx_fatal(FARGS, "Sorry, write_trxframe_indexed can not write %s",
ftp2ext(ftp));
break;
}
switch (ftp)
{
case efTRR:
case efTNG:
if (vout)
{
sfree(vout);
}
if (fout)
{
sfree(fout);
}
// fallthrough
case efXTC:
sfree(xout);
break;
default:
break;
}
return 0;
}
int main(int argc,char *argv[])
{
const char *desc[] = {
"[TT]do_multiprot[tt] ",
"reads a trajectory file and aligns it to a reference structure ",
"each time frame",
"calling the multiprot program. This allows you to use a reference",
"structure whose sequence is different than that of the protein in the ",
"trajectory, since the alignment is based on the geometry, not sequence.",
"The output of [TT]do_multiprot[tt] includes the rmsd and the number of residues",
"on which it was calculated.",
"[PAR]",
"An aligned trajectory file is generated with the [TT]-ox[tt] option.[PAR]",
"With the [TT]-cr[tt] option, the number of hits in the alignment is given",
"per residue. This number can be between 0 and the number of frames, and",
"indicates the structural conservation of this residue.[PAR]",
"If you do not have the [TT]multiprot[tt] program, get it. [TT]do_multiprot[tt] assumes",
"that the [TT]multiprot[tt] executable is [TT]/usr/local/bin/multiprot[tt]. If this is ",
"not the case, then you should set an environment variable [BB]MULTIPROT[bb]",
"pointing to the [TT]multiprot[tt] executable, e.g.: [PAR]",
"[TT]setenv MULTIPROT /usr/MultiProtInstall/multiprot.Linux[tt][PAR]",
"Note that at the current implementation only binary alignment (your",
"molecule to a reference) is supported. In addition, note that the ",
"by default [TT]multiprot[tt] aligns the two proteins on their C-alpha carbons.",
"and that this depends on the [TT]multiprot[tt] parameters which are not dealt ",
"with here. Thus, the C-alpha carbons is expected to give the same "
"results as choosing the whole protein and will be slightly faster.[PAR]",
"For information about [TT]multiprot[tt], see:",
"http://bioinfo3d.cs.tau.ac.il/MultiProt/.[PAR]"
};
static bool bVerbose;
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"HIDDENGenerate miles of useless information" }
};
const char *bugs[] = {
"The program is very slow, since multiprot is run externally"
};
t_trxstatus *status;
t_trxstatus *trxout=NULL;
FILE *tapein,*fo,*frc,*tmpf,*out=NULL,*fres=NULL;
const char *fnRef;
const char *fn="2_sol.res";
t_topology top;
int ePBC;
t_atoms *atoms,ratoms,useatoms;
t_trxframe fr;
t_pdbinfo p;
int nres,nres2,nr0;
real t;
int i,j,natoms,nratoms,nframe=0,model_nr=-1;
int cur_res,prev_res;
int nout;
t_countres *countres=NULL;
matrix box,rbox;
int gnx;
char *grpnm,*ss_str;
atom_id *index;
rvec *xp,*x,*xr;
char pdbfile[32],refpdb[256],title[256],rtitle[256],filemode[5];
char out_title[256];
char multiprot[256],*mptr;
int ftp;
int outftp=-1;
real rmsd;
bool bTrjout,bCountres;
const char *TrjoutFile=NULL;
output_env_t oenv;
static rvec translation={0,0,0},rotangles={0,0,0};
gmx_rmpbc_t gpbc=NULL;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efSTX, "-r", NULL , ffREAD },
{ efXVG, "-o", "rmss", ffWRITE },
{ efXVG, "-rc", "rescount", ffWRITE},
{ efXVG, "-cr", "countres", ffOPTWR},
{ efTRX, "-ox", "aligned", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_TIME_UNIT,
NFILE,fnm, asize(pa),pa, asize(desc),desc,
asize(bugs),bugs,&oenv
);
fnRef=opt2fn("-r",NFILE,fnm);
bTrjout = opt2bSet("-ox",NFILE,fnm);
bCountres= opt2bSet("-cr",NFILE,fnm);
if (bTrjout) {
TrjoutFile = opt2fn_null("-ox",NFILE,fnm);
}
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xp,NULL,box,FALSE);
gpbc = gmx_rmpbc_init(&top.idef,ePBC,top.atoms.nr,box);
atoms=&(top.atoms);
ftp=fn2ftp(fnRef);
get_stx_coordnum(fnRef,&nratoms);
init_t_atoms(&ratoms,nratoms,TRUE);
snew(xr,nratoms);
read_stx_conf(fnRef,rtitle,&ratoms,xr,NULL,&ePBC,rbox);
if (bVerbose) {
fprintf(stderr,"Read %d atoms\n",atoms->nr);
fprintf(stderr,"Read %d reference atoms\n",ratoms.nr);
}
if (bCountres) {
snew(countres,ratoms.nres);
j=0;
cur_res=0;
for (i=0;i<ratoms.nr;i++) {
prev_res=cur_res;
cur_res=ratoms.atom[i].resind;
if (cur_res != prev_res) {
countres[j].resnr=cur_res;
countres[j].count=0;
j++;
}
}
}
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]].resind != nr0) {
nr0=atoms->atom[index[i]].resind;
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 {
gmx_ffclose(tmpf);
}
if (ftp != efPDB) {
strcpy(refpdb,"ddXXXXXX");
gmx_tmpnam(refpdb);
strcat(refpdb,".pdb");
write_sto_conf(refpdb,rtitle,&ratoms,xr,NULL,ePBC,rbox);
}
else {
strcpy(refpdb,fnRef);
}
if ((mptr=getenv("MULTIPROT")) == NULL) {
mptr="/usr/local/bin/multiprot";
}
if (!gmx_fexist(mptr)) {
gmx_fatal(FARGS,"MULTIPROT executable (%s) does not exist (use setenv MULTIPROT)",
mptr);
}
sprintf (multiprot,"%s %s %s > /dev/null %s",
mptr, refpdb, pdbfile, "2> /dev/null");
if (bVerbose)
fprintf(stderr,"multiprot cmd='%s'\n",multiprot);
if (!read_first_frame(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&fr,TRX_READ_X))
gmx_fatal(FARGS,"Could not read a frame from %s",ftp2fn(efTRX,NFILE,fnm));
natoms = fr.natoms;
if (bTrjout) {
nout=natoms;
/* open file now */
outftp=fn2ftp(TrjoutFile);
if (bVerbose)
fprintf(stderr,"Will write %s: %s\n",ftp2ext(ftp),ftp2desc(outftp));
strcpy(filemode,"w");
switch (outftp) {
case efXTC:
case efG87:
case efTRR:
case efTRJ:
out=NULL;
trxout = open_trx(TrjoutFile,filemode);
break;
case efGRO:
case efG96:
case efPDB:
/* Make atoms struct for output in GRO or PDB files */
/* get memory for stuff to go in pdb file */
init_t_atoms(&useatoms,nout,FALSE);
sfree(useatoms.resinfo);
useatoms.resinfo=atoms->resinfo;
for(i=0;(i<nout);i++) {
useatoms.atomname[i]=atoms->atomname[i];
useatoms.atom[i]=atoms->atom[i];
useatoms.nres=max(useatoms.nres,useatoms.atom[i].resind+1);
}
useatoms.nr=nout;
out=gmx_ffopen(TrjoutFile,filemode);
break;
}
}
if (natoms > atoms->nr) {
gmx_fatal(FARGS,"\nTrajectory does not match topology!");
}
if (gnx > natoms) {
gmx_fatal(FARGS,"\nTrajectory does not match selected group!");
}
fo = xvgropen(opt2fn("-o",NFILE,fnm),"RMSD","Time (ps)","RMSD (nm)",oenv);
frc = xvgropen(opt2fn("-rc",NFILE,fnm),"Number of Residues in the alignment","Time (ps)","Residues",oenv);
do {
t = output_env_conv_time(oenv,fr.time);
gmx_rmpbc(gpbc,natoms,fr.box,fr.x);
tapein=gmx_ffopen(pdbfile,"w");
write_pdbfile_indexed(tapein,NULL,atoms,fr.x,ePBC,fr.box,' ',-1,gnx,index,NULL,TRUE);
gmx_ffclose(tapein);
system(multiprot);
remove(pdbfile);
process_multiprot_output(fn, &rmsd, &nres2,rotangles,translation,bCountres,countres);
fprintf(fo,"%12.7f",t);
fprintf(fo," %12.7f\n",rmsd);
fprintf(frc,"%12.7f",t);
fprintf(frc,"%12d\n",nres2);
if (bTrjout) {
rotate_conf(natoms,fr.x,NULL,rotangles[XX],rotangles[YY],rotangles[ZZ]);
for(i=0; i<natoms; i++) {
rvec_inc(fr.x[i],translation);
}
switch(outftp) {
case efTRJ:
case efTRR:
case efG87:
case efXTC:
write_trxframe(trxout,&fr,NULL);
break;
case efGRO:
case efG96:
case efPDB:
sprintf(out_title,"Generated by do_multiprot : %s t= %g %s",
title,output_env_conv_time(oenv,fr.time),output_env_get_time_unit(oenv));
switch(outftp) {
case efGRO:
write_hconf_p(out,out_title,&useatoms,prec2ndec(fr.prec),
fr.x,NULL,fr.box);
break;
case efPDB:
fprintf(out,"REMARK GENERATED BY DO_MULTIPROT\n");
sprintf(out_title,"%s t= %g %s",title,output_env_conv_time(oenv,fr.time),output_env_get_time_unit(oenv));
/* if reading from pdb, we want to keep the original
model numbering else we write the output frame
number plus one, because model 0 is not allowed in pdb */
if (ftp==efPDB && fr.step > model_nr) {
model_nr = fr.step;
}
else {
model_nr++;
}
write_pdbfile(out,out_title,&useatoms,fr.x,ePBC,fr.box,' ',model_nr,NULL,TRUE);
break;
case efG96:
fr.title = out_title;
fr.bTitle = (nframe == 0);
fr.bAtoms = FALSE;
fr.bStep = TRUE;
fr.bTime = TRUE;
write_g96_conf(out,&fr,-1,NULL);
}
break;
}
}
nframe++;
} while(read_next_frame(oenv,status,&fr));
if (bCountres) {
fres= xvgropen(opt2fn("-cr",NFILE,fnm),"Number of frames in which the residues are aligned to","Residue","Number",oenv);
for (i=0;i<ratoms.nres;i++) {
fprintf(fres,"%10d %12d\n",countres[i].resnr,countres[i].count);
}
gmx_ffclose(fres);
}
gmx_ffclose(fo);
gmx_ffclose(frc);
fprintf(stderr,"\n");
close_trj(status);
if (trxout != NULL) {
close_trx(trxout);
}
else if (out != NULL) {
gmx_ffclose(out);
}
view_all(oenv,NFILE, fnm);
sfree(xr);
if (bCountres) {
sfree(countres);
}
free_t_atoms(&ratoms,TRUE);
if (bTrjout) {
if (outftp==efPDB || outftp==efGRO || outftp==efG96) {
free_t_atoms(&useatoms,TRUE);
}
}
gmx_thanx(stderr);
return 0;
}
int gmx_editconf(int argc, char *argv[])
{
const char
*desc[] =
{
"editconf converts generic structure format to [TT].gro[tt], [TT].g96[tt]",
"or [TT].pdb[tt].",
"[PAR]",
"The box can be modified with options [TT]-box[tt], [TT]-d[tt] and",
"[TT]-angles[tt]. Both [TT]-box[tt] and [TT]-d[tt]",
"will center the system in the box, unless [TT]-noc[tt] is used.",
"[PAR]",
"Option [TT]-bt[tt] determines the box type: [TT]triclinic[tt] is a",
"triclinic box, [TT]cubic[tt] is a rectangular box with all sides equal",
"[TT]dodecahedron[tt] represents a rhombic dodecahedron and",
"[TT]octahedron[tt] is a truncated octahedron.",
"The last two are special cases of a triclinic box.",
"The length of the three box vectors of the truncated octahedron is the",
"shortest distance between two opposite hexagons.",
"The volume of a dodecahedron is 0.71 and that of a truncated octahedron",
"is 0.77 of that of a cubic box with the same periodic image distance.",
"[PAR]",
"Option [TT]-box[tt] requires only",
"one value for a cubic box, dodecahedron and a truncated octahedron.",
"[PAR]",
"With [TT]-d[tt] and a [TT]triclinic[tt] box the size of the system in the x, y",
"and z directions is used. With [TT]-d[tt] and [TT]cubic[tt],",
"[TT]dodecahedron[tt] or [TT]octahedron[tt] boxes, the dimensions are set",
"to the diameter of the system (largest distance between atoms) plus twice",
"the specified distance.",
"[PAR]",
"Option [TT]-angles[tt] is only meaningful with option [TT]-box[tt] and",
"a triclinic box and can not be used with option [TT]-d[tt].",
"[PAR]",
"When [TT]-n[tt] or [TT]-ndef[tt] is set, a group",
"can be selected for calculating the size and the geometric center,",
"otherwise the whole system is used.",
"[PAR]",
"[TT]-rotate[tt] rotates the coordinates and velocities.",
"[PAR]",
"[TT]-princ[tt] aligns the principal axes of the system along the",
"coordinate axes, this may allow you to decrease the box volume,",
"but beware that molecules can rotate significantly in a nanosecond.",
"[PAR]",
"Scaling is applied before any of the other operations are",
"performed. Boxes and coordinates can be scaled to give a certain density (option",
"[TT]-density[tt]). Note that this may be inaccurate in case a gro",
"file is given as input. A special feature of the scaling option, when the",
"factor -1 is given in one dimension, one obtains a mirror image,",
"mirrored in one of the plains, when one uses -1 in three dimensions",
"a point-mirror image is obtained.[PAR]",
"Groups are selected after all operations have been applied.[PAR]",
"Periodicity can be removed in a crude manner.",
"It is important that the box sizes at the bottom of your input file",
"are correct when the periodicity is to be removed.",
"[PAR]",
"When writing [TT].pdb[tt] files, B-factors can be",
"added with the [TT]-bf[tt] option. B-factors are read",
"from a file with with following format: first line states number of",
"entries in the file, next lines state an index",
"followed by a B-factor. The B-factors will be attached per residue",
"unless an index is larger than the number of residues or unless the",
"[TT]-atom[tt] option is set. Obviously, any type of numeric data can",
"be added instead of B-factors. [TT]-legend[tt] will produce",
"a row of CA atoms with B-factors ranging from the minimum to the",
"maximum value found, effectively making a legend for viewing.",
"[PAR]",
"With the option -mead a special pdb (pqr) file for the MEAD electrostatics",
"program (Poisson-Boltzmann solver) can be made. A further prerequisite",
"is that the input file is a run input file.",
"The B-factor field is then filled with the Van der Waals radius",
"of the atoms while the occupancy field will hold the charge.",
"[PAR]",
"The option -grasp is similar, but it puts the charges in the B-factor",
"and the radius in the occupancy.",
"[PAR]",
"Option [TT]-align[tt] allows alignment",
"of the principal axis of a specified group against the given vector, ",
"with an optional center of rotation specified by [TT]-aligncenter[tt].",
"[PAR]",
"Finally with option [TT]-label[tt] editconf can add a chain identifier",
"to a pdb file, which can be useful for analysis with e.g. rasmol.",
"[PAR]",
"To convert a truncated octrahedron file produced by a package which uses",
"a cubic box with the corners cut off (such as Gromos) use:[BR]",
"[TT]editconf -f <in> -rotate 0 45 35.264 -bt o -box <veclen> -o <out>[tt][BR]",
"where [TT]veclen[tt] is the size of the cubic box times sqrt(3)/2." };
const char *bugs[] =
{
"For complex molecules, the periodicity removal routine may break down, ",
"in that case you can use trjconv." };
static real dist = 0.0, rbox = 0.0, to_diam = 0.0;
static gmx_bool bNDEF = FALSE, bRMPBC = FALSE, bCenter = FALSE, bReadVDW =
FALSE, bCONECT = FALSE;
static gmx_bool peratom = FALSE, bLegend = FALSE, bOrient = FALSE, bMead =
FALSE, bGrasp = FALSE, bSig56 = FALSE;
static rvec scale =
{ 1, 1, 1 }, newbox =
{ 0, 0, 0 }, newang =
{ 90, 90, 90 };
static real rho = 1000.0, rvdw = 0.12;
static rvec center =
{ 0, 0, 0 }, translation =
{ 0, 0, 0 }, rotangles =
{ 0, 0, 0 }, aligncenter =
{ 0, 0, 0 }, targetvec =
{ 0, 0, 0 };
static const char *btype[] =
{ NULL, "triclinic", "cubic", "dodecahedron", "octahedron", NULL },
*label = "A";
static rvec visbox =
{ 0, 0, 0 };
t_pargs
pa[] =
{
{ "-ndef", FALSE, etBOOL,
{ &bNDEF }, "Choose output from default index groups" },
{ "-visbox", FALSE, etRVEC,
{ visbox },
"HIDDENVisualize a grid of boxes, -1 visualizes the 14 box images" },
{ "-bt", FALSE, etENUM,
{ btype }, "Box type for -box and -d" },
{ "-box", FALSE, etRVEC,
{ newbox }, "Box vector lengths (a,b,c)" },
{ "-angles", FALSE, etRVEC,
{ newang }, "Angles between the box vectors (bc,ac,ab)" },
{ "-d", FALSE, etREAL,
{ &dist }, "Distance between the solute and the box" },
{ "-c", FALSE, etBOOL,
{ &bCenter },
"Center molecule in box (implied by -box and -d)" },
{ "-center", FALSE, etRVEC,
{ center }, "Coordinates of geometrical center" },
{ "-aligncenter", FALSE, etRVEC,
{ aligncenter }, "Center of rotation for alignment" },
{ "-align", FALSE, etRVEC,
{ targetvec },
"Align to target vector" },
{ "-translate", FALSE, etRVEC,
{ translation }, "Translation" },
{ "-rotate", FALSE, etRVEC,
{ rotangles },
"Rotation around the X, Y and Z axes in degrees" },
{ "-princ", FALSE, etBOOL,
{ &bOrient },
"Orient molecule(s) along their principal axes" },
{ "-scale", FALSE, etRVEC,
{ scale }, "Scaling factor" },
{ "-density", FALSE, etREAL,
{ &rho },
"Density (g/l) of the output box achieved by scaling" },
{ "-pbc", FALSE, etBOOL,
{ &bRMPBC },
"Remove the periodicity (make molecule whole again)" },
{ "-grasp", FALSE, etBOOL,
{ &bGrasp },
"Store the charge of the atom in the B-factor field and the radius of the atom in the occupancy field" },
{
"-rvdw", FALSE, etREAL,
{ &rvdw },
"Default Van der Waals radius (in nm) if one can not be found in the database or if no parameters are present in the topology file" },
{ "-sig56", FALSE, etREAL,
{ &bSig56 },
"Use rmin/2 (minimum in the Van der Waals potential) rather than sigma/2 " },
{
"-vdwread", FALSE, etBOOL,
{ &bReadVDW },
"Read the Van der Waals radii from the file vdwradii.dat rather than computing the radii based on the force field" },
{ "-atom", FALSE, etBOOL,
{ &peratom }, "Force B-factor attachment per atom" },
{ "-legend", FALSE, etBOOL,
{ &bLegend }, "Make B-factor legend" },
{ "-label", FALSE, etSTR,
{ &label }, "Add chain label for all residues" },
{
"-conect", FALSE, etBOOL,
{ &bCONECT },
"Add CONECT records to a pdb file when written. Can only be done when a topology is present" } };
#define NPA asize(pa)
FILE *out;
const char *infile, *outfile;
char title[STRLEN];
int outftp, inftp, natom, i, j, n_bfac, itype, ntype;
double *bfac = NULL, c6, c12;
int *bfac_nr = NULL;
t_topology *top = NULL;
t_atoms atoms;
char *grpname, *sgrpname, *agrpname;
int isize, ssize, tsize, asize;
atom_id *index, *sindex, *tindex, *aindex;
rvec *x, *v, gc, min, max, size;
int ePBC;
matrix box,rotmatrix,trans;
rvec princd,tmpvec;
gmx_bool bIndex, bSetSize, bSetAng, bCubic, bDist, bSetCenter, bAlign;
gmx_bool bHaveV, bScale, bRho, bTranslate, bRotate, bCalcGeom, bCalcDiam;
real xs, ys, zs, xcent, ycent, zcent, diam = 0, mass = 0, d, vdw;
gmx_atomprop_t aps;
gmx_conect conect;
output_env_t oenv;
t_filenm fnm[] =
{
{ efSTX, "-f", NULL, ffREAD },
{ efNDX, "-n", NULL, ffOPTRD },
{ efSTO, NULL, NULL, ffOPTWR },
{ efPQR, "-mead", "mead", ffOPTWR },
{ efDAT, "-bf", "bfact", ffOPTRD } };
#define NFILE asize(fnm)
CopyRight(stderr, argv[0]);
parse_common_args(&argc, argv, PCA_CAN_VIEW, NFILE, fnm, NPA, pa,
asize(desc), desc, asize(bugs), bugs, &oenv);
bIndex = opt2bSet("-n", NFILE, fnm) || bNDEF;
bMead = opt2bSet("-mead", NFILE, fnm);
bSetSize = opt2parg_bSet("-box", NPA, pa);
bSetAng = opt2parg_bSet("-angles", NPA, pa);
bSetCenter = opt2parg_bSet("-center", NPA, pa);
bDist = opt2parg_bSet("-d", NPA, pa);
bAlign = opt2parg_bSet("-align", NPA, pa);
/* Only automatically turn on centering without -noc */
if ((bDist || bSetSize || bSetCenter) && !opt2parg_bSet("-c", NPA, pa))
{
bCenter = TRUE;
}
bScale = opt2parg_bSet("-scale", NPA, pa);
bRho = opt2parg_bSet("-density", NPA, pa);
bTranslate = opt2parg_bSet("-translate", NPA, pa);
bRotate = opt2parg_bSet("-rotate", NPA, pa);
if (bScale && bRho)
fprintf(stderr, "WARNING: setting -density overrides -scale\n");
bScale = bScale || bRho;
bCalcGeom = bCenter || bRotate || bOrient || bScale;
bCalcDiam = btype[0][0] == 'c' || btype[0][0] == 'd' || btype[0][0] == 'o';
infile = ftp2fn(efSTX, NFILE, fnm);
if (bMead)
outfile = ftp2fn(efPQR, NFILE, fnm);
else
outfile = ftp2fn(efSTO, NFILE, fnm);
outftp = fn2ftp(outfile);
inftp = fn2ftp(infile);
aps = gmx_atomprop_init();
if (bMead && bGrasp)
{
printf("Incompatible options -mead and -grasp. Turning off -grasp\n");
bGrasp = FALSE;
}
if (bGrasp && (outftp != efPDB))
gmx_fatal(FARGS, "Output file should be a .pdb file"
" when using the -grasp option\n");
if ((bMead || bGrasp) && !((fn2ftp(infile) == efTPR) ||
(fn2ftp(infile) == efTPA) ||
(fn2ftp(infile) == efTPB)))
gmx_fatal(FARGS,"Input file should be a .tp[abr] file"
" when using the -mead option\n");
get_stx_coordnum(infile,&natom);
init_t_atoms(&atoms,natom,TRUE);
snew(x,natom);
snew(v,natom);
read_stx_conf(infile,title,&atoms,x,v,&ePBC,box);
if (fn2ftp(infile) == efPDB)
{
get_pdb_atomnumber(&atoms,aps);
}
printf("Read %d atoms\n",atoms.nr);
/* Get the element numbers if available in a pdb file */
if (fn2ftp(infile) == efPDB)
get_pdb_atomnumber(&atoms,aps);
if (ePBC != epbcNONE)
{
real vol = det(box);
printf("Volume: %g nm^3, corresponds to roughly %d electrons\n",
vol,100*((int)(vol*4.5)));
}
if (bMead || bGrasp || bCONECT)
top = read_top(infile,NULL);
if (bMead || bGrasp)
{
if (atoms.nr != top->atoms.nr)
gmx_fatal(FARGS,"Atom numbers don't match (%d vs. %d)",atoms.nr,top->atoms.nr);
snew(atoms.pdbinfo,top->atoms.nr);
ntype = top->idef.atnr;
for(i=0; (i<atoms.nr); i++) {
/* Determine the Van der Waals radius from the force field */
if (bReadVDW) {
if (!gmx_atomprop_query(aps,epropVDW,
*top->atoms.resinfo[top->atoms.atom[i].resind].name,
*top->atoms.atomname[i],&vdw))
vdw = rvdw;
}
else {
itype = top->atoms.atom[i].type;
c12 = top->idef.iparams[itype*ntype+itype].lj.c12;
c6 = top->idef.iparams[itype*ntype+itype].lj.c6;
if ((c6 != 0) && (c12 != 0)) {
real sig6;
if (bSig56)
sig6 = 2*c12/c6;
else
sig6 = c12/c6;
vdw = 0.5*pow(sig6,1.0/6.0);
}
else
vdw = rvdw;
}
/* Factor of 10 for nm -> Angstroms */
vdw *= 10;
if (bMead) {
atoms.pdbinfo[i].occup = top->atoms.atom[i].q;
atoms.pdbinfo[i].bfac = vdw;
}
else {
atoms.pdbinfo[i].occup = vdw;
atoms.pdbinfo[i].bfac = top->atoms.atom[i].q;
}
}
}
bHaveV=FALSE;
for (i=0; (i<natom) && !bHaveV; i++)
for (j=0; (j<DIM) && !bHaveV; j++)
bHaveV=bHaveV || (v[i][j]!=0);
printf("%selocities found\n",bHaveV?"V":"No v");
if (visbox[0] > 0) {
if (bIndex)
gmx_fatal(FARGS,"Sorry, can not visualize box with index groups");
if (outftp != efPDB)
gmx_fatal(FARGS,"Sorry, can only visualize box with a pdb file");
} else if (visbox[0] == -1)
visualize_images("images.pdb",ePBC,box);
/* remove pbc */
if (bRMPBC)
rm_gropbc(&atoms,x,box);
if (bCalcGeom) {
if (bIndex) {
fprintf(stderr,"\nSelect a group for determining the system size:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&ssize,&sindex,&sgrpname);
} else {
ssize = atoms.nr;
sindex = NULL;
}
diam=calc_geom(ssize,sindex,x,gc,min,max,bCalcDiam);
rvec_sub(max, min, size);
printf(" system size :%7.3f%7.3f%7.3f (nm)\n",
size[XX], size[YY], size[ZZ]);
if (bCalcDiam)
printf(" diameter :%7.3f (nm)\n",diam);
printf(" center :%7.3f%7.3f%7.3f (nm)\n", gc[XX], gc[YY], gc[ZZ]);
printf(" box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf(" box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[YY],box[ZZ])),
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[ZZ])),
norm2(box[YY])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[YY])));
printf(" box volume :%7.2f (nm^3)\n",det(box));
}
if (bRho || bOrient || bAlign)
mass = calc_mass(&atoms,!fn2bTPX(infile),aps);
if (bOrient) {
atom_id *index;
char *grpnames;
/* Get a group for principal component analysis */
fprintf(stderr,"\nSelect group for the determining the orientation\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&isize,&index,&grpnames);
/* Orient the principal axes along the coordinate axes */
orient_princ(&atoms,isize,index,natom,x,bHaveV ? v : NULL, NULL);
sfree(index);
sfree(grpnames);
}
if ( bScale ) {
/* scale coordinates and box */
if (bRho) {
/* Compute scaling constant */
real vol,dens;
vol = det(box);
dens = (mass*AMU)/(vol*NANO*NANO*NANO);
fprintf(stderr,"Volume of input %g (nm^3)\n",vol);
fprintf(stderr,"Mass of input %g (a.m.u.)\n",mass);
fprintf(stderr,"Density of input %g (g/l)\n",dens);
if (vol==0 || mass==0)
gmx_fatal(FARGS,"Cannot scale density with "
"zero mass (%g) or volume (%g)\n",mass,vol);
scale[XX] = scale[YY] = scale[ZZ] = pow(dens/rho,1.0/3.0);
fprintf(stderr,"Scaling all box vectors by %g\n",scale[XX]);
}
scale_conf(atoms.nr,x,box,scale);
}
if (bAlign) {
if (bIndex) {
fprintf(stderr,"\nSelect a group that you want to align:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&asize,&aindex,&agrpname);
} else {
asize = atoms.nr;
snew(aindex,asize);
for (i=0;i<asize;i++)
aindex[i]=i;
}
printf("Aligning %d atoms (out of %d) to %g %g %g, center of rotation %g %g %g\n",asize,natom,
targetvec[XX],targetvec[YY],targetvec[ZZ],
aligncenter[XX],aligncenter[YY],aligncenter[ZZ]);
/*subtract out pivot point*/
for(i=0; i<asize; i++)
rvec_dec(x[aindex[i]],aligncenter);
/*now determine transform and rotate*/
/*will this work?*/
principal_comp(asize,aindex,atoms.atom,x, trans,princd);
unitv(targetvec,targetvec);
printf("Using %g %g %g as principal axis\n", trans[0][2],trans[1][2],trans[2][2]);
tmpvec[XX]=trans[0][2]; tmpvec[YY]=trans[1][2]; tmpvec[ZZ]=trans[2][2];
calc_rotmatrix(tmpvec, targetvec, rotmatrix);
/* rotmatrix finished */
for (i=0;i<asize;++i)
{
mvmul(rotmatrix,x[aindex[i]],tmpvec);
copy_rvec(tmpvec,x[aindex[i]]);
}
/*add pivot point back*/
for(i=0; i<asize; i++)
rvec_inc(x[aindex[i]],aligncenter);
if (!bIndex)
sfree(aindex);
}
if (bTranslate) {
if (bIndex) {
fprintf(stderr,"\nSelect a group that you want to translate:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&ssize,&sindex,&sgrpname);
} else {
ssize = atoms.nr;
sindex = NULL;
}
printf("Translating %d atoms (out of %d) by %g %g %g nm\n",ssize,natom,
translation[XX],translation[YY],translation[ZZ]);
if (sindex) {
for(i=0; i<ssize; i++)
rvec_inc(x[sindex[i]],translation);
}
else {
for(i=0; i<natom; i++)
rvec_inc(x[i],translation);
}
}
if (bRotate) {
/* Rotate */
printf("Rotating %g, %g, %g degrees around the X, Y and Z axis respectively\n",rotangles[XX],rotangles[YY],rotangles[ZZ]);
for(i=0; i<DIM; i++)
rotangles[i] *= DEG2RAD;
rotate_conf(natom,x,v,rotangles[XX],rotangles[YY],rotangles[ZZ]);
}
if (bCalcGeom) {
/* recalc geometrical center and max and min coordinates and size */
calc_geom(ssize,sindex,x,gc,min,max,FALSE);
rvec_sub(max, min, size);
if (bScale || bOrient || bRotate)
printf("new system size : %6.3f %6.3f %6.3f\n",
size[XX],size[YY],size[ZZ]);
}
if (bSetSize || bDist || (btype[0][0]=='t' && bSetAng)) {
ePBC = epbcXYZ;
if (!(bSetSize || bDist))
for (i=0; i<DIM; i++)
newbox[i] = norm(box[i]);
clear_mat(box);
/* calculate new boxsize */
switch(btype[0][0]){
case 't':
if (bDist)
for(i=0; i<DIM; i++)
newbox[i] = size[i]+2*dist;
if (!bSetAng) {
box[XX][XX] = newbox[XX];
box[YY][YY] = newbox[YY];
box[ZZ][ZZ] = newbox[ZZ];
} else {
matrix_convert(box,newbox,newang);
}
break;
case 'c':
case 'd':
case 'o':
if (bSetSize)
d = newbox[0];
else
d = diam+2*dist;
if (btype[0][0] == 'c')
for(i=0; i<DIM; i++)
box[i][i] = d;
else if (btype[0][0] == 'd') {
box[XX][XX] = d;
box[YY][YY] = d;
box[ZZ][XX] = d/2;
box[ZZ][YY] = d/2;
box[ZZ][ZZ] = d*sqrt(2)/2;
} else {
box[XX][XX] = d;
box[YY][XX] = d/3;
box[YY][YY] = d*sqrt(2)*2/3;
box[ZZ][XX] = -d/3;
box[ZZ][YY] = d*sqrt(2)/3;
box[ZZ][ZZ] = d*sqrt(6)/3;
}
break;
}
}
/* calculate new coords for geometrical center */
if (!bSetCenter)
calc_box_center(ecenterDEF,box,center);
/* center molecule on 'center' */
if (bCenter)
center_conf(natom,x,center,gc);
/* print some */
if (bCalcGeom) {
calc_geom(ssize,sindex,x, gc, min, max, FALSE);
printf("new center :%7.3f%7.3f%7.3f (nm)\n",gc[XX],gc[YY],gc[ZZ]);
}
if (bOrient || bScale || bDist || bSetSize) {
printf("new box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf("new box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[YY],box[ZZ])),
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[ZZ])),
norm2(box[YY])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[YY])));
printf("new box volume :%7.2f (nm^3)\n",det(box));
}
if (check_box(epbcXYZ,box))
printf("\nWARNING: %s\n",check_box(epbcXYZ,box));
if (bDist && btype[0][0]=='t')
{
if(TRICLINIC(box))
{
printf("\nWARNING: Your box is triclinic with non-orthogonal axes. In this case, the\n"
"distance from the solute to a box surface along the corresponding normal\n"
"vector might be somewhat smaller than your specified value %f.\n"
"You can check the actual value with g_mindist -pi\n",dist);
}
else
{
printf("\nWARNING: No boxtype specified - distance condition applied in each dimension.\n"
"If the molecule rotates the actual distance will be smaller. You might want\n"
"to use a cubic box instead, or why not try a dodecahedron today?\n");
}
}
if (bCONECT && (outftp == efPDB) && (inftp == efTPR))
conect = gmx_conect_generate(top);
else
conect = NULL;
if (bIndex) {
fprintf(stderr,"\nSelect a group for output:\n");
get_index(&atoms,opt2fn_null("-n",NFILE,fnm),
1,&isize,&index,&grpname);
if (opt2parg_bSet("-label",NPA,pa)) {
for(i=0; (i<atoms.nr); i++)
atoms.resinfo[atoms.atom[i].resind].chainid=label[0];
}
if (opt2bSet("-bf",NFILE,fnm) || bLegend)
{
gmx_fatal(FARGS,"Sorry, cannot do bfactors with an index group.");
}
if (outftp == efPDB)
{
out=ffopen(outfile,"w");
write_pdbfile_indexed(out,title,&atoms,x,ePBC,box,' ',1,isize,index,conect,TRUE);
ffclose(out);
}
else
{
write_sto_conf_indexed(outfile,title,&atoms,x,bHaveV?v:NULL,ePBC,box,isize,index);
}
}
else {
if ((outftp == efPDB) || (outftp == efPQR)) {
out=ffopen(outfile,"w");
if (bMead) {
set_pdb_wide_format(TRUE);
fprintf(out,"REMARK "
"The B-factors in this file hold atomic radii\n");
fprintf(out,"REMARK "
"The occupancy in this file hold atomic charges\n");
}
else if (bGrasp) {
fprintf(out,"GRASP PDB FILE\nFORMAT NUMBER=1\n");
fprintf(out,"REMARK "
"The B-factors in this file hold atomic charges\n");
fprintf(out,"REMARK "
"The occupancy in this file hold atomic radii\n");
}
else if (opt2bSet("-bf",NFILE,fnm)) {
read_bfac(opt2fn("-bf",NFILE,fnm),&n_bfac,&bfac,&bfac_nr);
set_pdb_conf_bfac(atoms.nr,atoms.nres,&atoms,
n_bfac,bfac,bfac_nr,peratom);
}
if (opt2parg_bSet("-label",NPA,pa)) {
for(i=0; (i<atoms.nr); i++)
atoms.resinfo[atoms.atom[i].resind].chainid=label[0];
}
write_pdbfile(out,title,&atoms,x,ePBC,box,' ',-1,conect,TRUE);
if (bLegend)
pdb_legend(out,atoms.nr,atoms.nres,&atoms,x);
if (visbox[0] > 0)
visualize_box(out,bLegend ? atoms.nr+12 : atoms.nr,
bLegend? atoms.nres=12 : atoms.nres,box,visbox);
ffclose(out);
}
else
write_sto_conf(outfile,title,&atoms,x,bHaveV?v:NULL,ePBC,box);
}
gmx_atomprop_destroy(aps);
do_view(oenv,outfile,NULL);
thanx(stderr);
return 0;
}
int gmx_do_dssp(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] ",
"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 from http://swift.cmbi.ru.nl/gv/dssp. [THISMODULE] assumes ",
"that the dssp executable is located in ",
"[TT]/usr/local/bin/dssp[tt]. If this is not the case, then you should",
"set an environment variable [TT]DSSP[tt] pointing to the dssp",
"executable, e.g.: [PAR]",
"[TT]setenv DSSP /opt/dssp/bin/dssp[tt][PAR]",
"Since version 2.0.0, dssp is invoked with a syntax that differs",
"from earlier versions. If you have an older version of dssp,",
"use the [TT]-ver[tt] option to direct do_dssp to use the older syntax.",
"By default, do_dssp uses the syntax introduced with version 2.0.0.",
"Even newer versions (which at the time of writing are not yet released)",
"are assumed to have the same syntax as 2.0.0.[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].",
"Individual chains are separated by light grey lines in the [TT].xpm[tt] and",
"postscript files.",
"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 [gmx-sas] 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 [gmx-chi]. Together",
"these two programs can be used to analyze dihedral properties as a",
"function of secondary structure type."
};
static gmx_bool bVerbose;
static const char *ss_string = "HEBT";
static int dsspVersion = 2;
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"HIDDENGenerate miles of useless information" },
{ "-sss", FALSE, etSTR, {&ss_string},
"Secondary structures for structure count"},
{ "-ver", FALSE, etINT, {&dsspVersion},
"DSSP major version. Syntax changed with version 2"}
};
t_trxstatus *status;
FILE *tapein;
FILE *ss, *acc, *fTArea, *tmpf;
const char *fnSCount, *fnArea, *fnTArea, *fnAArea;
const char *leg[] = { "Phobic", "Phylic" };
t_topology top;
int ePBC;
t_atoms *atoms;
t_matrix mat;
int nres, nr0, naccr, nres_plus_separators;
gmx_bool *bPhbres, bDoAccSurf;
real t;
int i, j, natoms, nframe = 0;
matrix box = {{0}};
int gnx;
char *grpnm, *ss_str;
atom_id *index;
rvec *xp, *x;
int *average_area;
real **accr, *accr_ptr = NULL, *av_area, *norm_av_area;
char pdbfile[32], tmpfile[32], title[256];
char dssp[256];
const char *dptr;
output_env_t oenv;
gmx_rmpbc_t gpbc = NULL;
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)
if (!parse_common_args(&argc, argv,
PCA_CAN_TIME | PCA_CAN_VIEW | PCA_TIME_UNIT,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
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]].resind != nr0)
{
nr0 = atoms->atom[index[i]].resind;
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 (!gmx_fexist(dptr))
{
gmx_fatal(FARGS, "DSSP executable (%s) does not exist (use setenv DSSP)",
dptr);
}
if (dsspVersion >= 2)
{
if (dsspVersion > 2)
{
printf("\nWARNING: You use DSSP version %d, which is not explicitly\nsupported by do_dssp. Assuming version 2 syntax.\n\n", dsspVersion);
}
sprintf(dssp, "%s -i %s -o %s > /dev/null %s",
dptr, pdbfile, tmpfile, bVerbose ? "" : "2> /dev/null");
}
else
{
sprintf(dssp, "%s %s %s %s > /dev/null %s",
dptr, bDoAccSurf ? "" : "-na", pdbfile, tmpfile, bVerbose ? "" : "2> /dev/null");
}
fprintf(stderr, "dssp cmd='%s'\n", dssp);
if (fnTArea)
{
fTArea = xvgropen(fnTArea, "Solvent Accessible Surface Area",
output_env_get_xvgr_tlabel(oenv), "Area (nm\\S2\\N)", oenv);
xvgr_legend(fTArea, 2, leg, oenv);
}
else
{
fTArea = NULL;
}
mat.map = NULL;
mat.nmap = readcmap(opt2fn("-map", NFILE, fnm), &(mat.map));
natoms = read_first_x(oenv, &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);
snew(av_area, atoms->nres);
snew(norm_av_area, atoms->nres);
accr = NULL;
naccr = 0;
gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
do
{
t = output_env_conv_time(oenv, t);
if (bDoAccSurf && nframe >= naccr)
{
naccr += 10;
srenew(accr, naccr);
for (i = naccr-10; i < naccr; i++)
{
snew(accr[i], 2*atoms->nres-1);
}
}
gmx_rmpbc(gpbc, natoms, box, x);
tapein = gmx_ffopen(pdbfile, "w");
write_pdbfile_indexed(tapein, NULL, atoms, x, ePBC, box, ' ', -1, gnx, index, NULL, TRUE);
gmx_ffclose(tapein);
if (0 != system(dssp))
{
gmx_fatal(FARGS, "Failed to execute command: %s\n",
"Try specifying your dssp version with the -ver option.", dssp);
}
/* strip_dssp returns the number of lines found in the dssp file, i.e.
* the number of residues plus the separator lines */
if (bDoAccSurf)
{
accr_ptr = accr[nframe];
}
nres_plus_separators = strip_dssp(tmpfile, nres, bPhbres, t,
accr_ptr, fTArea, &mat, average_area, oenv);
remove(tmpfile);
remove(pdbfile);
nframe++;
}
while (read_next_x(oenv, status, &t, x, box));
fprintf(stderr, "\n");
close_trj(status);
if (fTArea)
{
xvgrclose(fTArea);
}
gmx_rmpbc_done(gpbc);
prune_ss_legend(&mat);
ss = opt2FILE("-o", NFILE, fnm, "w");
mat.flags = 0;
write_xpm_m(ss, mat);
gmx_ffclose(ss);
if (opt2bSet("-ssdump", NFILE, fnm))
{
ss = opt2FILE("-ssdump", NFILE, fnm, "w");
snew(ss_str, nres+1);
fprintf(ss, "%d\n", nres);
for (j = 0; j < mat.nx; j++)
{
for (i = 0; (i < mat.ny); i++)
{
ss_str[i] = mat.map[mat.matrix[j][i]].code.c1;
}
ss_str[i] = '\0';
fprintf(ss, "%s\n", ss_str);
}
gmx_ffclose(ss);
sfree(ss_str);
}
analyse_ss(fnSCount, &mat, ss_string, oenv);
if (bDoAccSurf)
{
write_sas_mat(fnArea, accr, nframe, nres_plus_separators, &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", oenv);
for (i = 0; (i < nres); i++)
{
fprintf(acc, "%5d %10g %10g\n", i+1, av_area[i], norm_av_area[i]);
}
xvgrclose(acc);
}
}
view_all(oenv, NFILE, fnm);
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 write_trxframe_indexed(t_trxstatus *status, t_trxframe *fr, int nind,
const atom_id *ind, gmx_conect gc)
{
char title[STRLEN];
rvec *xout = NULL, *vout = NULL, *fout = NULL;
int i;
real prec;
if (fr->bPrec)
{
prec = fr->prec;
}
else
{
prec = 1000.0;
}
switch (gmx_fio_getftp(status->fio))
{
case efTRJ:
case efTRR:
break;
default:
if (!fr->bX)
{
gmx_fatal(FARGS, "Need coordinates to write a %s trajectory",
ftp2ext(gmx_fio_getftp(status->fio)));
}
break;
}
switch (gmx_fio_getftp(status->fio))
{
case efTRJ:
case efTRR:
if (fr->bV)
{
snew(vout, nind);
for (i = 0; i < nind; i++)
{
copy_rvec(fr->v[ind[i]], vout[i]);
}
}
if (fr->bF)
{
snew(fout, nind);
for (i = 0; i < nind; i++)
{
copy_rvec(fr->f[ind[i]], fout[i]);
}
}
/* no break */
case efXTC:
case efG87:
if (fr->bX)
{
snew(xout, nind);
for (i = 0; i < nind; i++)
{
copy_rvec(fr->x[ind[i]], xout[i]);
}
}
break;
default:
break;
}
switch (gmx_fio_getftp(status->fio))
{
case efXTC:
write_xtc(status->fio, nind, fr->step, fr->time, fr->box, xout, prec);
break;
case efTRJ:
case efTRR:
fwrite_trn(status->fio, nframes_read(status),
fr->time, fr->step, fr->box, nind, xout, vout, fout);
break;
case efGRO:
case efPDB:
case efBRK:
case efENT:
if (!fr->bAtoms)
{
gmx_fatal(FARGS, "Can not write a %s file without atom names",
ftp2ext(gmx_fio_getftp(status->fio)));
}
sprintf(title, "frame t= %.3f", fr->time);
if (gmx_fio_getftp(status->fio) == efGRO)
{
write_hconf_indexed_p(gmx_fio_getfp(status->fio), title, fr->atoms, nind, ind,
prec2ndec(prec),
fr->x, fr->bV ? fr->v : NULL, fr->box);
}
else
{
write_pdbfile_indexed(gmx_fio_getfp(status->fio), title, fr->atoms,
fr->x, -1, fr->box, ' ', fr->step, nind, ind, gc, TRUE);
}
break;
case efG87:
write_gms(gmx_fio_getfp(status->fio), nind, xout, fr->box);
break;
case efG96:
write_g96_conf(gmx_fio_getfp(status->fio), fr, nind, ind);
break;
default:
gmx_fatal(FARGS, "Sorry, write_trxframe_indexed can not write %s",
ftp2ext(gmx_fio_getftp(status->fio)));
break;
}
switch (gmx_fio_getftp(status->fio))
{
case efTRN:
case efTRJ:
case efTRR:
if (vout)
{
sfree(vout);
}
if (fout)
{
sfree(fout);
}
/* no break */
case efXTC:
case efG87:
sfree(xout);
break;
default:
break;
}
return 0;
}
int gmx_energy2bfac (int argc, char *argv[]) {
const char *desc[] =
{ "It maps the binding energy contribution of each residue on the structure.",
"The energy will be written in the B-factor field of the output PDB file/s",
"This PDB file can be used with any molecular visualizer and ",
"residues can be viewed in color according to the energy of respective residue.",
"The molecular visualizer should support method to color residues by B-factor values."
};
t_filenm fnm[] =
{
{ efTPS, "-s", NULL, ffREAD },
{ efDAT, "-i", "decomp_energy", ffREAD },
{ efNDX, "-n", "index", ffOPTRD },
{ efPDB, "-c", "complex.pdb", ffOPTWR },
{ efPDB, "-s1", "subunit_1.pdb", ffOPTWR },
{ efPDB, "-s2", "subunit_2.pdb", ffOPTWR },
};
char title[STRLEN], buf[256];
t_topology top;
int ePBC;
rvec *xtop;
matrix box;
t_atoms *atoms;
char *atomtype, *resname, *atomname, **modresname = NULL;
output_env_t oenv;
//Variable for index file
int *isize; //Number of index group
atom_id **index;
char **grpnm;
int i=0,j=0,k=0;
gmx_bool *bAtomA, *bAtomB, *bAtomAB;
int nres = 0, prev_res, curr_res;
gmx_bool *bResA, *bResB;
real *energy;
char fnEnergy[256];
FILE *fComplex, *fS1, *fS2;
#define NFILE asize(fnm)
CopyRightMsg();
//To show the option on the screen and to take the all option
parse_common_args(&argc, argv,
PCA_CAN_TIME | PCA_CAN_VIEW | PCA_TIME_UNIT | PCA_BE_NICE, NFILE, fnm,
0, NULL, asize(desc), desc, 0, NULL, &oenv);
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC, &xtop, NULL, box, FALSE);
atoms = &(top.atoms);
if (opt2fn_null("-i", NFILE, fnm) == NULL )
gmx_fatal(FARGS, "Residue energy file is missing, use \"-i\" option\n");
else
sprintf(fnEnergy, "%s", opt2fn("-i", NFILE, fnm));
snew(isize, 2);
snew(index, 2);
snew(grpnm, 2);
printf(
"\n\n\nEnter the group number for Protein or first Protein or first group\n\n");
get_index(atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &isize[0], &index[0],
&grpnm[0]);
printf(
"\n\n\nEnter the group number of Ligand or second Protein or second group\n\n");
get_index(atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &isize[1], &index[1],
&grpnm[1]);
srenew(index, 3);
srenew(isize, 3);
isize[2] = isize[0] + isize[1];
snew(index[2], isize[0]+isize[1]);
for (i = 0; i < isize[0]; i++)
index[2][i] = index[0][i];
for (i = 0; i < isize[1]; i++)
index[2][i + isize[0]] = index[1][i];
snew(bResA,top.atoms.nres);
snew(bResB,top.atoms.nres);
for(i = 0; i<top.atoms.nres;i++)
{
bResA[i] = FALSE;
bResB[i] = FALSE;
}
nres = 1;
prev_res = atoms->atom[index[2][0]].resind;
bResA[atoms->atom[index[2][0]].resind] = TRUE;
for(i=0;i<isize[2];i++)
{
curr_res = atoms->atom[index[2][i]].resind;
if(curr_res != prev_res)
{
nres++;
if(i<isize[0])
bResA[atoms->atom[index[2][i]].resind] = TRUE;
else
bResB[atoms->atom[index[2][i]].resind] = TRUE;
prev_res = curr_res;
}
}
printf("\nTotal number of residues in topology: %d \n", nres);
snew(energy,nres);
get_energy( fnEnergy, nres, energy);
snew(atoms->pdbinfo, atoms->nr);
for(i = 0; i<isize[2];i++)
{
if((bResA[atoms->atom[index[2][i]].resind]) || (bResB[atoms->atom[index[2][i]].resind])) {
atoms->pdbinfo[index[2][i]].bfac = energy[atoms->atom[index[2][i]].resind];
atoms->pdbinfo[index[2][i]].occup = 1.00;
}
else{
atoms->pdbinfo[index[2][i]].bfac = 0.00;
atoms->pdbinfo[index[2][i]].occup = 1.00;
}
}
fComplex = gmx_ffopen(opt2fn("-c", NFILE, fnm),"w");
write_pdbfile_indexed(fComplex,NULL,atoms,xtop,ePBC,box,' ',-1,isize[2],index[2],NULL,TRUE);
fS1 = gmx_ffopen(opt2fn("-s1", NFILE, fnm),"w");
write_pdbfile_indexed(fS1,NULL,atoms,xtop,ePBC,box,' ',-1,isize[0],index[0],NULL,TRUE);
fS2 = gmx_ffopen(opt2fn("-s2", NFILE, fnm),"w");
write_pdbfile_indexed(fS2,NULL,atoms,xtop,ePBC,box,' ',-1,isize[1],index[1],NULL,TRUE);
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;
}
