NAMD
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | List of all members
DihedralElem Class Reference

#include <ComputeDihedrals.h>

Public Types

enum  { size = 4 }
 
enum  {
  dihedralEnergyIndex, dihedralEnergyIndex_f, dihedralEnergyIndex_ti_1, dihedralEnergyIndex_ti_2,
  TENSOR =(virialIndex), reductionDataSize
}
 
enum  { reductionChecksumLabel = REDUCTION_DIHEDRAL_CHECKSUM }
 

Public Member Functions

int hash () const
 
 DihedralElem ()
 
 DihedralElem (AtomID atom0, const TupleSignature *sig, const DihedralValue *v)
 
 DihedralElem (const Dihedral *a, const DihedralValue *v)
 
 DihedralElem (AtomID atom0, AtomID atom1, AtomID atom2, AtomID atom3)
 
 ~DihedralElem ()
 
int operator== (const DihedralElem &a) const
 
int operator< (const DihedralElem &a) const
 

Static Public Member Functions

static void computeForce (DihedralElem *, int, BigReal *, BigReal *)
 
static void getMoleculePointers (Molecule *, int *, int32 ***, Dihedral **)
 
static void getParameterPointers (Parameters *, const DihedralValue **)
 
static void getTupleInfo (AtomSignature *sig, int *count, TupleSignature **t)
 
static void submitReductionData (BigReal *, SubmitReduction *)
 

Public Attributes

AtomID atomID [size]
 
int localIndex [size]
 
TuplePatchElemp [size]
 
Real scale
 
const DihedralValuevalue
 

Static Public Attributes

static int pressureProfileSlabs = 0
 
static int pressureProfileAtomTypes = 1
 
static BigReal pressureProfileThickness = 0
 
static BigReal pressureProfileMin = 0
 

Detailed Description

Definition at line 17 of file ComputeDihedrals.h.

Member Enumeration Documentation

anonymous enum
Enumerator
size 

Definition at line 20 of file ComputeDihedrals.h.

anonymous enum
anonymous enum

Constructor & Destructor Documentation

DihedralElem::DihedralElem ( )
inline

Definition at line 12 of file ComputeDihedrals.inl.

12 { ; }
DihedralElem::DihedralElem ( AtomID  atom0,
const TupleSignature sig,
const DihedralValue v 
)
inline

Definition at line 14 of file ComputeDihedrals.inl.

References atomID, TupleSignature::offset, TupleSignature::tupleParamType, and value.

14  {
15  atomID[0] = atom0;
16  atomID[1] = atom0 + sig->offset[0];
17  atomID[2] = atom0 + sig->offset[1];
18  atomID[3] = atom0 + sig->offset[2];
19  value = &v[sig->tupleParamType];
20 }
const DihedralValue * value
AtomID atomID[size]
Index tupleParamType
Definition: structures.h:202
DihedralElem::DihedralElem ( const Dihedral a,
const DihedralValue v 
)
inline

Definition at line 22 of file ComputeDihedrals.inl.

References dihedral::atom1, dihedral::atom2, dihedral::atom3, dihedral::atom4, atomID, dihedral::dihedral_type, and value.

23  {
24  atomID[0] = a->atom1;
25  atomID[1] = a->atom2;
26  atomID[2] = a->atom3;
27  atomID[3] = a->atom4;
28  value = &v[a->dihedral_type];
29  }
int32 atom3
Definition: structures.h:65
int32 atom4
Definition: structures.h:66
const DihedralValue * value
Index dihedral_type
Definition: structures.h:67
AtomID atomID[size]
int32 atom2
Definition: structures.h:64
int32 atom1
Definition: structures.h:63
DihedralElem::DihedralElem ( AtomID  atom0,
AtomID  atom1,
AtomID  atom2,
AtomID  atom3 
)
inline

Definition at line 31 of file ComputeDihedrals.inl.

References atomID.

33  {
34  if (atom0 > atom3) { // Swap end atoms so lowest is first!
35  AtomID tmp = atom3; atom3 = atom0; atom0 = tmp;
36  tmp = atom1; atom1 = atom2; atom2 = tmp;
37  }
38  atomID[0] = atom0;
39  atomID[1] = atom1;
40  atomID[2] = atom2;
41  atomID[3] = atom3;
42  }
int AtomID
Definition: NamdTypes.h:29
AtomID atomID[size]
DihedralElem::~DihedralElem ( )
inline

