#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 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.

                                    : 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
     }

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.

                                                       : 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
     }

template<class T, class S, class P>

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

inlinevirtual

Definition at line 620 of file ComputeHomeTuples.h.

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

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.

                           {
       doLoadTuples = true;
     }

template<class T, class S, class P>

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

inlinevirtual

Reimplemented from Compute.

Definition at line 693 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));
       }
     }

template<class T, class S, class P>

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

inlinevirtual

Reimplemented from Compute.

Definition at line 634 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
     }

template<class T, class S, class P>

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

inlineprotectedvirtual

Definition at line 370 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

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:

ComputeHomeTuples.h

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

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

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

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