NAMD
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
ComputeHomeTuples< T, S, P > Class Template Reference

#include <ComputeHomeTuples.h>

Inheritance diagram for ComputeHomeTuples< T, S, P >:
Compute ComputeSelfTuples< T, S, P >

Public Member Functions

virtual ~ComputeHomeTuples ()
 
virtual void initialize (void)
 
void atomUpdate (void)
 
virtual void doWork (void)
 
- Public Member Functions inherited from Compute
 Compute (ComputeID)
 
int type ()
 
virtual ~Compute ()
 
void setNumPatches (int n)
 
int getNumPatches ()
 
virtual void patchReady (PatchID, int doneMigration, int seq)
 
virtual int noWork ()
 
virtual void finishPatch (int)
 
int sequence (void)
 
int priority (void)
 
int getGBISPhase (void)
 
virtual void gbisP2PatchReady (PatchID, int seq)
 
virtual void gbisP3PatchReady (PatchID, int seq)
 

Protected Member Functions

virtual void loadTuples (void)
 
 ComputeHomeTuples (ComputeID c)
 
 ComputeHomeTuples (ComputeID c, PatchIDList &pids)
 
- Protected Member Functions inherited from Compute
void enqueueWork ()
 

Protected Attributes

int doLoadTuples
 
ResizeArray< T > tupleList
 
TuplePatchList tuplePatchList
 
PatchMappatchMap
 
AtomMapatomMap
 
SubmitReductionreduction
 
int accelMDdoDihe
 
SubmitReductionpressureProfileReduction
 
BigRealpressureProfileData
 
int pressureProfileSlabs
 
char * isBasePatch
 
- Protected Attributes inherited from Compute
int computeType
 
int basePriority
 
int gbisPhase
 
int gbisPhasePriority [3]
 

Additional Inherited Members

- Public Attributes inherited from Compute
const ComputeID cid
 
LDObjHandle ldObjHandle
 
LocalWorkMsg *const localWorkMsg
 

Detailed Description

template<class T, class S, class P>
class ComputeHomeTuples< T, S, P >

Definition at line 367 of file ComputeHomeTuples.h.

Constructor & Destructor Documentation

◆ ComputeHomeTuples() [1/2]

template<class T, class S, class P>
ComputeHomeTuples< T, S, P >::ComputeHomeTuples ( ComputeID  c)
inlineprotected

Definition at line 559 of file ComputeHomeTuples.h.

559  : Compute(c) {
563 
565  accelMDdoDihe=false;
566  if (params->accelMDOn) {
567  if (params->accelMDdihe || params->accelMDdual) accelMDdoDihe=true;
568  }
569  if (params->pressureProfileOn) {
570  pressureProfileSlabs = T::pressureProfileSlabs =
571  params->pressureProfileSlabs;
572  int n = T::pressureProfileAtomTypes = params->pressureProfileAtomTypes;
575  int numAtomTypePairs = n*n;
576  pressureProfileData = new BigReal[3*pressureProfileSlabs*numAtomTypePairs];
577  } else {
579  pressureProfileData = NULL;
580  }
581  doLoadTuples = false;
582  isBasePatch = 0;
583 #ifdef USE_HOMETUPLES
584  tuples = NULL;
585 #endif
586  }
static Node * Object()
Definition: Node.h:86
static PatchMap * Object()
Definition: PatchMap.h:27
SimParameters * simParameters
Definition: Node.h:181
BigReal * pressureProfileData
SubmitReduction * pressureProfileReduction
SubmitReduction * willSubmit(int setID, int size=-1)
Definition: ReductionMgr.C:366
static ReductionMgr * Object(void)
Definition: ReductionMgr.h:279
int pressureProfileSlabs
static AtomMap * Object()
Definition: AtomMap.h:37
int pressureProfileAtomTypes
SubmitReduction * reduction
Bool pressureProfileOn
Compute(ComputeID)
Definition: Compute.C:37
double BigReal
Definition: common.h:123

◆ ComputeHomeTuples() [2/2]

template<class T, class S, class P>
ComputeHomeTuples< T, S, P >::ComputeHomeTuples ( ComputeID  c,
PatchIDList pids 
)
inlineprotected