Definition at line 56 of file ComputeDihedrals.h.

56 {};

Member Function Documentation

void DihedralElem::computeForce ( DihedralElem tuples,
int  ntuple,
BigReal reduction,
BigReal pressureProfileData 
)
static

Definition at line 40 of file ComputeDihedrals.C.

References A, TuplePatchElem::af, SimParameters::alchOn, atomID, B, cross(), DebugM, four_body_consts::delta, Lattice::delta(), dihedralEnergyIndex, dihedralEnergyIndex_f, dihedralEnergyIndex_ti_1, dihedralEnergyIndex_ti_2, TuplePatchElem::f, Patch::flags, Molecule::get_fep_bonded_type(), SimParameters::getBondLambda(), SimParameters::getCurrentLambda(), SimParameters::getCurrentLambda2(), four_body_consts::k, Patch::lattice, localIndex, Node::molecule, DihedralValue::multiplicity, four_body_consts::n, Node::Object(), p, TuplePatchElem::p, CompAtom::partition, PI, CompAtom::position, pp_clamp(), pp_reduction(), pressureProfileAtomTypes, pressureProfileMin, pressureProfileSlabs, pressureProfileThickness, Vector::rlength(), scale, Node::simParameters, simParams, SimParameters::singleTopology, size, Flags::step, TWOPI, value, DihedralValue::values, TuplePatchElem::x, Vector::x, Vector::y, and Vector::z.

