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

#include <ComputeNonbondedCUDAExcl.h>

Inheritance diagram for ExclElem:
ComputeNonbondedUtil

Public Types

enum  { size = 2 }
 
enum  {
  vdwEnergyIndex, electEnergyIndex, fullElectEnergyIndex, TENSOR =(virialIndex),
  TENSOR =(virialIndex), reductionDataSize
}
 
enum  { reductionChecksumLabel = REDUCTION_EXCLUSION_CHECKSUM }
 
- Public Types inherited from ComputeNonbondedUtil
enum  {
  exclChecksumIndex, pairlistWarningIndex, electEnergyIndex, fullElectEnergyIndex,
  vdwEnergyIndex, goNativeEnergyIndex, goNonnativeEnergyIndex, groLJEnergyIndex,
  groGaussEnergyIndex, electEnergyIndex_s, fullElectEnergyIndex_s, vdwEnergyIndex_s,
  electEnergyIndex_ti_1, fullElectEnergyIndex_ti_1, vdwEnergyIndex_ti_1, electEnergyIndex_ti_2,
  fullElectEnergyIndex_ti_2, vdwEnergyIndex_ti_2, TENSOR =(virialIndex), TENSOR =(virialIndex),
  VECTOR =(pairVDWForceIndex), VECTOR =(pairVDWForceIndex), reductionDataSize
}
 

Public Member Functions

int hash () const
 
 ExclElem ()
 
 ExclElem (AtomID atom0, const TupleSignature *sig, const int *v)
 
 ExclElem (const Exclusion *a, const int *v)
 
 ExclElem (AtomID atom0, AtomID atom1)
 
 ~ExclElem ()
 
int operator== (const ExclElem &a) const
 
int operator< (const ExclElem &a) const
 
- Public Member Functions inherited from ComputeNonbondedUtil
 ComputeNonbondedUtil ()
 
 ~ComputeNonbondedUtil ()
 
void calcGBIS (nonbonded *params, GBISParamStruct *gbisParams)
 

Static Public Member Functions

static void computeForce (ExclElem *, int, BigReal *, BigReal *)
 
static void getMoleculePointers (Molecule *, int *, int32 ***, Exclusion **)
 
static void getParameterPointers (Parameters *, const int **)
 
static void getTupleInfo (ExclusionSignature *sig, int *count, TupleSignature **t)
 
static void submitReductionData (BigReal *, SubmitReduction *)
 
- Static Public Member Functions inherited from ComputeNonbondedUtil
static void select (void)
 
static void submitReductionData (BigReal *, SubmitReduction *)
 
static void submitPressureProfileData (BigReal *, SubmitReduction *)
 
static BigReal square (const BigReal &x, const BigReal &y, const BigReal &z)
 
static void calc_error (nonbonded *)
 
static void calc_pair (nonbonded *)
 
static void calc_pair_energy (nonbonded *)
 
static void calc_pair_fullelect (nonbonded *)
 
static void calc_pair_energy_fullelect (nonbonded *)
 
static void calc_pair_merge_fullelect (nonbonded *)
 
static void calc_pair_energy_merge_fullelect (nonbonded *)
 
static void calc_pair_slow_fullelect (nonbonded *)
 
static void calc_pair_energy_slow_fullelect (nonbonded *)
 
static void calc_self (nonbonded *)
 
static void calc_self_energy (nonbonded *)
 
static void calc_self_fullelect (nonbonded *)
 
static void calc_self_energy_fullelect (nonbonded *)
 
static void calc_self_merge_fullelect (nonbonded *)
 
static void calc_self_energy_merge_fullelect (nonbonded *)
 
static void calc_self_slow_fullelect (nonbonded *)
 
static void calc_self_energy_slow_fullelect (nonbonded *)
 
static void calc_pair_energy_fep (nonbonded *)
 
static void calc_pair_energy_fullelect_fep (nonbonded *)
 
static void calc_pair_energy_merge_fullelect_fep (nonbonded *)
 
static void calc_pair_energy_slow_fullelect_fep (nonbonded *)
 
static void calc_self_energy_fep (nonbonded *)
 
static void calc_self_energy_fullelect_fep (nonbonded *)
 
static void calc_self_energy_merge_fullelect_fep (nonbonded *)
 
static void calc_self_energy_slow_fullelect_fep (nonbonded *)
 