Definition at line 588 of file ComputeHomeTuples.h.

588  : Compute(c) {
593  accelMDdoDihe=false;
594  if (params->accelMDOn) {
595  if (params->accelMDdihe || params->accelMDdual) accelMDdoDihe=true;
596  }
597  if (params->pressureProfileOn) {
598  pressureProfileSlabs = T::pressureProfileSlabs =
599  params->pressureProfileSlabs;
600  int n = T::pressureProfileAtomTypes = params->pressureProfileAtomTypes;
603  int numAtomTypePairs = n*n;
604  pressureProfileData = new BigReal[3*pressureProfileSlabs*numAtomTypePairs];
605  } else {
607  pressureProfileData = NULL;
608  }
609  doLoadTuples = false;
610  int nPatches = patchMap->numPatches();
611  isBasePatch = new char[nPatches];
612  int i;
613  for (i=0; i<nPatches; ++i) { isBasePatch[i] = 0; }
614  for (i=0; i<pids.size(); ++i) { isBasePatch[pids[i]] = 1; }
615 #ifdef USE_HOMETUPLES
616  tuples = NULL;
617 #endif
618  }
static Node * Object()
Definition: Node.h:86
int size(void) const
Definition: ResizeArray.h:131
static PatchMap * Object()
Definition: PatchMap.h:27
SimParameters * simParameters
Definition: Node.h:181
BigReal * pressureProfileData
SubmitReduction * pressureProfileReduction
SubmitReduction * willSubmit(int setID, int size=-1)
Definition: ReductionMgr.C:366
static ReductionMgr * Object(void)
Definition: ReductionMgr.h:279
int pressureProfileSlabs
int numPatches(void) const
Definition: PatchMap.h:59
static AtomMap * Object()
Definition: AtomMap.h:37
int pressureProfileAtomTypes
SubmitReduction * reduction
Bool pressureProfileOn
Compute(ComputeID)
Definition: Compute.C:37
double BigReal
Definition: common.h:123

◆ ~ComputeHomeTuples()

template<class T, class S, class P>
virtual ComputeHomeTuples< T, S, P >::~ComputeHomeTuples ( )
inlinevirtual

Definition at line 622 of file ComputeHomeTuples.h.

622  {
623  delete reduction;
624  delete [] isBasePatch;
626  delete pressureProfileData;
627 #ifdef USE_HOMETUPLES
628  if (tuples != NULL) delete tuples;
629 #endif
630  }
BigReal * pressureProfileData
SubmitReduction * pressureProfileReduction
SubmitReduction * reduction

Member Function Documentation

◆ atomUpdate()

template<class T, class S, class P>
void ComputeHomeTuples< T, S, P >::atomUpdate ( void  )
inlinevirtual

Reimplemented from Compute.

Definition at line 686 of file ComputeHomeTuples.h.

686  {
687  doLoadTuples = true;
688  }

◆ doWork()

template<class T, class S, class P>
virtual void ComputeHomeTuples< T, S, P >::doWork ( void  )
inlinevirtual

Reimplemented from Compute.

Reimplemented in ComputeSelfTuples< T, S, P >, ComputeSelfTuples< AnisoElem, Aniso, AnisoValue >, ComputeSelfTuples< AngleElem, Angle, AngleValue >, ComputeSelfTuples< GromacsPairElem, GromacsPair, GromacsPairValue >, ComputeSelfTuples< ExclElem, Exclusion, int >, ComputeSelfTuples< DihedralElem, Dihedral, DihedralValue >, ComputeSelfTuples< ImproperElem, Improper, ImproperValue >, ComputeSelfTuples< BondElem, Bond, BondValue >, ComputeSelfTuples< CrosstermElem, Crossterm, CrosstermValue >, and ComputeSelfTuples< TholeElem, Thole, TholeValue >.

Definition at line 695 of file ComputeHomeTuples.h.

Referenced by ComputeSelfTuples< TholeElem, Thole, TholeValue >::doWork().