42 {
43  const Lattice & lattice = tuples[0].p[0]->p->lattice;
44 
45  //fepb BKR
47  const int step = tuples[0].p[0]->p->flags.step;
48  const BigReal alchLambda = simParams->getCurrentLambda(step);
49  const BigReal alchLambda2 = simParams->getCurrentLambda2(step);
50  const BigReal bond_lambda_1 = simParams->getBondLambda(alchLambda);
51  const BigReal bond_lambda_2 = simParams->getBondLambda(1-alchLambda);
52  const BigReal bond_lambda_12 = simParams->getBondLambda(alchLambda2);
53  const BigReal bond_lambda_22 = simParams->getBondLambda(1-alchLambda2);
54  Molecule *const mol = Node::Object()->molecule;
55  //fepe
56 
57  for ( int ituple=0; ituple<ntuple; ++ituple ) {
58  const DihedralElem &tup = tuples[ituple];
59  enum { size = 4 };
60  const AtomID (&atomID)[size](tup.atomID);
61  const int (&localIndex)[size](tup.localIndex);
62  TuplePatchElem * const(&p)[size](tup.p);
63  const Real (&scale)(tup.scale);
64  const DihedralValue * const(&value)(tup.value);
65 
66  DebugM(3, "::computeForce() localIndex = " << localIndex[0] << " "
67  << localIndex[1] << " " << localIndex[2] << std::endl);
68 
69  // Calculate the vectors between atoms
70  const Position & pos0 = p[0]->x[localIndex[0]].position;
71  const Position & pos1 = p[1]->x[localIndex[1]].position;
72  const Vector r12 = lattice.delta(pos0,pos1);
73  const Position & pos2 = p[2]->x[localIndex[2]].position;
74  const Vector r23 = lattice.delta(pos1,pos2);
75  const Position & pos3 = p[3]->x[localIndex[3]].position;
76  const Vector r34 = lattice.delta(pos2,pos3);
77 
78  // Calculate the cross products and distances
79  Vector A = cross(r12,r23);
80  register BigReal rAinv = A.rlength();
81  Vector B = cross(r23,r34);
82  register BigReal rBinv = B.rlength();
83  Vector C = cross(r23,A);
84  register BigReal rCinv = C.rlength();
85 
86  // Calculate the sin and cos
87  BigReal cos_phi = (A*B)*(rAinv*rBinv);
88  BigReal sin_phi = (C*B)*(rCinv*rBinv);
89 
90  BigReal phi= -atan2(sin_phi,cos_phi);
91 
92  BigReal K=0; // energy
93  BigReal K1=0; // force
94 
95  // get the dihedral information
96  int multiplicity = value->multiplicity;
97 
98  // Loop through the multiple parameter sets for this
99  // bond. We will only loop more than once if this
100  // has multiple parameter sets from Charmm22
101  for (int mult_num=0; mult_num<multiplicity; mult_num++)
102  {
103  /* get angle information */
104  Real k = value->values[mult_num].k * scale;
105  Real delta = value->values[mult_num].delta;
106  int n = value->values[mult_num].n;
107 
108  // Calculate the energy
109  if (n)
110  {
111  // Periodicity is greater than 0, so use cos form
112  K += k*(1+cos(n*phi - delta));
113  K1 += -n*k*sin(n*phi - delta);
114  }
115  else
116  {
117  // Periodicity is 0, so just use the harmonic form
118  BigReal diff = phi-delta;
119  if (diff < -PI) diff += TWOPI;
120  else if (diff > PI) diff -= TWOPI;
121 
122  K += k*diff*diff;
123  K1 += 2.0*k*diff;
124  }
125  } /* for multiplicity */
126 
127  //fepb - BKR scaling of alchemical bonded terms
128  // NB: TI derivative is the _unscaled_ energy.
129  if ( simParams->alchOn && !simParams->singleTopology) {
130  switch ( mol->get_fep_bonded_type(atomID, 4) ) {
131  case 1:
132  reduction[dihedralEnergyIndex_ti_1] += K;
133  reduction[dihedralEnergyIndex_f] += (bond_lambda_12 - bond_lambda_1)*K;
134  K *= bond_lambda_1;
135  K1 *= bond_lambda_1;
136  break;
137  case 2:
138  reduction[dihedralEnergyIndex_ti_2] += K;
139  reduction[dihedralEnergyIndex_f] += (bond_lambda_22 - bond_lambda_2)*K;
140  K *= bond_lambda_2;
141  K1 *= bond_lambda_2;
142  break;
143  }
144  }
145  //fepe
146 
147  Force f1,f2,f3;
148 
149  // Normalize B
150  //rB = 1.0/rB;
151  B *= rBinv;
152 
153  // Next, we want to calculate the forces. In order
154  // to do that, we first need to figure out whether the
155  // sin or cos form will be more stable. For this,
156  // just look at the value of phi
157  if (fabs(sin_phi) > 0.1)
158  {
159  // use the sin version to avoid 1/cos terms
160 
161  // Normalize A
162  A *= rAinv;
163  Vector dcosdA;
164  Vector dcosdB;
165 
166  dcosdA.x = rAinv*(cos_phi*A.x-B.x);
167  dcosdA.y = rAinv*(cos_phi*A.y-B.y);
168  dcosdA.z = rAinv*(cos_phi*A.z-B.z);
169 
170  dcosdB.x = rBinv*(cos_phi*B.x-A.x);
171  dcosdB.y = rBinv*(cos_phi*B.y-A.y);
172  dcosdB.z = rBinv*(cos_phi*B.z-A.z);
173 
174  K1 = K1/sin_phi;
175 
176  f1.x = K1*(r23.y*dcosdA.z - r23.z*dcosdA.y);
177  f1.y = K1*(r23.z*dcosdA.x - r23.x*dcosdA.z);
178  f1.z = K1*(r23.x*dcosdA.y - r23.y*dcosdA.x);
179 
180  f3.x = K1*(r23.z*dcosdB.y - r23.y*dcosdB.z);
181  f3.y = K1*(r23.x*dcosdB.z - r23.z*dcosdB.x);
182  f3.z = K1*(r23.y*dcosdB.x - r23.x*dcosdB.y);
183 
184  f2.x = K1*(r12.z*dcosdA.y - r12.y*dcosdA.z
185  + r34.y*dcosdB.z - r34.z*dcosdB.y);
186  f2.y = K1*(r12.x*dcosdA.z - r12.z*dcosdA.x
187  + r34.z*dcosdB.x - r34.x*dcosdB.z);
188  f2.z = K1*(r12.y*dcosdA.x - r12.x*dcosdA.y
189  + r34.x*dcosdB.y - r34.y*dcosdB.x);
190  }
191  else
192  {
193  // This angle is closer to 0 or 180 than it is to
194  // 90, so use the cos version to avoid 1/sin terms
195 
196  // Normalize C
197  // rC = 1.0/rC;
198  C *= rCinv;
199 
200  Vector dsindC;
201  Vector dsindB;
202 
203  dsindC.x = rCinv*(sin_phi*C.x-B.x);
204  dsindC.y = rCinv*(sin_phi*C.y-B.y);
205  dsindC.z = rCinv*(sin_phi*C.z-B.z);
206 
207  dsindB.x = rBinv*(sin_phi*B.x-C.x);
208  dsindB.y = rBinv*(sin_phi*B.y-C.y);
209  dsindB.z = rBinv*(sin_phi*B.z-C.z);
210 
211  K1 = -K1/cos_phi;
212 
213  f1.x = K1*((r23.y*r23.y + r23.z*r23.z)*dsindC.x
214  - r23.x*r23.y*dsindC.y
215  - r23.x*r23.z*dsindC.z);
216  f1.y = K1*((r23.z*r23.z + r23.x*r23.x)*dsindC.y
217  - r23.y*r23.z*dsindC.z
218  - r23.y*r23.x*dsindC.x);
219  f1.z = K1*((r23.x*r23.x + r23.y*r23.y)*dsindC.z
220  - r23.z*r23.x*dsindC.x
221  - r23.z*r23.y*dsindC.y);
222 
223  f3 = cross(K1,dsindB,r23);
224 
225  f2.x = K1*(-(r23.y*r12.y + r23.z*r12.z)*dsindC.x
226  +(2.0*r23.x*r12.y - r12.x*r23.y)*dsindC.y
227  +(2.0*r23.x*r12.z - r12.x*r23.z)*dsindC.z
228  +dsindB.z*r34.y - dsindB.y*r34.z);
229  f2.y = K1*(-(r23.z*r12.z + r23.x*r12.x)*dsindC.y
230  +(2.0*r23.y*r12.z - r12.y*r23.z)*dsindC.z
231  +(2.0*r23.y*r12.x - r12.y*r23.x)*dsindC.x
232  +dsindB.x*r34.z - dsindB.z*r34.x);
233  f2.z = K1*(-(r23.x*r12.x + r23.y*r12.y)*dsindC.z
234  +(2.0*r23.z*r12.x - r12.z*r23.x)*dsindC.x
235  +(2.0*r23.z*r12.y - r12.z*r23.y)*dsindC.y
236  +dsindB.y*r34.x - dsindB.x*r34.y);
237  }
238 
239  /* store the forces */
240  // p[0]->f[localIndex[0]] += f1;
241  // p[1]->f[localIndex[1]] += f2 - f1;
242  // p[2]->f[localIndex[2]] += f3 - f2;
243  // p[3]->f[localIndex[3]] += -f3;
244 
245  p[0]->f[localIndex[0]].x += f1.x;
246  p[0]->f[localIndex[0]].y += f1.y;
247  p[0]->f[localIndex[0]].z += f1.z;
248 
249  p[1]->f[localIndex[1]].x += f2.x - f1.x;
250  p[1]->f[localIndex[1]].y += f2.y - f1.y;
251  p[1]->f[localIndex[1]].z += f2.z - f1.z;
252 
253  p[2]->f[localIndex[2]].x += f3.x - f2.x;
254  p[2]->f[localIndex[2]].y += f3.y - f2.y;
255  p[2]->f[localIndex[2]].z += f3.z - f2.z;
256 
257  p[3]->f[localIndex[3]].x += -f3.x;
258  p[3]->f[localIndex[3]].y += -f3.y;
259  p[3]->f[localIndex[3]].z += -f3.z;
260 
261  /* store the force for dihedral-only accelMD */
262  if ( p[0]->af ) {
263  p[0]->af[localIndex[0]].x += f1.x;
264  p[0]->af[localIndex[0]].y += f1.y;
265  p[0]->af[localIndex[0]].z += f1.z;
266 
267  p[1]->af[localIndex[1]].x += f2.x - f1.x;
268  p[1]->af[localIndex[1]].y += f2.y - f1.y;
269  p[1]->af[localIndex[1]].z += f2.z - f1.z;
270 
271  p[2]->af[localIndex[2]].x += f3.x - f2.x;
272  p[2]->af[localIndex[2]].y += f3.y - f2.y;
273  p[2]->af[localIndex[2]].z += f3.z - f2.z;
274 
275  p[3]->af[localIndex[3]].x += -f3.x;
276  p[3]->af[localIndex[3]].y += -f3.y;
277  p[3]->af[localIndex[3]].z += -f3.z;
278  }
279 
280  DebugM(3, "::computeForce() -- ending with delta energy " << K << std::endl);
281  reduction[dihedralEnergyIndex] += K;
282  reduction[virialIndex_XX] += ( f1.x * r12.x + f2.x * r23.x + f3.x * r34.x );
283  reduction[virialIndex_XY] += ( f1.x * r12.y + f2.x * r23.y + f3.x * r34.y );
284  reduction[virialIndex_XZ] += ( f1.x * r12.z + f2.x * r23.z + f3.x * r34.z );
285  reduction[virialIndex_YX] += ( f1.y * r12.x + f2.y * r23.x + f3.y * r34.x );
286  reduction[virialIndex_YY] += ( f1.y * r12.y + f2.y * r23.y + f3.y * r34.y );
287  reduction[virialIndex_YZ] += ( f1.y * r12.z + f2.y * r23.z + f3.y * r34.z );
288  reduction[virialIndex_ZX] += ( f1.z * r12.x + f2.z * r23.x + f3.z * r34.x );
289  reduction[virialIndex_ZY] += ( f1.z * r12.y + f2.z * r23.y + f3.z * r34.y );
290  reduction[virialIndex_ZZ] += ( f1.z * r12.z + f2.z * r23.z + f3.z * r34.z );
291 
292  if (pressureProfileData) {
293  BigReal z1 = p[0]->x[localIndex[0]].position.z;
294  BigReal z2 = p[1]->x[localIndex[1]].position.z;
295  BigReal z3 = p[2]->x[localIndex[2]].position.z;
296  BigReal z4 = p[3]->x[localIndex[3]].position.z;
297  int n1 = (int)floor((z1-pressureProfileMin)/pressureProfileThickness);
298  int n2 = (int)floor((z2-pressureProfileMin)/pressureProfileThickness);
299  int n3 = (int)floor((z3-pressureProfileMin)/pressureProfileThickness);
300  int n4 = (int)floor((z4-pressureProfileMin)/pressureProfileThickness);
305  int p1 = p[0]->x[localIndex[0]].partition;
306  int p2 = p[1]->x[localIndex[1]].partition;
307  int p3 = p[2]->x[localIndex[2]].partition;
308  int p4 = p[3]->x[localIndex[3]].partition;
309  int pn = pressureProfileAtomTypes;
311  p1, p2, pn,
312  f1.x * r12.x, f1.y * r12.y, f1.z * r12.z,
313  pressureProfileData);
315  p2, p3, pn,
316  f2.x * r23.x, f2.y * r23.y, f2.z * r23.z,
317  pressureProfileData);
319  p3, p4, pn,
320  f3.x * r34.x, f3.y * r34.y, f3.z * r34.z,
321  pressureProfileData);
322  }
323 
324  }
325 }
static Node * Object()
Definition: Node.h:86
unsigned char partition
Definition: NamdTypes.h:56
int AtomID
Definition: NamdTypes.h:29
Lattice & lattice
Definition: Patch.h:126
void pp_reduction(int nslabs, int n1, int n2, int atype1, int atype2, int numtypes, BigReal vxx, BigReal vyy, BigReal vzz, BigReal *reduction)
const BigReal A
Definition: Vector.h:64
SimParameters * simParameters
Definition: Node.h:178
float Real
Definition: common.h:109
#define DebugM(x, y)
Definition: Debug.h:59
__device__ __forceinline__ float3 cross(const float3 v1, const float3 v2)
BigReal z
Definition: Vector.h:66
Position position
Definition: NamdTypes.h:53
int get_fep_bonded_type(const int *atomID, unsigned int order) const
Definition: Molecule.h:1385
static BigReal pressureProfileMin
int localIndex[size]
Flags flags
Definition: Patch.h:127
FourBodyConsts values[MAX_MULTIPLICITY]
Definition: Parameters.h:108
static int pressureProfileAtomTypes
#define PI
Definition: common.h:83
void pp_clamp(int &n, int nslabs)
static BigReal pressureProfileThickness
BigReal rlength(void)
Definition: Vector.h:177
const DihedralValue * value
BigReal getBondLambda(const BigReal)
AtomID atomID[size]
BigReal getCurrentLambda2(const int)
Vector delta(const Position &pos1, const Position &pos2) const
Definition: Lattice.h:144
BigReal x
Definition: Vector.h:66
#define TWOPI
Definition: common.h:87
#define simParams
Definition: Output.C:127
BigReal y
Definition: Vector.h:66
const BigReal B
BigReal getCurrentLambda(const int)
static int pressureProfileSlabs
TuplePatchElem * p[size]
Molecule * molecule
Definition: Node.h:176
double BigReal
Definition: common.h:114
int step
Definition: PatchTypes.h:16
void DihedralElem::getMoleculePointers ( Molecule mol,
int *  count,
int32 ***  byatom,
Dihedral **  structarray 
)
static

