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

#include <ComputeImpropers.h>

Public Types

enum  { size = 4 }
 
enum  {
  improperEnergyIndex, improperEnergyIndex_f, improperEnergyIndex_ti_1, improperEnergyIndex_ti_2,
  TENSOR =(virialIndex), reductionDataSize
}
 
enum  { reductionChecksumLabel = REDUCTION_IMPROPER_CHECKSUM }
 

Public Member Functions

int hash () const
 
 ImproperElem ()
 
 ImproperElem (AtomID atom0, const TupleSignature *sig, const ImproperValue *v)
 
 ImproperElem (const Improper *a, const ImproperValue *v)
 
 ImproperElem (AtomID atom0, AtomID atom1, AtomID atom2, AtomID atom3)
 
 ~ImproperElem ()
 
int operator== (const ImproperElem &a) const
 
int operator< (const ImproperElem &a) const
 

Static Public Member Functions

static void computeForce (ImproperElem *, int, BigReal *, BigReal *)
 
static void getMoleculePointers (Molecule *, int *, int32 ***, Improper **)
 
static void getParameterPointers (Parameters *, const ImproperValue **)
 
static void getTupleInfo (AtomSignature *sig, int *count, TupleSignature **t)
 
static void submitReductionData (BigReal *, SubmitReduction *)
 

Public Attributes

AtomID atomID [size]
 
int localIndex [size]
 
TuplePatchElem * p [size]
 
Real scale
 
const ImproperValue * value
 

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 ComputeImpropers.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
Enumerator
size 

Definition at line 20 of file ComputeImpropers.h.

20 { size = 4 };

◆ anonymous enum

anonymous enum
Enumerator
improperEnergyIndex 
improperEnergyIndex_f 
improperEnergyIndex_ti_1 
improperEnergyIndex_ti_2 
TENSOR 
reductionDataSize 

Definition at line 46 of file ComputeImpropers.h.

46  { improperEnergyIndex, improperEnergyIndex_f, improperEnergyIndex_ti_1,
47  improperEnergyIndex_ti_2, TENSOR(virialIndex), reductionDataSize };

◆ anonymous enum

anonymous enum
Enumerator
reductionChecksumLabel 

Definition at line 48 of file ComputeImpropers.h.

48 { reductionChecksumLabel = REDUCTION_IMPROPER_CHECKSUM };

Constructor & Destructor Documentation

◆ ImproperElem() [1/4]

ImproperElem::ImproperElem ( )
inline

Definition at line 51 of file ComputeImpropers.h.

51 { ; }

◆ ImproperElem() [2/4]

ImproperElem::ImproperElem ( AtomID  atom0,
const TupleSignature *  sig,
const ImproperValue *  v 
)
inline

Definition at line 53 of file ComputeImpropers.h.

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

53  {
54  atomID[0] = atom0;
55  atomID[1] = atom0 + sig->offset[0];
56  atomID[2] = atom0 + sig->offset[1];
57  atomID[3] = atom0 + sig->offset[2];
58  value = &v[sig->tupleParamType];
59  }
ImproperElem::value
const ImproperValue * value
Definition: ComputeImpropers.h:41
ImproperElem::atomID
AtomID atomID[size]
Definition: ComputeImpropers.h:21
TupleSignature::tupleParamType
Index tupleParamType
Definition: structures.h:204

◆ ImproperElem() [3/4]

ImproperElem::ImproperElem ( const Improper *  a,
const ImproperValue *  v 
)
inline

Definition at line 61 of file ComputeImpropers.h.

References improper::atom1, improper::atom2, improper::atom3, improper::atom4, atomID, improper::improper_type, and value.

61  {
62  atomID[0] = a->atom1;
63  atomID[1] = a->atom2;
64  atomID[2] = a->atom3;
65  atomID[3] = a->atom4;
66  value = &v[a->improper_type];
67  }
improper::atom4
int32 atom4
Definition: structures.h:77
improper::improper_type
Index improper_type
Definition: structures.h:78
ImproperElem::value
const ImproperValue * value
Definition: ComputeImpropers.h:41
ImproperElem::atomID
AtomID atomID[size]
Definition: ComputeImpropers.h:21
improper::atom1
int32 atom1
Definition: structures.h:74
improper::atom2
int32 atom2
Definition: structures.h:75
improper::atom3
int32 atom3
Definition: structures.h:76