695  {
696 
698  // Open Boxes - register that we are using Positions
699  // and will be depositing Forces.
701  for (ap = ap.begin(); ap != ap.end(); ap++) {
702  ap->x = ap->positionBox->open();
703  ap->xExt = ap->p->getCompAtomExtInfo();
704  if ( ap->p->flags.doMolly ) ap->x_avg = ap->avgPositionBox->open();
705  ap->r = ap->forceBox->open();
706  ap->f = ap->r->f[Results::normal];
707  if (accelMDdoDihe) ap->af = ap->r->f[Results::amdf]; // for dihedral-only or dual-boost accelMD
708  }
709 
710  BigReal reductionData[T::reductionDataSize];
711  int tupleCount = 0;
712  int numAtomTypes = T::pressureProfileAtomTypes;
713  int numAtomTypePairs = numAtomTypes*numAtomTypes;
714 
715  for ( int i = 0; i < T::reductionDataSize; ++i ) reductionData[i] = 0;
716  if (pressureProfileData) {
717  memset(pressureProfileData, 0, 3*pressureProfileSlabs*numAtomTypePairs*sizeof(BigReal));
718  // Silly variable hiding of the previous iterator
720  newap = newap.begin();
721  const Lattice &lattice = newap->p->lattice;
722  T::pressureProfileThickness = lattice.c().z / pressureProfileSlabs;
723  T::pressureProfileMin = lattice.origin().z - 0.5*lattice.c().z;
724  }
725 
726  if ( ! Node::Object()->simParameters->commOnly ) {
727  if ( doLoadTuples ) {
728 #ifdef USE_HOMETUPLES
729  tuples->loadTuples(tuplePatchList, isBasePatch, AtomMap::Object());
730 #else
731  loadTuples();
732 #endif
733  doLoadTuples = false;
734  }
735  // take triplet and pass with tuple info to force eval
736 #ifdef USE_HOMETUPLES
737  T *al = (T *)tuples->getTupleList();
738  const int ntuple = tuples->getNumTuples();
739 #else
740  T *al = tupleList.begin();
741  const int ntuple = tupleList.size();
742 #endif
743  if ( ntuple ) T::computeForce(al, ntuple, reductionData, pressureProfileData);
744  tupleCount += ntuple;
745  }
746 
748 
749  T::submitReductionData(reductionData,reduction);
750  reduction->item(T::reductionChecksumLabel) += (BigReal)tupleCount;
751  reduction->submit();
752 
754  // For ease of calculation we stored interactions between types
755  // i and j in (ni+j). For efficiency now we coalesce the
756  // cross interactions so that just i<=j are stored.
757  const int arraysize = 3*pressureProfileSlabs;
758  const BigReal *data = pressureProfileData;
759  for (int i=0; i<numAtomTypes; i++) {
760  for (int j=0; j<numAtomTypes; j++) {
761  int ii=i;
762  int jj=j;
763  if (ii > jj) { int tmp=ii; ii=jj; jj=tmp; }
764  const int reductionOffset =
765  (ii*numAtomTypes - (ii*(ii+1))/2 + jj)*arraysize;
766  for (int k=0; k<arraysize; k++) {
767  pressureProfileReduction->item(reductionOffset+k) += data[k];
768  }
769  data += arraysize;
770  }
771  }
773  }
774 
775  // Close boxes - i.e. signal we are done with Positions and
776  // AtomProperties and that we are depositing Forces
777  for (ap = ap.begin(); ap != ap.end(); ap++) {
778  ap->positionBox->close(&(ap->x));
779  if ( ap->p->flags.doMolly ) ap->avgPositionBox->close(&(ap->x_avg));
780  ap->forceBox->close(&(ap->r));
781  }
782  }
static Node * Object()
Definition: Node.h:86
int size(void) const
Definition: ResizeArray.h:131
NAMD_HOST_DEVICE Vector c() const
Definition: Lattice.h:270
BigReal & item(int i)
Definition: ReductionMgr.h:313
BigReal * pressureProfileData
void startWork(const LDObjHandle &handle)
BigReal z
Definition: Vector.h:74
TuplePatchList tuplePatchList
SubmitReduction * pressureProfileReduction
LDObjHandle ldObjHandle
Definition: Compute.h:44
static LdbCoordinator * Object()
static AtomMap * Object()
Definition: AtomMap.h:37
void endWork(const LDObjHandle &handle)
ResizeArray< T > tupleList
iterator begin(void)
Definition: ResizeArray.h:36
SubmitReduction * reduction
virtual void loadTuples(void)
void submit(void)
Definition: ReductionMgr.h:324
NAMD_HOST_DEVICE Vector origin() const
Definition: Lattice.h:278
double BigReal
Definition: common.h:123

