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 376 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 568 of file ComputeHomeTuples.h.

568  : Compute(c) {
572 
574  accelMDdoDihe=false;
575  if (params->accelMDOn) {
576  if (params->accelMDdihe || params->accelMDdual) accelMDdoDihe=true;
577  }
578  if (params->pressureProfileOn) {
579  pressureProfileSlabs = T::pressureProfileSlabs =
580  params->pressureProfileSlabs;
581  int n = T::pressureProfileAtomTypes = params->pressureProfileAtomTypes;
584  int numAtomTypePairs = n*n;
585  pressureProfileData = new BigReal[3*pressureProfileSlabs*numAtomTypePairs];
586  } else {
588  pressureProfileData = NULL;
589  }
590  doLoadTuples = false;
591  isBasePatch = 0;
592 #ifdef USE_HOMETUPLES
593  tuples = NULL;
594 #endif
595  }
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:368
static ReductionMgr * Object(void)
Definition: ReductionMgr.h:290
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 597 of file ComputeHomeTuples.h.

597  : Compute(c) {
602  accelMDdoDihe=false;
603  if (params->accelMDOn) {
604  if (params->accelMDdihe || params->accelMDdual) accelMDdoDihe=true;
605  }
606  if (params->pressureProfileOn) {
607  pressureProfileSlabs = T::pressureProfileSlabs =
608  params->pressureProfileSlabs;
609  int n = T::pressureProfileAtomTypes = params->pressureProfileAtomTypes;
612  int numAtomTypePairs = n*n;
613  pressureProfileData = new BigReal[3*pressureProfileSlabs*numAtomTypePairs];
614  } else {
616  pressureProfileData = NULL;
617  }
618  doLoadTuples = false;
619  int nPatches = patchMap->numPatches();
620  isBasePatch = new char[nPatches];
621  int i;
622  for (i=0; i<nPatches; ++i) { isBasePatch[i] = 0; }
623  for (i=0; i<pids.size(); ++i) { isBasePatch[pids[i]] = 1; }
624 #ifdef USE_HOMETUPLES
625  tuples = NULL;
626 #endif
627  }
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:368
static ReductionMgr * Object(void)
Definition: ReductionMgr.h:290
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 631 of file ComputeHomeTuples.h.

631  {
632  delete reduction;
633  delete [] isBasePatch;
635  delete pressureProfileData;
636 #ifdef USE_HOMETUPLES
637  if (tuples != NULL) delete tuples;
638 #endif
639  }
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 695 of file ComputeHomeTuples.h.

695  {
696  doLoadTuples = true;
697  }

◆ 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 >, ComputeSelfTuples< OneFourNbTholeElem, OneFourNbThole, OneFourNbTholeValue >, and ComputeSelfTuples< TholeElem, Thole, TholeValue >.

Definition at line 704 of file ComputeHomeTuples.h.

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

