void visualize_images(char *fn,int ePBC,matrix box)
{
t_atoms atoms;
rvec *img;
char *c,*ala;
int nat,i;
nat = NTRICIMG+1;
init_t_atoms(&atoms,nat,FALSE);
atoms.nr = nat;
snew(img,nat);
c = "C";
ala = "ALA";
for(i=0; i<nat; i++) {
atoms.atomname[i] = &c;
atoms.atom[i].resnr = i;
atoms.resname[i] = &ala;
atoms.atom[i].chain = 'A'+i/NCUCVERT;
}
calc_triclinic_images(box,img+1);
write_sto_conf(fn,"Images",&atoms,img,NULL,ePBC,box);
free_t_atoms(&atoms,FALSE);
sfree(img);
}
void visualize_images(const char *fn, int ePBC, matrix box)
{
t_atoms atoms;
rvec *img;
char *c, *ala;
int nat, i;
nat = NTRICIMG + 1;
init_t_atoms(&atoms, nat, FALSE);
atoms.nr = nat;
snew(img,nat);
/* FIXME: Constness should not be cast away */
c = (char *) "C";
ala = (char *) "ALA";
for (i = 0; i < nat; i++)
{
atoms.atomname[i] = &c;
atoms.atom[i].resind = i;
atoms.resinfo[i].name = &ala;
atoms.resinfo[i].nr = i + 1;
atoms.resinfo[i].chainid = 'A' + i / NCUCVERT;
}
calc_triclinic_images(box, img + 1);
write_sto_conf(fn, "Images", &atoms, img, NULL, ePBC, box);
free_t_atoms(&atoms, FALSE);
sfree(img);
}
void write_bfactors(t_filenm *fnm, int nfile, atom_id *index, atom_id *a, int nslices, int ngrps, real **order, t_topology *top, real **distvals, output_env_t oenv)
{
/*function to write order parameters as B factors in PDB file using
first frame of trajectory*/
t_trxstatus *status;
int natoms;
t_trxframe fr, frout;
t_atoms useatoms;
int i, j, ctr, nout;
ngrps -= 2; /*we don't have an order parameter for the first or
last atom in each chain*/
nout = nslices*ngrps;
natoms = read_first_frame(oenv, &status, ftp2fn(efTRX, nfile, fnm), &fr,
TRX_NEED_X);
close_trj(status);
frout = fr;
frout.natoms = nout;
frout.bF = FALSE;
frout.bV = FALSE;
frout.x = 0;
snew(frout.x, nout);
init_t_atoms(&useatoms, nout, TRUE);
useatoms.nr = nout;
/*initialize PDBinfo*/
for (i = 0; i < useatoms.nr; ++i)
{
useatoms.pdbinfo[i].type = 0;
useatoms.pdbinfo[i].occup = 0.0;
useatoms.pdbinfo[i].bfac = 0.0;
useatoms.pdbinfo[i].bAnisotropic = FALSE;
}
for (j = 0, ctr = 0; j < nslices; j++)
{
for (i = 0; i < ngrps; i++, ctr++)
{
/*iterate along each chain*/
useatoms.pdbinfo[ctr].bfac = order[j][i+1];
if (distvals)
{
useatoms.pdbinfo[ctr].occup = distvals[j][i+1];
}
copy_rvec(fr.x[a[index[i+1]+j]], frout.x[ctr]);
useatoms.atomname[ctr] = top->atoms.atomname[a[index[i+1]+j]];
useatoms.atom[ctr] = top->atoms.atom[a[index[i+1]+j]];
useatoms.nres = max(useatoms.nres, useatoms.atom[ctr].resind+1);
useatoms.resinfo[useatoms.atom[ctr].resind] = top->atoms.resinfo[useatoms.atom[ctr].resind]; /*copy resinfo*/
}
}
write_sto_conf(opt2fn("-ob", nfile, fnm), "Order parameters", &useatoms, frout.x, NULL, frout.ePBC, frout.box);
sfree(frout.x);
free_t_atoms(&useatoms, FALSE);
}
TopologyInformation::~TopologyInformation()
{
if (top_)
{
free_t_atoms(&top_->atoms, TRUE);
done_top(top_);
sfree(top_);
}
sfree(xtop_);
}
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;
}
static void project(const char *trajfile,t_topology *top,int ePBC,matrix topbox,
const char *projfile,const char *twodplotfile,
const char *threedplotfile, const char *filterfile,int skip,
const char *extremefile,gmx_bool bExtrAll,real extreme,
int nextr, t_atoms *atoms,int natoms,atom_id *index,
gmx_bool bFit,rvec *xref,int nfit,atom_id *ifit,real *w_rls,
real *sqrtm,rvec *xav,
int *eignr,rvec **eigvec,
int noutvec,int *outvec, gmx_bool bSplit,
const output_env_t oenv)
{
FILE *xvgrout=NULL;
int nat,i,j,d,v,vec,nfr,nframes=0,snew_size,frame;
t_trxstatus *out=NULL;
t_trxstatus *status;
int noutvec_extr,imin,imax;
real *pmin,*pmax;
atom_id *all_at;
matrix box;
rvec *xread,*x;
real t,inp,**inprod=NULL,min=0,max=0;
char str[STRLEN],str2[STRLEN],**ylabel,*c;
real fact;
gmx_rmpbc_t gpbc=NULL;
snew(x,natoms);
if (bExtrAll)
noutvec_extr=noutvec;
else
noutvec_extr=1;
if (trajfile) {
snew(inprod,noutvec+1);
if (filterfile) {
fprintf(stderr,"Writing a filtered trajectory to %s using eigenvectors\n",
filterfile);
for(i=0; i<noutvec; i++)
fprintf(stderr,"%d ",outvec[i]+1);
fprintf(stderr,"\n");
out=open_trx(filterfile,"w");
}
snew_size=0;
nfr=0;
nframes=0;
nat=read_first_x(oenv,&status,trajfile,&t,&xread,box);
if (nat>atoms->nr)
gmx_fatal(FARGS,"the number of atoms in your trajectory (%d) is larger than the number of atoms in your structure file (%d)",nat,atoms->nr);
snew(all_at,nat);
if (top)
gpbc = gmx_rmpbc_init(&top->idef,ePBC,nat,box);
for(i=0; i<nat; i++)
all_at[i]=i;
do {
if (nfr % skip == 0) {
if (top)
gmx_rmpbc(gpbc,nat,box,xread);
if (nframes>=snew_size) {
snew_size+=100;
for(i=0; i<noutvec+1; i++)
srenew(inprod[i],snew_size);
}
inprod[noutvec][nframes]=t;
/* calculate x: a fitted struture of the selected atoms */
if (bFit) {
reset_x(nfit,ifit,nat,NULL,xread,w_rls);
do_fit(nat,w_rls,xref,xread);
}
for (i=0; i<natoms; i++)
copy_rvec(xread[index[i]],x[i]);
for(v=0; v<noutvec; v++) {
vec=outvec[v];
/* calculate (mass-weighted) projection */
inp=0;
for (i=0; i<natoms; i++) {
inp+=(eigvec[vec][i][0]*(x[i][0]-xav[i][0])+
eigvec[vec][i][1]*(x[i][1]-xav[i][1])+
eigvec[vec][i][2]*(x[i][2]-xav[i][2]))*sqrtm[i];
}
inprod[v][nframes]=inp;
}
if (filterfile) {
for(i=0; i<natoms; i++)
for(d=0; d<DIM; d++) {
/* misuse xread for output */
xread[index[i]][d] = xav[i][d];
for(v=0; v<noutvec; v++)
xread[index[i]][d] +=
inprod[v][nframes]*eigvec[outvec[v]][i][d]/sqrtm[i];
}
write_trx(out,natoms,index,atoms,0,t,box,xread,NULL,NULL);
}
nframes++;
}
nfr++;
} while (read_next_x(oenv,status,&t,nat,xread,box));
close_trx(status);
sfree(x);
if (filterfile)
close_trx(out);
}
else
snew(xread,atoms->nr);
if (top)
gmx_rmpbc_done(gpbc);
if (projfile) {
snew(ylabel,noutvec);
for(v=0; v<noutvec; v++) {
sprintf(str,"vec %d",eignr[outvec[v]]+1);
ylabel[v]=strdup(str);
}
sprintf(str,"projection on eigenvectors (%s)",proj_unit);
write_xvgr_graphs(projfile, noutvec, 1, str, NULL, output_env_get_xvgr_tlabel(oenv),
(const char **)ylabel,
nframes, inprod[noutvec], inprod, NULL,
output_env_get_time_factor(oenv), FALSE, bSplit,oenv);
}
if (twodplotfile) {
sprintf(str,"projection on eigenvector %d (%s)",
eignr[outvec[0]]+1,proj_unit);
sprintf(str2,"projection on eigenvector %d (%s)",
eignr[outvec[noutvec-1]]+1,proj_unit);
xvgrout=xvgropen(twodplotfile,"2D projection of trajectory",str,str2,
oenv);
for(i=0; i<nframes; i++) {
if ( bSplit && i>0 && abs(inprod[noutvec][i])<1e-5 )
fprintf(xvgrout,"&\n");
fprintf(xvgrout,"%10.5f %10.5f\n",inprod[0][i],inprod[noutvec-1][i]);
}
ffclose(xvgrout);
}
if (threedplotfile) {
t_atoms atoms;
rvec *x;
real *b=NULL;
matrix box;
char *resnm,*atnm, pdbform[STRLEN];
gmx_bool bPDB, b4D;
FILE *out;
if (noutvec < 3)
gmx_fatal(FARGS,"You have selected less than 3 eigenvectors");
/* initialize */
bPDB = fn2ftp(threedplotfile)==efPDB;
clear_mat(box);
box[XX][XX] = box[YY][YY] = box[ZZ][ZZ] = 1;
b4D = bPDB && (noutvec >= 4);
if (b4D) {
fprintf(stderr, "You have selected four or more eigenvectors:\n"
"fourth eigenvector will be plotted "
"in bfactor field of pdb file\n");
sprintf(str,"4D proj. of traj. on eigenv. %d, %d, %d and %d",
eignr[outvec[0]]+1,eignr[outvec[1]]+1,
eignr[outvec[2]]+1,eignr[outvec[3]]+1);
} else {
sprintf(str,"3D proj. of traj. on eigenv. %d, %d and %d",
eignr[outvec[0]]+1,eignr[outvec[1]]+1,eignr[outvec[2]]+1);
}
init_t_atoms(&atoms,nframes,FALSE);
snew(x,nframes);
snew(b,nframes);
atnm=strdup("C");
resnm=strdup("PRJ");
if(nframes>10000)
fact=10000.0/nframes;
else
fact=1.0;
for(i=0; i<nframes; i++) {
atoms.atomname[i] = &atnm;
atoms.atom[i].resind = i;
atoms.resinfo[i].name = &resnm;
atoms.resinfo[i].nr = ceil(i*fact);
atoms.resinfo[i].ic = ' ';
x[i][XX]=inprod[0][i];
x[i][YY]=inprod[1][i];
x[i][ZZ]=inprod[2][i];
if (b4D)
b[i] =inprod[3][i];
}
if ( ( b4D || bSplit ) && bPDB ) {
strcpy(pdbform,get_pdbformat());
strcat(pdbform,"%8.4f%8.4f\n");
out=ffopen(threedplotfile,"w");
fprintf(out,"HEADER %s\n",str);
if ( b4D )
fprintf(out,"REMARK %s\n","fourth dimension plotted as B-factor");
j=0;
for(i=0; i<atoms.nr; i++) {
if ( j>0 && bSplit && abs(inprod[noutvec][i])<1e-5 ) {
fprintf(out,"TER\n");
j=0;
}
fprintf(out,pdbform,"ATOM",i+1,"C","PRJ",' ',j+1,
PR_VEC(10*x[i]), 1.0, 10*b[i]);
if (j>0)
fprintf(out,"CONECT%5d%5d\n", i, i+1);
j++;
}
fprintf(out,"TER\n");
ffclose(out);
} else
write_sto_conf(threedplotfile,str,&atoms,x,NULL,ePBC,box);
free_t_atoms(&atoms,FALSE);
}
if (extremefile) {
snew(pmin,noutvec_extr);
snew(pmax,noutvec_extr);
if (extreme==0) {
fprintf(stderr,"%11s %17s %17s\n","eigenvector","Minimum","Maximum");
fprintf(stderr,
"%11s %10s %10s %10s %10s\n","","value","frame","value","frame");
imin = 0;
imax = 0;
for(v=0; v<noutvec_extr; v++) {
for(i=0; i<nframes; i++) {
if (inprod[v][i]<inprod[v][imin])
imin = i;
if (inprod[v][i]>inprod[v][imax])
imax = i;
}
pmin[v] = inprod[v][imin];
pmax[v] = inprod[v][imax];
fprintf(stderr,"%7d %10.6f %10d %10.6f %10d\n",
eignr[outvec[v]]+1,
pmin[v],imin,pmax[v],imax);
}
}
else {
pmin[0] = -extreme;
pmax[0] = extreme;
}
/* build format string for filename: */
strcpy(str,extremefile);/* copy filename */
c=strrchr(str,'.'); /* find where extention begins */
strcpy(str2,c); /* get extention */
sprintf(c,"%%d%s",str2); /* append '%s' and extention to filename */
for(v=0; v<noutvec_extr; v++) {
/* make filename using format string */
if (noutvec_extr==1)
strcpy(str2,extremefile);
else
sprintf(str2,str,eignr[outvec[v]]+1);
fprintf(stderr,"Writing %d frames along eigenvector %d to %s\n",
nextr,outvec[v]+1,str2);
out=open_trx(str2,"w");
for(frame=0; frame<nextr; frame++) {
if ((extreme==0) && (nextr<=3))
for(i=0; i<natoms; i++) {
atoms->resinfo[atoms->atom[index[i]].resind].chainid = 'A' + frame;
}
for(i=0; i<natoms; i++)
for(d=0; d<DIM; d++)
xread[index[i]][d] =
(xav[i][d] + (pmin[v]*(nextr-frame-1)+pmax[v]*frame)/(nextr-1)
*eigvec[outvec[v]][i][d]/sqrtm[i]);
write_trx(out,natoms,index,atoms,0,frame,topbox,xread,NULL,NULL);
}
close_trx(out);
}
sfree(pmin);
sfree(pmax);
}
fprintf(stderr,"\n");
}
void connelly_plot(const char *fn,int ndots,real dots[],rvec x[],t_atoms *atoms,
t_symtab *symtab,int ePBC,matrix box,gmx_bool bSave)
{
static const char *atomnm="DOT";
static const char *resnm ="DOT";
static const char *title ="Connely Dot Surface Generated by g_sas";
int i,i0,r0,ii0,k;
rvec *xnew;
t_atoms aaa;
if (bSave) {
i0 = atoms->nr;
r0 = atoms->nres;
srenew(atoms->atom,atoms->nr+ndots);
srenew(atoms->atomname,atoms->nr+ndots);
srenew(atoms->resinfo,r0+1);
atoms->atom[i0].resind = r0;
t_atoms_set_resinfo(atoms,i0,symtab,resnm,r0+1,' ',0,' ');
srenew(atoms->pdbinfo,atoms->nr+ndots);
snew(xnew,atoms->nr+ndots);
for(i=0; (i<atoms->nr); i++)
copy_rvec(x[i],xnew[i]);
for(i=k=0; (i<ndots); i++) {
ii0 = i0+i;
atoms->atomname[ii0] = put_symtab(symtab,atomnm);
atoms->pdbinfo[ii0].type = epdbATOM;
atoms->pdbinfo[ii0].atomnr= ii0;
atoms->atom[ii0].resind = r0;
xnew[ii0][XX] = dots[k++];
xnew[ii0][YY] = dots[k++];
xnew[ii0][ZZ] = dots[k++];
atoms->pdbinfo[ii0].bfac = 0.0;
atoms->pdbinfo[ii0].occup = 0.0;
}
atoms->nr = i0+ndots;
atoms->nres = r0+1;
write_sto_conf(fn,title,atoms,xnew,NULL,ePBC,box);
atoms->nres = r0;
atoms->nr = i0;
}
else {
init_t_atoms(&aaa,ndots,TRUE);
aaa.atom[0].resind = 0;
t_atoms_set_resinfo(&aaa,0,symtab,resnm,1,' ',0,' ');
snew(xnew,ndots);
for(i=k=0; (i<ndots); i++) {
ii0 = i;
aaa.atomname[ii0] = put_symtab(symtab,atomnm);
aaa.pdbinfo[ii0].type = epdbATOM;
aaa.pdbinfo[ii0].atomnr= ii0;
aaa.atom[ii0].resind = 0;
xnew[ii0][XX] = dots[k++];
xnew[ii0][YY] = dots[k++];
xnew[ii0][ZZ] = dots[k++];
aaa.pdbinfo[ii0].bfac = 0.0;
aaa.pdbinfo[ii0].occup = 0.0;
}
aaa.nr = ndots;
write_sto_conf(fn,title,&aaa,xnew,NULL,ePBC,box);
do_conect(fn,ndots,xnew);
free_t_atoms(&aaa,FALSE);
}
sfree(xnew);
}
static void read_posres(gmx_mtop_t *mtop,t_molinfo *molinfo,bool bTopB,
char *fn,
int rc_scaling, int ePBC,
rvec com)
{
bool bFirst = TRUE;
rvec *x,*v,*xp;
dvec sum;
double totmass;
t_atoms dumat;
matrix box,invbox;
int natoms,npbcdim=0;
char title[STRLEN];
int a,i,ai,j,k,mb,nat_molb;
gmx_molblock_t *molb;
t_params *pr;
t_atom *atom;
get_stx_coordnum(fn,&natoms);
if (natoms != mtop->natoms) {
sprintf(warn_buf,"The number of atoms in %s (%d) does not match the number of atoms in the topology (%d). Will assume that the first %d atoms in the topology and %s match.",fn,natoms,mtop->natoms,min(mtop->natoms,natoms),fn);
warning(NULL);
}
snew(x,natoms);
snew(v,natoms);
init_t_atoms(&dumat,natoms,FALSE);
read_stx_conf(fn,title,&dumat,x,v,NULL,box);
npbcdim = ePBC2npbcdim(ePBC);
clear_rvec(com);
if (rc_scaling != erscNO) {
copy_mat(box,invbox);
for(j=npbcdim; j<DIM; j++) {
clear_rvec(invbox[j]);
invbox[j][j] = 1;
}
m_inv_ur0(invbox,invbox);
}
/* Copy the reference coordinates to mtop */
clear_dvec(sum);
totmass = 0;
a = 0;
for(mb=0; mb<mtop->nmolblock; mb++) {
molb = &mtop->molblock[mb];
nat_molb = molb->nmol*mtop->moltype[molb->type].atoms.nr;
pr = &(molinfo[molb->type].plist[F_POSRES]);
if (pr->nr > 0) {
atom = mtop->moltype[molb->type].atoms.atom;
for(i=0; (i<pr->nr); i++) {
ai=pr->param[i].AI;
if (ai >= natoms) {
gmx_fatal(FARGS,"Position restraint atom index (%d) in moltype '%s' is larger than number of atoms in %s (%d).\n",
ai+1,*molinfo[molb->type].name,fn,natoms);
}
if (rc_scaling == erscCOM) {
/* Determine the center of mass of the posres reference coordinates */
for(j=0; j<npbcdim; j++) {
sum[j] += atom[ai].m*x[a+ai][j];
}
totmass += atom[ai].m;
}
}
if (!bTopB) {
molb->nposres_xA = nat_molb;
snew(molb->posres_xA,molb->nposres_xA);
for(i=0; i<nat_molb; i++) {
copy_rvec(x[a+i],molb->posres_xA[i]);
}
} else {
molb->nposres_xB = nat_molb;
snew(molb->posres_xB,molb->nposres_xB);
for(i=0; i<nat_molb; i++) {
copy_rvec(x[a+i],molb->posres_xB[i]);
}
}
}
a += nat_molb;
}
if (rc_scaling == erscCOM) {
if (totmass == 0)
gmx_fatal(FARGS,"The total mass of the position restraint atoms is 0");
for(j=0; j<npbcdim; j++)
com[j] = sum[j]/totmass;
fprintf(stderr,"The center of mass of the position restraint coord's is %6.3f %6.3f %6.3f\n",com[XX],com[YY],com[ZZ]);
}
if (rc_scaling != erscNO) {
for(mb=0; mb<mtop->nmolblock; mb++) {
molb = &mtop->molblock[mb];
nat_molb = molb->nmol*mtop->moltype[molb->type].atoms.nr;
if (molb->nposres_xA > 0 || molb->nposres_xB > 0) {
xp = (!bTopB ? molb->posres_xA : molb->posres_xB);
for(i=0; i<nat_molb; i++) {
for(j=0; j<npbcdim; j++) {
if (rc_scaling == erscALL) {
/* Convert from Cartesian to crystal coordinates */
xp[i][j] *= invbox[j][j];
for(k=j+1; k<npbcdim; k++) {
xp[i][j] += invbox[k][j]*xp[i][k];
}
} else if (rc_scaling == erscCOM) {
/* Subtract the center of mass */
xp[i][j] -= com[j];
}
}
}
}
}
if (rc_scaling == erscCOM) {
/* Convert the COM from Cartesian to crystal coordinates */
for(j=0; j<npbcdim; j++) {
com[j] *= invbox[j][j];
for(k=j+1; k<npbcdim; k++) {
com[j] += invbox[k][j]*com[k];
}
}
}
}
free_t_atoms(&dumat,TRUE);
sfree(x);
sfree(v);
}
static void
new_status(char *topfile,char *topppfile,char *confin,
t_gromppopts *opts,t_inputrec *ir,bool bZero,
bool bGenVel,bool bVerbose,t_state *state,
gpp_atomtype_t atype,gmx_mtop_t *sys,
int *nmi,t_molinfo **mi,t_params plist[],
int *comb,double *reppow,real *fudgeQQ,
bool bMorse,
int *nerror)
{
t_molinfo *molinfo=NULL;
int nmolblock;
gmx_molblock_t *molblock,*molbs;
t_atoms *confat;
int mb,mbs,i,nrmols,nmismatch;
char buf[STRLEN];
bool bGB=FALSE;
init_mtop(sys);
/* Set boolean for GB */
if(ir->implicit_solvent)
bGB=TRUE;
/* TOPOLOGY processing */
sys->name = do_top(bVerbose,topfile,topppfile,opts,bZero,&(sys->symtab),
plist,comb,reppow,fudgeQQ,
atype,&nrmols,&molinfo,ir,
&nmolblock,&molblock,bGB);
sys->nmolblock = 0;
snew(sys->molblock,nmolblock);
mbs;
sys->natoms = 0;
for(mb=0; mb<nmolblock; mb++) {
if (sys->nmolblock > 0 &&
molblock[mb].type == sys->molblock[sys->nmolblock-1].type) {
/* Merge consecutive blocks with the same molecule type */
sys->molblock[sys->nmolblock-1].nmol += molblock[mb].nmol;
sys->natoms += molblock[mb].nmol*sys->molblock[sys->nmolblock-1].natoms_mol;
} else if (molblock[mb].nmol > 0) {
/* Add a new molblock to the topology */
molbs = &sys->molblock[sys->nmolblock];
*molbs = molblock[mb];
molbs->natoms_mol = molinfo[molbs->type].atoms.nr;
molbs->nposres_xA = 0;
molbs->nposres_xB = 0;
sys->natoms += molbs->nmol*molbs->natoms_mol;
sys->nmolblock++;
}
}
if (sys->nmolblock == 0) {
gmx_fatal(FARGS,"No molecules were defined in the system");
}
renumber_moltypes(sys,&nrmols,&molinfo);
if (bMorse)
convert_harmonics(nrmols,molinfo,atype);
if (ir->eDisre == edrNone) {
i = rm_interactions(F_DISRES,nrmols,molinfo);
if (i > 0) {
set_warning_line("unknown",-1);
sprintf(warn_buf,"disre = no, removed %d distance restraints",i);
warning_note(NULL);
}
}
if (opts->bOrire == FALSE) {
i = rm_interactions(F_ORIRES,nrmols,molinfo);
if (i > 0) {
set_warning_line("unknown",-1);
sprintf(warn_buf,"orire = no, removed %d orientation restraints",i);
warning_note(NULL);
}
}
if (opts->bDihre == FALSE) {
i = rm_interactions(F_DIHRES,nrmols,molinfo);
if (i > 0) {
set_warning_line("unknown",-1);
sprintf(warn_buf,"dihre = no, removed %d dihedral restraints",i);
warning_note(NULL);
}
}
/* Copy structures from msys to sys */
molinfo2mtop(nrmols,molinfo,sys);
/* COORDINATE file processing */
if (bVerbose)
fprintf(stderr,"processing coordinates...\n");
get_stx_coordnum(confin,&state->natoms);
if (state->natoms != sys->natoms)
gmx_fatal(FARGS,"number of coordinates in coordinate file (%s, %d)\n"
" does not match topology (%s, %d)",
confin,state->natoms,topfile,sys->natoms);
else {
/* make space for coordinates and velocities */
char title[STRLEN];
snew(confat,1);
init_t_atoms(confat,state->natoms,FALSE);
init_state(state,state->natoms,0);
read_stx_conf(confin,title,confat,state->x,state->v,NULL,state->box);
/* This call fixes the box shape for runs with pressure scaling */
set_box_rel(ir,state);
nmismatch = check_atom_names(topfile, confin, sys, confat);
free_t_atoms(confat,TRUE);
sfree(confat);
if (nmismatch) {
sprintf(buf,"%d non-matching atom name%s\n"
"atom names from %s will be used\n"
"atom names from %s will be ignored\n",
nmismatch,(nmismatch == 1) ? "" : "s",topfile,confin);
warning(buf);
}
if (bVerbose)
fprintf(stderr,"double-checking input for internal consistency...\n");
double_check(ir,state->box,nint_ftype(sys,molinfo,F_CONSTR),nerror);
}
if (bGenVel) {
real *mass;
gmx_mtop_atomloop_all_t aloop;
t_atom *atom;
snew(mass,state->natoms);
aloop = gmx_mtop_atomloop_all_init(sys);
while (gmx_mtop_atomloop_all_next(aloop,&i,&atom)) {
mass[i] = atom->m;
}
if (opts->seed == -1) {
opts->seed = make_seed();
fprintf(stderr,"Setting gen_seed to %d\n",opts->seed);
}
maxwell_speed(opts->tempi,opts->seed,sys,state->v);
stop_cm(stdout,state->natoms,mass,state->x,state->v);
sfree(mass);
}
*nmi = nrmols;
*mi = molinfo;
}