static void calc_pair_energy_ti (nonbonded *)
 
static void calc_pair_ti (nonbonded *)
 
static void calc_pair_energy_fullelect_ti (nonbonded *)
 
static void calc_pair_fullelect_ti (nonbonded *)
 
static void calc_pair_energy_merge_fullelect_ti (nonbonded *)
 
static void calc_pair_merge_fullelect_ti (nonbonded *)
 
static void calc_pair_energy_slow_fullelect_ti (nonbonded *)
 
static void calc_pair_slow_fullelect_ti (nonbonded *)
 
static void calc_self_energy_ti (nonbonded *)
 
static void calc_self_ti (nonbonded *)
 
static void calc_self_energy_fullelect_ti (nonbonded *)
 
static void calc_self_fullelect_ti (nonbonded *)
 
static void calc_self_energy_merge_fullelect_ti (nonbonded *)
 
static void calc_self_merge_fullelect_ti (nonbonded *)
 
static void calc_self_energy_slow_fullelect_ti (nonbonded *)
 
static void calc_self_slow_fullelect_ti (nonbonded *)
 
static void calc_pair_les (nonbonded *)
 
static void calc_pair_energy_les (nonbonded *)
 
static void calc_pair_fullelect_les (nonbonded *)
 
static void calc_pair_energy_fullelect_les (nonbonded *)
 
static void calc_pair_merge_fullelect_les (nonbonded *)
 
static void calc_pair_energy_merge_fullelect_les (nonbonded *)
 
static void calc_pair_slow_fullelect_les (nonbonded *)
 
static void calc_pair_energy_slow_fullelect_les (nonbonded *)
 
static void calc_self_les (nonbonded *)
 
static void calc_self_energy_les (nonbonded *)
 
static void calc_self_fullelect_les (nonbonded *)
 
static void calc_self_energy_fullelect_les (nonbonded *)
 
static void calc_self_merge_fullelect_les (nonbonded *)
 
static void calc_self_energy_merge_fullelect_les (nonbonded *)
 
static void calc_self_slow_fullelect_les (nonbonded *)
 
static void calc_self_energy_slow_fullelect_les (nonbonded *)
 
static void calc_pair_energy_int (nonbonded *)
 
static void calc_pair_energy_fullelect_int (nonbonded *)
 
static void calc_pair_energy_merge_fullelect_int (nonbonded *)
 
static void calc_self_energy_int (nonbonded *)
 
static void calc_self_energy_fullelect_int (nonbonded *)
 
static void calc_self_energy_merge_fullelect_int (nonbonded *)
 
static void calc_pair_pprof (nonbonded *)
 
static void calc_pair_energy_pprof (nonbonded *)
 
static void calc_pair_fullelect_pprof (nonbonded *)
 
static void calc_pair_energy_fullelect_pprof (nonbonded *)
 
static void calc_pair_merge_fullelect_pprof (nonbonded *)
 
static void calc_pair_energy_merge_fullelect_pprof (nonbonded *)
 
static void calc_pair_slow_fullelect_pprof (nonbonded *)
 
static void calc_pair_energy_slow_fullelect_pprof (nonbonded *)
 
static void calc_self_pprof (nonbonded *)
 
static void calc_self_energy_pprof (nonbonded *)
 
static void calc_self_fullelect_pprof (nonbonded *)
 
static void calc_self_energy_fullelect_pprof (nonbonded *)
 
static void calc_self_merge_fullelect_pprof (nonbonded *)
 
static void calc_self_energy_merge_fullelect_pprof (nonbonded *)
 
static void calc_self_slow_fullelect_pprof (nonbonded *)
 
static void calc_self_energy_slow_fullelect_pprof (nonbonded *)
 
static void calc_pair_tabener (nonbonded *)
 
static void calc_pair_energy_tabener (nonbonded *)
 
static void calc_pair_fullelect_tabener (nonbonded *)
 
static void calc_pair_energy_fullelect_tabener (nonbonded *)
 
static void calc_pair_merge_fullelect_tabener (nonbonded *)
 
static void calc_pair_energy_merge_fullelect_tabener (nonbonded *)
 
static void calc_pair_slow_fullelect_tabener (nonbonded *)
 
static void calc_pair_energy_slow_fullelect_tabener (nonbonded *)
 