◆ initialize()

template<class T, class S, class P>
virtual void ComputeHomeTuples< T, S, P >::initialize ( void  )
inlinevirtual

Reimplemented from Compute.

Reimplemented in ComputeSelfTuples< T, S, P >, ComputeSelfTuples< AnisoElem, Aniso, AnisoValue >, ComputeSelfTuples< AngleElem, Angle, AngleValue >, ComputeSelfTuples< GromacsPairElem, GromacsPair, GromacsPairValue >, ComputeSelfTuples< ExclElem, Exclusion, int >, ComputeSelfTuples< DihedralElem, Dihedral, DihedralValue >, ComputeSelfTuples< ImproperElem, Improper, ImproperValue >, ComputeSelfTuples< BondElem, Bond, BondValue >, ComputeSelfTuples< CrosstermElem, Crossterm, CrosstermValue >, and ComputeSelfTuples< TholeElem, Thole, TholeValue >.

Definition at line 636 of file ComputeHomeTuples.h.

636  {
637 
638 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
639  ProxyMgr *proxyMgr = ProxyMgr::Object();
640 #endif
641 
642 #ifdef USE_HOMETUPLES
643  tuples = new HomeTuples<T, S, P>();
644 #endif
645 
646  // Start with empty list
648 
649  int nPatches = patchMap->numPatches();
650  int pid;
651  for (pid=0; pid<nPatches; ++pid) {
652  if ( isBasePatch[pid] ) {
653 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
654  proxyMgr->createProxy(pid);
655 #endif
656  Patch *patch = patchMap->patch(pid);
657  tuplePatchList.add(TuplePatchElem(patch, this));
658  }
659  }
660 
661  // Gather all proxy patches (neighbors, that is)
663 
664  for (pid=0; pid<nPatches; ++pid) if ( isBasePatch[pid] ) {
665  int numNeighbors = patchMap->upstreamNeighbors(pid,neighbors);
666  for ( int i = 0; i < numNeighbors; ++i ) {
667  if ( ! tuplePatchList.find(TuplePatchElem(neighbors[i])) ) {
668 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
669  proxyMgr->createProxy(neighbors[i]);
670 #endif
671  Patch *patch = patchMap->patch(neighbors[i]);
672  tuplePatchList.add(TuplePatchElem(patch, this));
673  }
674  }
675  }
677  doLoadTuples = true;
678 
679  basePriority = COMPUTE_PROXY_PRIORITY; // no patch dependence
680  }
void setNumPatches(int n)
Definition: Compute.h:52
Elem * find(const Elem &elem)
Definition: UniqueSet.h:60
#define COMPUTE_PROXY_PRIORITY
Definition: Priorities.h:71
int size(void) const
Definition: UniqueSet.h:58
static ProxyMgr * Object()
Definition: ProxyMgr.h:394
void clear(void)
Definition: UniqueSet.h:62
int upstreamNeighbors(int pid, PatchID *neighbor_ids)
Definition: PatchMap.C:669
TuplePatchList tuplePatchList
int add(const Elem &elem)
Definition: UniqueSet.h:52
Patch * patch(PatchID pid)
Definition: PatchMap.h:244
Definition: Patch.h:35
int numPatches(void) const
Definition: PatchMap.h:59
void createProxy(PatchID pid)
Definition: ProxyMgr.C:492
int basePriority
Definition: Compute.h:37
int32 PatchID
Definition: NamdTypes.h:277

◆ loadTuples()

template<class T, class S, class P>
virtual void ComputeHomeTuples< T, S, P >::loadTuples ( void  )
inlineprotectedvirtual

