ComputeHomeTuples< T, S, P > Class Template Reference

#include <ComputeHomeTuples.h>

Inheritance diagram for ComputeHomeTuples< 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
PatchMap *	patchMap
AtomMap *	atomMap
SubmitReduction *	reduction
int	accelMDdoDihe
SubmitReduction *	pressureProfileReduction
BigReal *	pressureProfileData
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 375 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 567 of file ComputeHomeTuples.h.

                                   : Compute(c) {
      patchMap = PatchMap::Object();
      atomMap = AtomMap::Object();
      reduction = ReductionMgr::Object()->willSubmit(REDUCTIONS_BASIC);
      
      SimParameters *params = Node::Object()->simParameters;
      accelMDdoDihe=false;
      if (params->accelMDOn) {
         if (params->accelMDdihe || params->accelMDdual) accelMDdoDihe=true;
      }
      if (params->pressureProfileOn) {
        pressureProfileSlabs = T::pressureProfileSlabs = 
          params->pressureProfileSlabs;
        int n = T::pressureProfileAtomTypes = params->pressureProfileAtomTypes;
        pressureProfileReduction = ReductionMgr::Object()->willSubmit(
          REDUCTIONS_PPROF_BONDED, 3*pressureProfileSlabs*((n*(n+1))/2));
        int numAtomTypePairs = n*n;
        pressureProfileData = new BigReal[3*pressureProfileSlabs*numAtomTypePairs];
      } else {
        pressureProfileReduction = NULL;
        pressureProfileData = NULL;
      }
      doLoadTuples = false;
      isBasePatch = 0;
#ifdef USE_HOMETUPLES
      tuples = NULL;
#endif
    }

ComputeHomeTuples() [2/2]

template<class T, class S, class P>

ComputeHomeTuples< T, S, P >::ComputeHomeTuples ( ComputeID  c, PatchIDList &  pids  )

inlineprotected

Definition at line 596 of file ComputeHomeTuples.h.

                                                      : Compute(c) {
      patchMap = PatchMap::Object();
      atomMap = AtomMap::Object();
      reduction = ReductionMgr::Object()->willSubmit(REDUCTIONS_BASIC);
      SimParameters *params = Node::Object()->simParameters;
      accelMDdoDihe=false;
      if (params->accelMDOn) {
         if (params->accelMDdihe || params->accelMDdual) accelMDdoDihe=true;
      }
      if (params->pressureProfileOn) {
        pressureProfileSlabs = T::pressureProfileSlabs = 
          params->pressureProfileSlabs;
        int n = T::pressureProfileAtomTypes = params->pressureProfileAtomTypes;
        pressureProfileReduction = ReductionMgr::Object()->willSubmit(
          REDUCTIONS_PPROF_BONDED, 3*pressureProfileSlabs*((n*(n+1))/2));
        int numAtomTypePairs = n*n;
        pressureProfileData = new BigReal[3*pressureProfileSlabs*numAtomTypePairs];
      } else {
        pressureProfileReduction = NULL;
        pressureProfileData = NULL;
      }
      doLoadTuples = false;
      int nPatches = patchMap->numPatches();
      isBasePatch = new char[nPatches];
      int i;
      for (i=0; i<nPatches; ++i) { isBasePatch[i] = 0; }
      for (i=0; i<pids.size(); ++i) { isBasePatch[pids[i]] = 1; }
#ifdef USE_HOMETUPLES
      tuples = NULL;
#endif
    }

~ComputeHomeTuples()

template<class T, class S, class P>

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

inlinevirtual