static void calc_self_tabener (nonbonded *)
 
static void calc_self_energy_tabener (nonbonded *)
 
static void calc_self_fullelect_tabener (nonbonded *)
 
static void calc_self_energy_fullelect_tabener (nonbonded *)
 
static void calc_self_merge_fullelect_tabener (nonbonded *)
 
static void calc_self_energy_merge_fullelect_tabener (nonbonded *)
 
static void calc_self_slow_fullelect_tabener (nonbonded *)
 
static void calc_self_energy_slow_fullelect_tabener (nonbonded *)
 
static void calc_pair_go (nonbonded *)
 
static void calc_pair_energy_go (nonbonded *)
 
static void calc_pair_fullelect_go (nonbonded *)
 
static void calc_pair_energy_fullelect_go (nonbonded *)
 
static void calc_pair_merge_fullelect_go (nonbonded *)
 
static void calc_pair_energy_merge_fullelect_go (nonbonded *)
 
static void calc_pair_slow_fullelect_go (nonbonded *)
 
static void calc_pair_energy_slow_fullelect_go (nonbonded *)
 
static void calc_self_go (nonbonded *)
 
static void calc_self_energy_go (nonbonded *)
 
static void calc_self_fullelect_go (nonbonded *)
 
static void calc_self_energy_fullelect_go (nonbonded *)
 
static void calc_self_merge_fullelect_go (nonbonded *)
 
static void calc_self_energy_merge_fullelect_go (nonbonded *)
 
static void calc_self_slow_fullelect_go (nonbonded *)
 
static void calc_self_energy_slow_fullelect_go (nonbonded *)
 

Public Attributes

AtomID atomID [size]
 
int localIndex [size]
 
TuplePatchElemp [size]
 
Real scale
 
int modified
 

Static Public Attributes

static int pressureProfileSlabs = 0
 
static int pressureProfileAtomTypes = 1
 
static BigReal pressureProfileThickness = 0
 
static BigReal pressureProfileMin = 0
 
- Static Public Attributes inherited from ComputeNonbondedUtil
static void(* calcPair )(nonbonded *)
 
static void(* calcPairEnergy )(nonbonded *)
 
static void(* calcSelf )(nonbonded *)
 
static void(* calcSelfEnergy )(nonbonded *)
 
static void(* calcFullPair )(nonbonded *)
 
static void(* calcFullPairEnergy )(nonbonded *)
 
static void(* calcFullSelf )(nonbonded *)
 
static void(* calcFullSelfEnergy )(nonbonded *)
 
static void(* calcMergePair )(nonbonded *)
 
static void(* calcMergePairEnergy )(nonbonded *)
 
static void(* calcMergeSelf )(nonbonded *)
 
static void(* calcMergeSelfEnergy )(nonbonded *)
 
static void(* calcSlowPair )(nonbonded *)
 
static void(* calcSlowPairEnergy )(nonbonded *)
 
static void(* calcSlowSelf )(nonbonded *)
 
static void(* calcSlowSelfEnergy )(nonbonded *)
 
static Bool commOnly
 
static Bool fixedAtomsOn
 
static Bool qmForcesOn
 
static BigReal cutoff
 
static BigReal cutoff2
 
static float cutoff2_f
 
static BigReal dielectric_1
 
static const LJTableljTable = 0
 
static const Moleculemol
 
static BigReal r2_delta
 
static BigReal r2_delta_1
 
static int rowsize
 
static int columnsize
 
static int r2_delta_exp
 
static BigRealtable_alloc = 0
 
static BigRealtable_ener = 0
 
static BigRealtable_short
 
static BigRealtable_noshort
 
static BigRealfast_table
 
static BigRealscor_table
 
static BigRealslow_table
 
static BigRealcorr_table
 
static BigRealfull_table
 
static BigRealvdwa_table
 
static BigRealvdwb_table
 
static BigRealr2_table
 
static int table_length
 
static BigReal scaling
 
static BigReal scale14
 
static BigReal switchOn
 
static BigReal switchOn_1
 
static BigReal switchOn2
 
static BigReal v_vdwa
 
static BigReal v_vdwb
 
static BigReal k_vdwa
 
static BigReal k_vdwb
 
static BigReal cutoff_3
 
static BigReal cutoff_6
 
static float v_vdwa_f
 
static float v_vdwb_f
 
