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 > ComputeSelfTuples< AngleElem, Angle, AngleValue > ComputeSelfTuples< AnisoElem, Aniso, AnisoValue > ComputeSelfTuples< BondElem, Bond, BondValue > ComputeSelfTuples< CrosstermElem, Crossterm, CrosstermValue > ComputeSelfTuples< DihedralElem, Dihedral, DihedralValue > ComputeSelfTuples< ExclElem, Exclusion, int > ComputeSelfTuples< GromacsPairElem, GromacsPair, GromacsPairValue > ComputeSelfTuples< ImproperElem, Improper, ImproperValue > ComputeSelfTuples< TholeElem, Thole, TholeValue >

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

Constructor & Destructor Documentation

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

Definition at line 557 of file ComputeHomeTuples.h.

557  : Compute(c) {
561 
563  accelMDdoDihe=false;
564  if (params->accelMDOn) {
565  if (params->accelMDdihe || params->accelMDdual) accelMDdoDihe=true;
566  }
567  if (params->pressureProfileOn) {
568  pressureProfileSlabs = T::pressureProfileSlabs =
569  params->pressureProfileSlabs;
570  int n = T::pressureProfileAtomTypes = params->pressureProfileAtomTypes;
573  int numAtomTypePairs = n*n;
574  pressureProfileData = new BigReal[3*pressureProfileSlabs*numAtomTypePairs];
575  } else {
577  pressureProfileData = NULL;
578  }
579  doLoadTuples = false;
580  isBasePatch = 0;
581 #ifdef USE_HOMETUPLES
582  tuples = NULL;
583 #endif
584  }
static Node * Object()
Definition: Node.h:86
static PatchMap * Object()
Definition: PatchMap.h:27
SimParameters * simParameters
Definition: Node.h:178
BigReal * pressureProfileData
SubmitReduction * pressureProfileReduction
SubmitReduction * willSubmit(int setID, int size=-1)
Definition: ReductionMgr.C:365
static ReductionMgr * Object(void)
Definition: ReductionMgr.h:278
int pressureProfileSlabs
static AtomMap * Object()
Definition: AtomMap.h:36
int pressureProfileAtomTypes
SubmitReduction * reduction
Bool pressureProfileOn
Compute(ComputeID)
Definition: Compute.C:33
double BigReal
Definition: common.h:112
template<class T, class S, class P>
ComputeHomeTuples< T, S, P >::ComputeHomeTuples ( ComputeID  c,
PatchIDList pids 
)
inlineprotected

Definition at line 586 of file ComputeHomeTuples.h.

586  : Compute(c) {
591  accelMDdoDihe=false;
592  if (params->accelMDOn) {
593  if (params->accelMDdihe || params->accelMDdual) accelMDdoDihe=true;
594  }
595  if (params->pressureProfileOn) {
596  pressureProfileSlabs = T::pressureProfileSlabs =
597  params->pressureProfileSlabs;
598  int n = T::pressureProfileAtomTypes = params->pressureProfileAtomTypes;
601  int numAtomTypePairs = n*n;
602  pressureProfileData = new BigReal[3*pressureProfileSlabs*numAtomTypePairs];
603  } else {
605  pressureProfileData = NULL;
606  }
607  doLoadTuples = false;
608  int nPatches = patchMap->numPatches();
609  isBasePatch = new char[nPatches];
610  int i;
611  for (i=0; i<nPatches; ++i) { isBasePatch[i] = 0; }
612  for (i=0; i<pids.size(); ++i) { isBasePatch[pids[i]] = 1; }
613 #ifdef USE_HOMETUPLES
614  tuples = NULL;
615 #endif
616  }
static Node * Object()
Definition: Node.h:86
static PatchMap * Object()
Definition: PatchMap.h:27
SimParameters * simParameters
Definition: Node.h:178
BigReal * pressureProfileData
SubmitReduction * pressureProfileReduction
SubmitReduction * willSubmit(int setID, int size=-1)
Definition: ReductionMgr.C:365
static ReductionMgr * Object(void)
Definition: ReductionMgr.h:278
int pressureProfileSlabs
static AtomMap * Object()
Definition: AtomMap.h:36
int pressureProfileAtomTypes
int numPatches(void) const
Definition: PatchMap.h:59
SubmitReduction * reduction
Bool pressureProfileOn
int size(void) const
Definition: ResizeArray.h:127
Compute(ComputeID)
Definition: Compute.C:33
double BigReal
Definition: common.h:112
template<class T, class S, class P>
virtual ComputeHomeTuples< T, S, P >::~ComputeHomeTuples ( )
inlinevirtual

