static void corr_print(t_corr *curr, gmx_bool bTen, const char *fn, const char *title,
const char *yaxis,
real msdtime, real beginfit, real endfit,
real *DD, real *SigmaD, char *grpname[],
const output_env_t oenv)
{
FILE *out;
int i, j;
out = xvgropen(fn, title, output_env_get_xvgr_tlabel(oenv), yaxis, oenv);
if (DD)
{
fprintf(out, "# MSD gathered over %g %s with %d restarts\n",
msdtime, output_env_get_time_unit(oenv), curr->nrestart);
fprintf(out, "# Diffusion constants fitted from time %g to %g %s\n",
beginfit, endfit, output_env_get_time_unit(oenv));
for (i = 0; i < curr->ngrp; i++)
{
fprintf(out, "# D[%10s] = %.4f (+/- %.4f) (1e-5 cm^2/s)\n",
grpname[i], DD[i], SigmaD[i]);
}
}
for (i = 0; i < curr->nframes; i++)
{
fprintf(out, "%10g", output_env_conv_time(oenv, curr->time[i]));
for (j = 0; j < curr->ngrp; j++)
{
fprintf(out, " %10g", curr->data[j][i]);
if (bTen)
{
fprintf(out, " %10g %10g %10g %10g %10g %10g",
curr->datam[j][i][XX][XX],
curr->datam[j][i][YY][YY],
curr->datam[j][i][ZZ][ZZ],
curr->datam[j][i][YY][XX],
curr->datam[j][i][ZZ][XX],
curr->datam[j][i][ZZ][YY]);
}
}
fprintf(out, "\n");
}
xvgrclose(out);
}
int gmx_polystat(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] plots static properties of polymers as a function of time",
"and prints the average.[PAR]",
"By default it determines the average end-to-end distance and radii",
"of gyration of polymers. It asks for an index group and split this",
"into molecules. The end-to-end distance is then determined using",
"the first and the last atom in the index group for each molecules.",
"For the radius of gyration the total and the three principal components",
"for the average gyration tensor are written.",
"With option [TT]-v[tt] the eigenvectors are written.",
"With option [TT]-pc[tt] also the average eigenvalues of the individual",
"gyration tensors are written.",
"With option [TT]-i[tt] the mean square internal distances are",
"written.[PAR]",
"With option [TT]-p[tt] the persistence length is determined.",
"The chosen index group should consist of atoms that are",
"consecutively bonded in the polymer mainchains.",
"The persistence length is then determined from the cosine of",
"the angles between bonds with an index difference that is even,",
"the odd pairs are not used, because straight polymer backbones",
"are usually all trans and therefore only every second bond aligns.",
"The persistence length is defined as number of bonds where",
"the average cos reaches a value of 1/e. This point is determined",
"by a linear interpolation of [LOG]<cos>[log]."
};
static gmx_bool bMW = TRUE, bPC = FALSE;
t_pargs pa[] = {
{ "-mw", FALSE, etBOOL, {&bMW},
"Use the mass weighting for radii of gyration" },
{ "-pc", FALSE, etBOOL, {&bPC},
"Plot average eigenvalues" }
};
t_filenm fnm[] = {
{ efTPR, nullptr, nullptr, ffREAD },
{ efTRX, "-f", nullptr, ffREAD },
{ efNDX, nullptr, nullptr, ffOPTRD },
{ efXVG, "-o", "polystat", ffWRITE },
{ efXVG, "-v", "polyvec", ffOPTWR },
{ efXVG, "-p", "persist", ffOPTWR },
{ efXVG, "-i", "intdist", ffOPTWR }
};
#define NFILE asize(fnm)
t_topology *top;
gmx_output_env_t *oenv;
int ePBC;
int isize, *index, nmol, *molind, mol, nat_min = 0, nat_max = 0;
char *grpname;
t_trxstatus *status;
real t;
rvec *x, *bond = nullptr;
matrix box;
int natoms, i, j, frame, ind0, ind1, a, d, d2, ord[DIM] = {0};
dvec cm, sum_eig = {0, 0, 0};
double **gyr, **gyr_all, eig[DIM], **eigv;
double sum_eed2, sum_eed2_tot, sum_gyro, sum_gyro_tot, sum_pers_tot;
int *ninp = nullptr;
double *sum_inp = nullptr, pers;
double *intd, ymax, ymin;
double mmol, m;
char title[STRLEN];
FILE *out, *outv, *outp, *outi;
const char *leg[8] = {
"end to end", "<R\\sg\\N>",
"<R\\sg\\N> eig1", "<R\\sg\\N> eig2", "<R\\sg\\N> eig3",
"<R\\sg\\N eig1>", "<R\\sg\\N eig2>", "<R\\sg\\N eig3>"
};
char **legp, buf[STRLEN];
gmx_rmpbc_t gpbc = nullptr;
if (!parse_common_args(&argc, argv,
PCA_CAN_VIEW | PCA_CAN_TIME | PCA_TIME_UNIT,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, nullptr, &oenv))
{
return 0;
}
snew(top, 1);
ePBC = read_tpx_top(ftp2fn(efTPR, NFILE, fnm),
nullptr, box, &natoms, nullptr, nullptr, top);
fprintf(stderr, "Select a group of polymer mainchain atoms:\n");
get_index(&top->atoms, ftp2fn_null(efNDX, NFILE, fnm),
1, &isize, &index, &grpname);
snew(molind, top->mols.nr+1);
nmol = 0;
mol = -1;
for (i = 0; i < isize; i++)
{
if (i == 0 || index[i] >= top->mols.index[mol+1])
{
molind[nmol++] = i;
do
{
mol++;
}
while (index[i] >= top->mols.index[mol+1]);
}
}
molind[nmol] = i;
nat_min = top->atoms.nr;
nat_max = 0;
for (mol = 0; mol < nmol; mol++)
{
nat_min = std::min(nat_min, molind[mol+1]-molind[mol]);
nat_max = std::max(nat_max, molind[mol+1]-molind[mol]);
}
fprintf(stderr, "Group %s consists of %d molecules\n", grpname, nmol);
fprintf(stderr, "Group size per molecule, min: %d atoms, max %d atoms\n",
nat_min, nat_max);
sprintf(title, "Size of %d polymers", nmol);
out = xvgropen(opt2fn("-o", NFILE, fnm), title, output_env_get_xvgr_tlabel(oenv), "(nm)",
oenv);
xvgr_legend(out, bPC ? 8 : 5, leg, oenv);
if (opt2bSet("-v", NFILE, fnm))
{
outv = xvgropen(opt2fn("-v", NFILE, fnm), "Principal components",
output_env_get_xvgr_tlabel(oenv), "(nm)", oenv);
snew(legp, DIM*DIM);
for (d = 0; d < DIM; d++)
{
for (d2 = 0; d2 < DIM; d2++)
{
sprintf(buf, "eig%d %c", d+1, 'x'+d2);
legp[d*DIM+d2] = gmx_strdup(buf);
}
}
xvgr_legend(outv, DIM*DIM, (const char**)legp, oenv);
}
else
{
outv = nullptr;
}
if (opt2bSet("-p", NFILE, fnm))
{
outp = xvgropen(opt2fn("-p", NFILE, fnm), "Persistence length",
output_env_get_xvgr_tlabel(oenv), "bonds", oenv);
snew(bond, nat_max-1);
snew(sum_inp, nat_min/2);
snew(ninp, nat_min/2);
}
else
{
outp = nullptr;
}
if (opt2bSet("-i", NFILE, fnm))
{
outi = xvgropen(opt2fn("-i", NFILE, fnm), "Internal distances",
"n", "<R\\S2\\N(n)>/n (nm\\S2\\N)", oenv);
i = index[molind[1]-1] - index[molind[0]]; /* Length of polymer -1 */
snew(intd, i);
}
else
{
intd = nullptr;
outi = nullptr;
}
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
snew(gyr, DIM);
snew(gyr_all, DIM);
snew(eigv, DIM);
for (d = 0; d < DIM; d++)
{
snew(gyr[d], DIM);
snew(gyr_all[d], DIM);
snew(eigv[d], DIM);
}
frame = 0;
sum_eed2_tot = 0;
sum_gyro_tot = 0;
sum_pers_tot = 0;
gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
do
{
gmx_rmpbc(gpbc, natoms, box, x);
sum_eed2 = 0;
for (d = 0; d < DIM; d++)
{
clear_dvec(gyr_all[d]);
}
if (bPC)
{
clear_dvec(sum_eig);
}
if (outp)
{
for (i = 0; i < nat_min/2; i++)
{
sum_inp[i] = 0;
ninp[i] = 0;
}
}
for (mol = 0; mol < nmol; mol++)
{
ind0 = molind[mol];
ind1 = molind[mol+1];
/* Determine end to end distance */
sum_eed2 += distance2(x[index[ind0]], x[index[ind1-1]]);
/* Determine internal distances */
if (outi)
{
calc_int_dist(intd, x, index[ind0], index[ind1-1]);
}
/* Determine the radius of gyration */
clear_dvec(cm);
for (d = 0; d < DIM; d++)
{
clear_dvec(gyr[d]);
}
mmol = 0;
for (i = ind0; i < ind1; i++)
{
a = index[i];
if (bMW)
{
m = top->atoms.atom[a].m;
}
else
{
m = 1;
}
mmol += m;
for (d = 0; d < DIM; d++)
{
cm[d] += m*x[a][d];
for (d2 = 0; d2 < DIM; d2++)
{
gyr[d][d2] += m*x[a][d]*x[a][d2];
}
}
}
dsvmul(1/mmol, cm, cm);
for (d = 0; d < DIM; d++)
{
for (d2 = 0; d2 < DIM; d2++)
{
gyr[d][d2] = gyr[d][d2]/mmol - cm[d]*cm[d2];
gyr_all[d][d2] += gyr[d][d2];
}
}
if (bPC)
{
gyro_eigen(gyr, eig, eigv, ord);
for (d = 0; d < DIM; d++)
{
sum_eig[d] += eig[ord[d]];
}
}
if (outp)
{
for (i = ind0; i < ind1-1; i++)
{
rvec_sub(x[index[i+1]], x[index[i]], bond[i-ind0]);
unitv(bond[i-ind0], bond[i-ind0]);
}
for (i = ind0; i < ind1-1; i++)
{
for (j = 0; (i+j < ind1-1 && j < nat_min/2); j += 2)
{
sum_inp[j] += iprod(bond[i-ind0], bond[i-ind0+j]);
ninp[j]++;
}
}
}
}
sum_eed2 /= nmol;
sum_gyro = 0;
for (d = 0; d < DIM; d++)
{
for (d2 = 0; d2 < DIM; d2++)
{
gyr_all[d][d2] /= nmol;
}
sum_gyro += gyr_all[d][d];
}
gyro_eigen(gyr_all, eig, eigv, ord);
fprintf(out, "%10.3f %8.4f %8.4f %8.4f %8.4f %8.4f",
t*output_env_get_time_factor(oenv),
std::sqrt(sum_eed2), sqrt(sum_gyro),
std::sqrt(eig[ord[0]]), std::sqrt(eig[ord[1]]), std::sqrt(eig[ord[2]]));
if (bPC)
{
for (d = 0; d < DIM; d++)
{
fprintf(out, " %8.4f", std::sqrt(sum_eig[d]/nmol));
}
}
fprintf(out, "\n");
if (outv)
{
fprintf(outv, "%10.3f", t*output_env_get_time_factor(oenv));
for (d = 0; d < DIM; d++)
{
for (d2 = 0; d2 < DIM; d2++)
{
fprintf(outv, " %6.3f", eigv[ord[d]][d2]);
}
}
fprintf(outv, "\n");
}
sum_eed2_tot += sum_eed2;
sum_gyro_tot += sum_gyro;
if (outp)
{
i = -1;
for (j = 0; j < nat_min/2; j += 2)
{
sum_inp[j] /= ninp[j];
if (i == -1 && sum_inp[j] <= std::exp(-1.0))
{
i = j;
}
}
if (i == -1)
{
pers = j;
}
else
{
/* Do linear interpolation on a log scale */
pers = i - 2.0
+ 2.0*(std::log(sum_inp[i-2]) + 1.0)/(std::log(sum_inp[i-2]) - std::log(sum_inp[i]));
}
fprintf(outp, "%10.3f %8.4f\n", t*output_env_get_time_factor(oenv), pers);
sum_pers_tot += pers;
}
frame++;
}
while (read_next_x(oenv, status, &t, x, box));
gmx_rmpbc_done(gpbc);
close_trx(status);
xvgrclose(out);
if (outv)
{
xvgrclose(outv);
}
if (outp)
{
xvgrclose(outp);
}
sum_eed2_tot /= frame;
sum_gyro_tot /= frame;
sum_pers_tot /= frame;
fprintf(stdout, "\nAverage end to end distance: %.3f (nm)\n",
std::sqrt(sum_eed2_tot));
fprintf(stdout, "\nAverage radius of gyration: %.3f (nm)\n",
std::sqrt(sum_gyro_tot));
if (opt2bSet("-p", NFILE, fnm))
{
fprintf(stdout, "\nAverage persistence length: %.2f bonds\n",
sum_pers_tot);
}
/* Handle printing of internal distances. */
if (outi)
{
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(outi, "@ xaxes scale Logarithmic\n");
}
ymax = -1;
ymin = 1e300;
j = index[molind[1]-1] - index[molind[0]]; /* Polymer length -1. */
for (i = 0; i < j; i++)
{
intd[i] /= (i + 1) * frame * nmol;
if (intd[i] > ymax)
{
ymax = intd[i];
}
if (intd[i] < ymin)
{
ymin = intd[i];
}
}
xvgr_world(outi, 1, ymin, j, ymax, oenv);
for (i = 0; i < j; i++)
{
fprintf(outi, "%d %8.4f\n", i+1, intd[i]);
}
xvgrclose(outi);
}
do_view(oenv, opt2fn("-o", NFILE, fnm), "-nxy");
if (opt2bSet("-v", NFILE, fnm))
{
do_view(oenv, opt2fn("-v", NFILE, fnm), "-nxy");
}
if (opt2bSet("-p", NFILE, fnm))
{
do_view(oenv, opt2fn("-p", NFILE, fnm), "-nxy");
}
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");
}
int gmx_bundle(int argc,char *argv[])
{
const 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 gmx_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;
t_trxstatus *status;
t_trxstatus *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];
/* FIXME: The constness should not be cast away */
char *anm=(char *)"CA",*rnm=(char *)"GLY";
int i,j,gnx[MAX_ENDS];
atom_id *index[MAX_ENDS];
t_bundle bun;
gmx_bool bKink;
rvec va,vb,vc,vr,vl;
output_env_t oenv;
gmx_rmpbc_t gpbc=NULL;
#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,&oenv);
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",
output_env_get_xvgr_tlabel(oenv),"(nm)",oenv);
fdist = xvgropen(opt2fn("-od",NFILE,fnm),"Distance of axis centers",
output_env_get_xvgr_tlabel(oenv),"(nm)",oenv);
fz = xvgropen(opt2fn("-oz",NFILE,fnm),"Z-shift of axis centers",
output_env_get_xvgr_tlabel(oenv),"(nm)",oenv);
ftilt = xvgropen(opt2fn("-ot",NFILE,fnm),"Axis tilts",
output_env_get_xvgr_tlabel(oenv),"(degrees)",oenv);
ftiltr = xvgropen(opt2fn("-otr",NFILE,fnm),"Radial axis tilts",
output_env_get_xvgr_tlabel(oenv),"(degrees)",oenv);
ftiltl = xvgropen(opt2fn("-otl",NFILE,fnm),"Lateral axis tilts",
output_env_get_xvgr_tlabel(oenv),"(degrees)",oenv);
if (bKink) {
fkink = xvgropen(opt2fn("-ok",NFILE,fnm),"Kink angles",
output_env_get_xvgr_tlabel(oenv),"(degrees)",oenv);
fkinkr = xvgropen(opt2fn("-okr",NFILE,fnm),"Radial kink angles",
output_env_get_xvgr_tlabel(oenv),"(degrees)",oenv);
if (output_env_get_print_xvgr_codes(oenv))
fprintf(fkinkr,"@ subtitle \"+ = ) ( - = ( )\"\n");
fkinkl = xvgropen(opt2fn("-okl",NFILE,fnm),"Lateral kink angles",
output_env_get_xvgr_tlabel(oenv),"(degrees)",oenv);
}
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].resind = i/3;
outatoms.resinfo[i/3].name = &rnm;
outatoms.resinfo[i/3].nr = i/3 + 1;
outatoms.resinfo[i/3].ic = ' ';
}
fpdb = open_trx(opt2fn("-oa",NFILE,fnm),"w");
} else
fpdb = NULL;
read_first_frame(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&fr,TRX_NEED_X);
gpbc = gmx_rmpbc_init(&top.idef,ePBC,fr.natoms,fr.box);
do {
gmx_rmpbc_trxfr(gpbc,&fr);
calc_axes(fr.x,top.atoms.atom,gnx,index,!bZ,&bun);
t = output_env_conv_time(oenv,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 )
dump_axes(fpdb,&fr,&outatoms,&bun);
} while(read_next_frame(oenv,status,&fr));
gmx_rmpbc_done(gpbc);
close_trx(status);
if (fpdb )
close_trx(fpdb);
ffclose(flen);
ffclose(fdist);
ffclose(fz);
ffclose(ftilt);
ffclose(ftiltr);
ffclose(ftiltl);
if (bKink) {
ffclose(fkink);
ffclose(fkinkr);
ffclose(fkinkl);
}
thanx(stderr);
return 0;
}
int gmx_rms(int argc, char *argv[])
{
const char *desc[] =
{
"[THISMODULE] compares two structures by computing the root mean square",
"deviation (RMSD), the size-independent [GRK]rho[grk] similarity parameter",
"([TT]rho[tt]) or the scaled [GRK]rho[grk] ([TT]rhosc[tt]), ",
"see Maiorov & Crippen, Proteins [BB]22[bb], 273 (1995).",
"This is selected by [TT]-what[tt].[PAR]"
"Each structure from a trajectory ([TT]-f[tt]) is compared to a",
"reference structure. The reference structure",
"is taken from the structure file ([TT]-s[tt]).[PAR]",
"With option [TT]-mir[tt] also a comparison with the mirror image of",
"the reference structure is calculated.",
"This is useful as a reference for 'significant' values, see",
"Maiorov & Crippen, Proteins [BB]22[bb], 273 (1995).[PAR]",
"Option [TT]-prev[tt] produces the comparison with a previous frame",
"the specified number of frames ago.[PAR]",
"Option [TT]-m[tt] produces a matrix in [TT].xpm[tt] format of",
"comparison values of each structure in the trajectory with respect to",
"each other structure. This file can be visualized with for instance",
"[TT]xv[tt] and can be converted to postscript with [gmx-xpm2ps].[PAR]",
"Option [TT]-fit[tt] controls the least-squares fitting of",
"the structures on top of each other: complete fit (rotation and",
"translation), translation only, or no fitting at all.[PAR]",
"Option [TT]-mw[tt] controls whether mass weighting is done or not.",
"If you select the option (default) and ",
"supply a valid [TT].tpr[tt] file masses will be taken from there, ",
"otherwise the masses will be deduced from the [TT]atommass.dat[tt] file in",
"[TT]GMXLIB[tt]. This is fine for proteins, but not",
"necessarily for other molecules. A default mass of 12.011 amu (carbon)",
"is assigned to unknown atoms. You can check whether this happend by",
"turning on the [TT]-debug[tt] flag and inspecting the log file.[PAR]",
"With [TT]-f2[tt], the 'other structures' are taken from a second",
"trajectory, this generates a comparison matrix of one trajectory",
"versus the other.[PAR]",
"Option [TT]-bin[tt] does a binary dump of the comparison matrix.[PAR]",
"Option [TT]-bm[tt] produces a matrix of average bond angle deviations",
"analogously to the [TT]-m[tt] option. Only bonds between atoms in the",
"comparison group are considered."
};
static gmx_bool bPBC = TRUE, bFitAll = TRUE, bSplit = FALSE;
static gmx_bool bDeltaLog = FALSE;
static int prev = 0, freq = 1, freq2 = 1, nlevels = 80, avl = 0;
static real rmsd_user_max = -1, rmsd_user_min = -1, bond_user_max = -1,
bond_user_min = -1, delta_maxy = 0.0;
/* strings and things for selecting difference method */
enum
{
ewSel, ewRMSD, ewRho, ewRhoSc, ewNR
};
int ewhat;
const char *what[ewNR + 1] =
{ NULL, "rmsd", "rho", "rhosc", NULL };
const char *whatname[ewNR] =
{ NULL, "RMSD", "Rho", "Rho sc" };
const char *whatlabel[ewNR] =
{ NULL, "RMSD (nm)", "Rho", "Rho sc" };
const char *whatxvgname[ewNR] =
{ NULL, "RMSD", "\\8r\\4", "\\8r\\4\\ssc\\N" };
const char *whatxvglabel[ewNR] =
{ NULL, "RMSD (nm)", "\\8r\\4", "\\8r\\4\\ssc\\N" };
/* strings and things for fitting methods */
enum
{
efSel, efFit, efReset, efNone, efNR
};
int efit;
const char *fit[efNR + 1] =
{ NULL, "rot+trans", "translation", "none", NULL };
const char *fitgraphlabel[efNR + 1] =
{ NULL, "lsq fit", "translational fit", "no fit" };
static int nrms = 1;
static gmx_bool bMassWeighted = TRUE;
t_pargs pa[] =
{
{ "-what", FALSE, etENUM,
{ what }, "Structural difference measure" },
{ "-pbc", FALSE, etBOOL,
{ &bPBC }, "PBC check" },
{ "-fit", FALSE, etENUM,
{ fit }, "Fit to reference structure" },
{ "-prev", FALSE, etINT,
{ &prev }, "Compare with previous frame" },
{ "-split", FALSE, etBOOL,
{ &bSplit }, "Split graph where time is zero" },
{ "-fitall", FALSE, etBOOL,
{ &bFitAll }, "HIDDENFit all pairs of structures in matrix" },
{ "-skip", FALSE, etINT,
{ &freq }, "Only write every nr-th frame to matrix" },
{ "-skip2", FALSE, etINT,
{ &freq2 }, "Only write every nr-th frame to matrix" },
{ "-max", FALSE, etREAL,
{ &rmsd_user_max }, "Maximum level in comparison matrix" },
{ "-min", FALSE, etREAL,
{ &rmsd_user_min }, "Minimum level in comparison matrix" },
{ "-bmax", FALSE, etREAL,
{ &bond_user_max }, "Maximum level in bond angle matrix" },
{ "-bmin", FALSE, etREAL,
{ &bond_user_min }, "Minimum level in bond angle matrix" },
{ "-mw", FALSE, etBOOL,
{ &bMassWeighted }, "Use mass weighting for superposition" },
{ "-nlevels", FALSE, etINT,
{ &nlevels }, "Number of levels in the matrices" },
{ "-ng", FALSE, etINT,
{ &nrms }, "Number of groups to compute RMS between" },
{ "-dlog", FALSE, etBOOL,
{ &bDeltaLog },
"HIDDENUse a log x-axis in the delta t matrix" },
{ "-dmax", FALSE, etREAL,
{ &delta_maxy }, "HIDDENMaximum level in delta matrix" },
{ "-aver", FALSE, etINT,
{ &avl },
"HIDDENAverage over this distance in the RMSD matrix" }
};
int natoms_trx, natoms_trx2, natoms;
int i, j, k, m, teller, teller2, tel_mat, tel_mat2;
#define NFRAME 5000
int maxframe = NFRAME, maxframe2 = NFRAME;
real t, *w_rls, *w_rms, *w_rls_m = NULL, *w_rms_m = NULL;
gmx_bool bNorm, bAv, bFreq2, bFile2, bMat, bBond, bDelta, bMirror, bMass;
gmx_bool bFit, bReset;
t_topology top;
int ePBC;
t_iatom *iatom = NULL;
matrix box;
rvec *x, *xp, *xm = NULL, **mat_x = NULL, **mat_x2, *mat_x2_j = NULL, vec1,
vec2;
t_trxstatus *status;
char buf[256], buf2[256];
int ncons = 0;
FILE *fp;
real rlstot = 0, **rls, **rlsm = NULL, *time, *time2, *rlsnorm = NULL,
**rmsd_mat = NULL, **bond_mat = NULL, *axis, *axis2, *del_xaxis,
*del_yaxis, rmsd_max, rmsd_min, rmsd_avg, bond_max, bond_min, ang;
real **rmsdav_mat = NULL, av_tot, weight, weight_tot;
real **delta = NULL, delta_max, delta_scalex = 0, delta_scaley = 0,
*delta_tot;
int delta_xsize = 0, del_lev = 100, mx, my, abs_my;
gmx_bool bA1, bA2, bPrev, bTop, *bInMat = NULL;
int ifit, *irms, ibond = 0, *ind_bond1 = NULL, *ind_bond2 = NULL, n_ind_m =
0;
atom_id *ind_fit, **ind_rms, *ind_m = NULL, *rev_ind_m = NULL, *ind_rms_m =
NULL;
char *gn_fit, **gn_rms;
t_rgb rlo, rhi;
output_env_t oenv;
gmx_rmpbc_t gpbc = NULL;
t_filenm fnm[] =
{
{ efTPS, NULL, NULL, ffREAD },
{ efTRX, "-f", NULL, ffREAD },
{ efTRX, "-f2", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, NULL, "rmsd", ffWRITE },
{ efXVG, "-mir", "rmsdmir", ffOPTWR },
{ efXVG, "-a", "avgrp", ffOPTWR },
{ efXVG, "-dist", "rmsd-dist", ffOPTWR },
{ efXPM, "-m", "rmsd", ffOPTWR },
{ efDAT, "-bin", "rmsd", ffOPTWR },
{ efXPM, "-bm", "bond", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_TIME_UNIT | PCA_CAN_VIEW
| PCA_BE_NICE, NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL,
&oenv))
{
return 0;
}
/* parse enumerated options: */
ewhat = nenum(what);
if (ewhat == ewRho || ewhat == ewRhoSc)
{
please_cite(stdout, "Maiorov95");
}
efit = nenum(fit);
bFit = efit == efFit;
bReset = efit == efReset;
if (bFit)
{
bReset = TRUE; /* for fit, reset *must* be set */
}
else
{
bFitAll = FALSE;
}
/* mark active cmdline options */
bMirror = opt2bSet("-mir", NFILE, fnm); /* calc RMSD vs mirror of ref. */
bFile2 = opt2bSet("-f2", NFILE, fnm);
bMat = opt2bSet("-m", NFILE, fnm);
bBond = opt2bSet("-bm", NFILE, fnm);
bDelta = (delta_maxy > 0); /* calculate rmsd vs delta t matrix from *
* your RMSD matrix (hidden option */
bNorm = opt2bSet("-a", NFILE, fnm);
bFreq2 = opt2parg_bSet("-skip2", asize(pa), pa);
if (freq <= 0)
{
fprintf(stderr, "The number of frames to skip is <= 0. "
"Writing out all frames.\n\n");
freq = 1;
}
if (!bFreq2)
{
freq2 = freq;
}
else if (bFile2 && freq2 <= 0)
{
fprintf(stderr,
"The number of frames to skip in second trajectory is <= 0.\n"
" Writing out all frames.\n\n");
freq2 = 1;
}
bPrev = (prev > 0);
if (bPrev)
{
prev = abs(prev);
if (freq != 1)
{
fprintf(stderr, "WARNING: option -skip also applies to -prev\n");
}
}
if (bFile2 && !bMat && !bBond)
{
fprintf(
stderr,
"WARNING: second trajectory (-f2) useless when not calculating matrix (-m/-bm),\n"
" will not read from %s\n", opt2fn("-f2", NFILE,
fnm));
bFile2 = FALSE;
}
if (bDelta)
{
bMat = TRUE;
if (bFile2)
{
fprintf(stderr,
"WARNING: second trajectory (-f2) useless when making delta matrix,\n"
" will not read from %s\n", opt2fn("-f2",
NFILE, fnm));
bFile2 = FALSE;
}
}
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm), buf, &top, &ePBC, &xp,
NULL, box, TRUE);
snew(w_rls, top.atoms.nr);
snew(w_rms, top.atoms.nr);
if (!bTop && bBond)
{
fprintf(stderr,
"WARNING: Need a run input file for bond angle matrix,\n"
" will not calculate bond angle matrix.\n");
bBond = FALSE;
}
if (bReset)
{
fprintf(stderr, "Select group for %s fit\n", bFit ? "least squares"
: "translational");
get_index(&(top.atoms), ftp2fn_null(efNDX, NFILE, fnm), 1, &ifit,
&ind_fit, &gn_fit);
}
else
{
ifit = 0;
}
if (bReset)
{
if (bFit && ifit < 3)
{
gmx_fatal(FARGS, "Need >= 3 points to fit!\n" );
}
bMass = FALSE;
for (i = 0; i < ifit; i++)
{
if (bMassWeighted)
{
w_rls[ind_fit[i]] = top.atoms.atom[ind_fit[i]].m;
}
else
{
w_rls[ind_fit[i]] = 1;
}
bMass = bMass || (top.atoms.atom[ind_fit[i]].m != 0);
}
if (!bMass)
{
fprintf(stderr, "All masses in the fit group are 0, using masses of 1\n");
for (i = 0; i < ifit; i++)
{
w_rls[ind_fit[i]] = 1;
}
}
}
if (bMat || bBond)
{
nrms = 1;
}
snew(gn_rms, nrms);
snew(ind_rms, nrms);
snew(irms, nrms);
fprintf(stderr, "Select group%s for %s calculation\n",
(nrms > 1) ? "s" : "", whatname[ewhat]);
get_index(&(top.atoms), ftp2fn_null(efNDX, NFILE, fnm),
nrms, irms, ind_rms, gn_rms);
if (bNorm)
{
snew(rlsnorm, irms[0]);
}
snew(rls, nrms);
for (j = 0; j < nrms; j++)
{
snew(rls[j], maxframe);
}
if (bMirror)
{
snew(rlsm, nrms);
for (j = 0; j < nrms; j++)
{
snew(rlsm[j], maxframe);
}
}
snew(time, maxframe);
for (j = 0; j < nrms; j++)
{
bMass = FALSE;
for (i = 0; i < irms[j]; i++)
{
if (bMassWeighted)
{
w_rms[ind_rms[j][i]] = top.atoms.atom[ind_rms[j][i]].m;
}
else
{
w_rms[ind_rms[j][i]] = 1.0;
}
bMass = bMass || (top.atoms.atom[ind_rms[j][i]].m != 0);
}
if (!bMass)
{
fprintf(stderr, "All masses in group %d are 0, using masses of 1\n", j);
for (i = 0; i < irms[j]; i++)
{
w_rms[ind_rms[j][i]] = 1;
}
}
}
/* Prepare reference frame */
if (bPBC)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr);
gmx_rmpbc(gpbc, top.atoms.nr, box, xp);
}
if (bReset)
{
reset_x(ifit, ind_fit, top.atoms.nr, NULL, xp, w_rls);
}
if (bMirror)
{
/* generate reference structure mirror image: */
snew(xm, top.atoms.nr);
for (i = 0; i < top.atoms.nr; i++)
{
copy_rvec(xp[i], xm[i]);
xm[i][XX] = -xm[i][XX];
}
}
if (ewhat == ewRhoSc)
{
norm_princ(&top.atoms, ifit, ind_fit, top.atoms.nr, xp);
}
/* read first frame */
natoms_trx = read_first_x(oenv, &status, opt2fn("-f", NFILE, fnm), &t, &x, box);
if (natoms_trx != top.atoms.nr)
{
fprintf(stderr,
"\nWARNING: topology has %d atoms, whereas trajectory has %d\n",
top.atoms.nr, natoms_trx);
}
natoms = min(top.atoms.nr, natoms_trx);
if (bMat || bBond || bPrev)
{
snew(mat_x, NFRAME);
if (bPrev)
{
/* With -prev we use all atoms for simplicity */
n_ind_m = natoms;
}
else
{
/* Check which atoms we need (fit/rms) */
snew(bInMat, natoms);
for (i = 0; i < ifit; i++)
{
bInMat[ind_fit[i]] = TRUE;
}
n_ind_m = ifit;
for (i = 0; i < irms[0]; i++)
{
if (!bInMat[ind_rms[0][i]])
{
bInMat[ind_rms[0][i]] = TRUE;
n_ind_m++;
}
}
}
/* Make an index of needed atoms */
snew(ind_m, n_ind_m);
snew(rev_ind_m, natoms);
j = 0;
for (i = 0; i < natoms; i++)
{
if (bPrev || bInMat[i])
{
ind_m[j] = i;
rev_ind_m[i] = j;
j++;
}
}
snew(w_rls_m, n_ind_m);
snew(ind_rms_m, irms[0]);
snew(w_rms_m, n_ind_m);
for (i = 0; i < ifit; i++)
{
w_rls_m[rev_ind_m[ind_fit[i]]] = w_rls[ind_fit[i]];
}
for (i = 0; i < irms[0]; i++)
{
ind_rms_m[i] = rev_ind_m[ind_rms[0][i]];
w_rms_m[ind_rms_m[i]] = w_rms[ind_rms[0][i]];
}
sfree(bInMat);
}
if (bBond)
{
ncons = 0;
for (k = 0; k < F_NRE; k++)
{
if (IS_CHEMBOND(k))
{
iatom = top.idef.il[k].iatoms;
ncons += top.idef.il[k].nr/3;
}
}
fprintf(stderr, "Found %d bonds in topology\n", ncons);
snew(ind_bond1, ncons);
snew(ind_bond2, ncons);
ibond = 0;
for (k = 0; k < F_NRE; k++)
{
if (IS_CHEMBOND(k))
{
iatom = top.idef.il[k].iatoms;
ncons = top.idef.il[k].nr/3;
for (i = 0; i < ncons; i++)
{
bA1 = FALSE;
bA2 = FALSE;
for (j = 0; j < irms[0]; j++)
{
if (iatom[3*i+1] == ind_rms[0][j])
{
bA1 = TRUE;
}
if (iatom[3*i+2] == ind_rms[0][j])
{
bA2 = TRUE;
}
}
if (bA1 && bA2)
{
ind_bond1[ibond] = rev_ind_m[iatom[3*i+1]];
ind_bond2[ibond] = rev_ind_m[iatom[3*i+2]];
ibond++;
}
}
}
}
fprintf(stderr, "Using %d bonds for bond angle matrix\n", ibond);
if (ibond == 0)
{
gmx_fatal(FARGS, "0 bonds found");
}
}
/* start looping over frames: */
tel_mat = 0;
teller = 0;
do
{
if (bPBC)
{
gmx_rmpbc(gpbc, natoms, box, x);
}
if (bReset)
{
reset_x(ifit, ind_fit, natoms, NULL, x, w_rls);
}
if (ewhat == ewRhoSc)
{
norm_princ(&top.atoms, ifit, ind_fit, natoms, x);
}
if (bFit)
{
/*do the least squares fit to original structure*/
do_fit(natoms, w_rls, xp, x);
}
if (teller % freq == 0)
{
/* keep frame for matrix calculation */
if (bMat || bBond || bPrev)
{
if (tel_mat >= NFRAME)
{
srenew(mat_x, tel_mat+1);
}
snew(mat_x[tel_mat], n_ind_m);
for (i = 0; i < n_ind_m; i++)
{
copy_rvec(x[ind_m[i]], mat_x[tel_mat][i]);
}
}
tel_mat++;
}
/*calculate energy of root_least_squares*/
if (bPrev)
{
j = tel_mat-prev-1;
if (j < 0)
{
j = 0;
}
for (i = 0; i < n_ind_m; i++)
{
copy_rvec(mat_x[j][i], xp[ind_m[i]]);
}
if (bReset)
{
reset_x(ifit, ind_fit, natoms, NULL, xp, w_rls);
}
if (bFit)
{
do_fit(natoms, w_rls, x, xp);
}
}
for (j = 0; (j < nrms); j++)
{
rls[j][teller] =
calc_similar_ind(ewhat != ewRMSD, irms[j], ind_rms[j], w_rms, x, xp);
}
if (bNorm)
{
for (j = 0; (j < irms[0]); j++)
{
rlsnorm[j] +=
calc_similar_ind(ewhat != ewRMSD, 1, &(ind_rms[0][j]), w_rms, x, xp);
}
}
if (bMirror)
{
if (bFit)
{
/*do the least squares fit to mirror of original structure*/
do_fit(natoms, w_rls, xm, x);
}
for (j = 0; j < nrms; j++)
{
rlsm[j][teller] =
calc_similar_ind(ewhat != ewRMSD, irms[j], ind_rms[j], w_rms, x, xm);
}
}
time[teller] = output_env_conv_time(oenv, t);
teller++;
if (teller >= maxframe)
{
maxframe += NFRAME;
srenew(time, maxframe);
for (j = 0; (j < nrms); j++)
{
srenew(rls[j], maxframe);
}
if (bMirror)
{
for (j = 0; (j < nrms); j++)
{
srenew(rlsm[j], maxframe);
}
}
}
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (bFile2)
{
snew(time2, maxframe2);
fprintf(stderr, "\nWill read second trajectory file\n");
snew(mat_x2, NFRAME);
natoms_trx2 =
read_first_x(oenv, &status, opt2fn("-f2", NFILE, fnm), &t, &x, box);
if (natoms_trx2 != natoms_trx)
{
gmx_fatal(FARGS,
"Second trajectory (%d atoms) does not match the first one"
" (%d atoms)", natoms_trx2, natoms_trx);
}
tel_mat2 = 0;
teller2 = 0;
do
{
if (bPBC)
{
gmx_rmpbc(gpbc, natoms, box, x);
}
if (bReset)
{
reset_x(ifit, ind_fit, natoms, NULL, x, w_rls);
}
if (ewhat == ewRhoSc)
{
norm_princ(&top.atoms, ifit, ind_fit, natoms, x);
}
if (bFit)
{
/*do the least squares fit to original structure*/
do_fit(natoms, w_rls, xp, x);
}
if (teller2 % freq2 == 0)
{
/* keep frame for matrix calculation */
if (bMat)
{
if (tel_mat2 >= NFRAME)
{
srenew(mat_x2, tel_mat2+1);
}
snew(mat_x2[tel_mat2], n_ind_m);
for (i = 0; i < n_ind_m; i++)
{
copy_rvec(x[ind_m[i]], mat_x2[tel_mat2][i]);
}
}
tel_mat2++;
}
time2[teller2] = output_env_conv_time(oenv, t);
teller2++;
if (teller2 >= maxframe2)
{
maxframe2 += NFRAME;
srenew(time2, maxframe2);
}
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
}
else
{
mat_x2 = mat_x;
time2 = time;
tel_mat2 = tel_mat;
freq2 = freq;
}
gmx_rmpbc_done(gpbc);
if (bMat || bBond)
{
/* calculate RMS matrix */
fprintf(stderr, "\n");
if (bMat)
{
fprintf(stderr, "Building %s matrix, %dx%d elements\n",
whatname[ewhat], tel_mat, tel_mat2);
snew(rmsd_mat, tel_mat);
}
if (bBond)
{
fprintf(stderr, "Building bond angle matrix, %dx%d elements\n",
tel_mat, tel_mat2);
snew(bond_mat, tel_mat);
}
snew(axis, tel_mat);
snew(axis2, tel_mat2);
rmsd_max = 0;
if (bFile2)
{
rmsd_min = 1e10;
}
else
{
rmsd_min = 0;
}
rmsd_avg = 0;
bond_max = 0;
bond_min = 1e10;
for (j = 0; j < tel_mat2; j++)
{
axis2[j] = time2[freq2*j];
}
if (bDelta)
{
if (bDeltaLog)
{
delta_scalex = 8.0/log(2.0);
delta_xsize = (int)(log(tel_mat/2)*delta_scalex+0.5)+1;
}
else
{
delta_xsize = tel_mat/2;
}
delta_scaley = 1.0/delta_maxy;
snew(delta, delta_xsize);
for (j = 0; j < delta_xsize; j++)
{
snew(delta[j], del_lev+1);
}
if (avl > 0)
{
snew(rmsdav_mat, tel_mat);
for (j = 0; j < tel_mat; j++)
{
snew(rmsdav_mat[j], tel_mat);
}
}
}
if (bFitAll)
{
snew(mat_x2_j, natoms);
}
for (i = 0; i < tel_mat; i++)
{
axis[i] = time[freq*i];
fprintf(stderr, "\r element %5d; time %5.2f ", i, axis[i]);
if (bMat)
{
snew(rmsd_mat[i], tel_mat2);
}
if (bBond)
{
snew(bond_mat[i], tel_mat2);
}
for (j = 0; j < tel_mat2; j++)
{
if (bFitAll)
{
for (k = 0; k < n_ind_m; k++)
{
copy_rvec(mat_x2[j][k], mat_x2_j[k]);
}
do_fit(n_ind_m, w_rls_m, mat_x[i], mat_x2_j);
}
else
{
mat_x2_j = mat_x2[j];
}
if (bMat)
{
if (bFile2 || (i < j))
{
rmsd_mat[i][j] =
calc_similar_ind(ewhat != ewRMSD, irms[0], ind_rms_m,
w_rms_m, mat_x[i], mat_x2_j);
if (rmsd_mat[i][j] > rmsd_max)
{
rmsd_max = rmsd_mat[i][j];
}
if (rmsd_mat[i][j] < rmsd_min)
{
rmsd_min = rmsd_mat[i][j];
}
rmsd_avg += rmsd_mat[i][j];
}
else
{
rmsd_mat[i][j] = rmsd_mat[j][i];
}
}
if (bBond)
{
if (bFile2 || (i <= j))
{
ang = 0.0;
for (m = 0; m < ibond; m++)
{
rvec_sub(mat_x[i][ind_bond1[m]], mat_x[i][ind_bond2[m]], vec1);
rvec_sub(mat_x2_j[ind_bond1[m]], mat_x2_j[ind_bond2[m]], vec2);
ang += acos(cos_angle(vec1, vec2));
}
bond_mat[i][j] = ang*180.0/(M_PI*ibond);
if (bond_mat[i][j] > bond_max)
{
bond_max = bond_mat[i][j];
}
if (bond_mat[i][j] < bond_min)
{
bond_min = bond_mat[i][j];
}
}
else
{
bond_mat[i][j] = bond_mat[j][i];
}
}
}
}
if (bFile2)
{
rmsd_avg /= tel_mat*tel_mat2;
}
else
{
rmsd_avg /= tel_mat*(tel_mat - 1)/2;
}
if (bMat && (avl > 0))
{
rmsd_max = 0.0;
rmsd_min = 0.0;
rmsd_avg = 0.0;
for (j = 0; j < tel_mat-1; j++)
{
for (i = j+1; i < tel_mat; i++)
{
av_tot = 0;
weight_tot = 0;
for (my = -avl; my <= avl; my++)
{
if ((j+my >= 0) && (j+my < tel_mat))
{
abs_my = abs(my);
for (mx = -avl; mx <= avl; mx++)
{
if ((i+mx >= 0) && (i+mx < tel_mat))
{
weight = (real)(avl+1-max(abs(mx), abs_my));
av_tot += weight*rmsd_mat[i+mx][j+my];
weight_tot += weight;
}
}
}
}
rmsdav_mat[i][j] = av_tot/weight_tot;
rmsdav_mat[j][i] = rmsdav_mat[i][j];
if (rmsdav_mat[i][j] > rmsd_max)
{
rmsd_max = rmsdav_mat[i][j];
}
}
}
rmsd_mat = rmsdav_mat;
}
if (bMat)
{
fprintf(stderr, "\n%s: Min %f, Max %f, Avg %f\n",
whatname[ewhat], rmsd_min, rmsd_max, rmsd_avg);
rlo.r = 1; rlo.g = 1; rlo.b = 1;
rhi.r = 0; rhi.g = 0; rhi.b = 0;
if (rmsd_user_max != -1)
{
rmsd_max = rmsd_user_max;
}
if (rmsd_user_min != -1)
{
rmsd_min = rmsd_user_min;
}
if ((rmsd_user_max != -1) || (rmsd_user_min != -1))
{
fprintf(stderr, "Min and Max value set to resp. %f and %f\n",
rmsd_min, rmsd_max);
}
sprintf(buf, "%s %s matrix", gn_rms[0], whatname[ewhat]);
write_xpm(opt2FILE("-m", NFILE, fnm, "w"), 0, buf, whatlabel[ewhat],
output_env_get_time_label(oenv), output_env_get_time_label(oenv), tel_mat, tel_mat2,
axis, axis2, rmsd_mat, rmsd_min, rmsd_max, rlo, rhi, &nlevels);
/* Print the distribution of RMSD values */
if (opt2bSet("-dist", NFILE, fnm))
{
low_rmsd_dist(opt2fn("-dist", NFILE, fnm), rmsd_max, tel_mat, rmsd_mat, oenv);
}
if (bDelta)
{
snew(delta_tot, delta_xsize);
for (j = 0; j < tel_mat-1; j++)
{
for (i = j+1; i < tel_mat; i++)
{
mx = i-j;
if (mx < tel_mat/2)
{
if (bDeltaLog)
{
mx = (int)(log(mx)*delta_scalex+0.5);
}
my = (int)(rmsd_mat[i][j]*delta_scaley*del_lev+0.5);
delta_tot[mx] += 1.0;
if ((rmsd_mat[i][j] >= 0) && (rmsd_mat[i][j] <= delta_maxy))
{
delta[mx][my] += 1.0;
}
}
}
}
delta_max = 0;
for (i = 0; i < delta_xsize; i++)
{
if (delta_tot[i] > 0.0)
{
delta_tot[i] = 1.0/delta_tot[i];
for (j = 0; j <= del_lev; j++)
{
delta[i][j] *= delta_tot[i];
if (delta[i][j] > delta_max)
{
delta_max = delta[i][j];
}
}
}
}
fprintf(stderr, "Maximum in delta matrix: %f\n", delta_max);
snew(del_xaxis, delta_xsize);
snew(del_yaxis, del_lev+1);
for (i = 0; i < delta_xsize; i++)
{
del_xaxis[i] = axis[i]-axis[0];
}
for (i = 0; i < del_lev+1; i++)
{
del_yaxis[i] = delta_maxy*i/del_lev;
}
sprintf(buf, "%s %s vs. delta t", gn_rms[0], whatname[ewhat]);
fp = gmx_ffopen("delta.xpm", "w");
write_xpm(fp, 0, buf, "density", output_env_get_time_label(oenv), whatlabel[ewhat],
delta_xsize, del_lev+1, del_xaxis, del_yaxis,
delta, 0.0, delta_max, rlo, rhi, &nlevels);
gmx_ffclose(fp);
}
if (opt2bSet("-bin", NFILE, fnm))
{
/* NB: File must be binary if we use fwrite */
fp = ftp2FILE(efDAT, NFILE, fnm, "wb");
for (i = 0; i < tel_mat; i++)
{
if (fwrite(rmsd_mat[i], sizeof(**rmsd_mat), tel_mat2, fp) != tel_mat2)
{
gmx_fatal(FARGS, "Error writing to output file");
}
}
gmx_ffclose(fp);
}
}
if (bBond)
{
fprintf(stderr, "\nMin. angle: %f, Max. angle: %f\n", bond_min, bond_max);
if (bond_user_max != -1)
{
bond_max = bond_user_max;
}
if (bond_user_min != -1)
{
bond_min = bond_user_min;
}
if ((bond_user_max != -1) || (bond_user_min != -1))
{
fprintf(stderr, "Bond angle Min and Max set to:\n"
"Min. angle: %f, Max. angle: %f\n", bond_min, bond_max);
}
rlo.r = 1; rlo.g = 1; rlo.b = 1;
rhi.r = 0; rhi.g = 0; rhi.b = 0;
sprintf(buf, "%s av. bond angle deviation", gn_rms[0]);
write_xpm(opt2FILE("-bm", NFILE, fnm, "w"), 0, buf, "degrees",
output_env_get_time_label(oenv), output_env_get_time_label(oenv), tel_mat, tel_mat2,
axis, axis2, bond_mat, bond_min, bond_max, rlo, rhi, &nlevels);
}
}
bAv = opt2bSet("-a", NFILE, fnm);
/* Write the RMSD's to file */
if (!bPrev)
{
sprintf(buf, "%s", whatxvgname[ewhat]);
}
else
{
sprintf(buf, "%s with frame %g %s ago", whatxvgname[ewhat],
time[prev*freq]-time[0], output_env_get_time_label(oenv));
}
fp = xvgropen(opt2fn("-o", NFILE, fnm), buf, output_env_get_xvgr_tlabel(oenv),
whatxvglabel[ewhat], oenv);
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"%s%s after %s%s%s\"\n",
(nrms == 1) ? "" : "of ", gn_rms[0], fitgraphlabel[efit],
bFit ? " to " : "", bFit ? gn_fit : "");
}
if (nrms != 1)
{
xvgr_legend(fp, nrms, (const char**)gn_rms, oenv);
}
for (i = 0; (i < teller); i++)
{
if (bSplit && i > 0 &&
abs(time[bPrev ? freq*i : i]/output_env_get_time_factor(oenv)) < 1e-5)
{
fprintf(fp, "&\n");
}
fprintf(fp, "%12.7f", time[bPrev ? freq*i : i]);
for (j = 0; (j < nrms); j++)
{
fprintf(fp, " %12.7f", rls[j][i]);
if (bAv)
{
rlstot += rls[j][i];
}
}
fprintf(fp, "\n");
}
gmx_ffclose(fp);
if (bMirror)
{
/* Write the mirror RMSD's to file */
sprintf(buf, "%s with Mirror", whatxvgname[ewhat]);
sprintf(buf2, "Mirror %s", whatxvglabel[ewhat]);
fp = xvgropen(opt2fn("-mir", NFILE, fnm), buf, output_env_get_xvgr_tlabel(oenv),
buf2, oenv);
if (nrms == 1)
{
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"of %s after lsq fit to mirror of %s\"\n",
gn_rms[0], gn_fit);
}
}
else
{
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"after lsq fit to mirror %s\"\n", gn_fit);
}
xvgr_legend(fp, nrms, (const char**)gn_rms, oenv);
}
for (i = 0; (i < teller); i++)
{
if (bSplit && i > 0 && abs(time[i]) < 1e-5)
{
fprintf(fp, "&\n");
}
fprintf(fp, "%12.7f", time[i]);
for (j = 0; (j < nrms); j++)
{
fprintf(fp, " %12.7f", rlsm[j][i]);
}
fprintf(fp, "\n");
}
gmx_ffclose(fp);
}
if (bAv)
{
sprintf(buf, "Average %s", whatxvgname[ewhat]);
sprintf(buf2, "Average %s", whatxvglabel[ewhat]);
fp = xvgropen(opt2fn("-a", NFILE, fnm), buf, "Residue", buf2, oenv);
for (j = 0; (j < nrms); j++)
{
fprintf(fp, "%10d %10g\n", j, rlstot/teller);
}
gmx_ffclose(fp);
}
if (bNorm)
{
fp = xvgropen("aver.xvg", gn_rms[0], "Residue", whatxvglabel[ewhat], oenv);
for (j = 0; (j < irms[0]); j++)
{
fprintf(fp, "%10d %10g\n", j, rlsnorm[j]/teller);
}
gmx_ffclose(fp);
}
do_view(oenv, opt2fn_null("-a", NFILE, fnm), "-graphtype bar");
do_view(oenv, opt2fn("-o", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-mir", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-m", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-bm", NFILE, fnm), NULL);
do_view(oenv, opt2fn_null("-dist", NFILE, fnm), NULL);
return 0;
}
int 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;
}
void analyse_ss(const char *outfile, t_matrix *mat, const char *ss_string,
const output_env_t oenv)
{
FILE *fp;
t_mapping *map;
int f, r, *count, *total, ss_count, total_count;
size_t s;
const char** leg;
map = mat->map;
snew(count, mat->nmap);
snew(total, mat->nmap);
snew(leg, mat->nmap+1);
leg[0] = "Structure";
for (s = 0; s < (size_t)mat->nmap; s++)
{
leg[s+1] = gmx_strdup(map[s].desc);
}
fp = xvgropen(outfile, "Secondary Structure",
output_env_get_xvgr_tlabel(oenv), "Number of Residues", oenv);
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(fp, "@ subtitle \"Structure = ");
}
for (s = 0; s < strlen(ss_string); s++)
{
if (s > 0)
{
fprintf(fp, " + ");
}
for (f = 0; f < mat->nmap; f++)
{
if (ss_string[s] == map[f].code.c1)
{
fprintf(fp, "%s", map[f].desc);
}
}
}
fprintf(fp, "\"\n");
xvgr_legend(fp, mat->nmap+1, leg, oenv);
total_count = 0;
for (s = 0; s < (size_t)mat->nmap; s++)
{
total[s] = 0;
}
for (f = 0; f < mat->nx; f++)
{
ss_count = 0;
for (s = 0; s < (size_t)mat->nmap; s++)
{
count[s] = 0;
}
for (r = 0; r < mat->ny; r++)
{
count[mat->matrix[f][r]]++;
total[mat->matrix[f][r]]++;
}
for (s = 0; s < (size_t)mat->nmap; s++)
{
if (strchr(ss_string, map[s].code.c1))
{
ss_count += count[s];
total_count += count[s];
}
}
fprintf(fp, "%8g %5d", mat->axis_x[f], ss_count);
for (s = 0; s < (size_t)mat->nmap; s++)
{
fprintf(fp, " %5d", count[s]);
}
fprintf(fp, "\n");
}
/* now print column totals */
fprintf(fp, "%-8s %5d", "# Totals", total_count);
for (s = 0; s < (size_t)mat->nmap; s++)
{
fprintf(fp, " %5d", total[s]);
}
fprintf(fp, "\n");
/* now print percentages */
fprintf(fp, "%-8s %5.2f", "# SS %", total_count / (real) (mat->nx * mat->ny));
for (s = 0; s < (size_t)mat->nmap; s++)
{
fprintf(fp, " %5.2f", total[s] / (real) (mat->nx * mat->ny));
}
fprintf(fp, "\n");
xvgrclose(fp);
sfree(leg);
sfree(count);
}
int gmx_current(int argc, char *argv[])
{
static int nshift = 1000;
static real temp = 300.0;
static real eps_rf = 0.0;
static gmx_bool bNoJump = TRUE;
static real bfit = 100.0;
static real bvit = 0.5;
static real efit = 400.0;
static real evit = 5.0;
t_pargs pa[] = {
{ "-sh", FALSE, etINT, {&nshift},
"Shift of the frames for averaging the correlation functions and the mean-square displacement."},
{ "-nojump", FALSE, etBOOL, {&bNoJump},
"Removes jumps of atoms across the box."},
{ "-eps", FALSE, etREAL, {&eps_rf},
"Dielectric constant of the surrounding medium. The value zero corresponds to infinity (tin-foil boundary conditions)."},
{ "-bfit", FALSE, etREAL, {&bfit},
"Begin of the fit of the straight line to the MSD of the translational fraction of the dipole moment."},
{ "-efit", FALSE, etREAL, {&efit},
"End of the fit of the straight line to the MSD of the translational fraction of the dipole moment."},
{ "-bvit", FALSE, etREAL, {&bvit},
"Begin of the fit of the current autocorrelation function to a*t^b."},
{ "-evit", FALSE, etREAL, {&evit},
"End of the fit of the current autocorrelation function to a*t^b."},
{ "-temp", FALSE, etREAL, {&temp},
"Temperature for calculating epsilon."}
};
gmx_output_env_t *oenv;
t_topology top;
char **grpname = NULL;
const char *indexfn;
t_trxframe fr;
real *mass2 = NULL;
matrix box;
int *index0;
int *indexm = NULL;
int isize;
t_trxstatus *status;
int flags = 0;
gmx_bool bACF;
gmx_bool bINT;
int ePBC = -1;
int nmols;
int i;
real *qmol;
FILE *outf = NULL;
FILE *mcor = NULL;
FILE *fmj = NULL;
FILE *fmd = NULL;
FILE *fmjdsp = NULL;
FILE *fcur = NULL;
t_filenm fnm[] = {
{ efTPS, NULL, NULL, ffREAD }, /* this is for the topology */
{ efNDX, NULL, NULL, ffOPTRD },
{ efTRX, "-f", NULL, ffREAD }, /* and this for the trajectory */
{ efXVG, "-o", "current", ffWRITE },
{ efXVG, "-caf", "caf", ffOPTWR },
{ efXVG, "-dsp", "dsp", ffWRITE },
{ efXVG, "-md", "md", ffWRITE },
{ efXVG, "-mj", "mj", ffWRITE },
{ efXVG, "-mc", "mc", ffOPTWR }
};
#define NFILE asize(fnm)
const char *desc[] = {
"[THISMODULE] is a tool for calculating the current autocorrelation function, the correlation",
"of the rotational and translational dipole moment of the system, and the resulting static",
"dielectric constant. To obtain a reasonable result, the index group has to be neutral.",
"Furthermore, the routine is capable of extracting the static conductivity from the current ",
"autocorrelation function, if velocities are given. Additionally, an Einstein-Helfand fit ",
"can be used to obtain the static conductivity."
"[PAR]",
"The flag [TT]-caf[tt] is for the output of the current autocorrelation function and [TT]-mc[tt] writes the",
"correlation of the rotational and translational part of the dipole moment in the corresponding",
"file. However, this option is only available for trajectories containing velocities.",
"Options [TT]-sh[tt] and [TT]-tr[tt] are responsible for the averaging and integration of the",
"autocorrelation functions. Since averaging proceeds by shifting the starting point",
"through the trajectory, the shift can be modified with [TT]-sh[tt] to enable the choice of uncorrelated",
"starting points. Towards the end, statistical inaccuracy grows and integrating the",
"correlation function only yields reliable values until a certain point, depending on",
"the number of frames. The option [TT]-tr[tt] controls the region of the integral taken into account",
"for calculating the static dielectric constant.",
"[PAR]",
"Option [TT]-temp[tt] sets the temperature required for the computation of the static dielectric constant.",
"[PAR]",
"Option [TT]-eps[tt] controls the dielectric constant of the surrounding medium for simulations using",
"a Reaction Field or dipole corrections of the Ewald summation ([TT]-eps[tt]\\=0 corresponds to",
"tin-foil boundary conditions).",
"[PAR]",
"[TT]-[no]nojump[tt] unfolds the coordinates to allow free diffusion. This is required to get a continuous",
"translational dipole moment, required for the Einstein-Helfand fit. The results from the fit allow",
"the determination of the dielectric constant for system of charged molecules. However, it is also possible to extract",
"the dielectric constant from the fluctuations of the total dipole moment in folded coordinates. But this",
"option has to be used with care, since only very short time spans fulfill the approximation that the density",
"of the molecules is approximately constant and the averages are already converged. To be on the safe side,",
"the dielectric constant should be calculated with the help of the Einstein-Helfand method for",
"the translational part of the dielectric constant."
};
/* At first the arguments will be parsed and the system information processed */
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_CAN_VIEW,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
bACF = opt2bSet("-caf", NFILE, fnm);
bINT = opt2bSet("-mc", NFILE, fnm);
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, NULL, NULL, box, TRUE);
indexfn = ftp2fn_null(efNDX, NFILE, fnm);
snew(grpname, 1);
get_index(&(top.atoms), indexfn, 1, &isize, &index0, grpname);
flags = flags | TRX_READ_X | TRX_READ_V;
read_first_frame(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &fr, flags);
snew(mass2, top.atoms.nr);
snew(qmol, top.atoms.nr);
precalc(top, mass2, qmol);
snew(indexm, isize);
for (i = 0; i < isize; i++)
{
indexm[i] = index0[i];
}
nmols = isize;
index_atom2mol(&nmols, indexm, &top.mols);
if (fr.bV)
{
if (bACF)
{
outf = xvgropen(opt2fn("-caf", NFILE, fnm),
"Current autocorrelation function", output_env_get_xvgr_tlabel(oenv),
"ACF (e nm/ps)\\S2", oenv);
fprintf(outf, "# time\t acf\t average \t std.dev\n");
}
fcur = xvgropen(opt2fn("-o", NFILE, fnm),
"Current", output_env_get_xvgr_tlabel(oenv), "J(t) (e nm/ps)", oenv);
fprintf(fcur, "# time\t Jx\t Jy \t J_z \n");
if (bINT)
{
mcor = xvgropen(opt2fn("-mc", NFILE, fnm),
"M\\sD\\N - current autocorrelation function",
output_env_get_xvgr_tlabel(oenv),
"< M\\sD\\N (0)\\c7\\CJ(t) > (e nm/ps)\\S2", oenv);
fprintf(mcor, "# time\t M_D(0) J(t) acf \t Integral acf\n");
}
}
fmj = xvgropen(opt2fn("-mj", NFILE, fnm),
"Averaged translational part of M", output_env_get_xvgr_tlabel(oenv),
"< M\\sJ\\N > (enm)", oenv);
fprintf(fmj, "# time\t x\t y \t z \t average of M_J^2 \t std.dev\n");
fmd = xvgropen(opt2fn("-md", NFILE, fnm),
"Averaged rotational part of M", output_env_get_xvgr_tlabel(oenv),
"< M\\sD\\N > (enm)", oenv);
fprintf(fmd, "# time\t x\t y \t z \t average of M_D^2 \t std.dev\n");
fmjdsp = xvgropen(opt2fn("-dsp", NFILE, fnm),
"MSD of the squared translational dipole moment M",
output_env_get_xvgr_tlabel(oenv),
"<|M\\sJ\\N(t)-M\\sJ\\N(0)|\\S2\\N > / 6.0*V*k\\sB\\N*T / Sm\\S-1\\Nps\\S-1\\N",
oenv);
/* System information is read and prepared, dielectric() processes the frames
* and calculates the requested quantities */
dielectric(fmj, fmd, outf, fcur, mcor, fmjdsp, bNoJump, bACF, bINT, ePBC, top, fr,
temp, bfit, efit, bvit, evit, status, isize, nmols, nshift,
index0, indexm, mass2, qmol, eps_rf, oenv);
xvgrclose(fmj);
xvgrclose(fmd);
xvgrclose(fmjdsp);
if (fr.bV)
{
if (bACF)
{
xvgrclose(outf);
}
xvgrclose(fcur);
if (bINT)
{
xvgrclose(mcor);
}
}
return 0;
}
int gmx_traj(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] 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 [REF].pdb[ref] file with",
"the average coordinates or the coordinates at [TT]-ctime[tt].",
"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 [REF].xvg[ref] 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 gmx_bool bMol = FALSE, bCom = FALSE, bPBC = TRUE, bNoJump = FALSE;
static gmx_bool bX = TRUE, bY = TRUE, bZ = TRUE, bNorm = FALSE, bFP = FALSE;
static int ngroups = 1;
static real ctime = -1, scale = 0, binwidth = 1;
t_pargs pa[] = {
{ "-com", FALSE, etBOOL, {&bCom},
"Plot data for the com of each group" },
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Make molecules whole for COM" },
{ "-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" },
{ "-fp", FALSE, etBOOL, {&bFP},
"Full precision output" },
{ "-bin", FALSE, etREAL, {&binwidth},
"Binwidth for velocity histogram (nm/ps)" },
{ "-ctime", FALSE, etREAL, {&ctime},
"Use frame at this time for x in [TT]-cv[tt] and [TT]-cf[tt] instead of the average x" },
{ "-scale", FALSE, etREAL, {&scale},
"Scale factor for [REF].pdb[ref] 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;
const char *indexfn;
t_trxframe fr, frout;
int flags, nvhisto = 0, *vhisto = NULL;
rvec *xtop, *xp = NULL;
rvec *sumx = NULL, *sumv = NULL, *sumf = NULL;
matrix topbox;
t_trxstatus *status;
t_trxstatus *status_out = NULL;
gmx_rmpbc_t gpbc = NULL;
int i, j;
int nr_xfr, nr_vfr, nr_ffr;
char **grpname;
int *isize0, *isize;
int **index0, **index;
int *atndx;
t_block *mols;
gmx_bool bTop, bOX, bOXT, bOV, bOF, bOB, bOT, bEKT, bEKR, bCV, bCF;
gmx_bool bDim[4], bDum[4], bVD;
char sffmt[STRLEN], sffmt6[STRLEN];
const char *box_leg[6] = { "XX", "YY", "ZZ", "YX", "ZX", "ZY" };
gmx_output_env_t *oenv;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-ox", "coord", ffOPTWR },
{ efTRX, "-oxt", "coord", ffOPTWR },
{ efXVG, "-ov", "veloc", ffOPTWR },
{ efXVG, "-of", "force", ffOPTWR },
{ efXVG, "-ob", "box", ffOPTWR },
{ efXVG, "-ot", "temp", ffOPTWR },
{ efXVG, "-ekt", "ektrans", ffOPTWR },
{ efXVG, "-ekr", "ekrot", ffOPTWR },
{ efXVG, "-vd", "veldist", ffOPTWR },
{ efPDB, "-cv", "veloc", ffOPTWR },
{ efPDB, "-cf", "force", ffOPTWR },
{ efXVG, "-av", "all_veloc", ffOPTWR },
{ efXVG, "-af", "all_force", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv,
PCA_CAN_TIME | PCA_TIME_UNIT | PCA_CAN_VIEW,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
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;
if (bFP)
{
sprintf(sffmt, "\t%s", gmx_real_fullprecision_pfmt);
}
else
{
sprintf(sffmt, "\t%%g");
}
sprintf(sffmt6, "%s%s%s%s%s%s", sffmt, sffmt, sffmt, sffmt, sffmt, sffmt);
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &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",
output_env_get_xvgr_tlabel(oenv), "Coordinate (nm)", oenv);
make_legend(outx, ngroups, isize0[0], index0[0], grpname, bCom, bMol, bDim, oenv);
}
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",
output_env_get_xvgr_tlabel(oenv), "Velocity (nm/ps)", oenv);
make_legend(outv, ngroups, isize0[0], index0[0], grpname, bCom, bMol, bDim, oenv);
}
if (bOF)
{
flags = flags | TRX_READ_F;
outf = xvgropen(opt2fn("-of", NFILE, fnm), "Force",
output_env_get_xvgr_tlabel(oenv), "Force (kJ mol\\S-1\\N nm\\S-1\\N)",
oenv);
make_legend(outf, ngroups, isize0[0], index0[0], grpname, bCom, bMol, bDim, oenv);
}
if (bOB)
{
outb = xvgropen(opt2fn("-ob", NFILE, fnm), "Box vector elements",
output_env_get_xvgr_tlabel(oenv), "(nm)", oenv);
xvgr_legend(outb, 6, box_leg, oenv);
}
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",
output_env_get_xvgr_tlabel(oenv), "(K)", oenv);
make_legend(outt, ngroups, isize[0], index[0], grpname, bCom, bMol, bDum, oenv);
}
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",
output_env_get_xvgr_tlabel(oenv), "Energy (kJ mol\\S-1\\N)", oenv);
make_legend(outekt, ngroups, isize[0], index[0], grpname, bCom, bMol, bDum, oenv);
}
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",
output_env_get_xvgr_tlabel(oenv), "Energy (kJ mol\\S-1\\N)", oenv);
make_legend(outekr, ngroups, isize[0], index[0], grpname, bCom, bMol, bDum, oenv);
}
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(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &fr, flags);
if ((bOV || bOF) && fn2ftp(ftp2fn(efTRX, NFILE, fnm)) == efXTC)
{
gmx_fatal(FARGS, "Cannot extract velocities or forces since your input XTC file does not contain them.");
}
if (bCV || bCF)
{
snew(sumx, fr.natoms);
}
if (bCV)
{
snew(sumv, fr.natoms);
}
if (bCF)
{
snew(sumf, fr.natoms);
}
nr_xfr = 0;
nr_vfr = 0;
nr_ffr = 0;
if (bCom && bPBC)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, fr.natoms);
}
do
{
time = output_env_conv_time(oenv, 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 && bPBC)
{
gmx_rmpbc_trxfr(gpbc, &fr);
}
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, sffmt);
}
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, sffmt);
}
if (bOF && fr.bF)
{
print_data(outf, time, fr.f, NULL, bCom, ngroups, isize, index, bDim, sffmt);
}
if (bOB && fr.bBox)
{
fprintf(outb, "\t%g", fr.time);
fprintf(outb, sffmt6,
fr.box[XX][XX], fr.box[YY][YY], fr.box[ZZ][ZZ],
fr.box[YY][XX], fr.box[ZZ][XX], fr.box[ZZ][YY]);
fprintf(outb, "\n");
}
if (bOT && fr.bV)
{
fprintf(outt, " %g", time);
for (i = 0; i < ngroups; i++)
{
fprintf(outt, sffmt, 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, sffmt, 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, sffmt, ekrot(fr.x, fr.v, mass, isize[i], index[i]));
}
fprintf(outekr, "\n");
}
if ((bCV || bCF) && fr.bX &&
(ctime < 0 || (fr.time >= ctime*0.999999 &&
fr.time <= ctime*1.000001)))
{
for (i = 0; i < fr.natoms; i++)
{
rvec_inc(sumx[i], fr.x[i]);
}
nr_xfr++;
}
if (bCV && fr.bV)
{
for (i = 0; i < fr.natoms; i++)
{
rvec_inc(sumv[i], fr.v[i]);
}
nr_vfr++;
}
if (bCF && fr.bF)
{
for (i = 0; i < fr.natoms; i++)
{
rvec_inc(sumf[i], fr.f[i]);
}
nr_ffr++;
}
}
while (read_next_frame(oenv, status, &fr));
if (gpbc != NULL)
{
gmx_rmpbc_done(gpbc);
}
/* clean up a bit */
close_trj(status);
if (bOX)
{
xvgrclose(outx);
}
if (bOXT)
{
close_trx(status_out);
}
if (bOV)
{
xvgrclose(outv);
}
if (bOF)
{
xvgrclose(outf);
}
if (bOB)
{
xvgrclose(outb);
}
if (bOT)
{
xvgrclose(outt);
}
if (bEKT)
{
xvgrclose(outekt);
}
if (bEKR)
{
xvgrclose(outekr);
}
if (bVD)
{
print_histo(opt2fn("-vd", NFILE, fnm), nvhisto, vhisto, binwidth, oenv);
}
if (bCV || bCF)
{
if (nr_xfr > 1)
{
if (ePBC != epbcNONE && !bNoJump)
{
fprintf(stderr, "\nWARNING: More than one frame was used for option -cv or -cf\n"
"If atoms jump across the box you should use the -nojump or -ctime option\n\n");
}
for (i = 0; i < isize[0]; i++)
{
svmul(1.0/nr_xfr, sumx[index[0][i]], sumx[index[0][i]]);
}
}
else if (nr_xfr == 0)
{
fprintf(stderr, "\nWARNING: No coordinate frames found for option -cv or -cf\n\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, sumx,
nr_vfr, sumv, bDim, scale, oenv);
}
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, sumx,
nr_ffr, sumf, bDim, scale, oenv);
}
/* view it */
view_all(oenv, NFILE, fnm);
return 0;
}
int gmx_principal(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] calculates the three principal axes of inertia for a group",
"of atoms. NOTE: Old versions of GROMACS wrote the output data in a",
"strange transposed way. As of GROMACS 5.0, the output file paxis1.dat",
"contains the x/y/z components of the first (major) principal axis for",
"each frame, and similarly for the middle and minor axes in paxis2.dat",
"and paxis3.dat."
};
static gmx_bool foo = FALSE;
t_pargs pa[] = {
{ "-foo", FALSE, etBOOL, {&foo}, "Dummy option to avoid empty array" }
};
t_trxstatus *status;
t_topology top;
int ePBC;
real t;
rvec * x;
int natoms;
char *grpname;
int i, gnx;
atom_id *index;
rvec moi;
FILE * axis1;
FILE * axis2;
FILE * axis3;
FILE * fmoi;
matrix axes, box;
output_env_t oenv;
gmx_rmpbc_t gpbc = NULL;
char ** legend;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-a1", "paxis1", ffWRITE },
{ efXVG, "-a2", "paxis2", ffWRITE },
{ efXVG, "-a3", "paxis3", ffWRITE },
{ efXVG, "-om", "moi", ffWRITE }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv,
PCA_CAN_TIME | PCA_TIME_UNIT | PCA_CAN_VIEW,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
snew(legend, DIM);
for (i = 0; i < DIM; i++)
{
snew(legend[i], STRLEN);
sprintf(legend[i], "%c component", 'X'+i);
}
axis1 = xvgropen(opt2fn("-a1", NFILE, fnm), "Principal axis 1 (major axis)",
output_env_get_xvgr_tlabel(oenv), "Component (nm)", oenv);
xvgr_legend(axis1, DIM, (const char **)legend, oenv);
axis2 = xvgropen(opt2fn("-a2", NFILE, fnm), "Principal axis 2 (middle axis)",
output_env_get_xvgr_tlabel(oenv), "Component (nm)", oenv);
xvgr_legend(axis2, DIM, (const char **)legend, oenv);
axis3 = xvgropen(opt2fn("-a3", NFILE, fnm), "Principal axis 3 (minor axis)",
output_env_get_xvgr_tlabel(oenv), "Component (nm)", oenv);
xvgr_legend(axis3, DIM, (const char **)legend, oenv);
sprintf(legend[XX], "Axis 1 (major)");
sprintf(legend[YY], "Axis 2 (middle)");
sprintf(legend[ZZ], "Axis 3 (minor)");
fmoi = xvgropen(opt2fn("-om", NFILE, fnm), "Moments of inertia around inertial axes",
output_env_get_xvgr_tlabel(oenv), "I (au nm\\S2\\N)", oenv);
xvgr_legend(fmoi, DIM, (const char **)legend, oenv);
for (i = 0; i < DIM; i++)
{
sfree(legend[i]);
}
sfree(legend);
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, NULL, NULL, box, TRUE);
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &gnx, &index, &grpname);
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
do
{
gmx_rmpbc(gpbc, natoms, box, 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[XX][YY], axes[XX][ZZ]);
fprintf(axis2, "%15.10f %15.10f %15.10f %15.10f\n", t, axes[YY][XX], axes[YY][YY], axes[YY][ZZ]);
fprintf(axis3, "%15.10f %15.10f %15.10f %15.10f\n", t, axes[ZZ][XX], axes[ZZ][YY], 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(oenv, status, &t, x, box));
gmx_rmpbc_done(gpbc);
close_trj(status);
xvgrclose(axis1);
xvgrclose(axis2);
xvgrclose(axis3);
xvgrclose(fmoi);
return 0;
}