static float k_vdwa_f
 
static float k_vdwb_f
 
static float cutoff_3_f
 
static float cutoff_6_f
 
static float switchOn_f
 
static float A6_f
 
static float B6_f
 
static float C6_f
 
static float A12_f
 
static float B12_f
 
static float C12_f
 
static BigReal c0
 
static BigReal c1
 
static BigReal c3
 
static BigReal c5
 
static BigReal c6
 
static BigReal c7
 
static BigReal c8
 
static Bool alchFepOn
 
static Bool alchThermIntOn
 
static Bool alchWCAOn
 
static BigReal alchVdwShiftCoeff
 
static Bool vdwForceSwitching
 
static Bool alchDecouple
 
static Bool lesOn
 
static int lesFactor
 
static BigReal lesScaling
 
static BigReallambda_table = 0
 
static Bool pairInteractionOn
 
static Bool pairInteractionSelf
 
static Bool pressureProfileOn
 
static int pressureProfileSlabs
 
static int pressureProfileAtomTypes
 
static BigReal pressureProfileThickness
 
static BigReal pressureProfileMin
 
static Bool accelMDOn
 
static Bool drudeNbthole
 
static BigReal ewaldcof
 
static BigReal pi_ewaldcof
 
static int vdw_switch_mode
 
static Bool goGroPair
 
static Bool goForcesOn
 
static int goMethod
 

Detailed Description

Definition at line 21 of file ComputeNonbondedCUDAExcl.h.

Member Enumeration Documentation

anonymous enum
Enumerator
size 

Definition at line 24 of file ComputeNonbondedCUDAExcl.h.

anonymous enum
Enumerator
vdwEnergyIndex 
electEnergyIndex 
fullElectEnergyIndex 
TENSOR 
TENSOR 
reductionDataSize 

Definition at line 51 of file ComputeNonbondedCUDAExcl.h.

anonymous enum

Constructor & Destructor Documentation

ExclElem::ExclElem ( )
inline

Definition at line 12 of file ComputeNonbondedCUDAExcl.inl.

12 { ; }
ExclElem::ExclElem ( AtomID  atom0,
const TupleSignature sig,
const int *  v 
)
inline

Definition at line 14 of file ComputeNonbondedCUDAExcl.inl.

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

14  {
15  atomID[0] = atom0;
16  atomID[1] = atom0 + sig->offset[0];
17  modified = sig->tupleParamType;
18 }
AtomID atomID[size]
Index tupleParamType
Definition: structures.h:202
ExclElem::ExclElem ( const Exclusion a,
const int *  v 
)
inline

Definition at line 20 of file ComputeNonbondedCUDAExcl.inl.

References Exclusion::atom1, Exclusion::atom2, atomID, modified, and Exclusion::modified.

21  {
22  atomID[0] = a->atom1;
23  atomID[1] = a->atom2;
24  modified = a->modified;
25  }
int32 atom2
Definition: structures.h:160
Index modified
Definition: structures.h:161
int32 atom1
Definition: structures.h:159
AtomID atomID[size]
ExclElem::ExclElem ( AtomID  atom0,
AtomID  atom1 
)
inline

Definition at line 27 of file ComputeNonbondedCUDAExcl.inl.

References atomID.

28  {
29  if (atom0 > atom1) { // Swap end atoms so lowest is first!
30  AtomID tmp = atom1; atom1 = atom0; atom0 = tmp;
31  }
32  atomID[0] = atom0;
33  atomID[1] = atom1;
34  }
int AtomID
Definition: NamdTypes.h:29
AtomID atomID[size]
ExclElem::~ExclElem ( )
inline

Definition at line 60 of file ComputeNonbondedCUDAExcl.h.

60 {};

Member Function Documentation

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

Definition at line 41 of file ComputeNonbondedCUDAExcl.C.