◆ ImproperElem() [4/4]

ImproperElem::ImproperElem ( AtomID  atom0,
AtomID  atom1,
AtomID  atom2,
AtomID  atom3 
)
inline

Definition at line 69 of file ComputeImpropers.h.

References atomID.

69  {
70  if (atom0 > atom3) { // Swap end atoms so lowest is first!
71  AtomID tmp = atom3; atom3 = atom0; atom0 = tmp;
72  tmp = atom1; atom1 = atom2; atom2 = tmp;
73  }
74  atomID[0] = atom0;
75  atomID[1] = atom1;
76  atomID[2] = atom2;
77  atomID[3] = atom3;
78  }
ImproperElem::atomID
AtomID atomID[size]
Definition: ComputeImpropers.h:21
AtomID
int32 AtomID
Definition: NamdTypes.h:35

◆ ~ImproperElem()

ImproperElem::~ImproperElem ( )
inline

Definition at line 79 of file ComputeImpropers.h.

79 {};

Member Function Documentation

◆ computeForce()

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

Definition at line 40 of file ComputeImpropers.C.

References atomID, DebugM, four_body_consts::delta, Lattice::delta(), TuplePatchElem::f, Patch::flags, Molecule::get_fep_bonded_type(), improperEnergyIndex, improperEnergyIndex_f, improperEnergyIndex_ti_1, improperEnergyIndex_ti_2, four_body_consts::k, Patch::lattice, Vector::length(), localIndex, Node::molecule, ImproperValue::multiplicity, four_body_consts::n, Node::Object(), p, TuplePatchElem::p, CompAtom::partition, PI, CompAtom::position, pp_clamp(), pp_reduction(), pressureProfileAtomTypes, pressureProfileMin, pressureProfileSlabs, pressureProfileThickness, scale, Node::simParameters, simParams, size, Flags::step, TWOPI, value, ImproperValue::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
46  SimParameters *const simParams = Node::Object()->simParameters;
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 ImproperElem &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 ImproperValue * const(&value)(tup.value);
65 
66 #if defined(DEBUG_PROTOCELL)
67  if ((PRMIN <= atomID[0] && atomID[0] <= PRMAX) &&
68  (PRMIN <= atomID[1] && atomID[1] <= PRMAX) &&
69  (PRMIN <= atomID[2] && atomID[2] <= PRMAX) &&
70  (PRMIN <= atomID[3] && atomID[3] <= PRMAX)) {
71  int i = atomID[0];
72  int j = atomID[1];
73  int k = atomID[2];
74  int l = atomID[3];
75  if (atomID[3] < atomID[0]) {
76  i = atomID[3];
77  j = atomID[2];
78  k = atomID[1];
79  l = atomID[0];
80  }
81  int mult = value->multiplicity;
82  CkPrintf("%11d %11d %11d %11d mult=%d", i, j, k, l, mult);
83  for (int m=0; m < mult; m++) {
84  double kdelta = value->values[m].k;
85  double delta = value->values[m].delta;
86  int n = value->values[m].n;
87  CkPrintf(" k=%g delta=%g n=%d\n", kdelta, delta, n);
88  }
89  }
90 #endif
91 
92  DebugM(3, "::computeForce() localIndex = " << localIndex[0] << " "
93  << localIndex[1] << " " << localIndex[2] << " " <<
94  localIndex[3] << std::endl);
95 
96  // Vector r12, r23, r34; // vector between atoms
97  Vector A,B,C; // cross products
98  BigReal rA, rB, rC; // length of vectors A, B, and C
99  BigReal energy=0; // energy from the angle
100  BigReal phi; // angle between the plans
101  double cos_phi; // cos(phi)
102  double sin_phi; // sin(phi)
103  Vector dcosdA; // Derivative d(cos(phi))/dA
104  Vector dcosdB; // Derivative d(cos(phi))/dB
105  Vector dsindC; // Derivative d(sin(phi))/dC
106  Vector dsindB; // Derivative d(sin(phi))/dB
107  BigReal K,K1; // energy constants
108  BigReal diff; // for periodicity
109  Force f1(0,0,0),f2(0,0,0),f3(0,0,0); // force components
110 
111  //DebugM(3, "::computeForce() -- starting with improper type " << improperType << std::endl);
112 
113  // get the improper information
114  int multiplicity = value->multiplicity;
115 
116  // Calculate the vectors between atoms
117  const Position & pos0 = p[0]->x[localIndex[0]].position;
118  const Position & pos1 = p[1]->x[localIndex[1]].position;
119  const Position & pos2 = p[2]->x[localIndex[2]].position;
120  const Position & pos3 = p[3]->x[localIndex[3]].position;
121  const Vector r12 = lattice.delta(pos0,pos1);
122  const Vector r23 = lattice.delta(pos1,pos2);
123  const Vector r34 = lattice.delta(pos2,pos3);
124 
125  // Calculate the cross products
126  A = cross(r12,r23);
127  B = cross(r23,r34);
128  C = cross(r23,A);
129 
130  // Calculate the distances
131  rA = A.length();
132  rB = B.length();
133  rC = C.length();
134 
135  // Calculate the sin and cos
136  cos_phi = A*B/(rA*rB);
137  sin_phi = C*B/(rC*rB);
138 
139  // Normalize B
140  rB = 1.0/rB;
141  B *= rB;
142 
143  phi= -atan2(sin_phi,cos_phi);
144 
145  if (fabs(sin_phi) > 0.1)
146  {
147  // Normalize A
148  rA = 1.0/rA;
149  A *= rA;
150  dcosdA = rA*(cos_phi*A-B);
151  dcosdB = rB*(cos_phi*B-A);
152  }
153  else
154  {
155  // Normalize C
156  rC = 1.0/rC;
157  C *= rC;
158  dsindC = rC*(sin_phi*C-B);
159  dsindB = rB*(sin_phi*B-C);
160  }
161 
162  // Loop through the multiple parameter sets for this
163  // bond. We will only loop more than once if this
164  // has multiple parameter sets from Charmm22
165  for (int mult_num=0; mult_num<multiplicity; mult_num++)
166  {
167  /* get angle information */
168  Real k = value->values[mult_num].k * scale;
169  Real delta = value->values[mult_num].delta;
170  int n = value->values[mult_num].n;
171 
172  // Calculate the energy
173  if (n)
174  {
175  // Periodicity is greater than 0, so use cos form
176  K = k*(1+cos(n*phi - delta));
177  K1 = -n*k*sin(n*phi - delta);
178  }
179  else
180  {
181  // Periodicity is 0, so just use the harmonic form
182  diff = phi-delta;
183  if (diff < -PI) diff += TWOPI;
184  else if (diff > PI) diff -= TWOPI;
185 
186  K = k*diff*diff;
187  K1 = 2.0*k*diff;
188  }
189 
190  // Add the energy from this improper to the total energy
191  energy += K;
192 
193  // Next, we want to calculate the forces. In order
194  // to do that, we first need to figure out whether the
195  // sin or cos form will be more stable. For this,
196  // just look at the value of phi
197  if (fabs(sin_phi) > 0.1)
198  {
199  // use the sin version to avoid 1/cos terms
200  K1 = K1/sin_phi;
201 
202  f1.x += K1*(r23.y*dcosdA.z - r23.z*dcosdA.y);
203  f1.y += K1*(r23.z*dcosdA.x - r23.x*dcosdA.z);
204  f1.z += K1*(r23.x*dcosdA.y - r23.y*dcosdA.x);
205 
206  f3.x += K1*(r23.z*dcosdB.y - r23.y*dcosdB.z);
207  f3.y += K1*(r23.x*dcosdB.z - r23.z*dcosdB.x);
208  f3.z += K1*(r23.y*dcosdB.x - r23.x*dcosdB.y);
209 
210  f2.x += K1*(r12.z*dcosdA.y - r12.y*dcosdA.z
211  + r34.y*dcosdB.z - r34.z*dcosdB.y);
212  f2.y += K1*(r12.x*dcosdA.z - r12.z*dcosdA.x
213  + r34.z*dcosdB.x - r34.x*dcosdB.z);
214  f2.z += K1*(r12.y*dcosdA.x - r12.x*dcosdA.y
215  + r34.x*dcosdB.y - r34.y*dcosdB.x);
216  }
217  else
218  {
219  // This angle is closer to 0 or 180 than it is to
220  // 90, so use the cos version to avoid 1/sin terms
221  K1 = -K1/cos_phi;
222 
223  f1.x += K1*((r23.y*r23.y + r23.z*r23.z)*dsindC.x
224  - r23.x*r23.y*dsindC.y
225  - r23.x*r23.z*dsindC.z);
226  f1.y += K1*((r23.z*r23.z + r23.x*r23.x)*dsindC.y
227  - r23.y*r23.z*dsindC.z
228  - r23.y*r23.x*dsindC.x);
229  f1.z += K1*((r23.x*r23.x + r23.y*r23.y)*dsindC.z
230  - r23.z*r23.x*dsindC.x
231  - r23.z*r23.y*dsindC.y);
232 
233  f3 += cross(K1,dsindB,r23);
234 
235  f2.x += K1*(-(r23.y*r12.y + r23.z*r12.z)*dsindC.x
236  +(2.0*r23.x*r12.y - r12.x*r23.y)*dsindC.y
237  +(2.0*r23.x*r12.z - r12.x*r23.z)*dsindC.z
238  +dsindB.z*r34.y - dsindB.y*r34.z);
239  f2.y += K1*(-(r23.z*r12.z + r23.x*r12.x)*dsindC.y
240  +(2.0*r23.y*r12.z - r12.y*r23.z)*dsindC.z
241  +(2.0*r23.y*r12.x - r12.y*r23.x)*dsindC.x
242  +dsindB.x*r34.z - dsindB.z*r34.x);
243  f2.z += K1*(-(r23.x*r12.x + r23.y*r12.y)*dsindC.z
244  +(2.0*r23.z*r12.x - r12.z*r23.x)*dsindC.x
245  +(2.0*r23.z*r12.y - r12.z*r23.y)*dsindC.y
246  +dsindB.y*r34.x - dsindB.x*r34.y);
247  }
248  } /* for multiplicity */
249 
250  //fepb - BKR scaling of alchemical bonded terms
251  // NB: TI derivative is the _unscaled_ energy.
252  if ( simParams->alchOn && !simParams->singleTopology) {
253  switch ( mol->get_fep_bonded_type(atomID, 4) ) {
254  case 1:
255  reduction[improperEnergyIndex_ti_1] += energy;
256  reduction[improperEnergyIndex_f] += (bond_lambda_12 - bond_lambda_1) *
257  energy;
258  energy *= bond_lambda_1;
259  f1 *= bond_lambda_1;
260  f2 *= bond_lambda_1;
261  f3 *= bond_lambda_1;
262  break;
263  case 2:
264  reduction[improperEnergyIndex_ti_2] += energy;
265  reduction[improperEnergyIndex_f] += (bond_lambda_22 - bond_lambda_2) *
266  energy;
267  energy *= bond_lambda_2;
268  f1 *= bond_lambda_2;
269  f2 *= bond_lambda_2;
270  f3 *= bond_lambda_2;
271  break;
272  }
273  }
274  //fepe
275 
276  /* store the forces */
277  p[0]->f[localIndex[0]] += f1;
278  p[1]->f[localIndex[1]] += f2 - f1;
279  p[2]->f[localIndex[2]] += f3 - f2;
280  p[3]->f[localIndex[3]] += -f3;
281 
282  DebugM(3, "::computeForce() -- ending with delta energy " << energy << std::endl);
283  reduction[improperEnergyIndex] += energy;
284  reduction[virialIndex_XX] += ( f1.x * r12.x + f2.x * r23.x + f3.x * r34.x );
285  reduction[virialIndex_XY] += ( f1.x * r12.y + f2.x * r23.y + f3.x * r34.y );
286  reduction[virialIndex_XZ] += ( f1.x * r12.z + f2.x * r23.z + f3.x * r34.z );
287  reduction[virialIndex_YX] += ( f1.y * r12.x + f2.y * r23.x + f3.y * r34.x );
288  reduction[virialIndex_YY] += ( f1.y * r12.y + f2.y * r23.y + f3.y * r34.y );
289  reduction[virialIndex_YZ] += ( f1.y * r12.z + f2.y * r23.z + f3.y * r34.z );
290  reduction[virialIndex_ZX] += ( f1.z * r12.x + f2.z * r23.x + f3.z * r34.x );
291  reduction[virialIndex_ZY] += ( f1.z * r12.y + f2.z * r23.y + f3.z * r34.y );
292  reduction[virialIndex_ZZ] += ( f1.z * r12.z + f2.z * r23.z + f3.z * r34.z );
293 
294  if (pressureProfileData) {
295  BigReal z1 = p[0]->x[localIndex[0]].position.z;
296  BigReal z2 = p[1]->x[localIndex[1]].position.z;
297  BigReal z3 = p[2]->x[localIndex[2]].position.z;
298  BigReal z4 = p[3]->x[localIndex[3]].position.z;
299  int n1 = (int)floor((z1-pressureProfileMin)/pressureProfileThickness);
300  int n2 = (int)floor((z2-pressureProfileMin)/pressureProfileThickness);
301  int n3 = (int)floor((z3-pressureProfileMin)/pressureProfileThickness);
302  int n4 = (int)floor((z4-pressureProfileMin)/pressureProfileThickness);
303  pp_clamp(n1, pressureProfileSlabs);
304  pp_clamp(n2, pressureProfileSlabs);
305  pp_clamp(n3, pressureProfileSlabs);
306  pp_clamp(n4, pressureProfileSlabs);
307  int p1 = p[0]->x[localIndex[0]].partition;
308  int p2 = p[1]->x[localIndex[1]].partition;
309  int p3 = p[2]->x[localIndex[2]].partition;
310  int p4 = p[3]->x[localIndex[3]].partition;
311  int pn = pressureProfileAtomTypes;
312  pp_reduction(pressureProfileSlabs, n1, n2,
313  p1, p2, pn,
314  f1.x * r12.x, f1.y * r12.y, f1.z * r12.z,
315  pressureProfileData);
316  pp_reduction(pressureProfileSlabs, n2, n3,
317  p2, p3, pn,
318  f2.x * r23.x, f2.y * r23.y, f2.z * r23.z,
319  pressureProfileData);
320  pp_reduction(pressureProfileSlabs, n3, n4,
321  p3, p4, pn,
322  f3.x * r34.x, f3.y * r34.y, f3.z * r34.z,
323  pressureProfileData);
324  }
325 
326  }
327 }
Node::Object
static Node * Object()
Definition: Node.h:86
ImproperElem::pressureProfileAtomTypes
static int pressureProfileAtomTypes
Definition: ComputeImpropers.h:36
ImproperElem::p
TuplePatchElem * p[size]
Definition: ComputeImpropers.h:23
ImproperElem::value
const ImproperValue * value
Definition: ComputeImpropers.h:41
Patch::lattice
Lattice & lattice
Definition: Patch.h:127
four_body_consts::delta
Real delta
Definition: Parameters.h:122
pp_reduction
void pp_reduction(int nslabs, int n1, int n2, int atype1, int atype2, int numtypes, BigReal vxx, BigReal vyy, BigReal vzz, BigReal *reduction)
Definition: PressureProfile.h:22
Vector
Definition: Vector.h:72
Node::simParameters
SimParameters * simParameters
Definition: Node.h:181
Real
float Real
Definition: common.h:118
DebugM
#define DebugM(x, y)
Definition: Debug.h:75
ImproperElem::atomID
AtomID atomID[size]
Definition: ComputeImpropers.h:21
Vector::z
BigReal z
Definition: Vector.h:74
CompAtom::position
Position position
Definition: NamdTypes.h:77
Molecule
Molecule stores the structural information for the system.
Definition: Molecule.h:175
four_body_consts::k
Real k
Definition: Parameters.h:120
ImproperElem::pressureProfileMin
static BigReal pressureProfileMin
Definition: ComputeImpropers.h:38
Patch::flags
Flags flags
Definition: Patch.h:128
PI
#define PI
Definition: common.h:92
pp_clamp
void pp_clamp(int &n, int nslabs)
Definition: PressureProfile.h:15
ImproperElem::pressureProfileSlabs
static int pressureProfileSlabs
Definition: ComputeImpropers.h:35
Vector::length
NAMD_HOST_DEVICE BigReal length(void) const
Definition: Vector.h:202
CompAtom::partition
uint8 partition
Definition: NamdTypes.h:80
Vector::x
BigReal x
Definition: Vector.h:74
Molecule::get_fep_bonded_type
int get_fep_bonded_type(const int *atomID, unsigned int order) const
Definition: Molecule.h:1477
ImproperValue::values
FourBodyConsts values[MAX_MULTIPLICITY]
Definition: Parameters.h:134
TWOPI
#define TWOPI
Definition: common.h:96
simParams
#define simParams
Definition: Output.C:129
ImproperElem::localIndex
int localIndex[size]
Definition: ComputeImpropers.h:22
AtomID
int32 AtomID
Definition: NamdTypes.h:35
Vector::y
BigReal y
Definition: Vector.h:74
ImproperElem::pressureProfileThickness
static BigReal pressureProfileThickness
Definition: ComputeImpropers.h:37
four_body_consts::n
int n
Definition: Parameters.h:121
Node::molecule
Molecule * molecule
Definition: Node.h:179
BigReal
double BigReal
Definition: common.h:123
Lattice::delta
NAMD_HOST_DEVICE Vector delta(const Position &pos1, const Position &pos2) const
Definition: Lattice.h:149
Flags::step
int step
Definition: PatchTypes.h:16

