void gmx_write_pdb_box(FILE *out, int ePBC, const matrix box)
{
real alpha, beta, gamma;
if (ePBC == -1)
{
ePBC = guess_ePBC(box);
}
if (ePBC == epbcNONE)
{
return;
}
if (norm2(box[YY])*norm2(box[ZZ]) != 0)
{
alpha = RAD2DEG*gmx_angle(box[YY], box[ZZ]);
}
else
{
alpha = 90;
}
if (norm2(box[XX])*norm2(box[ZZ]) != 0)
{
beta = RAD2DEG*gmx_angle(box[XX], box[ZZ]);
}
else
{
beta = 90;
}
if (norm2(box[XX])*norm2(box[YY]) != 0)
{
gamma = RAD2DEG*gmx_angle(box[XX], box[YY]);
}
else
{
gamma = 90;
}
fprintf(out, "REMARK THIS IS A SIMULATION BOX\n");
if (ePBC != epbcSCREW)
{
fprintf(out, "CRYST1%9.3f%9.3f%9.3f%7.2f%7.2f%7.2f %-11s%4d\n",
10*norm(box[XX]), 10*norm(box[YY]), 10*norm(box[ZZ]),
alpha, beta, gamma, "P 1", 1);
}
else
{
/* Double the a-vector length and write the correct space group */
fprintf(out, "CRYST1%9.3f%9.3f%9.3f%7.2f%7.2f%7.2f %-11s%4d\n",
20*norm(box[XX]), 10*norm(box[YY]), 10*norm(box[ZZ]),
alpha, beta, gamma, "P 21 1 1", 1);
}
}
void calc_order(const char *fn, atom_id *index, atom_id *a, rvec **order,
real ***slOrder, real *slWidth, int nslices, gmx_bool bSliced,
gmx_bool bUnsat, t_topology *top, int ePBC, int ngrps, int axis,
gmx_bool permolecule, gmx_bool radial, gmx_bool distcalc, const char *radfn,
real ***distvals,
const gmx_output_env_t *oenv)
{
/* if permolecule = TRUE, order parameters will be calculed per molecule
* and stored in slOrder with #slices = # molecules */
rvec *x0, /* coordinates with pbc */
*x1, /* coordinates without pbc */
dist; /* vector between two atoms */
matrix box; /* box (3x3) */
t_trxstatus *status;
rvec cossum, /* sum of vector angles for three axes */
Sx, Sy, Sz, /* the three molecular axes */
tmp1, tmp2, /* temp. rvecs for calculating dot products */
frameorder; /* order parameters for one frame */
real *slFrameorder; /* order parameter for one frame, per slice */
real length, /* total distance between two atoms */
t, /* time from trajectory */
z_ave, z1, z2; /* average z, used to det. which slice atom is in */
int natoms, /* nr. atoms in trj */
nr_tails, /* nr tails, to check if index file is correct */
size = 0, /* nr. of atoms in group. same as nr_tails */
i, j, m, k, teller = 0,
slice, /* current slice number */
nr_frames = 0;
int *slCount; /* nr. of atoms in one slice */
real sdbangle = 0; /* sum of these angles */
gmx_bool use_unitvector = FALSE; /* use a specified unit vector instead of axis to specify unit normal*/
rvec direction, com, dref, dvec;
int comsize, distsize;
atom_id *comidx = NULL, *distidx = NULL;
char *grpname = NULL;
t_pbc pbc;
real arcdist, tmpdist;
gmx_rmpbc_t gpbc = NULL;
/* PBC added for center-of-mass vector*/
/* Initiate the pbc structure */
std::memset(&pbc, 0, sizeof(pbc));
if ((natoms = read_first_x(oenv, &status, fn, &t, &x0, box)) == 0)
{
gmx_fatal(FARGS, "Could not read coordinates from statusfile\n");
}
nr_tails = index[1] - index[0];
fprintf(stderr, "Number of elements in first group: %d\n", nr_tails);
/* take first group as standard. Not rocksolid, but might catch error in index*/
if (permolecule)
{
nslices = nr_tails;
bSliced = FALSE; /*force slices off */
fprintf(stderr, "Calculating order parameters for each of %d molecules\n",
nslices);
}
if (radial)
{
use_unitvector = TRUE;
fprintf(stderr, "Select an index group to calculate the radial membrane normal\n");
get_index(&top->atoms, radfn, 1, &comsize, &comidx, &grpname);
}
if (distcalc)
{
if (grpname != NULL)
{
sfree(grpname);
}
fprintf(stderr, "Select an index group to use as distance reference\n");
get_index(&top->atoms, radfn, 1, &distsize, &distidx, &grpname);
bSliced = FALSE; /*force slices off*/
}
if (use_unitvector && bSliced)
{
fprintf(stderr, "Warning: slicing and specified unit vectors are not currently compatible\n");
}
snew(slCount, nslices);
snew(*slOrder, nslices);
for (i = 0; i < nslices; i++)
{
snew((*slOrder)[i], ngrps);
}
if (distcalc)
{
snew(*distvals, nslices);
for (i = 0; i < nslices; i++)
{
snew((*distvals)[i], ngrps);
}
}
snew(*order, ngrps);
snew(slFrameorder, nslices);
snew(x1, natoms);
if (bSliced)
{
*slWidth = box[axis][axis]/nslices;
fprintf(stderr, "Box divided in %d slices. Initial width of slice: %f\n",
nslices, *slWidth);
}
#if 0
nr_tails = index[1] - index[0];
fprintf(stderr, "Number of elements in first group: %d\n", nr_tails);
/* take first group as standard. Not rocksolid, but might catch error
in index*/
#endif
teller = 0;
gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
/*********** Start processing trajectory ***********/
do
{
if (bSliced)
{
*slWidth = box[axis][axis]/nslices;
}
teller++;
set_pbc(&pbc, ePBC, box);
gmx_rmpbc_copy(gpbc, natoms, box, x0, x1);
/* Now loop over all groups. There are ngrps groups, the order parameter can
be calculated for grp 1 to grp ngrps - 1. For each group, loop over all
atoms in group, which is index[i] to (index[i+1] - 1) See block.h. Of
course, in this case index[i+1] -index[i] has to be the same for all
groups, namely the number of tails. i just runs over all atoms in a tail,
so for DPPC ngrps = 16 and i runs from 1 to 14, including 14
*/
if (radial)
{
/*center-of-mass determination*/
com[XX] = 0.0; com[YY] = 0.0; com[ZZ] = 0.0;
for (j = 0; j < comsize; j++)
{
rvec_inc(com, x1[comidx[j]]);
}
svmul(1.0/comsize, com, com);
}
if (distcalc)
{
dref[XX] = 0.0; dref[YY] = 0.0; dref[ZZ] = 0.0;
for (j = 0; j < distsize; j++)
{
rvec_inc(dist, x1[distidx[j]]);
}
svmul(1.0/distsize, dref, dref);
if (radial)
{
pbc_dx(&pbc, dref, com, dvec);
unitv(dvec, dvec);
}
}
for (i = 1; i < ngrps - 1; i++)
{
clear_rvec(frameorder);
size = index[i+1] - index[i];
if (size != nr_tails)
{
gmx_fatal(FARGS, "grp %d does not have same number of"
" elements as grp 1\n", i);
}
for (j = 0; j < size; j++)
{
if (radial)
/*create unit vector*/
{
pbc_dx(&pbc, x1[a[index[i]+j]], com, direction);
unitv(direction, direction);
/*DEBUG*/
/*if (j==0)
fprintf(stderr,"X %f %f %f\tcom %f %f %f\tdirection %f %f %f\n",x1[a[index[i]+j]][0],x1[a[index[i]+j]][1],x1[a[index[i]+j]][2],com[0],com[1],com[2],
direction[0],direction[1],direction[2]);*/
}
if (bUnsat)
{
/* Using convention for unsaturated carbons */
/* first get Sz, the vector from Cn to Cn+1 */
rvec_sub(x1[a[index[i+1]+j]], x1[a[index[i]+j]], dist);
length = norm(dist);
check_length(length, a[index[i]+j], a[index[i+1]+j]);
svmul(1.0/length, dist, Sz);
/* this is actually the cosine of the angle between the double bond
and axis, because Sz is normalized and the two other components of
the axis on the bilayer are zero */
if (use_unitvector)
{
sdbangle += gmx_angle(direction, Sz); /*this can probably be optimized*/
}
else
{
sdbangle += std::acos(Sz[axis]);
}
}
else
{
/* get vector dist(Cn-1,Cn+1) for tail atoms */
rvec_sub(x1[a[index[i+1]+j]], x1[a[index[i-1]+j]], dist);
length = norm(dist); /* determine distance between two atoms */
check_length(length, a[index[i-1]+j], a[index[i+1]+j]);
svmul(1.0/length, dist, Sz);
/* Sz is now the molecular axis Sz, normalized and all that */
}
/* now get Sx. Sx is normal to the plane of Cn-1, Cn and Cn+1 so
we can use the outer product of Cn-1->Cn and Cn+1->Cn, I hope */
rvec_sub(x1[a[index[i+1]+j]], x1[a[index[i]+j]], tmp1);
rvec_sub(x1[a[index[i-1]+j]], x1[a[index[i]+j]], tmp2);
cprod(tmp1, tmp2, Sx);
svmul(1.0/norm(Sx), Sx, Sx);
/* now we can get Sy from the outer product of Sx and Sz */
cprod(Sz, Sx, Sy);
svmul(1.0/norm(Sy), Sy, Sy);
/* the square of cosine of the angle between dist and the axis.
Using the innerproduct, but two of the three elements are zero
Determine the sum of the orderparameter of all atoms in group
*/
if (use_unitvector)
{
cossum[XX] = sqr(iprod(Sx, direction)); /* this is allowed, since Sa is normalized */
cossum[YY] = sqr(iprod(Sy, direction));
cossum[ZZ] = sqr(iprod(Sz, direction));
}
else
{
cossum[XX] = sqr(Sx[axis]); /* this is allowed, since Sa is normalized */
cossum[YY] = sqr(Sy[axis]);
cossum[ZZ] = sqr(Sz[axis]);
}
for (m = 0; m < DIM; m++)
{
frameorder[m] += 0.5 * (3.0 * cossum[m] - 1.0);
}
if (bSliced)
{
/* get average coordinate in box length for slicing,
determine which slice atom is in, increase count for that
slice. slFrameorder and slOrder are reals, not
rvecs. Only the component [axis] of the order tensor is
kept, until I find it necessary to know the others too
*/
z1 = x1[a[index[i-1]+j]][axis];
z2 = x1[a[index[i+1]+j]][axis];
z_ave = 0.5 * (z1 + z2);
if (z_ave < 0)
{
z_ave += box[axis][axis];
}
if (z_ave > box[axis][axis])
{
z_ave -= box[axis][axis];
}
slice = static_cast<int>((0.5 + (z_ave / (*slWidth))) - 1);
slCount[slice]++; /* determine slice, increase count */
slFrameorder[slice] += 0.5 * (3 * cossum[axis] - 1);
}
else if (permolecule)
{
/* store per-molecule order parameter
* To just track single-axis order: (*slOrder)[j][i] += 0.5 * (3 * iprod(cossum,direction) - 1);
* following is for Scd order: */
(*slOrder)[j][i] += -1* (1.0/3.0 * (3 * cossum[XX] - 1) + 1.0/3.0 * 0.5 * (3.0 * cossum[YY] - 1));
}
if (distcalc)
{
if (radial)
{
/* bin order parameter by arc distance from reference group*/
arcdist = gmx_angle(dvec, direction);
(*distvals)[j][i] += arcdist;
}
else if (i == 1)
{
/* Want minimum lateral distance to first group calculated */
tmpdist = trace(box); /* should be max value */
for (k = 0; k < distsize; k++)
{
pbc_dx(&pbc, x1[distidx[k]], x1[a[index[i]+j]], dvec);
/* at the moment, just remove dvec[axis] */
dvec[axis] = 0;
tmpdist = std::min(tmpdist, norm2(dvec));
}
//fprintf(stderr, "Min dist %f; trace %f\n", tmpdist, trace(box));
(*distvals)[j][i] += std::sqrt(tmpdist);
}
}
} /* end loop j, over all atoms in group */
for (m = 0; m < DIM; m++)
{
(*order)[i][m] += (frameorder[m]/size);
}
if (!permolecule)
{ /*Skip following if doing per-molecule*/
for (k = 0; k < nslices; k++)
{
if (slCount[k]) /* if no elements, nothing has to be added */
{
(*slOrder)[k][i] += slFrameorder[k]/slCount[k];
slFrameorder[k] = 0; slCount[k] = 0;
}
}
} /* end loop i, over all groups in indexfile */
}
nr_frames++;
}
while (read_next_x(oenv, status, &t, x0, box));
/*********** done with status file **********/
fprintf(stderr, "\nRead trajectory. Printing parameters to file\n");
gmx_rmpbc_done(gpbc);
/* average over frames */
for (i = 1; i < ngrps - 1; i++)
{
svmul(1.0/nr_frames, (*order)[i], (*order)[i]);
fprintf(stderr, "Atom %d Tensor: x=%g , y=%g, z=%g\n", i, (*order)[i][XX],
(*order)[i][YY], (*order)[i][ZZ]);
if (bSliced || permolecule)
{
for (k = 0; k < nslices; k++)
{
(*slOrder)[k][i] /= nr_frames;
}
}
if (distcalc)
{
for (k = 0; k < nslices; k++)
{
(*distvals)[k][i] /= nr_frames;
}
}
}
if (bUnsat)
{
fprintf(stderr, "Average angle between double bond and normal: %f\n",
180*sdbangle/(nr_frames * size*M_PI));
}
sfree(x0); /* free memory used by coordinate arrays */
sfree(x1);
if (comidx != NULL)
{
sfree(comidx);
}
if (distidx != NULL)
{
sfree(distidx);
}
if (grpname != NULL)
{
sfree(grpname);
}
}
void
Angle::analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc,
TrajectoryAnalysisModuleData *pdata)
{
AnalysisDataHandle dh = pdata->dataHandle(angles_);
const SelectionList &sel1 = pdata->parallelSelections(sel1_);
const SelectionList &sel2 = pdata->parallelSelections(sel2_);
checkSelections(sel1, sel2);
dh.startFrame(frnr, fr.time);
for (size_t g = 0; g < sel1_.size(); ++g)
{
rvec v1, v2;
rvec c1, c2;
switch (g2type_[0])
{
case 'z':
clear_rvec(v2);
v2[ZZ] = 1.0;
clear_rvec(c2);
break;
case 's':
copy_rvec(sel2_[g].position(0).x(), c2);
break;
}
for (int i = 0, j = 0, n = 0;
i < sel1[g].posCount();
i += natoms1_, j += natoms2_, ++n)
{
rvec x[4];
real angle;
copy_pos(sel1, natoms1_, g, i, x);
switch (g1type_[0])
{
case 'a':
if (pbc)
{
pbc_dx(pbc, x[0], x[1], v1);
pbc_dx(pbc, x[2], x[1], v2);
}
else
{
rvec_sub(x[0], x[1], v1);
rvec_sub(x[2], x[1], v2);
}
angle = gmx_angle(v1, v2);
break;
case 'd':
{
rvec dx[3];
if (pbc)
{
pbc_dx(pbc, x[0], x[1], dx[0]);
pbc_dx(pbc, x[2], x[1], dx[1]);
pbc_dx(pbc, x[2], x[3], dx[2]);
}
else
{
rvec_sub(x[0], x[1], dx[0]);
rvec_sub(x[2], x[1], dx[1]);
rvec_sub(x[2], x[3], dx[2]);
}
cprod(dx[0], dx[1], v1);
cprod(dx[1], dx[2], v2);
angle = gmx_angle(v1, v2);
real ipr = iprod(dx[0], v2);
if (ipr < 0)
{
angle = -angle;
}
break;
}
case 'v':
case 'p':
calc_vec(natoms1_, x, pbc, v1, c1);
switch (g2type_[0])
{
case 'v':
case 'p':
copy_pos(sel2, natoms2_, 0, j, x);
calc_vec(natoms2_, x, pbc, v2, c2);
break;
case 't':
// FIXME: This is not parallelizable.
if (frnr == 0)
{
copy_rvec(v1, vt0_[g][n]);
}
copy_rvec(vt0_[g][n], v2);
break;
case 'z':
c1[XX] = c1[YY] = 0.0;
break;
case 's':
if (pbc)
{
pbc_dx(pbc, c1, c2, v2);
}
else
{
rvec_sub(c1, c2, v2);
}
break;
default:
GMX_THROW(InternalError("invalid -g2 value"));
}
angle = gmx_angle(v1, v2);
break;
default:
GMX_THROW(InternalError("invalid -g1 value"));
}
/* TODO: Should we also calculate distances like g_sgangle?
* Could be better to leave that for a separate tool.
real dist = 0.0;
if (bDumpDist_)
{
if (pbc)
{
rvec dx;
pbc_dx(pbc, c2, c1, dx);
dist = norm(dx);
}
else
{
dist = sqrt(distance2(c1, c2));
}
}
*/
dh.setPoint(n, angle * RAD2DEG);
}
}
dh.finishFrame();
}
int gmx_editconf(int argc, char *argv[])
{
const char *desc[] =
{
"[THISMODULE] converts generic structure format to [REF].gro[ref], [TT].g96[tt]",
"or [REF].pdb[ref].",
"[PAR]",
"The box can be modified with options [TT]-box[tt], [TT]-d[tt] and",
"[TT]-angles[tt]. Both [TT]-box[tt] and [TT]-d[tt]",
"will center the system in the box, unless [TT]-noc[tt] is used.",
"The [TT]-center[tt] option can be used to shift the geometric center",
"of the system from the default of (x/2, y/2, z/2) implied by [TT]-c[tt]",
"to some other value.",
"[PAR]",
"Option [TT]-bt[tt] determines the box type: [TT]triclinic[tt] is a",
"triclinic box, [TT]cubic[tt] is a rectangular box with all sides equal",
"[TT]dodecahedron[tt] represents a rhombic dodecahedron and",
"[TT]octahedron[tt] is a truncated octahedron.",
"The last two are special cases of a triclinic box.",
"The length of the three box vectors of the truncated octahedron is the",
"shortest distance between two opposite hexagons.",
"Relative to a cubic box with some periodic image distance, the volume of a ",
"dodecahedron with this same periodic distance is 0.71 times that of the cube, ",
"and that of a truncated octahedron is 0.77 times.",
"[PAR]",
"Option [TT]-box[tt] requires only",
"one value for a cubic, rhombic dodecahedral, or truncated octahedral box.",
"[PAR]",
"With [TT]-d[tt] and a [TT]triclinic[tt] box the size of the system in the [IT]x[it]-, [IT]y[it]-,",
"and [IT]z[it]-directions is used. With [TT]-d[tt] and [TT]cubic[tt],",
"[TT]dodecahedron[tt] or [TT]octahedron[tt] boxes, the dimensions are set",
"to the diameter of the system (largest distance between atoms) plus twice",
"the specified distance.",
"[PAR]",
"Option [TT]-angles[tt] is only meaningful with option [TT]-box[tt] and",
"a triclinic box and cannot be used with option [TT]-d[tt].",
"[PAR]",
"When [TT]-n[tt] or [TT]-ndef[tt] is set, a group",
"can be selected for calculating the size and the geometric center,",
"otherwise the whole system is used.",
"[PAR]",
"[TT]-rotate[tt] rotates the coordinates and velocities.",
"[PAR]",
"[TT]-princ[tt] aligns the principal axes of the system along the",
"coordinate axes, with the longest axis aligned with the [IT]x[it]-axis. ",
"This may allow you to decrease the box volume,",
"but beware that molecules can rotate significantly in a nanosecond.",
"[PAR]",
"Scaling is applied before any of the other operations are",
"performed. Boxes and coordinates can be scaled to give a certain density (option",
"[TT]-density[tt]). Note that this may be inaccurate in case a [REF].gro[ref]",
"file is given as input. A special feature of the scaling option is that when the",
"factor -1 is given in one dimension, one obtains a mirror image,",
"mirrored in one of the planes. When one uses -1 in three dimensions, ",
"a point-mirror image is obtained.[PAR]",
"Groups are selected after all operations have been applied.[PAR]",
"Periodicity can be removed in a crude manner.",
"It is important that the box vectors at the bottom of your input file",
"are correct when the periodicity is to be removed.",
"[PAR]",
"When writing [REF].pdb[ref] files, B-factors can be",
"added with the [TT]-bf[tt] option. B-factors are read",
"from a file with with following format: first line states number of",
"entries in the file, next lines state an index",
"followed by a B-factor. The B-factors will be attached per residue",
"unless the number of B-factors is larger than the number of the residues or unless the",
"[TT]-atom[tt] option is set. Obviously, any type of numeric data can",
"be added instead of B-factors. [TT]-legend[tt] will produce",
"a row of CA atoms with B-factors ranging from the minimum to the",
"maximum value found, effectively making a legend for viewing.",
"[PAR]",
"With the option [TT]-mead[tt] a special [REF].pdb[ref] ([REF].pqr[ref])",
"file for the MEAD electrostatics",
"program (Poisson-Boltzmann solver) can be made. A further prerequisite",
"is that the input file is a run input file.",
"The B-factor field is then filled with the Van der Waals radius",
"of the atoms while the occupancy field will hold the charge.",
"[PAR]",
"The option [TT]-grasp[tt] is similar, but it puts the charges in the B-factor",
"and the radius in the occupancy.",
"[PAR]",
"Option [TT]-align[tt] allows alignment",
"of the principal axis of a specified group against the given vector, ",
"with an optional center of rotation specified by [TT]-aligncenter[tt].",
"[PAR]",
"Finally, with option [TT]-label[tt], [TT]editconf[tt] can add a chain identifier",
"to a [REF].pdb[ref] file, which can be useful for analysis with e.g. Rasmol.",
"[PAR]",
"To convert a truncated octrahedron file produced by a package which uses",
"a cubic box with the corners cut off (such as GROMOS), use::",
"",
" gmx editconf -f in -rotate 0 45 35.264 -bt o -box veclen -o out",
"",
"where [TT]veclen[tt] is the size of the cubic box times [SQRT]3[sqrt]/2."
};
const char *bugs[] =
{
"For complex molecules, the periodicity removal routine may break down, "
"in that case you can use [gmx-trjconv]."
};
static real dist = 0.0;
static gmx_bool bNDEF = FALSE, bRMPBC = FALSE, bCenter = FALSE, bReadVDW =
FALSE, bCONECT = FALSE;
static gmx_bool peratom = FALSE, bLegend = FALSE, bOrient = FALSE, bMead =
FALSE, bGrasp = FALSE, bSig56 = FALSE;
static rvec scale =
{ 1, 1, 1 }, newbox =
{ 0, 0, 0 }, newang =
{ 90, 90, 90 };
static real rho = 1000.0, rvdw = 0.12;
static rvec center =
{ 0, 0, 0 }, translation =
{ 0, 0, 0 }, rotangles =
{ 0, 0, 0 }, aligncenter =
{ 0, 0, 0 }, targetvec =
{ 0, 0, 0 };
static const char *btype[] =
{ nullptr, "triclinic", "cubic", "dodecahedron", "octahedron", nullptr },
*label = "A";
static rvec visbox =
{ 0, 0, 0 };
static int resnr_start = -1;
t_pargs
pa[] =
{
{ "-ndef", FALSE, etBOOL,
{ &bNDEF }, "Choose output from default index groups" },
{ "-visbox", FALSE, etRVEC,
{ visbox },
"HIDDENVisualize a grid of boxes, -1 visualizes the 14 box images" },
{ "-bt", FALSE, etENUM,
{ btype }, "Box type for [TT]-box[tt] and [TT]-d[tt]" },
{ "-box", FALSE, etRVEC,
{ newbox }, "Box vector lengths (a,b,c)" },
{ "-angles", FALSE, etRVEC,
{ newang }, "Angles between the box vectors (bc,ac,ab)" },
{ "-d", FALSE, etREAL,
{ &dist }, "Distance between the solute and the box" },
{ "-c", FALSE, etBOOL,
{ &bCenter },
"Center molecule in box (implied by [TT]-box[tt] and [TT]-d[tt])" },
{ "-center", FALSE, etRVEC,
{ center }, "Shift the geometrical center to (x,y,z)" },
{ "-aligncenter", FALSE, etRVEC,
{ aligncenter }, "Center of rotation for alignment" },
{ "-align", FALSE, etRVEC,
{ targetvec },
"Align to target vector" },
{ "-translate", FALSE, etRVEC,
{ translation }, "Translation" },
{ "-rotate", FALSE, etRVEC,
{ rotangles },
"Rotation around the X, Y and Z axes in degrees" },
{ "-princ", FALSE, etBOOL,
{ &bOrient },
"Orient molecule(s) along their principal axes" },
{ "-scale", FALSE, etRVEC,
{ scale }, "Scaling factor" },
{ "-density", FALSE, etREAL,
{ &rho },
"Density (g/L) of the output box achieved by scaling" },
{ "-pbc", FALSE, etBOOL,
{ &bRMPBC },
"Remove the periodicity (make molecule whole again)" },
{ "-resnr", FALSE, etINT,
{ &resnr_start },
" Renumber residues starting from resnr" },
{ "-grasp", FALSE, etBOOL,
{ &bGrasp },
"Store the charge of the atom in the B-factor field and the radius of the atom in the occupancy field" },
{
"-rvdw", FALSE, etREAL,
{ &rvdw },
"Default Van der Waals radius (in nm) if one can not be found in the database or if no parameters are present in the topology file"
},
{ "-sig56", FALSE, etBOOL,
{ &bSig56 },
"Use rmin/2 (minimum in the Van der Waals potential) rather than [GRK]sigma[grk]/2 " },
{
"-vdwread", FALSE, etBOOL,
{ &bReadVDW },
"Read the Van der Waals radii from the file [TT]vdwradii.dat[tt] rather than computing the radii based on the force field"
},
{ "-atom", FALSE, etBOOL,
{ &peratom }, "Force B-factor attachment per atom" },
{ "-legend", FALSE, etBOOL,
{ &bLegend }, "Make B-factor legend" },
{ "-label", FALSE, etSTR,
{ &label }, "Add chain label for all residues" },
{
"-conect", FALSE, etBOOL,
{ &bCONECT },
"Add CONECT records to a [REF].pdb[ref] file when written. Can only be done when a topology is present"
}
};
#define NPA asize(pa)
FILE *out;
const char *infile, *outfile;
int outftp, inftp, natom, i, j, n_bfac, itype, ntype;
double *bfac = nullptr, c6, c12;
int *bfac_nr = nullptr;
t_topology *top = nullptr;
char *grpname, *sgrpname, *agrpname;
int isize, ssize, numAlignmentAtoms;
int *index, *sindex, *aindex;
rvec *x, *v, gc, rmin, rmax, size;
int ePBC;
matrix box, rotmatrix, trans;
rvec princd, tmpvec;
gmx_bool bIndex, bSetSize, bSetAng, bDist, bSetCenter, bAlign;
gmx_bool bHaveV, bScale, bRho, bTranslate, bRotate, bCalcGeom, bCalcDiam;
real diam = 0, mass = 0, d, vdw;
gmx_atomprop_t aps;
gmx_conect conect;
gmx_output_env_t *oenv;
t_filenm fnm[] =
{
{ efSTX, "-f", nullptr, ffREAD },
{ efNDX, "-n", nullptr, ffOPTRD },
{ efSTO, nullptr, nullptr, ffOPTWR },
{ efPQR, "-mead", "mead", ffOPTWR },
{ efDAT, "-bf", "bfact", ffOPTRD }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_VIEW, NFILE, fnm, NPA, pa,
asize(desc), desc, asize(bugs), bugs, &oenv))
{
return 0;
}
bIndex = opt2bSet("-n", NFILE, fnm) || bNDEF;
bMead = opt2bSet("-mead", NFILE, fnm);
bSetSize = opt2parg_bSet("-box", NPA, pa);
bSetAng = opt2parg_bSet("-angles", NPA, pa);
bSetCenter = opt2parg_bSet("-center", NPA, pa);
bDist = opt2parg_bSet("-d", NPA, pa);
bAlign = opt2parg_bSet("-align", NPA, pa);
/* Only automatically turn on centering without -noc */
if ((bDist || bSetSize || bSetCenter) && !opt2parg_bSet("-c", NPA, pa))
{
bCenter = TRUE;
}
bScale = opt2parg_bSet("-scale", NPA, pa);
bRho = opt2parg_bSet("-density", NPA, pa);
bTranslate = opt2parg_bSet("-translate", NPA, pa);
bRotate = opt2parg_bSet("-rotate", NPA, pa);
if (bScale && bRho)
{
fprintf(stderr, "WARNING: setting -density overrides -scale\n");
}
bScale = bScale || bRho;
bCalcGeom = bCenter || bRotate || bOrient || bScale;
GMX_RELEASE_ASSERT(btype[0] != nullptr, "Option setting inconsistency; btype[0] is NULL");
bCalcDiam = (btype[0][0] == 'c' || btype[0][0] == 'd' || btype[0][0] == 'o');
infile = ftp2fn(efSTX, NFILE, fnm);
if (bMead)
{
outfile = ftp2fn(efPQR, NFILE, fnm);
}
else
{
outfile = ftp2fn(efSTO, NFILE, fnm);
}
outftp = fn2ftp(outfile);
inftp = fn2ftp(infile);
aps = gmx_atomprop_init();
if (bMead && bGrasp)
{
printf("Incompatible options -mead and -grasp. Turning off -grasp\n");
bGrasp = FALSE;
}
if (bGrasp && (outftp != efPDB))
{
gmx_fatal(FARGS, "Output file should be a .pdb file"
" when using the -grasp option\n");
}
if ((bMead || bGrasp) && (fn2ftp(infile) != efTPR))
{
gmx_fatal(FARGS, "Input file should be a .tpr file"
" when using the -mead option\n");
}
t_topology *top_tmp;
snew(top_tmp, 1);
read_tps_conf(infile, top_tmp, &ePBC, &x, &v, box, FALSE);
t_atoms &atoms = top_tmp->atoms;
natom = atoms.nr;
if (atoms.pdbinfo == nullptr)
{
snew(atoms.pdbinfo, atoms.nr);
}
atoms.havePdbInfo = TRUE;
if (fn2ftp(infile) == efPDB)
{
get_pdb_atomnumber(&atoms, aps);
}
printf("Read %d atoms\n", atoms.nr);
/* Get the element numbers if available in a pdb file */
if (fn2ftp(infile) == efPDB)
{
get_pdb_atomnumber(&atoms, aps);
}
if (ePBC != epbcNONE)
{
real vol = det(box);
printf("Volume: %g nm^3, corresponds to roughly %d electrons\n",
vol, 100*(static_cast<int>(vol*4.5)));
}
if (bMead || bGrasp || bCONECT)
{
top = read_top(infile, nullptr);
}
if (bMead || bGrasp)
{
if (atoms.nr != top->atoms.nr)
{
gmx_fatal(FARGS, "Atom numbers don't match (%d vs. %d)", atoms.nr, top->atoms.nr);
}
snew(atoms.pdbinfo, top->atoms.nr);
ntype = top->idef.atnr;
for (i = 0; (i < atoms.nr); i++)
{
/* Determine the Van der Waals radius from the force field */
if (bReadVDW)
{
if (!gmx_atomprop_query(aps, epropVDW,
*top->atoms.resinfo[top->atoms.atom[i].resind].name,
*top->atoms.atomname[i], &vdw))
{
vdw = rvdw;
}
}
else
{
itype = top->atoms.atom[i].type;
c12 = top->idef.iparams[itype*ntype+itype].lj.c12;
c6 = top->idef.iparams[itype*ntype+itype].lj.c6;
if ((c6 != 0) && (c12 != 0))
{
real sig6;
if (bSig56)
{
sig6 = 2*c12/c6;
}
else
{
sig6 = c12/c6;
}
vdw = 0.5*gmx::sixthroot(sig6);
}
else
{
vdw = rvdw;
}
}
/* Factor of 10 for nm -> Angstroms */
vdw *= 10;
if (bMead)
{
atoms.pdbinfo[i].occup = top->atoms.atom[i].q;
atoms.pdbinfo[i].bfac = vdw;
}
else
{
atoms.pdbinfo[i].occup = vdw;
atoms.pdbinfo[i].bfac = top->atoms.atom[i].q;
}
}
}
bHaveV = FALSE;
for (i = 0; (i < natom) && !bHaveV; i++)
{
for (j = 0; (j < DIM) && !bHaveV; j++)
{
bHaveV = bHaveV || (v[i][j] != 0);
}
}
printf("%selocities found\n", bHaveV ? "V" : "No v");
if (visbox[0] > 0)
{
if (bIndex)
{
gmx_fatal(FARGS, "Sorry, can not visualize box with index groups");
}
if (outftp != efPDB)
{
gmx_fatal(FARGS, "Sorry, can only visualize box with a pdb file");
}
}
else if (visbox[0] == -1)
{
visualize_images("images.pdb", ePBC, box);
}
/* remove pbc */
if (bRMPBC)
{
rm_gropbc(&atoms, x, box);
}
if (bCalcGeom)
{
if (bIndex)
{
fprintf(stderr, "\nSelect a group for determining the system size:\n");
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm),
1, &ssize, &sindex, &sgrpname);
}
else
{
ssize = atoms.nr;
sindex = nullptr;
}
diam = calc_geom(ssize, sindex, x, gc, rmin, rmax, bCalcDiam);
rvec_sub(rmax, rmin, size);
printf(" system size :%7.3f%7.3f%7.3f (nm)\n",
size[XX], size[YY], size[ZZ]);
if (bCalcDiam)
{
printf(" diameter :%7.3f (nm)\n", diam);
}
printf(" center :%7.3f%7.3f%7.3f (nm)\n", gc[XX], gc[YY], gc[ZZ]);
printf(" box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf(" box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ]) == 0 ? 0 :
RAD2DEG*gmx_angle(box[YY], box[ZZ]),
norm2(box[ZZ]) == 0 ? 0 :
RAD2DEG*gmx_angle(box[XX], box[ZZ]),
norm2(box[YY]) == 0 ? 0 :
RAD2DEG*gmx_angle(box[XX], box[YY]));
printf(" box volume :%7.2f (nm^3)\n", det(box));
}
if (bRho || bOrient || bAlign)
{
mass = calc_mass(&atoms, !fn2bTPX(infile), aps);
}
if (bOrient)
{
int *index;
char *grpnames;
/* Get a group for principal component analysis */
fprintf(stderr, "\nSelect group for the determining the orientation\n");
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &isize, &index, &grpnames);
/* Orient the principal axes along the coordinate axes */
orient_princ(&atoms, isize, index, natom, x, bHaveV ? v : nullptr, nullptr);
sfree(index);
sfree(grpnames);
}
if (bScale)
{
/* scale coordinates and box */
if (bRho)
{
/* Compute scaling constant */
real vol, dens;
vol = det(box);
dens = (mass*AMU)/(vol*NANO*NANO*NANO);
fprintf(stderr, "Volume of input %g (nm^3)\n", vol);
fprintf(stderr, "Mass of input %g (a.m.u.)\n", mass);
fprintf(stderr, "Density of input %g (g/l)\n", dens);
if (vol == 0 || mass == 0)
{
gmx_fatal(FARGS, "Cannot scale density with "
"zero mass (%g) or volume (%g)\n", mass, vol);
}
scale[XX] = scale[YY] = scale[ZZ] = std::cbrt(dens/rho);
fprintf(stderr, "Scaling all box vectors by %g\n", scale[XX]);
}
scale_conf(atoms.nr, x, box, scale);
}
if (bAlign)
{
if (bIndex)
{
fprintf(stderr, "\nSelect a group that you want to align:\n");
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm),
1, &numAlignmentAtoms, &aindex, &agrpname);
}
else
{
numAlignmentAtoms = atoms.nr;
snew(aindex, numAlignmentAtoms);
for (i = 0; i < numAlignmentAtoms; i++)
{
aindex[i] = i;
}
}
printf("Aligning %d atoms (out of %d) to %g %g %g, center of rotation %g %g %g\n", numAlignmentAtoms, natom,
targetvec[XX], targetvec[YY], targetvec[ZZ],
aligncenter[XX], aligncenter[YY], aligncenter[ZZ]);
/*subtract out pivot point*/
for (i = 0; i < numAlignmentAtoms; i++)
{
rvec_dec(x[aindex[i]], aligncenter);
}
/*now determine transform and rotate*/
/*will this work?*/
principal_comp(numAlignmentAtoms, aindex, atoms.atom, x, trans, princd);
unitv(targetvec, targetvec);
printf("Using %g %g %g as principal axis\n", trans[0][2], trans[1][2], trans[2][2]);
tmpvec[XX] = trans[0][2]; tmpvec[YY] = trans[1][2]; tmpvec[ZZ] = trans[2][2];
calc_rotmatrix(tmpvec, targetvec, rotmatrix);
/* rotmatrix finished */
for (i = 0; i < numAlignmentAtoms; ++i)
{
mvmul(rotmatrix, x[aindex[i]], tmpvec);
copy_rvec(tmpvec, x[aindex[i]]);
}
/*add pivot point back*/
for (i = 0; i < numAlignmentAtoms; i++)
{
rvec_inc(x[aindex[i]], aligncenter);
}
if (!bIndex)
{
sfree(aindex);
}
}
if (bTranslate)
{
if (bIndex)
{
fprintf(stderr, "\nSelect a group that you want to translate:\n");
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm),
1, &ssize, &sindex, &sgrpname);
}
else
{
ssize = atoms.nr;
sindex = nullptr;
}
printf("Translating %d atoms (out of %d) by %g %g %g nm\n", ssize, natom,
translation[XX], translation[YY], translation[ZZ]);
if (sindex)
{
for (i = 0; i < ssize; i++)
{
rvec_inc(x[sindex[i]], translation);
}
}
else
{
for (i = 0; i < natom; i++)
{
rvec_inc(x[i], translation);
}
}
}
if (bRotate)
{
/* Rotate */
printf("Rotating %g, %g, %g degrees around the X, Y and Z axis respectively\n", rotangles[XX], rotangles[YY], rotangles[ZZ]);
for (i = 0; i < DIM; i++)
{
rotangles[i] *= DEG2RAD;
}
rotate_conf(natom, x, v, rotangles[XX], rotangles[YY], rotangles[ZZ]);
}
if (bCalcGeom)
{
/* recalc geometrical center and max and min coordinates and size */
calc_geom(ssize, sindex, x, gc, rmin, rmax, FALSE);
rvec_sub(rmax, rmin, size);
if (bScale || bOrient || bRotate)
{
printf("new system size : %6.3f %6.3f %6.3f\n",
size[XX], size[YY], size[ZZ]);
}
}
if ((btype[0] != nullptr) && (bSetSize || bDist || (btype[0][0] == 't' && bSetAng)))
{
ePBC = epbcXYZ;
if (!(bSetSize || bDist))
{
for (i = 0; i < DIM; i++)
{
newbox[i] = norm(box[i]);
}
}
clear_mat(box);
/* calculate new boxsize */
switch (btype[0][0])
{
case 't':
if (bDist)
{
for (i = 0; i < DIM; i++)
{
newbox[i] = size[i]+2*dist;
}
}
if (!bSetAng)
{
box[XX][XX] = newbox[XX];
box[YY][YY] = newbox[YY];
box[ZZ][ZZ] = newbox[ZZ];
}
else
{
matrix_convert(box, newbox, newang);
}
break;
case 'c':
case 'd':
case 'o':
if (bSetSize)
{
d = newbox[0];
}
else
{
d = diam+2*dist;
}
if (btype[0][0] == 'c')
{
for (i = 0; i < DIM; i++)
{
box[i][i] = d;
}
}
else if (btype[0][0] == 'd')
{
box[XX][XX] = d;
box[YY][YY] = d;
box[ZZ][XX] = d/2;
box[ZZ][YY] = d/2;
box[ZZ][ZZ] = d*std::sqrt(2.0)/2.0;
}
else
{
box[XX][XX] = d;
box[YY][XX] = d/3;
box[YY][YY] = d*std::sqrt(2.0)*2.0/3.0;
box[ZZ][XX] = -d/3;
box[ZZ][YY] = d*std::sqrt(2.0)/3.0;
box[ZZ][ZZ] = d*std::sqrt(6.0)/3.0;
}
break;
}
}
/* calculate new coords for geometrical center */
if (!bSetCenter)
{
calc_box_center(ecenterDEF, box, center);
}
/* center molecule on 'center' */
if (bCenter)
{
center_conf(natom, x, center, gc);
}
/* print some */
if (bCalcGeom)
{
calc_geom(ssize, sindex, x, gc, rmin, rmax, FALSE);
printf("new center :%7.3f%7.3f%7.3f (nm)\n", gc[XX], gc[YY], gc[ZZ]);
}
if (bOrient || bScale || bDist || bSetSize)
{
printf("new box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf("new box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ]) == 0 ? 0 :
RAD2DEG*gmx_angle(box[YY], box[ZZ]),
norm2(box[ZZ]) == 0 ? 0 :
RAD2DEG*gmx_angle(box[XX], box[ZZ]),
norm2(box[YY]) == 0 ? 0 :
RAD2DEG*gmx_angle(box[XX], box[YY]));
printf("new box volume :%7.2f (nm^3)\n", det(box));
}
if (check_box(epbcXYZ, box))
{
printf("\nWARNING: %s\n"
"See the GROMACS manual for a description of the requirements that\n"
"must be satisfied by descriptions of simulation cells.\n",
check_box(epbcXYZ, box));
}
if (bDist && btype[0][0] == 't')
{
if (TRICLINIC(box))
{
printf("\nWARNING: Your box is triclinic with non-orthogonal axes. In this case, the\n"
"distance from the solute to a box surface along the corresponding normal\n"
"vector might be somewhat smaller than your specified value %f.\n"
"You can check the actual value with g_mindist -pi\n", dist);
}
else if (!opt2parg_bSet("-bt", NPA, pa))
{
printf("\nWARNING: No boxtype specified - distance condition applied in each dimension.\n"
"If the molecule rotates the actual distance will be smaller. You might want\n"
"to use a cubic box instead, or why not try a dodecahedron today?\n");
}
}
if (bCONECT && (outftp == efPDB) && (inftp == efTPR))
{
conect = gmx_conect_generate(top);
}
else
{
conect = nullptr;
}
if (bIndex)
{
fprintf(stderr, "\nSelect a group for output:\n");
get_index(&atoms, opt2fn_null("-n", NFILE, fnm),
1, &isize, &index, &grpname);
if (resnr_start >= 0)
{
renum_resnr(&atoms, isize, index, resnr_start);
}
if (opt2parg_bSet("-label", NPA, pa))
{
for (i = 0; (i < atoms.nr); i++)
{
atoms.resinfo[atoms.atom[i].resind].chainid = label[0];
}
}
if (opt2bSet("-bf", NFILE, fnm) || bLegend)
{
gmx_fatal(FARGS, "Sorry, cannot do bfactors with an index group.");
}
if (outftp == efPDB)
{
out = gmx_ffopen(outfile, "w");
write_pdbfile_indexed(out, *top_tmp->name, &atoms, x, ePBC, box, ' ', 1, isize, index, conect, TRUE, FALSE);
gmx_ffclose(out);
}
else
{
write_sto_conf_indexed(outfile, *top_tmp->name, &atoms, x, bHaveV ? v : nullptr, ePBC, box, isize, index);
}
}
else
{
if (resnr_start >= 0)
{
renum_resnr(&atoms, atoms.nr, nullptr, resnr_start);
}
if ((outftp == efPDB) || (outftp == efPQR))
{
out = gmx_ffopen(outfile, "w");
if (bMead)
{
fprintf(out, "REMARK "
"The B-factors in this file hold atomic radii\n");
fprintf(out, "REMARK "
"The occupancy in this file hold atomic charges\n");
}
else if (bGrasp)
{
fprintf(out, "GRASP PDB FILE\nFORMAT NUMBER=1\n");
fprintf(out, "REMARK "
"The B-factors in this file hold atomic charges\n");
fprintf(out, "REMARK "
"The occupancy in this file hold atomic radii\n");
}
else if (opt2bSet("-bf", NFILE, fnm))
{
read_bfac(opt2fn("-bf", NFILE, fnm), &n_bfac, &bfac, &bfac_nr);
set_pdb_conf_bfac(atoms.nr, atoms.nres, &atoms,
n_bfac, bfac, bfac_nr, peratom);
}
if (opt2parg_bSet("-label", NPA, pa))
{
for (i = 0; (i < atoms.nr); i++)
{
atoms.resinfo[atoms.atom[i].resind].chainid = label[0];
}
}
/* Need to bypass the regular write_pdbfile because I don't want to change
* all instances to include the boolean flag for writing out PQR files.
*/
int *index;
snew(index, atoms.nr);
for (int i = 0; i < atoms.nr; i++)
{
index[i] = i;
}
write_pdbfile_indexed(out, *top_tmp->name, &atoms, x, ePBC, box, ' ', -1, atoms.nr, index, conect,
TRUE, outftp == efPQR);
sfree(index);
if (bLegend)
{
pdb_legend(out, atoms.nr, atoms.nres, &atoms, x);
}
if (visbox[0] > 0)
{
visualize_box(out, bLegend ? atoms.nr+12 : atoms.nr,
bLegend ? atoms.nres = 12 : atoms.nres, box, visbox);
}
gmx_ffclose(out);
}
else
{
write_sto_conf(outfile, *top_tmp->name, &atoms, x, bHaveV ? v : nullptr, ePBC, box);
}
}
gmx_atomprop_destroy(aps);
do_view(oenv, outfile, nullptr);
return 0;
}
void
Angle::analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc,
TrajectoryAnalysisModuleData *pdata)
{
AnalysisDataHandle *dh = pdata->dataHandle("angle");
std::vector<Selection *> sel1 = pdata->parallelSelections(_sel1);
std::vector<Selection *> sel2 = pdata->parallelSelections(_sel2);
checkSelections(sel1, sel2);
rvec v1, v2;
rvec c1, c2;
switch (_g2type[0])
{
case 'z':
clear_rvec(v2);
v2[ZZ] = 1.0;
clear_rvec(c2);
break;
case 's':
copy_rvec(_sel2[0]->x(0), c2);
break;
}
dh->startFrame(frnr, fr.time);
int incr1 = _bSplit1 ? 1 : _natoms1;
int incr2 = _bSplit2 ? 1 : _natoms2;
int ngrps = _bMulti ? _sel1.size() : 1;
for (int g = 0; g < ngrps; ++g)
{
real ave = 0.0;
int n = 0;
int i, j;
for (i = j = 0; i < sel1[g]->posCount(); i += incr1)
{
rvec x[4];
real angle;
copy_pos(sel1, _bSplit1, _natoms1, g, i, x);
switch (_g1type[0])
{
case 'a':
if (pbc)
{
pbc_dx(pbc, x[0], x[1], v1);
pbc_dx(pbc, x[2], x[1], v2);
}
else
{
rvec_sub(x[0], x[1], v1);
rvec_sub(x[2], x[1], v2);
}
angle = gmx_angle(v1, v2);
break;
case 'd': {
rvec dx[3];
if (pbc)
{
pbc_dx(pbc, x[0], x[1], dx[0]);
pbc_dx(pbc, x[2], x[1], dx[1]);
pbc_dx(pbc, x[2], x[3], dx[2]);
}
else
{
rvec_sub(x[0], x[1], dx[0]);
rvec_sub(x[2], x[1], dx[1]);
rvec_sub(x[2], x[3], dx[2]);
}
cprod(dx[0], dx[1], v1);
cprod(dx[1], dx[2], v2);
angle = gmx_angle(v1, v2);
real ipr = iprod(dx[0], v2);
if (ipr < 0)
{
angle = -angle;
}
break;
}
case 'v':
case 'p':
calc_vec(_natoms1, x, pbc, v1, c1);
switch (_g2type[0])
{
case 'v':
case 'p':
copy_pos(sel2, _bSplit2, _natoms2, 0, j, x);
calc_vec(_natoms2, x, pbc, v2, c2);
j += incr2;
break;
case 't':
// FIXME: This is not parallelizable.
if (frnr == 0)
{
copy_rvec(v1, _vt0[n]);
}
copy_rvec(_vt0[n], v2);
break;
case 'z':
c1[XX] = c1[YY] = 0.0;
break;
case 's':
if (pbc)
{
pbc_dx(pbc, c1, c2, v2);
}
else
{
rvec_sub(c1, c2, v2);
}
break;
default:
GMX_THROW(InternalError("invalid -g2 value"));
}
angle = gmx_angle(v1, v2);
break;
default:
GMX_THROW(InternalError("invalid -g1 value"));
}
angle *= RAD2DEG;
real dist = 0.0;
if (_bDumpDist)
{
if (pbc)
{
rvec dx;
pbc_dx(pbc, c2, c1, dx);
dist = norm(dx);
}
else
{
dist = sqrt(distance2(c1, c2));
}
}
if (_bAll)
{
dh->addPoint(n + 1, angle);
}
ave += angle;
++n;
}
if (n > 0)
{
ave /= n;
}
dh->addPoint(g, ave);
}
dh->finishFrame();
}
