#include <structures.h>

Public Member Functions
	ExclusionSignature ()

	ExclusionSignature (const ExclusionSignature &sig)

	~ExclusionSignature ()

ExclusionSignature &	operator= (const ExclusionSignature &sig)

int	operator== (const ExclusionSignature &sig) const

void	setOffsets (std::vector< int > &fullVec, std::vector< int > &modVec)

void	buildTuples ()

int	hash () const

void	removeEmptyOffset ()

int	findOffset (int offset, int *fullOrMod)

void	pack (MOStream *msg)

void	unpack (MIStream *msg)

Public Attributes
int	fullExclCnt

int *	fullOffset

int	modExclCnt

int *	modOffset

int	allExclCnt

TupleSignature *	allTuples

Detailed Description

Definition at line 515 of file structures.h.

Constructor & Destructor Documentation

ExclusionSignature::ExclusionSignature ( )

inline

Definition at line 525 of file structures.h.

References allExclCnt, allTuples, fullExclCnt, fullOffset, modExclCnt, and modOffset.

                         {
         fullExclCnt = modExclCnt = 0;
         fullOffset = modOffset = NULL;
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
         allExclCnt = 0;
         allTuples = NULL;
 #endif
     }    

ExclusionSignature::ExclusionSignature ( const ExclusionSignature & sig )

inline

Definition at line 533 of file structures.h.

References allExclCnt, allTuples, fullExclCnt, fullOffset, modExclCnt, and modOffset.

                                                      {
         fullOffset = modOffset = NULL;
         fullExclCnt = sig.fullExclCnt;
         if(fullExclCnt>0){
             fullOffset = new int[fullExclCnt];
             for(int i=0; i<fullExclCnt; i++)
                 fullOffset[i] = sig.fullOffset[i];
         }
         
         modExclCnt = sig.modExclCnt;
         if(modExclCnt>0){
             modOffset = new int[modExclCnt];
             for(int i=0; i<modExclCnt; i++)
                 modOffset[i] = sig.modOffset[i];
         }
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
         allTuples = NULL;
         allExclCnt = sig.allExclCnt;
         if(allExclCnt>0){
             allTuples = new TupleSignature[allExclCnt];
             for(int i=0; i<allExclCnt; i++)
                 allTuples[i] = sig.allTuples[i];
         }
 #endif
     }

ExclusionSignature::~ExclusionSignature ( )

inline

Definition at line 558 of file structures.h.

References allTuples, fullOffset, and modOffset.

                          {
         if(fullOffset) delete [] fullOffset;
         if(modOffset) delete [] modOffset;
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
         if(allTuples) delete [] allTuples;
 #endif
     }

Member Function Documentation

void ExclusionSignature::buildTuples ( )

inline

Definition at line 627 of file structures.h.

References allExclCnt, allTuples, EXCLUSION, fullExclCnt, fullOffset, modExclCnt, modOffset, and TupleSignature::offset.

Referenced by setOffsets().

                        {
         delete [] allTuples;
         allTuples = NULL;
         allExclCnt = 0;
         for(int i=0; i<fullExclCnt; i++)
             if ( fullOffset[i] > 0 ) ++allExclCnt;
         for(int i=0; i<modExclCnt; i++)
             if ( modOffset[i] > 0 ) ++allExclCnt;
         if(allExclCnt>0){
             allTuples = new TupleSignature[allExclCnt];
             int j = 0;
             for(int i=0; i<fullExclCnt; i++){
                 if ( fullOffset[i] <= 0 ) continue;
                 TupleSignature oneSig(1,EXCLUSION,0);
                 oneSig.offset[0] = fullOffset[i];
                 allTuples[j++] = oneSig;
             }
             for(int i=0; i<modExclCnt; i++){
                 if ( modOffset[i] <= 0 ) continue;
                 TupleSignature oneSig(1,EXCLUSION,1);
                 oneSig.offset[0] = modOffset[i];
                 allTuples[j++] = oneSig;
             }
         }
 #endif
     }

int ExclusionSignature::findOffset	(	int	offset,
		int *	fullOrMod
	)

int ExclusionSignature::hash ( void ) const

inline

Definition at line 654 of file structures.h.

References circShift(), fullExclCnt, fullOffset, modExclCnt, and modOffset.

                      {
       unsigned int numOffset = fullExclCnt + modExclCnt;
       unsigned int code = 0x12345678;
       unsigned int codesz = 8 * sizeof(int);
       unsigned int shift = codesz / numOffset;
     
       if (shift == 0) shift=1;
       unsigned int i;
       for(i=0; i < fullExclCnt; i++) {
         code = circShift(code,shift);
         code ^= fullOffset[i];
       }
       for(i=0; i < modExclCnt; i++) {
         code = circShift(code,shift);
         code ^= modOffset[i];
       }
       return code;
     }

ExclusionSignature& ExclusionSignature::operator= ( const ExclusionSignature & sig )

inline

Definition at line 566 of file structures.h.

References allExclCnt, allTuples, fullExclCnt, fullOffset, modExclCnt, and modOffset.

                                                                 {
         fullExclCnt = sig.fullExclCnt;
         if(fullOffset) delete [] fullOffset;
         if(fullExclCnt>0){
             fullOffset = new int[fullExclCnt];
             for(int i=0; i<fullExclCnt; i++)
                 fullOffset[i] = sig.fullOffset[i];
         }else
             fullOffset = NULL;
     
         modExclCnt = sig.modExclCnt;
         if(modOffset) delete [] modOffset;
         if(modExclCnt>0){
             modOffset = new int[modExclCnt];
             for(int i=0; i<modExclCnt; i++)
                 modOffset[i] = sig.modOffset[i];
         }else
             modOffset = NULL;
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
         allExclCnt = sig.allExclCnt;
         if(allTuples) delete [] allTuples;
         if(allExclCnt>0){
             allTuples = new TupleSignature[allExclCnt];
             for(int i=0; i<allExclCnt; i++)
                 allTuples[i] = sig.allTuples[i];
         }else
             allTuples = NULL;
 #endif
 
         return *this;
     }

int ExclusionSignature::operator== ( const ExclusionSignature & sig ) const

inline

Definition at line 597 of file structures.h.

References fullExclCnt, fullOffset, modExclCnt, and modOffset.

                                                            {
             if(fullExclCnt!=sig.fullExclCnt) return 0;
             if(modExclCnt!=sig.modExclCnt) return 0;
             
             for(int i=0; i<fullExclCnt; i++){
                         if(fullOffset[i]!=sig.fullOffset[i]) return 0;
             }
             for(int i=0; i<modExclCnt; i++){
                         if(modOffset[i]!=sig.modOffset[i]) return 0;
             }
             return 1;
         }

void ExclusionSignature::pack ( MOStream * msg )

void ExclusionSignature::removeEmptyOffset ( )

void ExclusionSignature::setOffsets	(	std::vector< int > &	fullVec,
		std::vector< int > &	modVec
	)

inline

Definition at line 610 of file structures.h.

References buildTuples(), fullExclCnt, fullOffset, modExclCnt, and modOffset.

                                                                     {
         fullExclCnt = fullVec.size();
         modExclCnt = modVec.size();
         if(fullExclCnt>0) {        
             fullOffset = new int[fullExclCnt];
             for(int i=0; i<fullExclCnt; i++)
                 fullOffset[i] = fullVec[i];
         }
 
         if(modExclCnt>0) {        
             modOffset = new int[modExclCnt];
             for(int i=0; i<modExclCnt; i++)
                 modOffset[i] = modVec[i];       
         }
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
         buildTuples();
     }