Definition at line 25 of file ComputeDihedrals.C.

References NAMD_die(), and Molecule::numDihedrals.

26 {
27 #ifdef MEM_OPT_VERSION
28  NAMD_die("Should not be called in DihedralElem::getMoleculePointers in memory optimized version!");
29 #else
30  *count = mol->numDihedrals;
31  *byatom = mol->dihedralsByAtom;
32  *structarray = mol->dihedrals;
33 #endif
34 }
void NAMD_die(const char *err_msg)
Definition: common.C:83
int numDihedrals
Definition: Molecule.h:561
void DihedralElem::getParameterPointers ( Parameters p,
const DihedralValue **  v 
)
static

Definition at line 36 of file ComputeDihedrals.C.

References Parameters::dihedral_array.

36  {
37  *v = p->dihedral_array;
38 }
DihedralValue * dihedral_array
Definition: Parameters.h:243
static void DihedralElem::getTupleInfo ( AtomSignature sig,
int *  count,
TupleSignature **  t 
)
inlinestatic

Definition at line 29 of file ComputeDihedrals.h.

References AtomSignature::dihedralCnt, and AtomSignature::dihedralSigs.

29  {
30  *count = sig->dihedralCnt;
31  *t = sig->dihedralSigs;
32  }
TupleSignature * dihedralSigs
Definition: structures.h:335
int DihedralElem::hash ( void  ) const
inline

