static void print_histo(char *fn,int nhisto,int histo[],real binwidth)
{
FILE *fp;
int i;
fp = xvgropen(fn,"Velocity distribution","V (nm/ps)","arbitrary units");
for(i=0; (i<nhisto); i++)
fprintf(fp,"%10.3e %10d\n",i*binwidth,histo[i]);
fclose(fp);
}
void plot_potential(double *potential[], double *charge[], double *field[],
const char *afile, const char *bfile, const char *cfile,
int nslices, int nr_grps, const char *grpname[], double slWidth,
const output_env_t oenv)
{
FILE *pot, /* xvgr file with potential */
*cha, /* xvgr file with charges */
*fie; /* xvgr files with fields */
char buf[256]; /* for xvgr title */
int slice, n;
sprintf(buf, "Electrostatic Potential");
pot = xvgropen(afile, buf, "Box (nm)", "Potential (V)", oenv);
xvgr_legend(pot, nr_grps, grpname, oenv);
sprintf(buf, "Charge Distribution");
cha = xvgropen(bfile, buf, "Box (nm)", "Charge density (q/nm\\S3\\N)", oenv);
xvgr_legend(cha, nr_grps, grpname, oenv);
sprintf(buf, "Electric Field");
fie = xvgropen(cfile, buf, "Box (nm)", "Field (V/nm)", oenv);
xvgr_legend(fie, nr_grps, grpname, oenv);
for (slice = cb; slice < (nslices - ce); slice++)
{
fprintf(pot, "%20.16g ", slice * slWidth);
fprintf(cha, "%20.16g ", slice * slWidth);
fprintf(fie, "%20.16g ", slice * slWidth);
for (n = 0; n < nr_grps; n++)
{
fprintf(pot, " %20.16g", potential[n][slice]);
fprintf(fie, " %20.16g", field[n][slice]/1e9); /* convert to V/nm */
fprintf(cha, " %20.16g", charge[n][slice]);
}
fprintf(pot, "\n");
fprintf(cha, "\n");
fprintf(fie, "\n");
}
xvgrclose(pot);
xvgrclose(cha);
xvgrclose(fie);
}
static void do_geminate(const char *gemFile, int nData,
real *t, real **val, int nSet,
const real D, const real rcut, const real balTime,
const int nFitPoints, const real begFit, const real endFit,
const output_env_t oenv)
{
double **ctd = NULL, **ctdGem = NULL, *td = NULL;
t_gemParams *GP = init_gemParams(rcut, D, t, nData, nFitPoints,
begFit, endFit, balTime, 1);
const char *leg[] = {"Ac\\sgem\\N(t)"};
FILE *fp;
int i, set;
snew(ctd, nSet);
snew(ctdGem, nSet);
snew(td, nData);
fp = xvgropen(gemFile, "Hydrogen Bond Autocorrelation", "Time (ps)", "C'(t)", oenv);
xvgr_legend(fp, asize(leg), leg, oenv);
for (set = 0; set < nSet; set++)
{
snew(ctd[set], nData);
snew(ctdGem[set], nData);
for (i = 0; i < nData; i++)
{
ctd[set][i] = (double)val[set][i];
if (set == 0)
{
td[i] = (double)t[i];
}
}
fitGemRecomb(ctd[set], td, &(ctd[set]), nData, GP);
}
for (i = 0; i < nData; i++)
{
fprintf(fp, " %g", t[i]);
for (set = 0; set < nSet; set++)
{
fprintf(fp, " %g", ctdGem[set][i]);
}
fprintf(fp, "\n");
}
for (set = 0; set < nSet; set++)
{
sfree(ctd[set]);
sfree(ctdGem[set]);
}
sfree(ctd);
sfree(ctdGem);
sfree(td);
xvgrclose(fp);
}
static void calc_spectrum(int n, real c[], real dt, const char *fn,
gmx_output_env_t *oenv, gmx_bool bRecip)
{
FILE *fp;
gmx_fft_t fft;
int i, status;
real *data;
real nu, omega, recip_fac;
snew(data, n*2);
for (i = 0; (i < n); i++)
{
data[i] = c[i];
}
if ((status = gmx_fft_init_1d_real(&fft, n, GMX_FFT_FLAG_NONE)) != 0)
{
gmx_fatal(FARGS, "Invalid fft return status %d", status);
}
if ((status = gmx_fft_1d_real(fft, GMX_FFT_REAL_TO_COMPLEX, data, data)) != 0)
{
gmx_fatal(FARGS, "Invalid fft return status %d", status);
}
fp = xvgropen(fn, "Vibrational Power Spectrum",
bRecip ? "\\f{12}w\\f{4} (cm\\S-1\\N)" :
"\\f{12}n\\f{4} (ps\\S-1\\N)",
"a.u.", oenv);
/* This is difficult.
* The length of the ACF is dt (as passed to this routine).
* We pass the vacf with N time steps from 0 to dt.
* That means that after FFT we have lowest frequency = 1/dt
* then 1/(2 dt) etc. (this is the X-axis of the data after FFT).
* To convert to 1/cm we need to have to realize that
* E = hbar w = h nu = h c/lambda. We want to have reciprokal cm
* on the x-axis, that is 1/lambda, so we then have
* 1/lambda = nu/c. Since nu has units of 1/ps and c has gromacs units
* of nm/ps, we need to multiply by 1e7.
* The timestep between saving the trajectory is
* 1e7 is to convert nanometer to cm
*/
recip_fac = bRecip ? (1e7/SPEED_OF_LIGHT) : 1.0;
for (i = 0; (i < n); i += 2)
{
nu = i/(2*dt);
omega = nu*recip_fac;
/* Computing the square magnitude of a complex number, since this is a power
* spectrum.
*/
fprintf(fp, "%10g %10g\n", omega, gmx::square(data[i])+gmx::square(data[i+1]));
}
xvgrclose(fp);
gmx_fft_destroy(fft);
sfree(data);
}
void dump_ana_struct(char *rmax,char *nion,char *gyr_com,char *gyr_origin,
t_ana_struct *anal,int nsim)
{
FILE *fp,*gp,*hp,*kp;
int i,j;
real t,d2;
char *legend[] = { "Rg", "RgX", "RgY", "RgZ" };
fp = xvgropen(rmax,"rmax","Time (fs)","r (nm)");
gp = xvgropen(nion,"N ion","Time (fs)","N ions");
hp = xvgropen(gyr_com,"Radius of gyration wrt. C.O.M.",
"Time (fs)","Rg (nm)");
xvgr_legend(hp,asize(legend),legend);
kp = xvgropen(gyr_origin,"Radius of gyration wrt. Origin",
"Time (fs)","Rg (nm)");
xvgr_legend(kp,asize(legend),legend);
for(i=0; (i<anal->index); i++) {
t = 1000*anal->t[i];
fprintf(fp,"%12g %10.3f\n",t,anal->maxdist[i]);
fprintf(gp,"%12g %10.3f\n",t,(1.0*anal->nion[i])/nsim-1);
d2 = anal->d2_com[i][XX] + anal->d2_com[i][YY] + anal->d2_com[i][ZZ];
fprintf(hp,"%12g %10.3f %10.3f %10.3f %10.3f\n",
t,sqrt(d2/nsim),
sqrt(anal->d2_com[i][XX]/nsim),
sqrt(anal->d2_com[i][YY]/nsim),
sqrt(anal->d2_com[i][ZZ]/nsim));
d2 = anal->d2_origin[i][XX] + anal->d2_origin[i][YY] + anal->d2_origin[i][ZZ];
fprintf(kp,"%12g %10.3f %10.3f %10.3f %10.3f\n",
t,sqrt(d2/nsim),
sqrt(anal->d2_origin[i][XX]/nsim),
sqrt(anal->d2_origin[i][YY]/nsim),
sqrt(anal->d2_origin[i][ZZ]/nsim));
}
ffclose(hp);
ffclose(gp);
ffclose(fp);
ffclose(kp);
}
void plot_spectrum(char *noefn,int npair,t_pair pair[],t_sij *spec,real taum)
{
FILE *fp,*out;
int i,j,m;
t_rgb rlo = { 1,0,0 },rhi = {1,1,1};
real Sijmax,Sijmin,pow6,pow3,pp3,pp6,ppy,tauc;
real *Sij;
complex sij;
snew(Sij,npair);
Sijmax = -1000.0;
Sijmin = 1000.0;
fp=xvgropen(noefn,"Cross Relaxation","Pair Index","\\8s\\4\\sij\\N");
for(i=0; (i<npair); i++) {
tauc = spec[i].tauc;
sij.re = -0.4*((taum-tauc)*spec[i].y2.re + tauc*spec[i].rij_6);
sij.im = -0.4* (taum-tauc)*spec[i].y2.im;
Sij[i]=sij.re;
Sijmax=max(Sijmax,sij.re);
Sijmin=min(Sijmin,sij.re);
fprintf(fp,"%5d %10g\n",i,sij.re);
}
fclose(fp);
fprintf(stderr,"Sijmin: %g, Sijmax: %g\n",Sijmin,Sijmax);
out=ffopen("spec.out","w");
pow6 = -1.0/6.0;
pow3 = -1.0/3.0;
fprintf(out,"%5s %5s %8s %8s %8s %8s %8s %8s %8s %8s %8s\n",
"at i","at j","S^2","Sig S^2","tauc","Sig tauc",
"<rij6>","<rij3>","<ylm>","rij3-6","ylm-rij6");
for(i=0; (i<npair); i++) {
if (spec[i].bNOE) {
pp6 = pow(spec[i].rij_6,pow6);
pp3 = pow(spec[i].rij_3,pow3);
if (spec[i].y2.re < 0)
ppy = -pow(-spec[i].y2.re,pow6);
else
ppy = pow(spec[i].y2.re,pow6);
fprintf(out,"%5d %5d %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f\n",
pair[i].ai,pair[i].aj,
spec[i].S2,spec[i].dS2,spec[i].tauc,spec[i].dtauc,
pp6,pp3,ppy,pp3-pp6,ppy-pp6);
}
}
fclose(out);
sfree(Sij);
do_view(noefn,NULL);
}
static void ana_trans(t_clusters *clust, int nf,
char *transfn, char *ntransfn, FILE *log,
t_rgb rlo,t_rgb rhi)
{
FILE *fp;
real **trans,*axis;
int *ntrans;
int i,ntranst,maxtrans;
char buf[STRLEN];
snew(ntrans,clust->ncl);
snew(trans,clust->ncl);
snew(axis,clust->ncl);
for(i=0; i<clust->ncl; i++) {
axis[i]=i+1;
snew(trans[i],clust->ncl);
}
ntranst=0;
maxtrans=0;
for(i=1; i<nf; i++)
if(clust->cl[i] != clust->cl[i-1]) {
ntranst++;
ntrans[clust->cl[i-1]-1]++;
ntrans[clust->cl[i]-1]++;
trans[clust->cl[i-1]-1][clust->cl[i]-1]++;
maxtrans = max(maxtrans, trans[clust->cl[i]-1][clust->cl[i-1]-1]);
}
ffprintf2(stderr,log,buf,"Counted %d transitions in total, "
"max %d between two specific clusters\n",ntranst,maxtrans);
if (transfn) {
fp=ffopen(transfn,"w");
i = min(maxtrans+1, 80);
write_xpm(fp,0,"Cluster Transitions","# transitions",
"from cluster","to cluster",
clust->ncl, clust->ncl, axis, axis, trans,
0, maxtrans, rlo, rhi, &i);
ffclose(fp);
}
if (ntransfn) {
fp=xvgropen(ntransfn,"Cluster Transitions","Cluster #","# transitions");
for(i=0; i<clust->ncl; i++)
fprintf(fp,"%5d %5d\n",i+1,ntrans[i]);
ffclose(fp);
}
sfree(ntrans);
for(i=0; i<clust->ncl; i++)
sfree(trans[i]);
sfree(trans);
sfree(axis);
}
void correlate_aniso(char *fn,t_atoms *ref,t_atoms *calc)
{
FILE *fp;
int i,j;
fp = xvgropen(fn,"Correlation between X-Ray and Computed Uij","X-Ray","Computed");
for(i=0; (i<ref->nr); i++) {
if (ref->pdbinfo[i].bAnisotropic) {
for(j=U11; (j<=U23); j++)
fprintf(fp,"%10d %10d\n",ref->pdbinfo[i].uij[j],calc->pdbinfo[i].uij[j]);
}
}
fclose(fp);
}
static void print_histo(const char *fn, int nhisto, int histo[], real binwidth,
const gmx_output_env_t *oenv)
{
FILE *fp;
int i;
fp = xvgropen(fn, "Velocity distribution", "V (nm/ps)", "arbitrary units",
oenv);
for (i = 0; (i < nhisto); i++)
{
fprintf(fp, "%10.3e %10d\n", i*binwidth, histo[i]);
}
xvgrclose(fp);
}
extern void save_data (structure_factor_t *sft, const char *file, int ngrps,
real start_q, real end_q, const output_env_t oenv)
{
FILE *fp;
int i, g = 0;
double *tmp, polarization_factor, A;
structure_factor *sf = (structure_factor *)sft;
fp = xvgropen (file, "Scattering Intensity", "q (1/nm)",
"Intensity (a.u.)", oenv);
snew (tmp, ngrps);
for (g = 0; g < ngrps; g++)
{
for (i = 0; i < sf->n_angles; i++)
{
/*
* theta is half the angle between incoming and scattered vectors.
*
* polar. fact. = 0.5*(1+cos^2(2*theta)) = 1 - 0.5 * sin^2(2*theta)
*
* sin(theta) = q/(2k) := A -> sin^2(theta) = 4*A^2 (1-A^2) ->
* -> 0.5*(1+cos^2(2*theta)) = 1 - 2 A^2 (1-A^2)
*/
A = (double) (i * sf->ref_k) / (2.0 * sf->momentum);
polarization_factor = 1 - 2.0 * sqr (A) * (1 - sqr (A));
sf->F[g][i] *= polarization_factor;
}
}
for (i = 0; i < sf->n_angles; i++)
{
if (i * sf->ref_k >= start_q && i * sf->ref_k <= end_q)
{
fprintf (fp, "%10.5f ", i * sf->ref_k);
for (g = 0; g < ngrps; g++)
{
fprintf (fp, " %10.5f ", (sf->F[g][i]) /( sf->total_n_atoms*
sf->nSteps));
}
fprintf (fp, "\n");
}
}
ffclose (fp);
}
int gmx_rama(int argc,char *argv[])
{
const char *desc[] = {
"[TT]g_rama[tt] selects the [GRK]phi[grk]/[GRK]psi[grk] dihedral combinations from your topology file",
"and computes these as a function of time.",
"Using simple Unix tools such as [IT]grep[it] you can select out",
"specific residues."
};
FILE *out;
t_xrama *xr;
int j;
output_env_t oenv;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPX, NULL, NULL, ffREAD },
{ efXVG, NULL, "rama",ffWRITE }
};
#define NFILE asize(fnm)
parse_common_args(&argc,argv,PCA_CAN_VIEW | PCA_CAN_TIME | PCA_BE_NICE,
NFILE,fnm,0,NULL,asize(desc),desc,0,NULL,&oenv);
snew(xr,1);
init_rama(oenv,ftp2fn(efTRX,NFILE,fnm),ftp2fn(efTPX,NFILE,fnm),xr,3);
out=xvgropen(ftp2fn(efXVG,NFILE,fnm),"Ramachandran Plot","Phi","Psi",oenv);
xvgr_line_props(out,0,elNone,ecFrank,oenv);
xvgr_view(out,0.2,0.2,0.8,0.8,oenv);
xvgr_world(out,-180,-180,180,180,oenv);
fprintf(out,"@ xaxis tick on\n@ xaxis tick major 60\n@ xaxis tick minor 30\n");
fprintf(out,"@ yaxis tick on\n@ yaxis tick major 60\n@ yaxis tick minor 30\n");
fprintf(out,"@ s0 symbol 2\n@ s0 symbol size 0.4\n@ s0 symbol fill 1\n");
j=0;
do {
plot_rama(out,xr);
j++;
} while (new_data(xr));
fprintf(stderr,"\n");
ffclose(out);
do_view(oenv,ftp2fn(efXVG,NFILE,fnm),NULL);
thanx(stderr);
return 0;
}
static void analyse_em_all(int npdb,t_pdbfile *pdbf[],
char *edocked,char *efree)
{
FILE *fp;
int i;
for(bFreeSort = FALSE; (bFreeSort <= TRUE); bFreeSort++) {
qsort(pdbf,npdb,sizeof(pdbf[0]),pdbf_comp);
fp = xvgropen(bFreeSort ? efree : edocked,
etitles[bFreeSort],"()","E (kJ/mol)");
for(i=0; (i<npdb); i++)
fprintf(fp,"%12lf\n",bFreeSort ? pdbf[i]->efree : pdbf[i]->edocked);
fclose(fp);
}
}
void print_one(const char *base,const char *name,const char *title,
const char *ylabel,int nf,real time[],real data[])
{
FILE *fp;
char buf[256],t2[256];
int k;
sprintf(buf,"%s%s.xvg",base,name);
fprintf(stderr,"\rPrinting %s ",buf);
sprintf(t2,"%s %s",title,name);
fp=xvgropen(buf,t2,"Time (ps)",ylabel);
for(k=0; (k<nf); k++)
fprintf(fp,"%10g %10g\n",time[k],data[k]);
ffclose(fp);
}
static void ehisto(const char *fh,int n,real **enerT, const output_env_t oenv)
{
FILE *fp;
int i,j,k,nbin,blength;
int *bindex;
real *T,bmin,bmax,bwidth;
int **histo;
bmin = 1e8;
bmax = -1e8;
snew(bindex,n);
snew(T,n);
nbin = 0;
for(j=1; (j<n); j++) {
for(k=0; (k<nbin); k++) {
if (T[k] == enerT[1][j]) {
bindex[j] = k;
break;
}
}
if (k == nbin) {
bindex[j] = nbin;
T[nbin] = enerT[1][j];
nbin++;
}
bmin = min(enerT[0][j],bmin);
bmax = max(enerT[0][j],bmax);
}
bwidth = 1.0;
blength = (bmax - bmin)/bwidth + 2;
snew(histo,nbin);
for(i=0; (i<nbin); i++) {
snew(histo[i],blength);
}
for(j=0; (j<n); j++) {
k = (enerT[0][j]-bmin)/bwidth;
histo[bindex[j]][k]++;
}
fp = xvgropen(fh,"Energy distribution","E (kJ/mol)","",oenv);
for(j=0; (j<blength); j++) {
fprintf(fp,"%8.3f",bmin+j*bwidth);
for(k=0; (k<nbin); k++) {
fprintf(fp," %6d",histo[k][j]);
}
fprintf(fp,"\n");
}
ffclose(fp);
}
void analyse_ss(char *outfile, t_matrix *mat, char *ss_string)
{
FILE *fp;
t_mapping *map;
int s,f,r,*count,ss_count;
char **leg;
map=mat->map;
snew(count,mat->nmap);
snew(leg,mat->nmap+1);
leg[0]="Structure";
for(s=0; s<mat->nmap; s++)
leg[s+1]=map[s].desc;
fp=xvgropen(outfile,"Secondary Structure",
xvgr_tlabel(),"Number of Residues");
if (bPrintXvgrCodes())
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);
for(f=0; f<mat->nx; f++) {
ss_count=0;
for(s=0; s<mat->nmap; s++)
count[s]=0;
for(r=0; r<mat->ny; r++)
count[mat->matrix[f][r]]++;
for(s=0; s<mat->nmap; s++) {
if (strchr(ss_string,map[s].code.c1))
ss_count+=count[s];
}
fprintf(fp,"%8g %5d",mat->axis_x[f],ss_count);
for(s=0; s<mat->nmap; s++)
fprintf(fp," %5d",count[s]);
fprintf(fp,"\n");
}
fclose(fp);
sfree(leg);
sfree(count);
}
void write_xvg(char *fn,char *title,int nx,int ny,real **y,char **leg)
{
FILE *fp;
int i,j;
fp=xvgropen(fn,title,"X","Y");
if (leg)
xvgr_legend(fp,ny-1,leg);
for(i=0; (i<nx); i++) {
for(j=0; (j<ny); j++) {
fprintf(fp," %12.5e",y[j][i]);
}
fprintf(fp,"\n");
}
fclose(fp);
}
void
AbstractPlotModule::dataStarted(AbstractAnalysisData * /* data */)
{
if (!impl_->filename_.empty())
{
if (impl_->bPlain_)
{
impl_->fp_ = gmx_fio_fopen(impl_->filename_.c_str(), "w");
}
else
{
time_unit_t time_unit
= static_cast<time_unit_t>(impl_->settings_.timeUnit() + 1);
xvg_format_t xvg_format
= (impl_->settings_.plotFormat() > 0
? static_cast<xvg_format_t>(impl_->settings_.plotFormat())
: exvgNONE);
output_env_t oenv;
output_env_init(&oenv, getProgramContext(), time_unit, FALSE, xvg_format, 0);
boost::shared_ptr<output_env> oenvGuard(oenv, &output_env_done);
impl_->fp_ = xvgropen(impl_->filename_.c_str(), impl_->title_.c_str(),
impl_->xlabel_.c_str(), impl_->ylabel_.c_str(),
oenv);
const SelectionCollection *selections
= impl_->settings_.selectionCollection();
if (selections != NULL)
{
selections->printXvgrInfo(impl_->fp_, oenv);
}
if (!impl_->subtitle_.empty())
{
xvgr_subtitle(impl_->fp_, impl_->subtitle_.c_str(), oenv);
}
if (output_env_get_print_xvgr_codes(oenv)
&& !impl_->legend_.empty())
{
std::vector<const char *> legend;
legend.reserve(impl_->legend_.size());
for (size_t i = 0; i < impl_->legend_.size(); ++i)
{
legend.push_back(impl_->legend_[i].c_str());
}
xvgr_legend(impl_->fp_, legend.size(), &legend[0], oenv);
}
}
}
}
static void print_transitions(const char *fn,int maxchi,int nlist,
t_dlist dlist[], t_atoms *atoms,rvec x[],
matrix box, gmx_bool bPhi,gmx_bool bPsi,gmx_bool bChi,real dt,
const output_env_t oenv)
{
/* based on order_params below */
FILE *fp;
int nh[edMax];
int i,Dih,Xi;
/* must correspond with enum in pp2shift.h:38 */
char *leg[edMax];
#define NLEG asize(leg)
leg[0] = strdup("Phi");
leg[1] = strdup("Psi");
leg[2] = strdup("Omega");
leg[3] = strdup("Chi1");
leg[4] = strdup("Chi2");
leg[5] = strdup("Chi3");
leg[6] = strdup("Chi4");
leg[7] = strdup("Chi5");
leg[8] = strdup("Chi6");
/* Print order parameters */
fp=xvgropen(fn,"Dihedral Rotamer Transitions","Residue","Transitions/ns",
oenv);
xvgr_legend(fp,NONCHI+maxchi,(const char**)leg,oenv);
for (Dih=0; (Dih<edMax); Dih++)
nh[Dih]=0;
fprintf(fp,"%5s ","#Res.");
fprintf(fp,"%10s %10s %10s ",leg[edPhi],leg[edPsi],leg[edOmega]);
for (Xi=0; Xi<maxchi; Xi++)
fprintf(fp,"%10s ",leg[NONCHI+Xi]);
fprintf(fp,"\n");
for(i=0; (i<nlist); i++) {
fprintf(fp,"%5d ",dlist[i].resnr);
for (Dih=0; (Dih<NONCHI+maxchi); Dih++)
fprintf(fp,"%10.3f ",dlist[i].ntr[Dih]/dt);
/* fprintf(fp,"%12s\n",dlist[i].name); this confuses xmgrace */
fprintf(fp,"\n");
}
ffclose(fp);
}
static void dump_w(output_env_t oenv, real beta)
{
FILE *fp;
double nu;
const char *leg[] = { "wCv", "wS", "wA", "wE" };
fp = xvgropen("w.xvg", "Fig. 1, Berens1983a", "\\f{12}b\\f{4}h\\f{12}n",
"w", oenv);
xvgr_legend(fp, asize(leg), leg, oenv);
for (nu = 1; (nu < 100); nu += 0.05)
{
fprintf(fp, "%10g %10g %10g %10g %10g\n", beta*PLANCK*nu,
wCsolid(nu, beta), wSsolid(nu, beta),
wAsolid(nu, beta), wEsolid(nu, beta));
}
xvgrclose(fp);
}
static void plot_coscont(char *ccfile,int n,int nset,real **val)
{
FILE *fp;
int s;
real cc;
fp = xvgropen(ccfile,"Cosine content","set / half periods","cosine content");
for(s=0; s<nset; s++) {
cc = cosine_content(s+1,n,val[s]);
fprintf(fp," %d %g\n",s+1,cc);
fprintf(stdout,"Cosine content of set %d with %.1f periods: %g\n",
s+1,0.5*(s+1),cc);
}
fprintf(stdout,"\n");
fclose(fp);
}
void histogram(char *distfile,real binwidth,int n, int nset, real **val)
{
FILE *fp;
int i,s;
double min,max;
int nbin;
#if (defined SIZEOF_LONG_LONG_INT) && (SIZEOF_LONG_LONG_INT >= 8)
long long int *histo;
#else
double *histo;
#endif
min = val[0][0];
max = val[0][0];
for(s=0; s<nset; s++)
for(i=0; i<n; i++)
if (val[s][i] < min)
min = val[s][i];
else if (val[s][i] > max)
max = val[s][i];
min = binwidth*floor(min/binwidth);
max = binwidth*ceil(max/binwidth);
if (min != 0)
min -= binwidth;
max += binwidth;
nbin = (int)((max - min)/binwidth + 0.5) + 1;
fprintf(stderr,"Making distributions with %d bins\n",nbin);
snew(histo,nbin);
fp = xvgropen(distfile,"Distribution","","");
for(s=0; s<nset; s++) {
for(i=0; i<nbin; i++)
histo[i] = 0;
for(i=0; i<n; i++)
histo[(int)((val[s][i] - min)/binwidth + 0.5)]++;
for(i=0; i<nbin; i++)
fprintf(fp," %g %g\n",min+i*binwidth,(double)histo[i]/(n*binwidth));
if (s < nset-1)
fprintf(fp,"&\n");
}
fclose(fp);
}
static void dump_fy(output_env_t oenv, real toler)
{
FILE *fp;
double Delta, f, y, DD;
const char *leg[] = { "f", "fy", "y" };
DD = pow(10.0, 0.125);
fp = xvgropen("fy.xvg", "Fig. 2, Lin2003a", "Delta", "y or fy", oenv);
xvgr_legend(fp, asize(leg), leg, oenv);
fprintf(fp, "@ world 1e-05, 0, 1000, 1\n");
fprintf(fp, "@ xaxes scale Logarithmic\n");
for (Delta = 1e-5; (Delta <= 1000); Delta *= DD)
{
f = calc_fluidicity(Delta, toler);
y = calc_y(f, Delta, toler);
fprintf(fp, "%10g %10g %10g %10g\n", Delta, f, f*y, y);
}
xvgrclose(fp);
}
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);
}
static void ana_trans(FILE *out, t_xrama *xr,real **dih,real time[],
t_topology *top,int nframes)
{
FILE *outd;
real prev_phi,prev_psi;
int i,j,phi,psi;
char buf[10];
fprintf(out,"\n\t* * * D I H E D R A L S T A T I S T I C S * * *\n\n");
fprintf(out,"%-10s %10s %10s %10s %10s %10s %10s\n",
"index","minimum","average","maximum","variance","std.dev",
"transition");
for(i=0; (i>xr->ndih); i++) {
sprintf(buf,"dih-%d",i);
ana_dih(out,buf,nframes,dih[i],&(xr->dih[i]));
}
for(i=0; (i<xr->npp); i++) {
sprintf(buf,"%s",xr->pp[i].label);
outd=xvgropen(buf,"Dihedral Angles","Time (ps)","Degrees");
phi=xr->pp[i].iphi;
psi=xr->pp[i].ipsi;
prev_phi=dih[phi][0];
prev_psi=dih[psi][0];
for(j=0; (j<nframes); j++) {
/* PBC.. */
if ((dih[phi][j]-prev_phi) > 180)
dih[phi][j]-=360;
else if ((dih[phi][j]-prev_phi) < -180)
dih[phi][j]+=360;
prev_phi=dih[phi][j];
if ((dih[psi][j]-prev_psi) > 180)
dih[psi][j]-=360;
else if ((dih[psi][j]-prev_psi) < -180)
dih[psi][j]+=360;
prev_psi=dih[psi][j];
fprintf(outd,"%10g %10g %10g\n",time[j],prev_phi,prev_psi);
}
fclose(outd);
}
}
void write_xvg(const char *fn, const char *title, int nx, int ny, real **y,
const char **leg, const output_env_t oenv)
{
FILE *fp;
int i, j;
fp = xvgropen(fn, title, "X", "Y", oenv);
if (leg)
{
xvgr_legend(fp, ny-1, leg, oenv);
}
for (i = 0; (i < nx); i++)
{
for (j = 0; (j < ny); j++)
{
fprintf(fp, " %12.5e", y[j][i]);
}
fprintf(fp, "\n");
}
xvgrclose(fp);
}
void dump_ana_ener(t_ana_ener *ae,int nsim,real dt,char *edump,
t_ana_struct *total)
{
FILE *fp;
int i,j;
real fac;
fac = 1.0/(nsim*ELECTRONVOLT);
fp=xvgropen(edump,"Energies","Time (fs)","E (eV)");
xvgr_legend(fp,eNR,enms);
fprintf(fp,"@ s%d legend \"Ek/Nelec\"\n",eNR);
fprintf(fp,"@ type nxy\n");
for(i=0; (i<ae->nx); i++) {
fprintf(fp,"%10f",1000.0*dt*i);
for(j=0; (j<eNR); j++)
fprintf(fp," %8.3f",ae->e[i][j]*fac);
fprintf(fp," %8.3f\n",ae->e[i][eELECTRON]/(ELECTRONVOLT*total->nion[i]));
}
fprintf(fp,"&\n");
ffclose(fp);
}
void h2order_plot(rvec dipole[], real order[], const char *afile,
int nslices, real slWidth, const output_env_t oenv)
{
FILE *ord; /* xvgr files with order parameters */
int slice; /* loop index */
char buf[256]; /* for xvgr title */
real factor; /* conversion to Debye from electron*nm */
/* factor = 1e-9*1.60217733e-19/3.336e-30 */
factor = 1.60217733/3.336e-2;
fprintf(stderr,"%d slices\n",nslices);
sprintf(buf,"Water orientation with respect to normal");
ord = xvgropen(afile,buf,
"box (nm)","mu_x, mu_y, mu_z (D), cosine with normal",oenv);
for (slice = 0; slice < nslices; slice++)
fprintf(ord,"%8.3f %8.3f %8.3f %8.3f %e\n", slWidth*slice,
factor*dipole[slice][XX], factor*dipole[slice][YY],
factor*dipole[slice][ZZ], order[slice]);
ffclose(ord);
}
static void pr_dev(t_coupl_rec *tcr,
real t,real dev[eoObsNR],t_commrec *cr,int nfile,t_filenm fnm[])
{
static FILE *fp=NULL;
char **ptr;
int i,j;
if (!fp) {
fp=xvgropen(opt2fn("-devout",nfile,fnm),
"Deviations from target value","Time (ps)","");
snew(ptr,eoObsNR);
for(i=j=0; (i<eoObsNR); i++)
if (tcr->bObsUsed[i])
ptr[j++] = eoNames[i];
xvgr_legend(fp,j,ptr);
sfree(ptr);
}
fprintf(fp,"%10.3f",t);
for(i=0; (i<eoObsNR); i++)
if (tcr->bObsUsed[i])
fprintf(fp," %10.3e",dev[i]);
fprintf(fp,"\n");
fflush(fp);
}
int gmx_lie(int argc,char *argv[])
{
const char *desc[] = {
"g_lie computes a free energy estimate based on an energy analysis",
"from. One needs an energy file with the following components:",
"Coul (A-B) LJ-SR (A-B) etc."
};
static real lie_lj=0,lie_qq=0,fac_lj=0.181,fac_qq=0.5;
static const char *ligand="none";
t_pargs pa[] = {
{ "-Elj", FALSE, etREAL, {&lie_lj},
"Lennard-Jones interaction between ligand and solvent" },
{ "-Eqq", FALSE, etREAL, {&lie_qq},
"Coulomb interaction between ligand and solvent" },
{ "-Clj", FALSE, etREAL, {&fac_lj},
"Factor in the LIE equation for Lennard-Jones component of energy" },
{ "-Cqq", FALSE, etREAL, {&fac_qq},
"Factor in the LIE equation for Coulomb component of energy" },
{ "-ligand", FALSE, etSTR, {&ligand},
"Name of the ligand in the energy file" }
};
#define NPA asize(pa)
FILE *out;
int nre,nframes=0,ct=0;
ener_file_t fp;
gmx_bool bCont;
t_liedata *ld;
gmx_enxnm_t *enm=NULL;
t_enxframe *fr;
real lie;
double lieaver=0,lieav2=0;
output_env_t oenv;
t_filenm fnm[] = {
{ efEDR, "-f", "ener", ffREAD },
{ efXVG, "-o", "lie", ffWRITE }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_VIEW | PCA_CAN_TIME | PCA_BE_NICE,
NFILE,fnm,NPA,pa,asize(desc),desc,0,NULL,&oenv);
fp = open_enx(ftp2fn(efEDR,NFILE,fnm),"r");
do_enxnms(fp,&nre,&enm);
ld = analyze_names(nre,enm,ligand);
snew(fr,1);
out = xvgropen(ftp2fn(efXVG,NFILE,fnm),"LIE free energy estimate",
"Time (ps)","DGbind (kJ/mol)",oenv);
do {
bCont = do_enx(fp,fr);
ct = check_times(fr->t);
if (ct == 0) {
lie = calc_lie(ld,fr->ener,lie_lj,lie_qq,fac_lj,fac_qq);
lieaver += lie;
lieav2 += lie*lie;
nframes ++;
fprintf(out,"%10g %10g\n",fr->t,lie);
}
} while (bCont);
close_enx(fp);
ffclose(out);
fprintf(stderr,"\n");
if (nframes > 0)
printf("DGbind = %.3f (%.3f)\n",lieaver/nframes,
sqrt(lieav2/nframes-sqr(lieaver/nframes)));
do_view(oenv,ftp2fn(efXVG,NFILE,fnm),"-nxy");
thanx(stderr);
return 0;
}
int gmx_rmsf(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] computes the root mean square fluctuation (RMSF, i.e. standard ",
"deviation) of atomic positions in the trajectory (supplied with [TT]-f[tt])",
"after (optionally) fitting to a reference frame (supplied with [TT]-s[tt]).[PAR]",
"With option [TT]-oq[tt] the RMSF values are converted to B-factor",
"values, which are written to a [REF].pdb[ref] file with the coordinates, of the",
"structure file, or of a [REF].pdb[ref] file when [TT]-q[tt] is specified.",
"Option [TT]-ox[tt] writes the B-factors to a file with the average",
"coordinates.[PAR]",
"With the option [TT]-od[tt] the root mean square deviation with",
"respect to the reference structure is calculated.[PAR]",
"With the option [TT]-aniso[tt], [THISMODULE] will compute anisotropic",
"temperature factors and then it will also output average coordinates",
"and a [REF].pdb[ref] file with ANISOU records (corresonding to the [TT]-oq[tt]",
"or [TT]-ox[tt] option). Please note that the U values",
"are orientation-dependent, so before comparison with experimental data",
"you should verify that you fit to the experimental coordinates.[PAR]",
"When a [REF].pdb[ref] input file is passed to the program and the [TT]-aniso[tt]",
"flag is set",
"a correlation plot of the Uij will be created, if any anisotropic",
"temperature factors are present in the [REF].pdb[ref] file.[PAR]",
"With option [TT]-dir[tt] the average MSF (3x3) matrix is diagonalized.",
"This shows the directions in which the atoms fluctuate the most and",
"the least."
};
static gmx_bool bRes = FALSE, bAniso = FALSE, bFit = TRUE;
t_pargs pargs[] = {
{ "-res", FALSE, etBOOL, {&bRes},
"Calculate averages for each residue" },
{ "-aniso", FALSE, etBOOL, {&bAniso},
"Compute anisotropic termperature factors" },
{ "-fit", FALSE, etBOOL, {&bFit},
"Do a least squares superposition before computing RMSF. Without this you must make sure that the reference structure and the trajectory match." }
};
int natom;
int i, m, teller = 0;
real t, *w_rls;
t_topology top;
int ePBC;
t_atoms *pdbatoms, *refatoms;
matrix box, pdbbox;
rvec *x, *pdbx, *xref;
t_trxstatus *status;
const char *label;
FILE *fp; /* the graphics file */
const char *devfn, *dirfn;
int resind;
gmx_bool bReadPDB;
int *index;
int isize;
char *grpnames;
real bfac, pdb_bfac, *Uaver;
double **U, *xav;
int aid;
rvec *rmsd_x = nullptr;
double *rmsf, invcount, totmass;
int d;
real count = 0;
rvec xcm;
gmx_rmpbc_t gpbc = nullptr;
gmx_output_env_t *oenv;
const char *leg[2] = { "MD", "X-Ray" };
t_filenm fnm[] = {
{ efTRX, "-f", nullptr, ffREAD },
{ efTPS, nullptr, nullptr, ffREAD },
{ efNDX, nullptr, nullptr, ffOPTRD },
{ efPDB, "-q", nullptr, ffOPTRD },
{ efPDB, "-oq", "bfac", ffOPTWR },
{ efPDB, "-ox", "xaver", ffOPTWR },
{ efXVG, "-o", "rmsf", ffWRITE },
{ efXVG, "-od", "rmsdev", ffOPTWR },
{ efXVG, "-oc", "correl", ffOPTWR },
{ efLOG, "-dir", "rmsf", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_CAN_VIEW,
NFILE, fnm, asize(pargs), pargs, asize(desc), desc, 0, nullptr,
&oenv))
{
return 0;
}
bReadPDB = ftp2bSet(efPDB, NFILE, fnm);
devfn = opt2fn_null("-od", NFILE, fnm);
dirfn = opt2fn_null("-dir", NFILE, fnm);
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, &xref, nullptr, box, TRUE);
const char *title = *top.name;
snew(w_rls, top.atoms.nr);
fprintf(stderr, "Select group(s) for root mean square calculation\n");
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &isize, &index, &grpnames);
/* Set the weight */
for (i = 0; i < isize; i++)
{
w_rls[index[i]] = top.atoms.atom[index[i]].m;
}
/* Malloc the rmsf arrays */
snew(xav, isize*DIM);
snew(U, isize);
for (i = 0; i < isize; i++)
{
snew(U[i], DIM*DIM);
}
snew(rmsf, isize);
if (devfn)
{
snew(rmsd_x, isize);
}
if (bReadPDB)
{
t_topology *top_pdb;
snew(top_pdb, 1);
/* Read coordinates twice */
read_tps_conf(opt2fn("-q", NFILE, fnm), top_pdb, nullptr, nullptr, nullptr, pdbbox, FALSE);
snew(pdbatoms, 1);
*pdbatoms = top_pdb->atoms;
read_tps_conf(opt2fn("-q", NFILE, fnm), top_pdb, nullptr, &pdbx, nullptr, pdbbox, FALSE);
/* TODO Should this assert that top_pdb->atoms.nr == top.atoms.nr?
* See discussion at https://gerrit.gromacs.org/#/c/6430/1 */
title = *top_pdb->name;
snew(refatoms, 1);
*refatoms = top_pdb->atoms;
sfree(top_pdb);
}
else
{
pdbatoms = &top.atoms;
refatoms = &top.atoms;
pdbx = xref;
snew(pdbatoms->pdbinfo, pdbatoms->nr);
pdbatoms->havePdbInfo = TRUE;
copy_mat(box, pdbbox);
}
if (bFit)
{
sub_xcm(xref, isize, index, top.atoms.atom, xcm, FALSE);
}
natom = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
if (bFit)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, natom);
}
/* Now read the trj again to compute fluctuations */
teller = 0;
do
{
if (bFit)
{
/* Remove periodic boundary */
gmx_rmpbc(gpbc, natom, box, x);
/* Set center of mass to zero */
sub_xcm(x, isize, index, top.atoms.atom, xcm, FALSE);
/* Fit to reference structure */
do_fit(natom, w_rls, xref, x);
}
/* Calculate Anisotropic U Tensor */
for (i = 0; i < isize; i++)
{
aid = index[i];
for (d = 0; d < DIM; d++)
{
xav[i*DIM + d] += x[aid][d];
for (m = 0; m < DIM; m++)
{
U[i][d*DIM + m] += x[aid][d]*x[aid][m];
}
}
}
if (devfn)
{
/* Calculate RMS Deviation */
for (i = 0; (i < isize); i++)
{
aid = index[i];
for (d = 0; (d < DIM); d++)
{
rmsd_x[i][d] += gmx::square(x[aid][d]-xref[aid][d]);
}
}
}
count += 1.0;
teller++;
}
while (read_next_x(oenv, status, &t, x, box));
close_trx(status);
if (bFit)
{
gmx_rmpbc_done(gpbc);
}
invcount = 1.0/count;
snew(Uaver, DIM*DIM);
totmass = 0;
for (i = 0; i < isize; i++)
{
for (d = 0; d < DIM; d++)
{
xav[i*DIM + d] *= invcount;
}
for (d = 0; d < DIM; d++)
{
for (m = 0; m < DIM; m++)
{
U[i][d*DIM + m] = U[i][d*DIM + m]*invcount
- xav[i*DIM + d]*xav[i*DIM + m];
Uaver[3*d+m] += top.atoms.atom[index[i]].m*U[i][d*DIM + m];
}
}
totmass += top.atoms.atom[index[i]].m;
}
for (d = 0; d < DIM*DIM; d++)
{
Uaver[d] /= totmass;
}
if (bRes)
{
for (d = 0; d < DIM*DIM; d++)
{
average_residues(nullptr, U, d, isize, index, w_rls, &top.atoms);
}
}
if (bAniso)
{
for (i = 0; i < isize; i++)
{
aid = index[i];
pdbatoms->pdbinfo[aid].bAnisotropic = TRUE;
pdbatoms->pdbinfo[aid].uij[U11] = static_cast<int>(1e6*U[i][XX*DIM + XX]);
pdbatoms->pdbinfo[aid].uij[U22] = static_cast<int>(1e6*U[i][YY*DIM + YY]);
pdbatoms->pdbinfo[aid].uij[U33] = static_cast<int>(1e6*U[i][ZZ*DIM + ZZ]);
pdbatoms->pdbinfo[aid].uij[U12] = static_cast<int>(1e6*U[i][XX*DIM + YY]);
pdbatoms->pdbinfo[aid].uij[U13] = static_cast<int>(1e6*U[i][XX*DIM + ZZ]);
pdbatoms->pdbinfo[aid].uij[U23] = static_cast<int>(1e6*U[i][YY*DIM + ZZ]);
}
}
if (bRes)
{
label = "Residue";
}
else
{
label = "Atom";
}
for (i = 0; i < isize; i++)
{
rmsf[i] = U[i][XX*DIM + XX] + U[i][YY*DIM + YY] + U[i][ZZ*DIM + ZZ];
}
if (dirfn)
{
fprintf(stdout, "\n");
print_dir(stdout, Uaver);
fp = gmx_ffopen(dirfn, "w");
print_dir(fp, Uaver);
gmx_ffclose(fp);
}
for (i = 0; i < isize; i++)
{
sfree(U[i]);
}
sfree(U);
/* Write RMSF output */
if (bReadPDB)
{
bfac = 8.0*M_PI*M_PI/3.0*100;
fp = xvgropen(ftp2fn(efXVG, NFILE, fnm), "B-Factors",
label, "(A\\b\\S\\So\\N\\S2\\N)", oenv);
xvgr_legend(fp, 2, leg, oenv);
for (i = 0; (i < isize); i++)
{
if (!bRes || i+1 == isize ||
top.atoms.atom[index[i]].resind != top.atoms.atom[index[i+1]].resind)
{
resind = top.atoms.atom[index[i]].resind;
pdb_bfac = find_pdb_bfac(pdbatoms, &top.atoms.resinfo[resind],
*(top.atoms.atomname[index[i]]));
fprintf(fp, "%5d %10.5f %10.5f\n",
bRes ? top.atoms.resinfo[top.atoms.atom[index[i]].resind].nr : index[i]+1, rmsf[i]*bfac,
pdb_bfac);
}
}
xvgrclose(fp);
}
else
{
fp = xvgropen(ftp2fn(efXVG, NFILE, fnm), "RMS fluctuation", label, "(nm)", oenv);
for (i = 0; i < isize; i++)
{
if (!bRes || i+1 == isize ||
top.atoms.atom[index[i]].resind != top.atoms.atom[index[i+1]].resind)
{
fprintf(fp, "%5d %8.4f\n",
bRes ? top.atoms.resinfo[top.atoms.atom[index[i]].resind].nr : index[i]+1, std::sqrt(rmsf[i]));
}
}
xvgrclose(fp);
}
for (i = 0; i < isize; i++)
{
pdbatoms->pdbinfo[index[i]].bfac = 800*M_PI*M_PI/3.0*rmsf[i];
}
if (devfn)
{
for (i = 0; i < isize; i++)
{
rmsf[i] = (rmsd_x[i][XX]+rmsd_x[i][YY]+rmsd_x[i][ZZ])/count;
}
if (bRes)
{
average_residues(rmsf, nullptr, 0, isize, index, w_rls, &top.atoms);
}
/* Write RMSD output */
fp = xvgropen(devfn, "RMS Deviation", label, "(nm)", oenv);
for (i = 0; i < isize; i++)
{
if (!bRes || i+1 == isize ||
top.atoms.atom[index[i]].resind != top.atoms.atom[index[i+1]].resind)
{
fprintf(fp, "%5d %8.4f\n",
bRes ? top.atoms.resinfo[top.atoms.atom[index[i]].resind].nr : index[i]+1, std::sqrt(rmsf[i]));
}
}
xvgrclose(fp);
}
if (opt2bSet("-oq", NFILE, fnm))
{
/* Write a .pdb file with B-factors and optionally anisou records */
for (i = 0; i < isize; i++)
{
rvec_inc(pdbx[index[i]], xcm);
}
write_sto_conf_indexed(opt2fn("-oq", NFILE, fnm), title, pdbatoms, pdbx,
nullptr, ePBC, pdbbox, isize, index);
}
if (opt2bSet("-ox", NFILE, fnm))
{
rvec *bFactorX;
snew(bFactorX, top.atoms.nr);
for (i = 0; i < isize; i++)
{
for (d = 0; d < DIM; d++)
{
bFactorX[index[i]][d] = xcm[d] + xav[i*DIM + d];
}
}
/* Write a .pdb file with B-factors and optionally anisou records */
write_sto_conf_indexed(opt2fn("-ox", NFILE, fnm), title, pdbatoms, bFactorX, nullptr,
ePBC, pdbbox, isize, index);
sfree(bFactorX);
}
if (bAniso)
{
correlate_aniso(opt2fn("-oc", NFILE, fnm), refatoms, pdbatoms, oenv);
do_view(oenv, opt2fn("-oc", NFILE, fnm), "-nxy");
}
do_view(oenv, opt2fn("-o", NFILE, fnm), "-nxy");
if (devfn)
{
do_view(oenv, opt2fn("-od", NFILE, fnm), "-nxy");
}
return 0;
}