704  {
705 
707  // Open Boxes - register that we are using Positions
708  // and will be depositing Forces.
710  for (ap = ap.begin(); ap != ap.end(); ap++) {
711  ap->x = ap->positionBox->open();
712  ap->xExt = ap->p->getCompAtomExtInfo();
713  if ( ap->p->flags.doMolly ) ap->x_avg = ap->avgPositionBox->open();
714  ap->r = ap->forceBox->open();
715  ap->f = ap->r->f[Results::normal];
716  if (accelMDdoDihe) ap->af = ap->r->f[Results::amdf]; // for dihedral-only or dual-boost accelMD
717  }
718 
719  BigReal reductionData[T::reductionDataSize];
720  int tupleCount = 0;
721  int numAtomTypes = T::pressureProfileAtomTypes;
722  int numAtomTypePairs = numAtomTypes*numAtomTypes;
723 
724  for ( int i = 0; i < T::reductionDataSize; ++i ) reductionData[i] = 0;
725  if (pressureProfileData) {
726  memset(pressureProfileData, 0, 3*pressureProfileSlabs*numAtomTypePairs*sizeof(BigReal));
727  // Silly variable hiding of the previous iterator
729  newap = newap.begin();
730  const Lattice &lattice = newap->p->lattice;
731  T::pressureProfileThickness = lattice.c().z / pressureProfileSlabs;
732  T::pressureProfileMin = lattice.origin().z - 0.5*lattice.c().z;
733  }
734 
735  if ( ! Node::Object()->simParameters->commOnly ) {
736  if ( doLoadTuples ) {
737 #ifdef USE_HOMETUPLES
738  tuples->loadTuples(tuplePatchList, isBasePatch, AtomMap::Object());
739 #else
740  loadTuples();
741 #endif
742  doLoadTuples = false;
743  }
744  // take triplet and pass with tuple info to force eval
745 #ifdef USE_HOMETUPLES
746  T *al = (T *)tuples->getTupleList();
747  const int ntuple = tuples->getNumTuples();
748 #else
749  T *al = tupleList.begin();
750  const int ntuple = tupleList.size();
751 #endif
752  if ( ntuple ) T::computeForce(al, ntuple, reductionData, pressureProfileData);
753  tupleCount += ntuple;
754  }
755 
757 
758  T::submitReductionData(reductionData,reduction);
759  reduction->item(T::reductionChecksumLabel) += (BigReal)tupleCount;
760  reduction->submit();
761 
763  // For ease of calculation we stored interactions between types
764  // i and j in (ni+j). For efficiency now we coalesce the
765  // cross interactions so that just i<=j are stored.
766  const int arraysize = 3*pressureProfileSlabs;
767  const BigReal *data = pressureProfileData;
768  for (int i=0; i<numAtomTypes; i++) {
769  for (int j=0; j<numAtomTypes; j++) {
770  int ii=i;
771  int jj=j;
772  if (ii > jj) { int tmp=ii; ii=jj; jj=tmp; }
773  const int reductionOffset =
774  (ii*numAtomTypes - (ii*(ii+1))/2 + jj)*arraysize;
775  for (int k=0; k<arraysize; k++) {
776  pressureProfileReduction->item(reductionOffset+k) += data[k];
777  }
778  data += arraysize;
779  }
780  }
782  }
783 
784  // Close boxes - i.e. signal we are done with Positions and
785  // AtomProperties and that we are depositing Forces
786  for (ap = ap.begin(); ap != ap.end(); ap++) {
787  ap->positionBox->close(&(ap->x));
788  if ( ap->p->flags.doMolly ) ap->avgPositionBox->close(&(ap->x_avg));
789  ap->forceBox->close(&(ap->r));
790  }
791  }
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
virtual void submit(void)=0
BigReal & item(int i)
Definition: ReductionMgr.h:336
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)
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 >, ComputeSelfTuples< OneFourNbTholeElem, OneFourNbThole, OneFourNbTholeValue >, and ComputeSelfTuples< TholeElem, Thole, TholeValue >.

Definition at line 645 of file ComputeHomeTuples.h.

645  {
646 
647 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
648  ProxyMgr *proxyMgr = ProxyMgr::Object();
649 #endif
650 
651 #ifdef USE_HOMETUPLES
652  tuples = new HomeTuples<T, S, P>();
653 #endif
654 
655  // Start with empty list
657 
658  int nPatches = patchMap->numPatches();
659  int pid;
660  for (pid=0; pid<nPatches; ++pid) {
661  if ( isBasePatch[pid] ) {
662 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
663  proxyMgr->createProxy(pid);
664 #endif
665  Patch *patch = patchMap->patch(pid);
666  tuplePatchList.add(TuplePatchElem(patch, this));
667  }
668  }
669 
670  // Gather all proxy patches (neighbors, that is)
672 
673  for (pid=0; pid<nPatches; ++pid) if ( isBasePatch[pid] ) {
674  int numNeighbors = patchMap->upstreamNeighbors(pid,neighbors);
675  for ( int i = 0; i < numNeighbors; ++i ) {
676  if ( ! tuplePatchList.find(TuplePatchElem(neighbors[i])) ) {
677 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
678  proxyMgr->createProxy(neighbors[i]);
679 #endif
680  Patch *patch = patchMap->patch(neighbors[i]);
681  tuplePatchList.add(TuplePatchElem(patch, this));
682  }
683  }
684  }
686  doLoadTuples = true;
687 
688  basePriority = COMPUTE_PROXY_PRIORITY; // no patch dependence
689  }
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:287

◆ loadTuples()

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

Definition at line 381 of file ComputeHomeTuples.h.

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

◆ atomMap

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

Definition at line 560 of file ComputeHomeTuples.h.

◆ doLoadTuples

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

Definition at line 547 of file ComputeHomeTuples.h.

◆ isBasePatch

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

Definition at line 566 of file ComputeHomeTuples.h.

◆ patchMap

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

Definition at line 559 of file ComputeHomeTuples.h.

◆ pressureProfileData

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

Definition at line 564 of file ComputeHomeTuples.h.

◆ pressureProfileReduction

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

Definition at line 563 of file ComputeHomeTuples.h.

◆ pressureProfileSlabs

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

Definition at line 565 of file ComputeHomeTuples.h.

◆ reduction

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

Definition at line 561 of file ComputeHomeTuples.h.

◆ tupleList

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

Definition at line 555 of file ComputeHomeTuples.h.

◆ tuplePatchList

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

Definition at line 556 of file ComputeHomeTuples.h.


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