Definition at line 43 of file ComputeDihedrals.h.

References atomID.

43  {
44  return 0x7FFFFFFF &((atomID[0]<<24) + (atomID[1]<<16) + (atomID[2]<<8) + atomID[3]);
45  }
AtomID atomID[size]
int DihedralElem::operator< ( const DihedralElem a) const
inline

Definition at line 50 of file ComputeDihedrals.inl.

References atomID.

51  {
52  return (atomID[0] < a.atomID[0] ||
53  (atomID[0] == a.atomID[0] &&
54  (atomID[1] < a.atomID[1] ||
55  (atomID[1] == a.atomID[1] &&
56  (atomID[2] < a.atomID[2] ||
57  (atomID[2] == a.atomID[2] &&
58  atomID[3] < a.atomID[3]
59  ))))));
60  }
AtomID atomID[size]
int DihedralElem::operator== ( const DihedralElem a) const
inline

Definition at line 44 of file ComputeDihedrals.inl.

References atomID.

45  {
46  return (a.atomID[0] == atomID[0] && a.atomID[1] == atomID[1] &&
47  a.atomID[2] == atomID[2] && a.atomID[3] == atomID[3]);
48  }
AtomID atomID[size]
void DihedralElem::submitReductionData ( BigReal data,
SubmitReduction reduction 
)
static

