// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
void LapH::distillery::initialise(const LapH::input_parameter& in_param) {
param = in_param;
const size_t Ls = param.Ls;
const size_t Lt = param.Lt;
const size_t dim_row = Ls * Ls * Ls * 3;
int numprocs = 0;
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
// Initializing memory for eigenvectors, perambulator and random vector
V = new Eigen::MatrixXcd[Lt/numprocs];
perambulator = new Eigen::MatrixXcd[Lt/numprocs];
for(size_t t = 0; t < Lt/numprocs; ++t){
V[t] = Eigen::MatrixXcd::Zero(dim_row, param.nb_ev);
perambulator[t] = Eigen::MatrixXcd::Zero( 4 * param.nb_ev,
param.dilution_size_so[0] *
param.dilution_size_so[1] *
param.dilution_size_so[2] );
}
random_vector = new Eigen::VectorXcd[Lt];
for(size_t t = 0; t < Lt; ++t)
random_vector[t] = Eigen::VectorXcd::Zero(4 * param.nb_ev);
// reading eigenvectors from disk
read_eigenvectors();
// generating random vector
set_random_vector();
// is everything allocated?
memory_allocated = true;
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
void LapH::distillery::reset_all(const LapH::input_parameter& in_param){
param = in_param;
const size_t Ls = param.Ls;
const size_t Lt = param.Lt;
const size_t dim_row = Ls * Ls * Ls * 3;
int numprocs = 0;
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
for(size_t t = 0; t < Lt/numprocs; ++t){
V[t] = Eigen::MatrixXcd::Zero(dim_row, param.nb_ev);
perambulator[t] = Eigen::MatrixXcd::Zero( 4 * param.nb_ev,
param.dilution_size_so[0] *
param.dilution_size_so[1] *
param.dilution_size_so[2] );
}
for(size_t t = 0; t < Lt; ++t)
random_vector[t] = Eigen::VectorXcd::Zero(4 * param.nb_ev);
read_eigenvectors();
set_random_vector();
}
int gmx_nmens(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] generates an ensemble around an average structure",
"in a subspace that is defined by a set of normal modes (eigenvectors).",
"The eigenvectors are assumed to be mass-weighted.",
"The position along each eigenvector is randomly taken from a Gaussian",
"distribution with variance kT/eigenvalue.[PAR]",
"By default the starting eigenvector is set to 7, since the first six",
"normal modes are the translational and rotational degrees of freedom."
};
static int nstruct = 100, first = 7, last = -1, seed = -1;
static real temp = 300.0;
t_pargs pa[] = {
{ "-temp", FALSE, etREAL, {&temp},
"Temperature in Kelvin" },
{ "-seed", FALSE, etINT, {&seed},
"Random seed, -1 generates a seed from time and pid" },
{ "-num", FALSE, etINT, {&nstruct},
"Number of structures to generate" },
{ "-first", FALSE, etINT, {&first},
"First eigenvector to use (-1 is select)" },
{ "-last", FALSE, etINT, {&last},
"Last eigenvector to use (-1 is till the last)" }
};
#define NPA asize(pa)
t_trxstatus *out;
int status, trjout;
t_topology top;
int ePBC;
t_atoms *atoms;
rvec *xtop, *xref, *xav, *xout1, *xout2;
gmx_bool bDMR, bDMA, bFit;
int nvec, *eignr = NULL;
rvec **eigvec = NULL;
matrix box;
real *eigval, totmass, *invsqrtm, t, disp;
int natoms, neigval;
char *grpname, title[STRLEN];
const char *indexfile;
int i, j, d, s, v;
int nout, *iout, noutvec, *outvec;
atom_id *index;
real rfac, invfr, rhalf, jr;
int * eigvalnr;
output_env_t oenv;
gmx_rng_t rng;
unsigned long jran;
const unsigned long im = 0xffff;
const unsigned long ia = 1093;
const unsigned long ic = 18257;
t_filenm fnm[] = {
{ efTRN, "-v", "eigenvec", ffREAD },
{ efXVG, "-e", "eigenval", ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTRO, "-o", "ensemble", ffWRITE }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_BE_NICE,
NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
indexfile = ftp2fn_null(efNDX, NFILE, fnm);
read_eigenvectors(opt2fn("-v", NFILE, fnm), &natoms, &bFit,
&xref, &bDMR, &xav, &bDMA, &nvec, &eignr, &eigvec, &eigval);
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC, &xtop, NULL, box, bDMA);
atoms = &top.atoms;
printf("\nSelect an index group of %d elements that corresponds to the eigenvectors\n", natoms);
get_index(atoms, indexfile, 1, &i, &index, &grpname);
if (i != natoms)
{
gmx_fatal(FARGS, "you selected a group with %d elements instead of %d",
i, natoms);
}
printf("\n");
snew(invsqrtm, natoms);
if (bDMA)
{
for (i = 0; (i < natoms); i++)
{
invsqrtm[i] = gmx_invsqrt(atoms->atom[index[i]].m);
}
}
else
{
for (i = 0; (i < natoms); i++)
{
invsqrtm[i] = 1.0;
}
}
if (last == -1)
{
last = natoms*DIM;
}
if (first > -1)
{
/* make an index from first to last */
nout = last-first+1;
snew(iout, nout);
for (i = 0; i < nout; i++)
{
iout[i] = first-1+i;
}
}
else
{
printf("Select eigenvectors for output, end your selection with 0\n");
nout = -1;
iout = NULL;
do
{
nout++;
srenew(iout, nout+1);
if (1 != scanf("%d", &iout[nout]))
{
gmx_fatal(FARGS, "Error reading user input");
}
iout[nout]--;
}
while (iout[nout] >= 0);
printf("\n");
}
/* make an index of the eigenvectors which are present */
snew(outvec, nout);
noutvec = 0;
for (i = 0; i < nout; i++)
{
j = 0;
while ((j < nvec) && (eignr[j] != iout[i]))
{
j++;
}
if ((j < nvec) && (eignr[j] == iout[i]))
{
outvec[noutvec] = j;
iout[noutvec] = iout[i];
noutvec++;
}
}
fprintf(stderr, "%d eigenvectors selected for output\n", noutvec);
if (seed == -1)
{
seed = (int)gmx_rng_make_seed();
rng = gmx_rng_init(seed);
}
else
{
rng = gmx_rng_init(seed);
}
fprintf(stderr, "Using seed %d and a temperature of %g K\n", seed, temp);
snew(xout1, natoms);
snew(xout2, atoms->nr);
out = open_trx(ftp2fn(efTRO, NFILE, fnm), "w");
jran = (unsigned long)((real)im*gmx_rng_uniform_real(rng));
gmx_rng_destroy(rng);
for (s = 0; s < nstruct; s++)
{
for (i = 0; i < natoms; i++)
{
copy_rvec(xav[i], xout1[i]);
}
for (j = 0; j < noutvec; j++)
{
v = outvec[j];
/* (r-0.5) n times: var_n = n * var_1 = n/12
n=4: var_n = 1/3, so multiply with 3 */
rfac = sqrt(3.0 * BOLTZ*temp/eigval[iout[j]]);
rhalf = 2.0*rfac;
rfac = rfac/(real)im;
jran = (jran*ia+ic) & im;
jr = (real)jran;
jran = (jran*ia+ic) & im;
jr += (real)jran;
jran = (jran*ia+ic) & im;
jr += (real)jran;
jran = (jran*ia+ic) & im;
jr += (real)jran;
disp = rfac * jr - rhalf;
for (i = 0; i < natoms; i++)
{
for (d = 0; d < DIM; d++)
{
xout1[i][d] += disp*eigvec[v][i][d]*invsqrtm[i];
}
}
}
for (i = 0; i < natoms; i++)
{
copy_rvec(xout1[i], xout2[index[i]]);
}
t = s+1;
write_trx(out, natoms, index, atoms, 0, t, box, xout2, NULL, NULL);
fprintf(stderr, "\rGenerated %d structures", s+1);
}
fprintf(stderr, "\n");
close_trx(out);
return 0;
}
int gmx_anaeig(int argc,char *argv[])
{
static const char *desc[] = {
"[TT]g_anaeig[tt] analyzes eigenvectors. The eigenvectors can be of a",
"covariance matrix ([TT]g_covar[tt]) or of a Normal Modes analysis",
"([TT]g_nmeig[tt]).[PAR]",
"When a trajectory is projected on eigenvectors, all structures are",
"fitted to the structure in the eigenvector file, if present, otherwise",
"to the structure in the structure file. When no run input file is",
"supplied, periodicity will not be taken into account. Most analyses",
"are performed on eigenvectors [TT]-first[tt] to [TT]-last[tt], but when",
"[TT]-first[tt] is set to -1 you will be prompted for a selection.[PAR]",
"[TT]-comp[tt]: plot the vector components per atom of eigenvectors",
"[TT]-first[tt] to [TT]-last[tt].[PAR]",
"[TT]-rmsf[tt]: plot the RMS fluctuation per atom of eigenvectors",
"[TT]-first[tt] to [TT]-last[tt] (requires [TT]-eig[tt]).[PAR]",
"[TT]-proj[tt]: calculate projections of a trajectory on eigenvectors",
"[TT]-first[tt] to [TT]-last[tt].",
"The projections of a trajectory on the eigenvectors of its",
"covariance matrix are called principal components (pc's).",
"It is often useful to check the cosine content of the pc's,",
"since the pc's of random diffusion are cosines with the number",
"of periods equal to half the pc index.",
"The cosine content of the pc's can be calculated with the program",
"[TT]g_analyze[tt].[PAR]",
"[TT]-2d[tt]: calculate a 2d projection of a trajectory on eigenvectors",
"[TT]-first[tt] and [TT]-last[tt].[PAR]",
"[TT]-3d[tt]: calculate a 3d projection of a trajectory on the first",
"three selected eigenvectors.[PAR]",
"[TT]-filt[tt]: filter the trajectory to show only the motion along",
"eigenvectors [TT]-first[tt] to [TT]-last[tt].[PAR]",
"[TT]-extr[tt]: calculate the two extreme projections along a trajectory",
"on the average structure and interpolate [TT]-nframes[tt] frames",
"between them, or set your own extremes with [TT]-max[tt]. The",
"eigenvector [TT]-first[tt] will be written unless [TT]-first[tt] and",
"[TT]-last[tt] have been set explicitly, in which case all eigenvectors",
"will be written to separate files. Chain identifiers will be added",
"when writing a [TT].pdb[tt] file with two or three structures (you",
"can use [TT]rasmol -nmrpdb[tt] to view such a [TT].pdb[tt] file).[PAR]",
" Overlap calculations between covariance analysis:[BR]",
" [BB]Note:[bb] the analysis should use the same fitting structure[PAR]",
"[TT]-over[tt]: calculate the subspace overlap of the eigenvectors in",
"file [TT]-v2[tt] with eigenvectors [TT]-first[tt] to [TT]-last[tt]",
"in file [TT]-v[tt].[PAR]",
"[TT]-inpr[tt]: calculate a matrix of inner-products between",
"eigenvectors in files [TT]-v[tt] and [TT]-v2[tt]. All eigenvectors",
"of both files will be used unless [TT]-first[tt] and [TT]-last[tt]",
"have been set explicitly.[PAR]",
"When [TT]-v[tt], [TT]-eig[tt], [TT]-v2[tt] and [TT]-eig2[tt] are given,",
"a single number for the overlap between the covariance matrices is",
"generated. The formulas are:[BR]",
" difference = sqrt(tr((sqrt(M1) - sqrt(M2))^2))[BR]",
"normalized overlap = 1 - difference/sqrt(tr(M1) + tr(M2))[BR]",
" shape overlap = 1 - sqrt(tr((sqrt(M1/tr(M1)) - sqrt(M2/tr(M2)))^2))[BR]",
"where M1 and M2 are the two covariance matrices and tr is the trace",
"of a matrix. The numbers are proportional to the overlap of the square",
"root of the fluctuations. The normalized overlap is the most useful",
"number, it is 1 for identical matrices and 0 when the sampled",
"subspaces are orthogonal.[PAR]",
"When the [TT]-entropy[tt] flag is given an entropy estimate will be",
"computed based on the Quasiharmonic approach and based on",
"Schlitter's formula."
};
static int first=1,last=-1,skip=1,nextr=2,nskip=6;
static real max=0.0,temp=298.15;
static gmx_bool bSplit=FALSE,bEntropy=FALSE;
t_pargs pa[] = {
{ "-first", FALSE, etINT, {&first},
"First eigenvector for analysis (-1 is select)" },
{ "-last", FALSE, etINT, {&last},
"Last eigenvector for analysis (-1 is till the last)" },
{ "-skip", FALSE, etINT, {&skip},
"Only analyse every nr-th frame" },
{ "-max", FALSE, etREAL, {&max},
"Maximum for projection of the eigenvector on the average structure, "
"max=0 gives the extremes" },
{ "-nframes", FALSE, etINT, {&nextr},
"Number of frames for the extremes output" },
{ "-split", FALSE, etBOOL, {&bSplit},
"Split eigenvector projections where time is zero" },
{ "-entropy", FALSE, etBOOL, {&bEntropy},
"Compute entropy according to the Quasiharmonic formula or Schlitter's method." },
{ "-temp", FALSE, etREAL, {&temp},
"Temperature for entropy calculations" },
{ "-nevskip", FALSE, etINT, {&nskip},
"Number of eigenvalues to skip when computing the entropy due to the quasi harmonic approximation. When you do a rotational and/or translational fit prior to the covariance analysis, you get 3 or 6 eigenvalues that are very close to zero, and which should not be taken into account when computing the entropy." }
};
#define NPA asize(pa)
FILE *out;
int status,trjout;
t_topology top;
int ePBC=-1;
t_atoms *atoms=NULL;
rvec *xtop,*xref1,*xref2,*xrefp=NULL;
gmx_bool bDMR1,bDMA1,bDMR2,bDMA2;
int nvec1,nvec2,*eignr1=NULL,*eignr2=NULL;
rvec *x,*xread,*xav1,*xav2,**eigvec1=NULL,**eigvec2=NULL;
matrix topbox;
real xid,totmass,*sqrtm,*w_rls,t,lambda;
int natoms,step;
char *grpname;
const char *indexfile;
char title[STRLEN];
int i,j,d;
int nout,*iout,noutvec,*outvec,nfit;
atom_id *index,*ifit;
const char *VecFile,*Vec2File,*topfile;
const char *EigFile,*Eig2File;
const char *CompFile,*RmsfFile,*ProjOnVecFile;
const char *TwoDPlotFile,*ThreeDPlotFile;
const char *FilterFile,*ExtremeFile;
const char *OverlapFile,*InpMatFile;
gmx_bool bFit1,bFit2,bM,bIndex,bTPS,bTop,bVec2,bProj;
gmx_bool bFirstToLast,bFirstLastSet,bTraj,bCompare,bPDB3D;
real *eigval1=NULL,*eigval2=NULL;
int neig1,neig2;
double **xvgdata;
output_env_t oenv;
gmx_rmpbc_t gpbc;
t_filenm fnm[] = {
{ efTRN, "-v", "eigenvec", ffREAD },
{ efTRN, "-v2", "eigenvec2", ffOPTRD },
{ efTRX, "-f", NULL, ffOPTRD },
{ efTPS, NULL, NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-eig", "eigenval", ffOPTRD },
{ efXVG, "-eig2", "eigenval2", ffOPTRD },
{ efXVG, "-comp", "eigcomp", ffOPTWR },
{ efXVG, "-rmsf", "eigrmsf", ffOPTWR },
{ efXVG, "-proj", "proj", ffOPTWR },
{ efXVG, "-2d", "2dproj", ffOPTWR },
{ efSTO, "-3d", "3dproj.pdb", ffOPTWR },
{ efTRX, "-filt", "filtered", ffOPTWR },
{ efTRX, "-extr", "extreme.pdb", ffOPTWR },
{ efXVG, "-over", "overlap", ffOPTWR },
{ efXPM, "-inpr", "inprod", ffOPTWR }
};
#define NFILE asize(fnm)
parse_common_args(&argc,argv,
PCA_CAN_TIME | PCA_TIME_UNIT | PCA_CAN_VIEW | PCA_BE_NICE ,
NFILE,fnm,NPA,pa,asize(desc),desc,0,NULL,&oenv);
indexfile=ftp2fn_null(efNDX,NFILE,fnm);
VecFile = opt2fn("-v",NFILE,fnm);
Vec2File = opt2fn_null("-v2",NFILE,fnm);
topfile = ftp2fn(efTPS,NFILE,fnm);
EigFile = opt2fn_null("-eig",NFILE,fnm);
Eig2File = opt2fn_null("-eig2",NFILE,fnm);
CompFile = opt2fn_null("-comp",NFILE,fnm);
RmsfFile = opt2fn_null("-rmsf",NFILE,fnm);
ProjOnVecFile = opt2fn_null("-proj",NFILE,fnm);
TwoDPlotFile = opt2fn_null("-2d",NFILE,fnm);
ThreeDPlotFile = opt2fn_null("-3d",NFILE,fnm);
FilterFile = opt2fn_null("-filt",NFILE,fnm);
ExtremeFile = opt2fn_null("-extr",NFILE,fnm);
OverlapFile = opt2fn_null("-over",NFILE,fnm);
InpMatFile = ftp2fn_null(efXPM,NFILE,fnm);
bTop = fn2bTPX(topfile);
bProj = ProjOnVecFile || TwoDPlotFile || ThreeDPlotFile
|| FilterFile || ExtremeFile;
bFirstLastSet =
opt2parg_bSet("-first",NPA,pa) && opt2parg_bSet("-last",NPA,pa);
bFirstToLast = CompFile || RmsfFile || ProjOnVecFile || FilterFile ||
OverlapFile || ((ExtremeFile || InpMatFile) && bFirstLastSet);
bVec2 = Vec2File || OverlapFile || InpMatFile;
bM = RmsfFile || bProj;
bTraj = ProjOnVecFile || FilterFile || (ExtremeFile && (max==0))
|| TwoDPlotFile || ThreeDPlotFile;
bIndex = bM || bProj;
bTPS = ftp2bSet(efTPS,NFILE,fnm) || bM || bTraj ||
FilterFile || (bIndex && indexfile);
bCompare = Vec2File || Eig2File;
bPDB3D = fn2ftp(ThreeDPlotFile)==efPDB;
read_eigenvectors(VecFile,&natoms,&bFit1,
&xref1,&bDMR1,&xav1,&bDMA1,
&nvec1,&eignr1,&eigvec1,&eigval1);
neig1 = DIM*natoms;
/* Overwrite eigenvalues from separate files if the user provides them */
if (EigFile != NULL) {
int neig_tmp = read_xvg(EigFile,&xvgdata,&i);
if (neig_tmp != neig1)
fprintf(stderr,"Warning: number of eigenvalues in xvg file (%d) does not mtch trr file (%d)\n",neig1,natoms);
neig1 = neig_tmp;
srenew(eigval1,neig1);
for(j=0;j<neig1;j++) {
real tmp = eigval1[j];
eigval1[j]=xvgdata[1][j];
if (debug && (eigval1[j] != tmp))
fprintf(debug,"Replacing eigenvalue %d. From trr: %10g, from xvg: %10g\n",
j,tmp,eigval1[j]);
}
for(j=0;j<i;j++)
sfree(xvgdata[j]);
sfree(xvgdata);
fprintf(stderr,"Read %d eigenvalues from %s\n",neig1,EigFile);
}
if (bEntropy) {
if (bDMA1) {
gmx_fatal(FARGS,"Can not calculate entropies from mass-weighted eigenvalues, redo the analysis without mass-weighting");
}
calc_entropy_qh(stdout,neig1,eigval1,temp,nskip);
calc_entropy_schlitter(stdout,neig1,nskip,eigval1,temp);
}
if (bVec2) {
if (!Vec2File)
gmx_fatal(FARGS,"Need a second eigenvector file to do this analysis.");
read_eigenvectors(Vec2File,&neig2,&bFit2,
&xref2,&bDMR2,&xav2,&bDMA2,&nvec2,&eignr2,&eigvec2,&eigval2);
neig2 = DIM*neig2;
if (neig2 != neig1)
gmx_fatal(FARGS,"Dimensions in the eigenvector files don't match");
}
if(Eig2File != NULL) {
neig2 = read_xvg(Eig2File,&xvgdata,&i);
srenew(eigval2,neig2);
for(j=0;j<neig2;j++)
eigval2[j]=xvgdata[1][j];
for(j=0;j<i;j++)
sfree(xvgdata[j]);
sfree(xvgdata);
fprintf(stderr,"Read %d eigenvalues from %s\n",neig2,Eig2File);
}
if ((!bFit1 || xref1) && !bDMR1 && !bDMA1)
bM=FALSE;
if ((xref1==NULL) && (bM || bTraj))
bTPS=TRUE;
xtop=NULL;
nfit=0;
ifit=NULL;
w_rls=NULL;
if (!bTPS) {
bTop=FALSE;
} else {
bTop=read_tps_conf(ftp2fn(efTPS,NFILE,fnm),
title,&top,&ePBC,&xtop,NULL,topbox,bM);
atoms=&top.atoms;
gpbc = gmx_rmpbc_init(&top.idef,ePBC,atoms->nr,topbox);
gmx_rmpbc(gpbc,atoms->nr,topbox,xtop);
/* Fitting is only required for the projection */
if (bProj && bFit1) {
if (xref1 == NULL) {
printf("\nNote: the structure in %s should be the same\n"
" as the one used for the fit in g_covar\n",topfile);
}
printf("\nSelect the index group that was used for the least squares fit in g_covar\n");
get_index(atoms,indexfile,1,&nfit,&ifit,&grpname);
snew(w_rls,atoms->nr);
for(i=0; (i<nfit); i++) {
if (bDMR1) {
w_rls[ifit[i]] = atoms->atom[ifit[i]].m;
} else {
w_rls[ifit[i]] = 1.0;
}
}
snew(xrefp,atoms->nr);
if (xref1 != NULL) {
for(i=0; (i<nfit); i++) {
copy_rvec(xref1[i],xrefp[ifit[i]]);
}
} else {
/* The top coordinates are the fitting reference */
for(i=0; (i<nfit); i++) {
copy_rvec(xtop[ifit[i]],xrefp[ifit[i]]);
}
reset_x(nfit,ifit,atoms->nr,NULL,xrefp,w_rls);
}
}
gmx_rmpbc_done(gpbc);
}
if (bIndex) {
printf("\nSelect an index group of %d elements that corresponds to the eigenvectors\n",natoms);
get_index(atoms,indexfile,1,&i,&index,&grpname);
if (i!=natoms)
gmx_fatal(FARGS,"you selected a group with %d elements instead of %d",i,natoms);
printf("\n");
}
snew(sqrtm,natoms);
if (bM && bDMA1) {
proj_unit="u\\S1/2\\Nnm";
for(i=0; (i<natoms); i++)
sqrtm[i]=sqrt(atoms->atom[index[i]].m);
}
else {
proj_unit="nm";
for(i=0; (i<natoms); i++)
sqrtm[i]=1.0;
}
if (bVec2) {
t=0;
totmass=0;
for(i=0; (i<natoms); i++)
for(d=0;(d<DIM);d++) {
t+=sqr((xav1[i][d]-xav2[i][d])*sqrtm[i]);
totmass+=sqr(sqrtm[i]);
}
fprintf(stdout,"RMSD (without fit) between the two average structures:"
" %.3f (nm)\n\n",sqrt(t/totmass));
}
if (last==-1)
last=natoms*DIM;
if (first>-1) {
if (bFirstToLast) {
/* make an index from first to last */
nout=last-first+1;
snew(iout,nout);
for(i=0; i<nout; i++)
iout[i]=first-1+i;
}
else if (ThreeDPlotFile) {
/* make an index of first+(0,1,2) and last */
nout = bPDB3D ? 4 : 3;
nout = min(last-first+1, nout);
snew(iout,nout);
iout[0]=first-1;
iout[1]=first;
if (nout>3)
iout[2]=first+1;
iout[nout-1]=last-1;
}
else {
/* make an index of first and last */
nout=2;
snew(iout,nout);
iout[0]=first-1;
iout[1]=last-1;
}
}
else {
printf("Select eigenvectors for output, end your selection with 0\n");
nout=-1;
iout=NULL;
do {
nout++;
srenew(iout,nout+1);
if(1 != scanf("%d",&iout[nout]))
{
gmx_fatal(FARGS,"Error reading user input");
}
iout[nout]--;
}
while (iout[nout]>=0);
printf("\n");
}
/* make an index of the eigenvectors which are present */
snew(outvec,nout);
noutvec=0;
for(i=0; i<nout; i++)
{
j=0;
while ((j<nvec1) && (eignr1[j]!=iout[i]))
j++;
if ((j<nvec1) && (eignr1[j]==iout[i]))
{
outvec[noutvec]=j;
noutvec++;
}
}
fprintf(stderr,"%d eigenvectors selected for output",noutvec);
if (noutvec <= 100)
{
fprintf(stderr,":");
for(j=0; j<noutvec; j++)
fprintf(stderr," %d",eignr1[outvec[j]]+1);
}
fprintf(stderr,"\n");
if (CompFile)
components(CompFile,natoms,eignr1,eigvec1,noutvec,outvec,oenv);
if (RmsfFile)
rmsf(RmsfFile,natoms,sqrtm,eignr1,eigvec1,noutvec,outvec,eigval1,
neig1,oenv);
if (bProj)
project(bTraj ? opt2fn("-f",NFILE,fnm) : NULL,
bTop ? &top : NULL,ePBC,topbox,
ProjOnVecFile,TwoDPlotFile,ThreeDPlotFile,FilterFile,skip,
ExtremeFile,bFirstLastSet,max,nextr,atoms,natoms,index,
bFit1,xrefp,nfit,ifit,w_rls,
sqrtm,xav1,eignr1,eigvec1,noutvec,outvec,bSplit,
oenv);
if (OverlapFile)
overlap(OverlapFile,natoms,
eigvec1,nvec2,eignr2,eigvec2,noutvec,outvec,oenv);
if (InpMatFile)
inprod_matrix(InpMatFile,natoms,
nvec1,eignr1,eigvec1,nvec2,eignr2,eigvec2,
bFirstLastSet,noutvec,outvec);
if (bCompare)
compare(natoms,nvec1,eigvec1,nvec2,eigvec2,eigval1,neig1,eigval2,neig2);
if (!CompFile && !bProj && !OverlapFile && !InpMatFile &&
!bCompare && !bEntropy)
{
fprintf(stderr,"\nIf you want some output,"
" set one (or two or ...) of the output file options\n");
}
view_all(oenv,NFILE, fnm);
thanx(stdout);
return 0;
}
int gmx_make_edi(int argc, char *argv[])
{
static const char *desc[] = {
"[THISMODULE] generates an essential dynamics (ED) sampling input file to be used with [TT]mdrun[tt]",
"based on eigenvectors of a covariance matrix ([gmx-covar]) or from a",
"normal modes analysis ([gmx-nmeig]).",
"ED sampling can be used to manipulate the position along collective coordinates",
"(eigenvectors) of (biological) macromolecules during a simulation. Particularly,",
"it may be used to enhance the sampling efficiency of MD simulations by stimulating",
"the system to explore new regions along these collective coordinates. A number",
"of different algorithms are implemented to drive the system along the eigenvectors",
"([TT]-linfix[tt], [TT]-linacc[tt], [TT]-radfix[tt], [TT]-radacc[tt], [TT]-radcon[tt]),",
"to keep the position along a certain (set of) coordinate(s) fixed ([TT]-linfix[tt]),",
"or to only monitor the projections of the positions onto",
"these coordinates ([TT]-mon[tt]).[PAR]",
"References:[BR]",
"A. Amadei, A.B.M. Linssen, B.L. de Groot, D.M.F. van Aalten and ",
"H.J.C. Berendsen; An efficient method for sampling the essential subspace ",
"of proteins., J. Biomol. Struct. Dyn. 13:615-626 (1996)[BR]",
"B.L. de Groot, A. Amadei, D.M.F. van Aalten and H.J.C. Berendsen; ",
"Towards an exhaustive sampling of the configurational spaces of the ",
"two forms of the peptide hormone guanylin,",
"J. Biomol. Struct. Dyn. 13 : 741-751 (1996)[BR]",
"B.L. de Groot, A.Amadei, R.M. Scheek, N.A.J. van Nuland and H.J.C. Berendsen; ",
"An extended sampling of the configurational space of HPr from E. coli",
"Proteins: Struct. Funct. Gen. 26: 314-322 (1996)",
"[PAR]You will be prompted for one or more index groups that correspond to the eigenvectors,",
"reference structure, target positions, etc.[PAR]",
"[TT]-mon[tt]: monitor projections of the coordinates onto selected eigenvectors.[PAR]",
"[TT]-linfix[tt]: perform fixed-step linear expansion along selected eigenvectors.[PAR]",
"[TT]-linacc[tt]: perform acceptance linear expansion along selected eigenvectors.",
"(steps in the desired directions will be accepted, others will be rejected).[PAR]",
"[TT]-radfix[tt]: perform fixed-step radius expansion along selected eigenvectors.[PAR]",
"[TT]-radacc[tt]: perform acceptance radius expansion along selected eigenvectors.",
"(steps in the desired direction will be accepted, others will be rejected).",
"[BB]Note:[bb] by default the starting MD structure will be taken as origin of the first",
"expansion cycle for radius expansion. If [TT]-ori[tt] is specified, you will be able",
"to read in a structure file that defines an external origin.[PAR]",
"[TT]-radcon[tt]: perform acceptance radius contraction along selected eigenvectors",
"towards a target structure specified with [TT]-tar[tt].[PAR]",
"NOTE: each eigenvector can be selected only once. [PAR]",
"[TT]-outfrq[tt]: frequency (in steps) of writing out projections etc. to [TT].xvg[tt] file[PAR]",
"[TT]-slope[tt]: minimal slope in acceptance radius expansion. A new expansion",
"cycle will be started if the spontaneous increase of the radius (in nm/step)",
"is less than the value specified.[PAR]",
"[TT]-maxedsteps[tt]: maximum number of steps per cycle in radius expansion",
"before a new cycle is started.[PAR]",
"Note on the parallel implementation: since ED sampling is a 'global' thing",
"(collective coordinates etc.), at least on the 'protein' side, ED sampling",
"is not very parallel-friendly from an implementation point of view. Because",
"parallel ED requires some extra communication, expect the performance to be",
"lower as in a free MD simulation, especially on a large number of nodes and/or",
"when the ED group contains a lot of atoms. [PAR]",
"Please also note that if your ED group contains more than a single protein,",
"then the [TT].tpr[tt] file must contain the correct PBC representation of the ED group.",
"Take a look on the initial RMSD from the reference structure, which is printed",
"out at the start of the simulation; if this is much higher than expected, one",
"of the ED molecules might be shifted by a box vector. [PAR]",
"All ED-related output of [TT]mdrun[tt] (specify with [TT]-eo[tt]) is written to a [TT].xvg[tt] file",
"as a function of time in intervals of OUTFRQ steps.[PAR]",
"[BB]Note[bb] that you can impose multiple ED constraints and flooding potentials in",
"a single simulation (on different molecules) if several [TT].edi[tt] files were concatenated",
"first. The constraints are applied in the order they appear in the [TT].edi[tt] file. ",
"Depending on what was specified in the [TT].edi[tt] input file, the output file contains for each ED dataset[PAR]",
"[TT]*[tt] the RMSD of the fitted molecule to the reference structure (for atoms involved in fitting prior to calculating the ED constraints)[BR]",
"[TT]*[tt] projections of the positions onto selected eigenvectors[BR]",
"[PAR][PAR]",
"FLOODING:[PAR]",
"with [TT]-flood[tt], you can specify which eigenvectors are used to compute a flooding potential,",
"which will lead to extra forces expelling the structure out of the region described",
"by the covariance matrix. If you switch -restrain the potential is inverted and the structure",
"is kept in that region.",
"[PAR]",
"The origin is normally the average structure stored in the [TT]eigvec.trr[tt] file.",
"It can be changed with [TT]-ori[tt] to an arbitrary position in configuration space.",
"With [TT]-tau[tt], [TT]-deltaF0[tt], and [TT]-Eflnull[tt] you control the flooding behaviour.",
"Efl is the flooding strength, it is updated according to the rule of adaptive flooding.",
"Tau is the time constant of adaptive flooding, high [GRK]tau[grk] means slow adaption (i.e. growth). ",
"DeltaF0 is the flooding strength you want to reach after tau ps of simulation.",
"To use constant Efl set [TT]-tau[tt] to zero.",
"[PAR]",
"[TT]-alpha[tt] is a fudge parameter to control the width of the flooding potential. A value of 2 has been found",
"to give good results for most standard cases in flooding of proteins.",
"[GRK]alpha[grk] basically accounts for incomplete sampling, if you sampled further the width of the ensemble would",
"increase, this is mimicked by [GRK]alpha[grk] > 1.",
"For restraining, [GRK]alpha[grk] < 1 can give you smaller width in the restraining potential.",
"[PAR]",
"RESTART and FLOODING:",
"If you want to restart a crashed flooding simulation please find the values deltaF and Efl in",
"the output file and manually put them into the [TT].edi[tt] file under DELTA_F0 and EFL_NULL."
};
/* Save all the params in this struct and then save it in an edi file.
* ignoring fields nmass,massnrs,mass,tmass,nfit,fitnrs,edo
*/
static t_edipar edi_params;
enum {
evStepNr = evRADFIX + 1
};
static const char* evSelections[evNr] = {NULL, NULL, NULL, NULL, NULL, NULL};
static const char* evOptions[evNr] = {"-linfix", "-linacc", "-flood", "-radfix", "-radacc", "-radcon", "-mon"};
static const char* evParams[evStepNr] = {NULL, NULL};
static const char* evStepOptions[evStepNr] = {"-linstep", "-accdir", "-not_used", "-radstep"};
static const char* ConstForceStr;
static real * evStepList[evStepNr];
static real radstep = 0.0;
static real deltaF0 = 150;
static real deltaF = 0;
static real tau = .1;
static real constEfl = 0.0;
static real alpha = 1;
static int eqSteps = 0;
static int * listen[evNr];
static real T = 300.0;
const real kB = 2.5 / 300.0; /* k_boltzmann in MD units */
static gmx_bool bRestrain = FALSE;
static gmx_bool bHesse = FALSE;
static gmx_bool bHarmonic = FALSE;
t_pargs pa[] = {
{ "-mon", FALSE, etSTR, {&evSelections[evMON]},
"Indices of eigenvectors for projections of x (e.g. 1,2-5,9) or 1-100:10 means 1 11 21 31 ... 91" },
{ "-linfix", FALSE, etSTR, {&evSelections[0]},
"Indices of eigenvectors for fixed increment linear sampling" },
{ "-linacc", FALSE, etSTR, {&evSelections[1]},
"Indices of eigenvectors for acceptance linear sampling" },
{ "-radfix", FALSE, etSTR, {&evSelections[3]},
"Indices of eigenvectors for fixed increment radius expansion" },
{ "-radacc", FALSE, etSTR, {&evSelections[4]},
"Indices of eigenvectors for acceptance radius expansion" },
{ "-radcon", FALSE, etSTR, {&evSelections[5]},
"Indices of eigenvectors for acceptance radius contraction" },
{ "-flood", FALSE, etSTR, {&evSelections[2]},
"Indices of eigenvectors for flooding"},
{ "-outfrq", FALSE, etINT, {&edi_params.outfrq},
"Freqency (in steps) of writing output in [TT].xvg[tt] file" },
{ "-slope", FALSE, etREAL, { &edi_params.slope},
"Minimal slope in acceptance radius expansion"},
{ "-linstep", FALSE, etSTR, {&evParams[0]},
"Stepsizes (nm/step) for fixed increment linear sampling (put in quotes! \"1.0 2.3 5.1 -3.1\")"},
{ "-accdir", FALSE, etSTR, {&evParams[1]},
"Directions for acceptance linear sampling - only sign counts! (put in quotes! \"-1 +1 -1.1\")"},
{ "-radstep", FALSE, etREAL, {&radstep},
"Stepsize (nm/step) for fixed increment radius expansion"},
{ "-maxedsteps", FALSE, etINT, {&edi_params.maxedsteps},
"Maximum number of steps per cycle" },
{ "-eqsteps", FALSE, etINT, {&eqSteps},
"Number of steps to run without any perturbations "},
{ "-deltaF0", FALSE, etREAL, {&deltaF0},
"Target destabilization energy for flooding"},
{ "-deltaF", FALSE, etREAL, {&deltaF},
"Start deltaF with this parameter - default 0, nonzero values only needed for restart"},
{ "-tau", FALSE, etREAL, {&tau},
"Coupling constant for adaption of flooding strength according to deltaF0, 0 = infinity i.e. constant flooding strength"},
{ "-Eflnull", FALSE, etREAL, {&constEfl},
"The starting value of the flooding strength. The flooding strength is updated "
"according to the adaptive flooding scheme. For a constant flooding strength use [TT]-tau[tt] 0. "},
{ "-T", FALSE, etREAL, {&T},
"T is temperature, the value is needed if you want to do flooding "},
{ "-alpha", FALSE, etREAL, {&alpha},
"Scale width of gaussian flooding potential with alpha^2 "},
{ "-restrain", FALSE, etBOOL, {&bRestrain},
"Use the flooding potential with inverted sign -> effects as quasiharmonic restraining potential"},
{ "-hessian", FALSE, etBOOL, {&bHesse},
"The eigenvectors and eigenvalues are from a Hessian matrix"},
{ "-harmonic", FALSE, etBOOL, {&bHarmonic},
"The eigenvalues are interpreted as spring constant"},
{ "-constF", FALSE, etSTR, {&ConstForceStr},
"Constant force flooding: manually set the forces for the eigenvectors selected with -flood "
"(put in quotes! \"1.0 2.3 5.1 -3.1\"). No other flooding parameters are needed when specifying the forces directly."}
};
#define NPA asize(pa)
rvec *xref1;
int nvec1, *eignr1 = NULL;
rvec *xav1, **eigvec1 = NULL;
t_atoms *atoms = NULL;
int nav; /* Number of atoms in the average structure */
char *grpname;
const char *indexfile;
int i;
atom_id *index, *ifit;
int nfit; /* Number of atoms in the reference/fit structure */
int ev_class; /* parameter _class i.e. evMON, evRADFIX etc. */
int nvecs;
real *eigval1 = NULL; /* in V3.3 this is parameter of read_eigenvectors */
const char *EdiFile;
const char *TargetFile;
const char *OriginFile;
const char *EigvecFile;
output_env_t oenv;
/*to read topology file*/
t_topology top;
int ePBC;
char title[STRLEN];
matrix topbox;
rvec *xtop;
gmx_bool bTop, bFit1;
t_filenm fnm[] = {
{ efTRN, "-f", "eigenvec", ffREAD },
{ efXVG, "-eig", "eigenval", ffOPTRD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efSTX, "-tar", "target", ffOPTRD},
{ efSTX, "-ori", "origin", ffOPTRD},
{ efEDI, "-o", "sam", ffWRITE }
};
#define NFILE asize(fnm)
edi_params.outfrq = 100; edi_params.slope = 0.0; edi_params.maxedsteps = 0;
if (!parse_common_args(&argc, argv, 0,
NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
indexfile = ftp2fn_null(efNDX, NFILE, fnm);
EdiFile = ftp2fn(efEDI, NFILE, fnm);
TargetFile = opt2fn_null("-tar", NFILE, fnm);
OriginFile = opt2fn_null("-ori", NFILE, fnm);
for (ev_class = 0; ev_class < evNr; ++ev_class)
{
if (opt2parg_bSet(evOptions[ev_class], NPA, pa))
{
/*get list of eigenvectors*/
nvecs = sscan_list(&(listen[ev_class]), opt2parg_str(evOptions[ev_class], NPA, pa), evOptions[ev_class]);
if (ev_class < evStepNr-2)
{
/*if apropriate get list of stepsizes for these eigenvectors*/
if (opt2parg_bSet(evStepOptions[ev_class], NPA, pa))
{
evStepList[ev_class] =
scan_vecparams(opt2parg_str(evStepOptions[ev_class], NPA, pa), evStepOptions[ev_class], nvecs);
}
else /*if list is not given fill with zeros */
{
snew(evStepList[ev_class], nvecs);
for (i = 0; i < nvecs; i++)
{
evStepList[ev_class][i] = 0.0;
}
}
}
else if (ev_class == evRADFIX)
{
snew(evStepList[ev_class], nvecs);
for (i = 0; i < nvecs; i++)
{
evStepList[ev_class][i] = radstep;
}
}
else if (ev_class == evFLOOD)
{
snew(evStepList[ev_class], nvecs);
/* Are we doing constant force flooding? In that case, we read in
* the fproj values from the command line */
if (opt2parg_bSet("-constF", NPA, pa))
{
evStepList[ev_class] = scan_vecparams(opt2parg_str("-constF", NPA, pa), "-constF", nvecs);
}
}
else
{
}; /*to avoid ambiguity */
}
else /* if there are no eigenvectors for this option set list to zero */
{
listen[ev_class] = NULL;
snew(listen[ev_class], 1);
listen[ev_class][0] = 0;
}
}
/* print the interpreted list of eigenvectors - to give some feedback*/
for (ev_class = 0; ev_class < evNr; ++ev_class)
{
printf("Eigenvector list %7s consists of the indices: ", evOptions[ev_class]);
i = 0;
while (listen[ev_class][i])
{
printf("%d ", listen[ev_class][i++]);
}
printf("\n");
}
EigvecFile = NULL;
EigvecFile = opt2fn("-f", NFILE, fnm);
/*read eigenvectors from eigvec.trr*/
read_eigenvectors(EigvecFile, &nav, &bFit1,
&xref1, &edi_params.fitmas, &xav1, &edi_params.pcamas, &nvec1, &eignr1, &eigvec1, &eigval1);
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm),
title, &top, &ePBC, &xtop, NULL, topbox, 0);
atoms = &top.atoms;
printf("\nSelect an index group of %d elements that corresponds to the eigenvectors\n", nav);
get_index(atoms, indexfile, 1, &i, &index, &grpname); /*if indexfile != NULL parameter 'atoms' is ignored */
if (i != nav)
{
gmx_fatal(FARGS, "you selected a group with %d elements instead of %d",
i, nav);
}
printf("\n");
if (xref1 == NULL)
{
if (bFit1)
{
/* if g_covar used different coordinate groups to fit and to do the PCA */
printf("\nNote: the structure in %s should be the same\n"
" as the one used for the fit in g_covar\n", ftp2fn(efTPS, NFILE, fnm));
printf("\nSelect the index group that was used for the least squares fit in g_covar\n");
}
else
{
printf("\nNote: Apparently no fitting was done in g_covar.\n"
" However, you need to select a reference group for fitting in mdrun\n");
}
get_index(atoms, indexfile, 1, &nfit, &ifit, &grpname);
snew(xref1, nfit);
for (i = 0; i < nfit; i++)
{
copy_rvec(xtop[ifit[i]], xref1[i]);
}
}
else
{
nfit = nav;
ifit = index;
}
if (opt2parg_bSet("-constF", NPA, pa))
{
/* Constant force flooding is special: Most of the normal flooding
* options are not needed. */
edi_params.flood.bConstForce = TRUE;
}
else
{
/* For normal flooding read eigenvalues and store them in evSteplist[evFLOOD] */
if (listen[evFLOOD][0] != 0)
{
read_eigenvalues(listen[evFLOOD], opt2fn("-eig", NFILE, fnm), evStepList[evFLOOD], bHesse, kB*T);
}
edi_params.flood.tau = tau;
edi_params.flood.deltaF0 = deltaF0;
edi_params.flood.deltaF = deltaF;
edi_params.presteps = eqSteps;
edi_params.flood.kT = kB*T;
edi_params.flood.bHarmonic = bHarmonic;
if (bRestrain)
{
/* Trick: invert sign of Efl and alpha2 then this will give the same sign in the exponential and inverted sign outside */
edi_params.flood.constEfl = -constEfl;
edi_params.flood.alpha2 = -sqr(alpha);
}
else
{
edi_params.flood.constEfl = constEfl;
edi_params.flood.alpha2 = sqr(alpha);
}
}
edi_params.ned = nav;
/*number of system atoms */
edi_params.nini = atoms->nr;
/*store reference and average structure in edi_params*/
make_t_edx(&edi_params.sref, nfit, xref1, ifit );
make_t_edx(&edi_params.sav, nav, xav1, index);
/* Store target positions in edi_params */
if (opt2bSet("-tar", NFILE, fnm))
{
if (0 != listen[evFLOOD][0])
{
fprintf(stderr, "\nNote: Providing a TARGET structure has no effect when using flooding.\n"
" You may want to use -ori to define the flooding potential center.\n\n");
}
get_structure(atoms, indexfile, TargetFile, &edi_params.star, nfit, ifit, nav, index);
}
else
{
make_t_edx(&edi_params.star, 0, NULL, index);
}
/* Store origin positions */
if (opt2bSet("-ori", NFILE, fnm))
{
get_structure(atoms, indexfile, OriginFile, &edi_params.sori, nfit, ifit, nav, index);
}
else
{
make_t_edx(&edi_params.sori, 0, NULL, index);
}
/* Write edi-file */
write_the_whole_thing(gmx_ffopen(EdiFile, "w"), &edi_params, eigvec1, nvec1, listen, evStepList);
return 0;
}
int gmx_nmtraj(int argc, char *argv[])
{
const char *desc[] =
{
"[THISMODULE] generates an virtual trajectory from an eigenvector, ",
"corresponding to a harmonic Cartesian oscillation around the average ",
"structure. The eigenvectors should normally be mass-weighted, but you can ",
"use non-weighted eigenvectors to generate orthogonal motions. ",
"The output frames are written as a trajectory file covering an entire period, and ",
"the first frame is the average structure. If you write the trajectory in (or convert to) ",
"PDB format you can view it directly in PyMol and also render a photorealistic movie. ",
"Motion amplitudes are calculated from the eigenvalues and a preset temperature, ",
"assuming equipartition of the energy over all modes. To make the motion clearly visible ",
"in PyMol you might want to amplify it by setting an unrealistically high temperature. ",
"However, be aware that both the linear Cartesian displacements and mass weighting will ",
"lead to serious structure deformation for high amplitudes - this is is simply a limitation ",
"of the Cartesian normal mode model. By default the selected eigenvector is set to 7, since ",
"the first six normal modes are the translational and rotational degrees of freedom."
};
static real refamplitude = 0.25;
static int nframes = 30;
static real temp = 300.0;
static const char *eignrvec = "7";
static const char *phasevec = "0.0";
t_pargs pa[] =
{
{ "-eignr", FALSE, etSTR, {&eignrvec}, "String of eigenvectors to use (first is 1)" },
{ "-phases", FALSE, etSTR, {&phasevec}, "String of phases (default is 0.0)" },
{ "-temp", FALSE, etREAL, {&temp}, "Temperature (K)" },
{ "-amplitude", FALSE, etREAL, {&refamplitude}, "Amplitude for modes with eigenvalue<=0" },
{ "-nframes", FALSE, etINT, {&nframes}, "Number of frames to generate" }
};
#define NPA asize(pa)
t_trxstatus *out;
t_topology top;
int ePBC;
t_atoms *atoms;
rvec *xtop, *xref, *xav, *xout;
int nvec, *eignr = NULL;
rvec **eigvec = NULL;
matrix box;
int natoms;
int i, j, k, kmode, d;
gmx_bool bDMR, bDMA, bFit;
real * eigval;
int * dummy;
real * invsqrtm;
real fraction;
int *out_eigidx;
rvec * this_eigvec;
real omega, Ekin, m, vel;
int nmodes, nphases;
int *imodes;
real *amplitude;
real *phases;
const char *p;
char *pe;
output_env_t oenv;
t_filenm fnm[] =
{
{ efTPS, NULL, NULL, ffREAD },
{ efTRN, "-v", "eigenvec", ffREAD },
{ efTRO, "-o", "nmtraj", ffWRITE }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, 0,
NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
read_eigenvectors(opt2fn("-v", NFILE, fnm), &natoms, &bFit,
&xref, &bDMR, &xav, &bDMA, &nvec, &eignr, &eigvec, &eigval);
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, &xtop, NULL, box, bDMA);
/* Find vectors and phases */
/* first find number of args in string */
nmodes = gmx::countWords(eignrvec);
snew(imodes, nmodes);
p = eignrvec;
for (i = 0; i < nmodes; i++)
{
/* C indices start on 0 */
imodes[i] = std::strtol(p, &pe, 10)-1;
p = pe;
}
/* Now read phases */
nphases = gmx::countWords(phasevec);
if (nphases > nmodes)
{
gmx_fatal(FARGS, "More phases than eigenvector indices specified.\n");
}
snew(phases, nmodes);
p = phasevec;
for (i = 0; i < nphases; i++)
{
phases[i] = strtod(p, &pe);
p = pe;
}
if (nmodes > nphases)
{
printf("Warning: Setting phase of last %d modes to zero...\n", nmodes-nphases);
}
for (i = nphases; i < nmodes; i++)
{
phases[i] = 0;
}
atoms = &top.atoms;
if (atoms->nr != natoms)
{
gmx_fatal(FARGS, "Different number of atoms in topology and eigenvectors.\n");
}
snew(dummy, natoms);
for (i = 0; i < natoms; i++)
{
dummy[i] = i;
}
/* Find the eigenvalue/vector to match our select one */
snew(out_eigidx, nmodes);
for (i = 0; i < nmodes; i++)
{
out_eigidx[i] = -1;
}
for (i = 0; i < nvec; i++)
{
for (j = 0; j < nmodes; j++)
{
if (imodes[j] == eignr[i])
{
out_eigidx[j] = i;
}
}
}
for (i = 0; i < nmodes; i++)
{
if (out_eigidx[i] == -1)
{
gmx_fatal(FARGS, "Could not find mode %d in eigenvector file.\n", imodes[i]);
}
}
snew(invsqrtm, natoms);
if (bDMA)
{
for (i = 0; (i < natoms); i++)
{
invsqrtm[i] = gmx_invsqrt(atoms->atom[i].m);
}
}
else
{
for (i = 0; (i < natoms); i++)
{
invsqrtm[i] = 1.0;
}
}
snew(xout, natoms);
snew(amplitude, nmodes);
printf("mode phases: %g %g\n", phases[0], phases[1]);
for (i = 0; i < nmodes; i++)
{
kmode = out_eigidx[i];
this_eigvec = eigvec[kmode];
if ( (kmode >= 6) && (eigval[kmode] > 0))
{
/* Derive amplitude from temperature and eigenvalue if we can */
/* Convert eigenvalue to angular frequency, in units s^(-1) */
omega = std::sqrt(eigval[kmode]*1.0E21/(AVOGADRO*AMU));
/* Harmonic motion will be x=x0 + A*sin(omega*t)*eigenvec.
* The velocity is thus:
*
* v = A*omega*cos(omega*t)*eigenvec.
*
* And the average kinetic energy the integral of mass*v*v/2 over a
* period:
*
* (1/4)*mass*A*omega*eigenvec
*
* For t =2*pi*n, all energy will be kinetic, and v=A*omega*eigenvec.
* The kinetic energy will be sum(0.5*mass*v*v) if we temporarily set A to 1,
* and the average over a period half of this.
*/
Ekin = 0;
for (k = 0; k < natoms; k++)
{
m = atoms->atom[k].m;
for (d = 0; d < DIM; d++)
{
vel = omega*this_eigvec[k][d];
Ekin += 0.5*0.5*m*vel*vel;
}
}
/* Convert Ekin from amu*(nm/s)^2 to J, i.e., kg*(m/s)^2
* This will also be proportional to A^2
*/
Ekin *= AMU*1E-18;
/* Set the amplitude so the energy is kT/2 */
amplitude[i] = std::sqrt(0.5*BOLTZMANN*temp/Ekin);
}
else
{
amplitude[i] = refamplitude;
}
}
out = open_trx(ftp2fn(efTRO, NFILE, fnm), "w");
/* Write a sine oscillation around the average structure,
* modulated by the eigenvector with selected amplitude.
*/
for (i = 0; i < nframes; i++)
{
fraction = static_cast<real>(i)/nframes;
for (j = 0; j < natoms; j++)
{
copy_rvec(xav[j], xout[j]);
}
for (k = 0; k < nmodes; k++)
{
kmode = out_eigidx[k];
this_eigvec = eigvec[kmode];
for (j = 0; j < natoms; j++)
{
for (d = 0; d < DIM; d++)
{
xout[j][d] += amplitude[k]*std::sin(2*M_PI*(fraction+phases[k]/360.0))*this_eigvec[j][d];
}
}
}
write_trx(out, natoms, dummy, atoms, i, static_cast<real>(i)/nframes, box, xout, NULL, NULL);
}
fprintf(stderr, "\n");
close_trx(out);
return 0;
}