◆ getMoleculePointers()

void ImproperElem::getMoleculePointers ( Molecule *  mol,
int *  count,
int32 ***  byatom,
Improper **  structarray 
)
static

Definition at line 25 of file ComputeImpropers.C.

References NAMD_die(), and Molecule::numImpropers.

26 {
27 #ifdef MEM_OPT_VERSION
28  NAMD_die("Should not be called in ImproperElem::getMoleculePointers in memory optimized version!");
29 #else
30  *count = mol->numImpropers;
31  *byatom = mol->impropersByAtom;
32  *structarray = mol->impropers;
33 #endif
34 }
NAMD_die
void NAMD_die(const char *err_msg)
Definition: common.C:147
Molecule::numImpropers
int numImpropers
Definition: Molecule.h:595

◆ getParameterPointers()

void ImproperElem::getParameterPointers ( Parameters *  p,
const ImproperValue **  v 
)
static

Definition at line 36 of file ComputeImpropers.C.

References p.

36  {
37  *v = p->improper_array;
38 }
ImproperElem::p
TuplePatchElem * p[size]
Definition: ComputeImpropers.h:23

◆ getTupleInfo()

static void ImproperElem::getTupleInfo ( AtomSignature *  sig,
int *  count,
TupleSignature **  t 
)
inlinestatic