Definition at line 630 of file ComputeHomeTuples.h.

                                 {
      delete reduction;
      delete [] isBasePatch;
      delete pressureProfileReduction;
      delete pressureProfileData;
#ifdef USE_HOMETUPLES
      if (tuples != NULL) delete tuples;
#endif
    }

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

                          {
      doLoadTuples = true;
    }

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

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

                              {

      LdbCoordinator::Object()->startWork(ldObjHandle);
      // Open Boxes - register that we are using Positions
      // and will be depositing Forces.
      UniqueSetIter<TuplePatchElem> ap(tuplePatchList);
      for (ap = ap.begin(); ap != ap.end(); ap++) {
        ap->x = ap->positionBox->open();
        ap->xExt = ap->p->getCompAtomExtInfo();
        if ( ap->p->flags.doMolly ) ap->x_avg = ap->avgPositionBox->open();
        ap->r = ap->forceBox->open();
        ap->f = ap->r->f[Results::normal];
        if (accelMDdoDihe) ap->af = ap->r->f[Results::amdf]; // for dihedral-only or dual-boost accelMD
      } 
    
      BigReal reductionData[T::reductionDataSize];
      int tupleCount = 0;
      int numAtomTypes = T::pressureProfileAtomTypes;
      int numAtomTypePairs = numAtomTypes*numAtomTypes;
    
      for ( int i = 0; i < T::reductionDataSize; ++i ) reductionData[i] = 0;
      if (pressureProfileData) {
        memset(pressureProfileData, 0, 3*pressureProfileSlabs*numAtomTypePairs*sizeof(BigReal));
        // Silly variable hiding of the previous iterator
        UniqueSetIter<TuplePatchElem> newap(tuplePatchList);
        newap = newap.begin();
        const Lattice &lattice = newap->p->lattice;
        T::pressureProfileThickness = lattice.c().z / pressureProfileSlabs;
        T::pressureProfileMin = lattice.origin().z - 0.5*lattice.c().z;
      }

      if ( ! Node::Object()->simParameters->commOnly ) {
      if ( doLoadTuples ) {
#ifdef USE_HOMETUPLES
        tuples->loadTuples(tuplePatchList, isBasePatch, AtomMap::Object());
#else
        loadTuples();
#endif
        doLoadTuples = false;
      }
      // take triplet and pass with tuple info to force eval
#ifdef USE_HOMETUPLES
      T *al = (T *)tuples->getTupleList();
      const int ntuple = tuples->getNumTuples();
#else
      T *al = tupleList.begin();
      const int ntuple = tupleList.size();
#endif
      if ( ntuple ) T::computeForce(al, ntuple, reductionData, pressureProfileData);
      tupleCount += ntuple;
      }
 
    LdbCoordinator::Object()->endWork(ldObjHandle);

      T::submitReductionData(reductionData,reduction);
      reduction->item(T::reductionChecksumLabel) += (BigReal)tupleCount;
      reduction->submit();

      if (pressureProfileReduction) {
        // For ease of calculation we stored interactions between types
        // i and j in (ni+j).  For efficiency now we coalesce the
        // cross interactions so that just i<=j are stored.
        const int arraysize = 3*pressureProfileSlabs;
        const BigReal *data = pressureProfileData;
        for (int i=0; i<numAtomTypes; i++) {
          for (int j=0; j<numAtomTypes; j++) {
            int ii=i;
            int jj=j;
            if (ii > jj) { int tmp=ii; ii=jj; jj=tmp; }
            const int reductionOffset = 
              (ii*numAtomTypes - (ii*(ii+1))/2 + jj)*arraysize;
            for (int k=0; k<arraysize; k++) {
              pressureProfileReduction->item(reductionOffset+k) += data[k];
            }
            data += arraysize;
          }
        }
        pressureProfileReduction->submit();
      }
    
      // Close boxes - i.e. signal we are done with Positions and
      // AtomProperties and that we are depositing Forces
      for (ap = ap.begin(); ap != ap.end(); ap++) {
        ap->positionBox->close(&(ap->x));
        if ( ap->p->flags.doMolly ) ap->avgPositionBox->close(&(ap->x_avg));
        ap->forceBox->close(&(ap->r));
      }
    }

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

                                  {

#if defined(NAMD_CUDA) || defined(NAMD_HIP)
      ProxyMgr *proxyMgr = ProxyMgr::Object();
#endif

#ifdef USE_HOMETUPLES
      tuples = new HomeTuples<T, S, P>();
#endif

      // Start with empty list
      tuplePatchList.clear();
    
      int nPatches = patchMap->numPatches();
      int pid;
      for (pid=0; pid<nPatches; ++pid) {
        if ( isBasePatch[pid] ) {
#if defined(NAMD_CUDA) || defined(NAMD_HIP)
          proxyMgr->createProxy(pid);
#endif
          Patch *patch = patchMap->patch(pid);
          tuplePatchList.add(TuplePatchElem(patch, this));
        }
      }
    
      // Gather all proxy patches (neighbors, that is)
      PatchID neighbors[PatchMap::MaxOneOrTwoAway];
    
      for (pid=0; pid<nPatches; ++pid) if ( isBasePatch[pid] ) {
        int numNeighbors = patchMap->upstreamNeighbors(pid,neighbors);
        for ( int i = 0; i < numNeighbors; ++i ) {
          if ( ! tuplePatchList.find(TuplePatchElem(neighbors[i])) ) {
#if defined(NAMD_CUDA) || defined(NAMD_HIP)
            proxyMgr->createProxy(neighbors[i]);
#endif
            Patch *patch = patchMap->patch(neighbors[i]);
            tuplePatchList.add(TuplePatchElem(patch, this));
          }
        }
      }
      setNumPatches(tuplePatchList.size());
      doLoadTuples = true;

      basePriority = COMPUTE_PROXY_PRIORITY;  // no patch dependence
    }