References LJTable::TableEntry::A, A, atomID, LJTable::TableEntry::B, B, CompAtom::charge, COULOMB, ComputeNonbondedUtil::cutoff2, Lattice::delta(), ComputeNonbondedUtil::dielectric_1, Flags::doEnergy, Flags::doFullElectrostatics, Flags::doNonbonded, electEnergyIndex, Results::f, fast_a, fast_b, fast_c, fast_dir, ComputeNonbondedUtil::fast_table, Patch::flags, fullElectEnergyIndex, if(), Patch::lattice, Vector::length2(), lj_pars, ComputeNonbondedUtil::ljTable, localIndex, modified, Results::nbond, p, TuplePatchElem::p, p_j, CompAtom::position, TuplePatchElem::r, ComputeNonbondedUtil::r2_delta, ComputeNonbondedUtil::r2_delta_exp, ComputeNonbondedUtil::r2_table, scale, ComputeNonbondedUtil::scale14, ComputeNonbondedUtil::scaling, size, Results::slow, ComputeNonbondedUtil::slow_table, table_four_i, ComputeNonbondedUtil::table_noshort, LJTable::table_row(), vdw_a, vdw_b, vdw_c, vdw_d, vdwEnergyIndex, CompAtom::vdwType, TuplePatchElem::x, Vector::x, Vector::y, and Vector::z.