Definition at line 29 of file ComputeImpropers.h.

References AtomSignature::improperCnt, and AtomSignature::improperSigs.

29  {
30  *count = sig->improperCnt;
31  *t = sig->improperSigs;
32  }
AtomSignature::improperSigs
TupleSignature * improperSigs
Definition: structures.h:338

◆ hash()

int ImproperElem::hash ( void  ) const
inline

Definition at line 43 of file ComputeImpropers.h.

References atomID.

43  {
44  return 0x7FFFFFFF &((atomID[0]<<24) + (atomID[1]<<16) + (atomID[2]<<8) + atomID[3]);
45  }
ImproperElem::atomID
AtomID atomID[size]
Definition: ComputeImpropers.h:21

◆ operator<()

int ImproperElem::operator< ( const ImproperElem &  a) const
inline

Definition at line 86 of file ComputeImpropers.h.

References atomID.

86  {
87  return (atomID[0] < a.atomID[0] ||
88  (atomID[0] == a.atomID[0] &&
89  (atomID[1] < a.atomID[1] ||
90  (atomID[1] == a.atomID[1] &&
91  (atomID[2] < a.atomID[2] ||
92  (atomID[2] == a.atomID[2] &&
93  atomID[3] < a.atomID[3]
94  ))))));
95  }
ImproperElem::atomID
AtomID atomID[size]
Definition: ComputeImpropers.h:21