Definition at line 372 of file ComputeHomeTuples.h.

372  {
373  int numTuples;
374 
375  #ifdef MEM_OPT_VERSION
376  typename ElemTraits<T>::signature *allSigs;
377  #else
378  int32 **tuplesByAtom;
379  /* const (need to propagate const) */ S *tupleStructs;
380  #endif
381 
382  const P *tupleValues;
383  Node *node = Node::Object();
384 
385  #ifdef MEM_OPT_VERSION
386  allSigs = ElemTraits<T>::get_sig_pointer(node->molecule);
387  #else
388  T::getMoleculePointers(node->molecule,
389  &numTuples, &tuplesByAtom, &tupleStructs);
390  #endif
391 
392  T::getParameterPointers(node->parameters, &tupleValues);
393 
394  tupleList.resize(0);
395 
396  LocalID aid[T::size];
397  int partition[T::size];
398 
399  const int lesOn = node->simParameters->lesOn;
400  const int soluteScalingOn = node->simParameters->soluteScalingOn;
401  const int fepOn = node->simParameters->singleTopology;
402  const int sdScaling = node->simParameters->sdScaling;
403  Real invLesFactor = lesOn ?
404  1.0/node->simParameters->lesFactor :
405  1.0;
406  const Real soluteScalingFactor = node->simParameters->soluteScalingFactor;
407  const Bool soluteScalingAll = node->simParameters->soluteScalingAll;
408  BigReal OneMinusLambda = 1.0 - node->simParameters->alchLambda;
409  BigReal Lambda = node->simParameters->alchLambda;
410  const int num_unpert_bonds = node->molecule->num_alch_unpert_Bonds;
411  const int num_unpert_angles = node->molecule->num_alch_unpert_Angles;
412  const int num_unpert_dihedrals = node->molecule->num_alch_unpert_Dihedrals;
413  Bond *unpert_bonds = node->molecule->alch_unpert_bonds;
414  Angle *unpert_angles = node->molecule->alch_unpert_angles;
415  Dihedral *unpert_dihedrals = node->molecule->alch_unpert_dihedrals;
416 
417  // cycle through each patch and gather all tuples
419 
420  for ( ai = ai.begin(); ai != ai.end(); ai++ )
421  {
422  // CompAtom *atom = (*ai).x;
423  Patch *patch = (*ai).p;
424  int numAtoms = patch->getNumAtoms();
425  CompAtomExt *atomExt = (*ai).xExt; //patch->getCompAtomExtInfo();
426 
427  // cycle through each atom in the patch and load up tuples
428  for (int j=0; j < numAtoms; j++)
429  {
430  /* cycle through each tuple */
431  #ifdef MEM_OPT_VERSION
432  typename ElemTraits<T>::signature *thisAtomSig =
433  &allSigs[ElemTraits<T>::get_sig_id(atomExt[j])];
434  TupleSignature *allTuples;
435  T::getTupleInfo(thisAtomSig, &numTuples, &allTuples);
436  for(int k=0; k<numTuples; k++) {
437  T t(atomExt[j].id, &allTuples[k], tupleValues);
438  #else
439  /* get list of all tuples for the atom */
440  int32 *curTuple = tuplesByAtom[atomExt[j].id];
441  for( ; *curTuple != -1; ++curTuple) {
442  T t(&tupleStructs[*curTuple],tupleValues);
443  #endif
444  register int i;
445  aid[0] = atomMap->localID(t.atomID[0]);
446  int homepatch = aid[0].pid;
447  int samepatch = 1;
448  partition[0] = fepOn ? node->molecule->get_fep_type(t.atomID[0]) : 0;
449  int has_les = lesOn ? node->molecule->get_fep_type(t.atomID[0]) : 0;
450  int has_ss = soluteScalingOn ? node->molecule->get_ss_type(t.atomID[0]) : 0;
451  int is_fep_ss = partition[0] > 2;
452  int is_fep_sd = 0;
453  int fep_tuple_type = 0;
454  for (i=1; i < T::size; i++) {
455  aid[i] = atomMap->localID(t.atomID[i]);
456  samepatch = samepatch && ( homepatch == aid[i].pid );
457  partition[i] = fepOn ? node->molecule->get_fep_type(t.atomID[i]) : 0;
458  has_les |= lesOn ? node->molecule->get_fep_type(t.atomID[i]) : 0;
459  has_ss |= soluteScalingOn ? node->molecule->get_ss_type(t.atomID[i]) : 0;
460  if (fepOn) {
461  is_fep_ss &= partition[i] > 2;
462  is_fep_sd |= (abs(partition[i] - partition[0]) == 2);
463  fep_tuple_type = partition[i];
464  }
465  }
466  if (sdScaling && is_fep_sd) {
467  for (i=0; i < num_unpert_bonds; i++) {
468  if (T::size == 2
469  && t.atomID[0]==unpert_bonds[i].atom1
470  && t.atomID[1]==unpert_bonds[i].atom2) is_fep_sd = 0;
471  }
472  for (i=0; i < num_unpert_angles; i++) {
473  if (T::size == 3
474  && t.atomID[0]==unpert_angles[i].atom1
475  && t.atomID[1]==unpert_angles[i].atom2
476  && t.atomID[2]==unpert_angles[i].atom3) is_fep_sd = 0;
477  }
478  for (i=0; i < num_unpert_dihedrals; i++) {
479  if (T::size == 4
480  && t.atomID[0]==unpert_dihedrals[i].atom1
481  && t.atomID[1]==unpert_dihedrals[i].atom2
482  && t.atomID[2]==unpert_dihedrals[i].atom3
483  && t.atomID[3]==unpert_dihedrals[i].atom4) is_fep_sd = 0;
484  }
485  }
486  if (T::size < 4 && !soluteScalingAll) has_ss = false;
487  if ( samepatch ) continue;
488  t.scale = (!has_les && !has_ss) ? 1.0 : ( has_les ? invLesFactor : soluteScalingFactor );
489  if (is_fep_ss) t.scale = (fep_tuple_type == 4) ? OneMinusLambda : Lambda;
490  if (is_fep_sd && sdScaling) t.scale = (fep_tuple_type == 4 || fep_tuple_type == 2) ? OneMinusLambda : Lambda;
491 
492  for (i=1; i < T::size; i++) {
493  homepatch = patchMap->downstream(homepatch,aid[i].pid);
494  }
495  if ( homepatch != notUsed && isBasePatch[homepatch] ) {
496  TuplePatchElem *p;
497  for (i=0; i < T::size; i++) {
498  t.p[i] = p = tuplePatchList.find(TuplePatchElem(aid[i].pid));
499  if ( ! p ) {
500  #ifdef MEM_OPT_VERSION
501  iout << iWARN << "Tuple with atoms ";
502  #else
503  iout << iWARN << "Tuple " << *curTuple << " with atoms ";
504  #endif
505  int erri;
506  for( erri = 0; erri < T::size; erri++ ) {
507  iout << t.atomID[erri] << "(" << aid[erri].pid << ") ";
508  }
509  iout << "missing patch " << aid[i].pid << "\n" << endi;
510  break;
511  }
512  t.localIndex[i] = aid[i].index;
513  }
514  if ( ! p ) continue;
515  #ifdef MEM_OPT_VERSION
516  //avoid adding Tuples whose atoms are all fixed
517  if(node->simParameters->fixedAtomsOn &&
519  int allfixed = 1;
520  for(i=0; i<T::size; i++){
521  CompAtomExt *one = &(t.p[i]->xExt[aid[i].index]);
522  allfixed = allfixed & one->atomFixed;
523  }
524  if(!allfixed) tupleList.add(t);
525  }else{
526  tupleList.add(t);
527  }
528  #else
529  tupleList.add(t);
530  #endif
531  }
532  }
533  }
534  }
535  }
static Node * Object()
Definition: Node.h:86
Elem * find(const Elem &elem)
Definition: UniqueSet.h:60
int num_alch_unpert_Dihedrals
Definition: Molecule.h:603
int getNumAtoms() const
Definition: Patch.h:105
Definition: Node.h:78
static void partition(int *order, const FullAtom *atoms, int begin, int end)
Definition: SortAtoms.C:45
Angle * alch_unpert_angles
Definition: Molecule.h:605
SimParameters * simParameters
Definition: Node.h:181
int num_alch_unpert_Bonds
Definition: Molecule.h:601
float Real
Definition: common.h:118
int32_t int32
Definition: common.h:38
std::ostream & endi(std::ostream &s)
Definition: InfoStream.C:54
int downstream(int pid1, int pid2)
Definition: PatchMap.inl:51
TuplePatchList tuplePatchList
std::ostream & iWARN(std::ostream &s)
Definition: InfoStream.C:82
int num_alch_unpert_Angles
Definition: Molecule.h:602
unsigned char get_ss_type(int anum) const
Definition: Molecule.h:1443
#define iout
Definition: InfoStream.h:51
int add(const Elem &elem)
Definition: ResizeArray.h:101
BigReal alchLambda
Dihedral * alch_unpert_dihedrals
Definition: Molecule.h:606
Definition: Patch.h:35
void resize(int i)
Definition: ResizeArray.h:84
int32 index
Definition: NamdTypes.h:290
uint32 id
Definition: NamdTypes.h:156
BigReal soluteScalingFactor
int Bool
Definition: common.h:142
CompAtomList p
Definition: Patch.h:153
LocalID localID(AtomID id)
Definition: AtomMap.h:78
Bond * alch_unpert_bonds
Definition: Molecule.h:604
PatchID pid
Definition: NamdTypes.h:289
unsigned char get_fep_type(int anum) const
Definition: Molecule.h:1432
Parameters * parameters
Definition: Node.h:180
ResizeArray< T > tupleList
uint32 atomFixed
Definition: NamdTypes.h:158
Molecule * molecule
Definition: Node.h:179
double BigReal
Definition: common.h:123

Member Data Documentation

◆ accelMDdoDihe

template<class T, class S, class P>
int ComputeHomeTuples< T, S, P >::accelMDdoDihe
protected

Definition at line 553 of file ComputeHomeTuples.h.

◆ atomMap

template<class T, class S, class P>
AtomMap* ComputeHomeTuples< T, S, P >::atomMap
protected

Definition at line 551 of file ComputeHomeTuples.h.

◆ doLoadTuples

template<class T, class S, class P>
int ComputeHomeTuples< T, S, P >::doLoadTuples
protected

Definition at line 538 of file ComputeHomeTuples.h.

◆ isBasePatch

template<class T, class S, class P>
char* ComputeHomeTuples< T, S, P >::isBasePatch
protected

Definition at line 557 of file ComputeHomeTuples.h.

◆ patchMap

template<class T, class S, class P>
PatchMap* ComputeHomeTuples< T, S, P >::patchMap
protected

Definition at line 550 of file ComputeHomeTuples.h.

◆ pressureProfileData

template<class T, class S, class P>
BigReal* ComputeHomeTuples< T, S, P >::pressureProfileData
protected

Definition at line 555 of file ComputeHomeTuples.h.

◆ pressureProfileReduction

template<class T, class S, class P>
SubmitReduction* ComputeHomeTuples< T, S, P >::pressureProfileReduction
protected

Definition at line 554 of file ComputeHomeTuples.h.

◆ pressureProfileSlabs

template<class T, class S, class P>
int ComputeHomeTuples< T, S, P >::pressureProfileSlabs
protected

Definition at line 556 of file ComputeHomeTuples.h.

◆ reduction

template<class T, class S, class P>
SubmitReduction* ComputeHomeTuples< T, S, P >::reduction
protected

Definition at line 552 of file ComputeHomeTuples.h.

◆ tupleList

template<class T, class S, class P>
ResizeArray<T> ComputeHomeTuples< T, S, P >::tupleList
protected

Definition at line 546 of file ComputeHomeTuples.h.

◆ tuplePatchList

template<class T, class S, class P>
TuplePatchList ComputeHomeTuples< T, S, P >::tuplePatchList
protected

Definition at line 547 of file ComputeHomeTuples.h.


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