43 {
44  const Lattice & lattice = tuples[0].p[0]->p->lattice;
45  const Flags &flags = tuples[0].p[0]->p->flags;
46  if ( ! flags.doNonbonded ) return;
47  const int doFull = flags.doFullElectrostatics;
48  const int doEnergy = flags.doEnergy;
49 
50  for ( int ituple=0; ituple<ntuple; ++ituple ) {
51  const ExclElem &tup = tuples[ituple];
52  enum { size = 2 };
53  const AtomID (&atomID)[size](tup.atomID);
54  const int (&localIndex)[size](tup.localIndex);
55  TuplePatchElem * const(&p)[size](tup.p);
56  const Real (&scale)(tup.scale);
57  const int (&modified)(tup.modified);
58 
59  const CompAtom &p_i = p[0]->x[localIndex[0]];
60  const CompAtom &p_j = p[1]->x[localIndex[1]];
61 
62  // compute vectors between atoms and their distances
63  const Vector r12 = lattice.delta(p_i.position, p_j.position);
64  BigReal r2 = r12.length2();
65 
66  if ( r2 > cutoff2 ) continue;
67 
68  if ( modified && r2 < 1.0 ) r2 = 1.0; // match CUDA interpolation
69 
70  r2 += r2_delta;
71 
72  union { double f; int64 i; } r2i;
73  r2i.f = r2;
74  const int r2_delta_expc = 64 * (r2_delta_exp - 1023);
75  int table_i = (r2i.i >> (32+14)) + r2_delta_expc; // table_i >= 0
76 
77  const BigReal* const table_four_i = table_noshort + 16*table_i;
78 
79  BigReal diffa = r2 - r2_table[table_i];
80 
81  BigReal fast_a = 0., fast_b = 0., fast_c = 0., fast_d = 0.;
82  BigReal slow_a, slow_b, slow_c, slow_d;
83 
84  if ( modified ) {
85 
87  ljTable->table_row(p_i.vdwType) + 2 * p_j.vdwType;
88 
89  // modified - normal = correction
90  const BigReal A = scaling * ( (lj_pars+1)->A - lj_pars->A );
91  const BigReal B = scaling * ( (lj_pars+1)->B - lj_pars->B );
92 
93  BigReal vdw_d = A * table_four_i[0] - B * table_four_i[4];
94  BigReal vdw_c = A * table_four_i[1] - B * table_four_i[5];
95  BigReal vdw_b = A * table_four_i[2] - B * table_four_i[6];
96  BigReal vdw_a = A * table_four_i[3] - B * table_four_i[7];
97 
98  const BigReal kqq = (1.0 - scale14) *
99  COULOMB * p_i.charge * p_j.charge * scaling * dielectric_1;
100 
101  fast_a = kqq * fast_table[4*table_i+0]; // not used!
102  fast_b = 2. * kqq * fast_table[4*table_i+1];
103  fast_c = 4. * kqq * fast_table[4*table_i+2];
104  fast_d = 6. * kqq * fast_table[4*table_i+3];
105 
106  if ( doFull ) {
107  slow_a = kqq * slow_table[4*table_i+3]; // not used!
108  slow_b = 2. * kqq * slow_table[4*table_i+2];
109  slow_c = 4. * kqq * slow_table[4*table_i+1];
110  slow_d = 6. * kqq * slow_table[4*table_i+0];
111  }
112 
113  if ( doEnergy ) {
114  reduction[vdwEnergyIndex] -=
115  ( ( diffa * (1./6.)*vdw_d + 0.25*vdw_c ) * diffa
116  + 0.5*vdw_b ) * diffa + vdw_a;
117  reduction[electEnergyIndex] -=
118  ( ( diffa * (1./6.)*fast_d + 0.25*fast_c ) * diffa
119  + 0.5*fast_b ) * diffa + fast_a;
120  if ( doFull ) {
121  reduction[fullElectEnergyIndex] -=
122  ( ( diffa * (1./6.)*slow_d + 0.25*slow_c ) * diffa
123  + 0.5*slow_b ) * diffa + slow_a;
124  }
125  }
126 
127  fast_a += vdw_a;
128  fast_b += vdw_b;
129  fast_c += vdw_c;
130  fast_d += vdw_d;
131 
132  } else if ( doFull ) { // full exclusion
133 
134  const BigReal kqq =
135  COULOMB * p_i.charge * p_j.charge * scaling * dielectric_1;
136 
137  slow_d = kqq * ( table_four_i[8] - table_four_i[12] );
138  slow_c = kqq * ( table_four_i[9] - table_four_i[13] );
139  slow_b = kqq * ( table_four_i[10] - table_four_i[14] );
140  slow_a = kqq * ( table_four_i[11] - table_four_i[15] ); // not used!
141 
142  if ( doEnergy ) {
143  reduction[fullElectEnergyIndex] -=
144  ( ( diffa * (1./6.)*slow_d + 0.25*slow_c ) * diffa
145  + 0.5*slow_b ) * diffa + slow_a;
146  }
147  }
148 
149  register BigReal fast_dir =
150  (diffa * fast_d + fast_c) * diffa + fast_b;
151 
152  const Force f12 = fast_dir * r12;
153 
154  // Now add the forces to each force vector
155  p[0]->r->f[Results::nbond][localIndex[0]] += f12;
156  p[1]->r->f[Results::nbond][localIndex[1]] -= f12;
157 
158  // reduction[nonbondedEnergyIndex] += energy;
159  reduction[virialIndex_XX] += f12.x * r12.x;
160  reduction[virialIndex_XY] += f12.x * r12.y;
161  reduction[virialIndex_XZ] += f12.x * r12.z;
162  reduction[virialIndex_YX] += f12.y * r12.x;
163  reduction[virialIndex_YY] += f12.y * r12.y;
164  reduction[virialIndex_YZ] += f12.y * r12.z;
165  reduction[virialIndex_ZX] += f12.z * r12.x;
166  reduction[virialIndex_ZY] += f12.z * r12.y;
167  reduction[virialIndex_ZZ] += f12.z * r12.z;
168 
169  if ( doFull ) {
170  register BigReal slow_dir =
171  (diffa * slow_d + slow_c) * diffa + slow_b;
172 
173  const Force slow_f12 = slow_dir * r12;
174 
175  p[0]->r->f[Results::slow][localIndex[0]] += slow_f12;
176  p[1]->r->f[Results::slow][localIndex[1]] -= slow_f12;
177 
178  // reduction[nonbondedEnergyIndex] += energy;
179  reduction[slowVirialIndex_XX] += slow_f12.x * r12.x;
180  reduction[slowVirialIndex_XY] += slow_f12.x * r12.y;
181  reduction[slowVirialIndex_XZ] += slow_f12.x * r12.z;
182  reduction[slowVirialIndex_YX] += slow_f12.y * r12.x;
183  reduction[slowVirialIndex_YY] += slow_f12.y * r12.y;
184  reduction[slowVirialIndex_YZ] += slow_f12.y * r12.z;
185  reduction[slowVirialIndex_ZX] += slow_f12.z * r12.x;
186  reduction[slowVirialIndex_ZY] += slow_f12.z * r12.y;
187  reduction[slowVirialIndex_ZZ] += slow_f12.z * r12.z;
188  }
189 
190  }
191 }
static BigReal * fast_table
register BigReal fast_dir
int AtomID
Definition: NamdTypes.h:29
Lattice & lattice
Definition: Patch.h:126
const BigReal A
Definition: Vector.h:64
float Real
Definition: common.h:107
#define COULOMB
Definition: common.h:44
#define table_four_i
BigReal z
Definition: Vector.h:66
Position position
Definition: NamdTypes.h:53
if(ComputeNonbondedUtil::goMethod==2)
#define p_j
BigReal vdw_b
#define lj_pars
Flags flags
Definition: Patch.h:127
BigReal vdw_c
Charge charge
Definition: NamdTypes.h:54
static BigReal * table_noshort
int doEnergy
Definition: PatchTypes.h:20
int doFullElectrostatics
Definition: PatchTypes.h:23
Force * f[maxNumForces]
Definition: PatchTypes.h:67
Vector delta(const Position &pos1, const Position &pos2) const
Definition: Lattice.h:144
BigReal x
Definition: Vector.h:66
int doNonbonded
Definition: PatchTypes.h:22
TuplePatchElem * p[size]
AtomID atomID[size]
static BigReal * slow_table
BigReal length2(void) const
Definition: Vector.h:173
long long int64
Definition: common.h:34
short vdwType
Definition: NamdTypes.h:55
BigReal vdw_d
BigReal y
Definition: Vector.h:66
static const LJTable * ljTable
const BigReal B
BigReal vdw_a
const TableEntry * table_row(unsigned int i) const
Definition: LJTable.h:31
double BigReal
Definition: common.h:112
void ExclElem::getMoleculePointers ( Molecule mol,
int *  count,
int32 ***  byatom,
Exclusion **  structarray 
)
static