◆ operator==()

int ImproperElem::operator== ( const ImproperElem &  a) const
inline

Definition at line 81 of file ComputeImpropers.h.

References atomID.

81  {
82  return (a.atomID[0] == atomID[0] && a.atomID[1] == atomID[1] &&
83  a.atomID[2] == atomID[2] && a.atomID[3] == atomID[3]);
84  }
ImproperElem::atomID
AtomID atomID[size]
Definition: ComputeImpropers.h:21

◆ submitReductionData()

void ImproperElem::submitReductionData ( BigReal *  data,
SubmitReduction *  reduction 
)
static

Definition at line 329 of file ComputeImpropers.C.

References ADD_TENSOR, improperEnergyIndex, improperEnergyIndex_f, improperEnergyIndex_ti_1, improperEnergyIndex_ti_2, SubmitReduction::item(), REDUCTION_BONDED_ENERGY_F, REDUCTION_BONDED_ENERGY_TI_1, REDUCTION_BONDED_ENERGY_TI_2, and REDUCTION_IMPROPER_ENERGY.

330 {
331  reduction->item(REDUCTION_IMPROPER_ENERGY) += data[improperEnergyIndex];
332  reduction->item(REDUCTION_BONDED_ENERGY_F) += data[improperEnergyIndex_f];
333  reduction->item(REDUCTION_BONDED_ENERGY_TI_1) += data[improperEnergyIndex_ti_1];
334  reduction->item(REDUCTION_BONDED_ENERGY_TI_2) += data[improperEnergyIndex_ti_2];
335  ADD_TENSOR(reduction,REDUCTION_VIRIAL_NORMAL,data,virialIndex);
336 }
ADD_TENSOR
#define ADD_TENSOR(R, RL, D, DL)
Definition: ReductionMgr.h:33
SubmitReduction::item
BigReal & item(int i)
Definition: ReductionMgr.h:313