Definition at line 620 of file ComputeHomeTuples.h.

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

Member Function Documentation

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

Reimplemented from Compute.

Definition at line 684 of file ComputeHomeTuples.h.

684  {
685  doLoadTuples = true;
686  }
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 693 of file ComputeHomeTuples.h.

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

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

634  {
635 
636 #ifdef NAMD_CUDA
637  ProxyMgr *proxyMgr = ProxyMgr::Object();
638 #endif
639 
640 #ifdef USE_HOMETUPLES
641  tuples = new HomeTuples<T, S, P>();
642 #endif
643 
644  // Start with empty list
646 
647  int nPatches = patchMap->numPatches();
648  int pid;
649  for (pid=0; pid<nPatches; ++pid) {
650  if ( isBasePatch[pid] ) {
651 #ifdef NAMD_CUDA
652  proxyMgr->createProxy(pid);
653 #endif
654  Patch *patch = patchMap->patch(pid);
655  tuplePatchList.add(TuplePatchElem(patch, this));
656  }
657  }
658 
659  // Gather all proxy patches (neighbors, that is)
661 
662  for (pid=0; pid<nPatches; ++pid) if ( isBasePatch[pid] ) {
663  int numNeighbors = patchMap->upstreamNeighbors(pid,neighbors);
664  for ( int i = 0; i < numNeighbors; ++i ) {
665  if ( ! tuplePatchList.find(TuplePatchElem(neighbors[i])) ) {
666 #ifdef NAMD_CUDA
667  proxyMgr->createProxy(neighbors[i]);
668 #endif
669  Patch *patch = patchMap->patch(neighbors[i]);
670  tuplePatchList.add(TuplePatchElem(patch, this));
671  }
672  }
673  }
675  doLoadTuples = true;
676 
677  basePriority = COMPUTE_PROXY_PRIORITY; // no patch dependence
678  }
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
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
int size(void) const
Definition: UniqueSet.h:58
Patch * patch(PatchID pid)
Definition: PatchMap.h:235
Definition: Patch.h:35
int PatchID
Definition: NamdTypes.h:182
void createProxy(PatchID pid)
Definition: ProxyMgr.C:493
int numPatches(void) const
Definition: PatchMap.h:59
int basePriority
Definition: Compute.h:37
template<class T, class S, class P>
virtual void ComputeHomeTuples< T, S, P >::loadTuples ( void  )
inlineprotectedvirtual

Definition at line 370 of file ComputeHomeTuples.h.

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

Member Data Documentation

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

Definition at line 551 of file ComputeHomeTuples.h.

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

Definition at line 549 of file ComputeHomeTuples.h.

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

Definition at line 536 of file ComputeHomeTuples.h.

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

Definition at line 555 of file ComputeHomeTuples.h.

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

Definition at line 548 of file ComputeHomeTuples.h.

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

Definition at line 553 of file ComputeHomeTuples.h.

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

Definition at line 552 of file ComputeHomeTuples.h.

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

Definition at line 554 of file ComputeHomeTuples.h.

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

Definition at line 550 of file ComputeHomeTuples.h.

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

Definition at line 544 of file ComputeHomeTuples.h.

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

Definition at line 545 of file ComputeHomeTuples.h.


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