Definition at line 26 of file ComputeNonbondedCUDAExcl.C.

References NAMD_die(), and Molecule::numExclusions.

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

Definition at line 37 of file ComputeNonbondedCUDAExcl.C.

37  {
38  *v = 0;
39 }
static void ExclElem::getTupleInfo ( ExclusionSignature sig,
int *  count,
TupleSignature **  t 
)
inlinestatic

Definition at line 33 of file ComputeNonbondedCUDAExcl.h.

References ExclusionSignature::allExclCnt, and ExclusionSignature::allTuples.

33  {
34 #ifdef NAMD_CUDA
35  *count = sig->allExclCnt;
36  *t = sig->allTuples;
37 #endif
38  }
TupleSignature * allTuples
Definition: structures.h:522
int ExclElem::hash ( void  ) const
inline

Definition at line 46 of file ComputeNonbondedCUDAExcl.h.

References atomID.

46 { return 0x7FFFFFFF & ( (atomID[0]<<16) + (atomID[1])); }
AtomID atomID[size]
int ExclElem::operator< ( const ExclElem a) const
inline

Definition at line 41 of file ComputeNonbondedCUDAExcl.inl.

References atomID.

42  {
43  return (atomID[0] < a.atomID[0] ||
44  (atomID[0] == a.atomID[0] &&
45  (atomID[1] < a.atomID[1]) ));
46  }
AtomID atomID[size]
int ExclElem::operator== ( const ExclElem a) const
inline

Definition at line 36 of file ComputeNonbondedCUDAExcl.inl.

References atomID.

37  {
38  return (a.atomID[0] == atomID[0] && a.atomID[1] == atomID[1]);
39  }
AtomID atomID[size]
void ExclElem::submitReductionData ( BigReal data,
SubmitReduction reduction 
)
static

Member Data Documentation

AtomID ExclElem::atomID[size]

Definition at line 25 of file ComputeNonbondedCUDAExcl.h.

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

int ExclElem::localIndex[size]

Definition at line 26 of file ComputeNonbondedCUDAExcl.h.

Referenced by computeForce().

int ExclElem::modified

Definition at line 49 of file ComputeNonbondedCUDAExcl.h.

Referenced by computeForce(), and ExclElem().

TuplePatchElem* ExclElem::p[size]

Definition at line 27 of file ComputeNonbondedCUDAExcl.h.

Referenced by computeForce().

int ExclElem::pressureProfileAtomTypes = 1
static

Definition at line 42 of file ComputeNonbondedCUDAExcl.h.

BigReal ExclElem::pressureProfileMin = 0
static

Definition at line 44 of file ComputeNonbondedCUDAExcl.h.

int ExclElem::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 41 of file ComputeNonbondedCUDAExcl.h.

BigReal ExclElem::pressureProfileThickness = 0
static

Definition at line 43 of file ComputeNonbondedCUDAExcl.h.

Real ExclElem::scale

Definition at line 28 of file ComputeNonbondedCUDAExcl.h.

Referenced by computeForce().


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