Member Data Documentation

◆ atomID

AtomID ImproperElem::atomID[size]

Definition at line 21 of file ComputeImpropers.h.

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

◆ localIndex

int ImproperElem::localIndex[size]

Definition at line 22 of file ComputeImpropers.h.

Referenced by computeForce().

◆ p

TuplePatchElem* ImproperElem::p[size]

Definition at line 23 of file ComputeImpropers.h.

Referenced by computeForce(), and getParameterPointers().

◆ pressureProfileAtomTypes

int ImproperElem::pressureProfileAtomTypes = 1
static

Definition at line 36 of file ComputeImpropers.h.

Referenced by computeForce().

◆ pressureProfileMin

BigReal ImproperElem::pressureProfileMin = 0
static

Definition at line 38 of file ComputeImpropers.h.

Referenced by computeForce().

◆ pressureProfileSlabs

int ImproperElem::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 ComputeImpropers.h.

Referenced by computeForce().

◆ pressureProfileThickness

BigReal ImproperElem::pressureProfileThickness = 0
static

Definition at line 37 of file ComputeImpropers.h.

Referenced by computeForce().

◆ scale

Real ImproperElem::scale

Definition at line 24 of file ComputeImpropers.h.

Referenced by computeForce().

◆ value

const ImproperValue* ImproperElem::value

Definition at line 41 of file ComputeImpropers.h.

Referenced by computeForce(), and ImproperElem().

The documentation for this class was generated from the following files:
Generated by   doxygen 1.8.14