loadTuples()

template<class T, class S, class P>

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

inlineprotectedvirtual

Definition at line 380 of file ComputeHomeTuples.h.

                                  {
      int numTuples;

      #ifdef MEM_OPT_VERSION
      typename ElemTraits<T>::signature *allSigs;      
      #else
      int32 **tuplesByAtom;
      /* const (need to propagate const) */ S *tupleStructs;
      #endif
      
      const P *tupleValues;
      Node *node = Node::Object();

      #ifdef MEM_OPT_VERSION
      allSigs = ElemTraits<T>::get_sig_pointer(node->molecule);
      #else      
      T::getMoleculePointers(node->molecule,
                    &numTuples, &tuplesByAtom, &tupleStructs);      
      #endif
      
      T::getParameterPointers(node->parameters, &tupleValues);

      tupleList.resize(0);

      LocalID aid[T::size];
      int partition[T::size];

      const int lesOn = node->simParameters->lesOn;
      const int soluteScalingOn = node->simParameters->soluteScalingOn;
      const int fepOn = node->simParameters->singleTopology;
      const int sdScaling = node->simParameters->sdScaling;
      Real invLesFactor = lesOn ? 
                          1.0/node->simParameters->lesFactor :
                          1.0;
      const Real soluteScalingFactor = node->simParameters->soluteScalingFactor;
      const Bool soluteScalingAll = node->simParameters->soluteScalingAll;
      BigReal OneMinusLambda = 1.0 - node->simParameters->alchLambda;
      BigReal Lambda = node->simParameters->alchLambda;
      const int num_unpert_bonds = node->molecule->num_alch_unpert_Bonds;
      const int num_unpert_angles = node->molecule->num_alch_unpert_Angles;
      const int num_unpert_dihedrals = node->molecule->num_alch_unpert_Dihedrals;
      Bond *unpert_bonds = node->molecule->alch_unpert_bonds;
      Angle *unpert_angles = node->molecule->alch_unpert_angles;
      Dihedral *unpert_dihedrals = node->molecule->alch_unpert_dihedrals;

      // cycle through each patch and gather all tuples
      TuplePatchListIter ai(tuplePatchList);
    
      for ( ai = ai.begin(); ai != ai.end(); ai++ )
      {
        // CompAtom *atom = (*ai).x;
        Patch *patch = (*ai).p;
        int numAtoms = patch->getNumAtoms();
        CompAtomExt *atomExt = (*ai).xExt; //patch->getCompAtomExtInfo();
    
        // cycle through each atom in the patch and load up tuples
        for (int j=0; j < numAtoms; j++)
        {              
           /* cycle through each tuple */
           #ifdef MEM_OPT_VERSION
           typename ElemTraits<T>::signature *thisAtomSig =
                   &allSigs[ElemTraits<T>::get_sig_id(atomExt[j])];
           TupleSignature *allTuples;
           T::getTupleInfo(thisAtomSig, &numTuples, &allTuples);
           for(int k=0; k<numTuples; k++) {
               T t(atomExt[j].id, &allTuples[k], tupleValues);
           #else
           /* get list of all tuples for the atom */
           int32 *curTuple = tuplesByAtom[atomExt[j].id];
           for( ; *curTuple != -1; ++curTuple) {             
             T t(&tupleStructs[*curTuple],tupleValues);
           #endif            
             register int i;
             aid[0] = atomMap->localID(t.atomID[0]);
             int homepatch = aid[0].pid;
             int samepatch = 1;
             partition[0] = fepOn ? node->molecule->get_fep_type(t.atomID[0]) : 0;
             int has_les = lesOn ? node->molecule->get_fep_type(t.atomID[0]) : 0;
             int has_ss = soluteScalingOn ? node->molecule->get_ss_type(t.atomID[0]) : 0;
             int is_fep_ss = partition[0] > 2;
             int is_fep_sd = 0;
             int fep_tuple_type = 0;
             for (i=1; i < T::size; i++) {
               aid[i] = atomMap->localID(t.atomID[i]);
               samepatch = samepatch && ( homepatch == aid[i].pid );
               partition[i] = fepOn ? node->molecule->get_fep_type(t.atomID[i]) : 0;
               has_les |= lesOn ? node->molecule->get_fep_type(t.atomID[i]) : 0;
               has_ss |= soluteScalingOn ? node->molecule->get_ss_type(t.atomID[i]) : 0;  
               if (fepOn) {
                 is_fep_ss &= partition[i] > 2;
                 is_fep_sd |= (abs(partition[i] - partition[0]) == 2);
                 fep_tuple_type = partition[i];
               }
             }
             if (sdScaling && is_fep_sd) {
               for (i=0; i < num_unpert_bonds; i++) {
                 if (T::size == 2
                     && t.atomID[0]==unpert_bonds[i].atom1
                     && t.atomID[1]==unpert_bonds[i].atom2) is_fep_sd = 0;
               }
               for (i=0; i < num_unpert_angles; i++) {
                 if (T::size == 3
                     && t.atomID[0]==unpert_angles[i].atom1
                     && t.atomID[1]==unpert_angles[i].atom2
                     && t.atomID[2]==unpert_angles[i].atom3) is_fep_sd = 0;
               }
               for (i=0; i < num_unpert_dihedrals; i++) {
                 if (T::size == 4
                     && t.atomID[0]==unpert_dihedrals[i].atom1
                     && t.atomID[1]==unpert_dihedrals[i].atom2
                     && t.atomID[2]==unpert_dihedrals[i].atom3
                     && t.atomID[3]==unpert_dihedrals[i].atom4) is_fep_sd = 0;
               }
             }
             if (T::size < 4 && !soluteScalingAll) has_ss = false;
             if ( samepatch ) continue;
             t.scale = (!has_les && !has_ss) ? 1.0 : ( has_les ? invLesFactor : soluteScalingFactor );
             if (is_fep_ss) t.scale = (fep_tuple_type == 4) ? OneMinusLambda : Lambda;
             if (is_fep_sd && sdScaling) t.scale = (fep_tuple_type == 4 || fep_tuple_type == 2) ? OneMinusLambda : Lambda;

             for (i=1; i < T::size; i++) {
               homepatch = patchMap->downstream(homepatch,aid[i].pid);
             }
             if ( homepatch != notUsed && isBasePatch[homepatch] ) {
               TuplePatchElem *p;
               for (i=0; i < T::size; i++) {
                 t.p[i] = p = tuplePatchList.find(TuplePatchElem(aid[i].pid));
                 if ( ! p ) {
                     #ifdef MEM_OPT_VERSION
                     iout << iWARN << "Tuple with atoms ";
                     #else
                   iout << iWARN << "Tuple " << *curTuple << " with atoms ";
                     #endif
                   int erri;
                   for( erri = 0; erri < T::size; erri++ ) {
                     iout << t.atomID[erri] << "(" <<  aid[erri].pid << ") ";
                   }
                   iout << "missing patch " << aid[i].pid << "\n" << endi;
                   break;
                 }
                 t.localIndex[i] = aid[i].index;
               }
               if ( ! p ) continue;
             #ifdef MEM_OPT_VERSION
               //avoid adding Tuples whose atoms are all fixed
               if(node->simParameters->fixedAtomsOn &&
                  !node->simParameters->fixedAtomsForces) {
                 int allfixed = 1;
                 for(i=0; i<T::size; i++){
                   CompAtomExt *one = &(t.p[i]->xExt[aid[i].index]);
                   allfixed = allfixed & one->atomFixed;
                 }
                 if(!allfixed) tupleList.add(t);
               }else{
                 tupleList.add(t);
               }
             #else
               tupleList.add(t);
             #endif               
             }
           }
        }
      }
    }

Member Data Documentation

accelMDdoDihe

template<class T, class S, class P>

int ComputeHomeTuples< T, S, P >::accelMDdoDihe

protected

Definition at line 561 of file ComputeHomeTuples.h.

atomMap

template<class T, class S, class P>

AtomMap* ComputeHomeTuples< T, S, P >::atomMap

protected

Definition at line 559 of file ComputeHomeTuples.h.

doLoadTuples

template<class T, class S, class P>

int ComputeHomeTuples< T, S, P >::doLoadTuples

protected

Definition at line 546 of file ComputeHomeTuples.h.

isBasePatch

template<class T, class S, class P>

char* ComputeHomeTuples< T, S, P >::isBasePatch

protected

Definition at line 565 of file ComputeHomeTuples.h.

patchMap

template<class T, class S, class P>

PatchMap* ComputeHomeTuples< T, S, P >::patchMap

protected

Definition at line 558 of file ComputeHomeTuples.h.

pressureProfileData

template<class T, class S, class P>

BigReal* ComputeHomeTuples< T, S, P >::pressureProfileData

protected

Definition at line 563 of file ComputeHomeTuples.h.

pressureProfileReduction

template<class T, class S, class P>

SubmitReduction* ComputeHomeTuples< T, S, P >::pressureProfileReduction

protected

Definition at line 562 of file ComputeHomeTuples.h.

pressureProfileSlabs

template<class T, class S, class P>

int ComputeHomeTuples< T, S, P >::pressureProfileSlabs

protected

Definition at line 564 of file ComputeHomeTuples.h.

reduction

template<class T, class S, class P>

SubmitReduction* ComputeHomeTuples< T, S, P >::reduction

protected

Definition at line 560 of file ComputeHomeTuples.h.

tupleList

template<class T, class S, class P>

ResizeArray<T> ComputeHomeTuples< T, S, P >::tupleList

protected

Definition at line 554 of file ComputeHomeTuples.h.

tuplePatchList

template<class T, class S, class P>

TuplePatchList ComputeHomeTuples< T, S, P >::tuplePatchList

protected

Definition at line 555 of file ComputeHomeTuples.h.

---

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

• ComputeHomeTuples.h