Member Data Documentation

AtomID DihedralElem::atomID[size]

Definition at line 21 of file ComputeDihedrals.h.

Referenced by computeForce(), DihedralElem(), hash(), operator<(), and operator==().

int DihedralElem::localIndex[size]

Definition at line 22 of file ComputeDihedrals.h.

Referenced by computeForce().

TuplePatchElem* DihedralElem::p[size]

Definition at line 23 of file ComputeDihedrals.h.

Referenced by computeForce().

int DihedralElem::pressureProfileAtomTypes = 1
static

Definition at line 36 of file ComputeDihedrals.h.

Referenced by computeForce().

BigReal DihedralElem::pressureProfileMin = 0
static

Definition at line 38 of file ComputeDihedrals.h.

Referenced by computeForce().

int DihedralElem::pressureProfileSlabs = 0
static

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

Definition at line 35 of file ComputeDihedrals.h.

Referenced by computeForce().

BigReal DihedralElem::pressureProfileThickness = 0
static

Definition at line 37 of file ComputeDihedrals.h.

Referenced by computeForce().

Real DihedralElem::scale

Definition at line 24 of file ComputeDihedrals.h.

Referenced by computeForce().

const DihedralValue* DihedralElem::value

Definition at line 41 of file ComputeDihedrals.h.

Referenced by computeForce(), and DihedralElem().


The documentation for this class was generated from the following files: