Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members

ExclusionSignature Struct Reference

#include <structures.h>

List of all members.

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

Constructor & Destructor Documentation

ExclusionSignature::ExclusionSignature (   )  [inline]
 

Definition at line 472 of file structures.h.

00472                         {
00473         fullExclCnt = modExclCnt = 0;
00474         fullOffset = modOffset = NULL;
00475 #ifdef NAMD_CUDA
00476         allExclCnt = 0;
00477         allTuples = NULL;
00478 #endif
00479     }

ExclusionSignature::ExclusionSignature (  const ExclusionSignature &  sig  )  [inline]
 

Definition at line 480 of file structures.h.

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

00480                                                      {
00481         fullOffset = modOffset = NULL;
00482         fullExclCnt = sig.fullExclCnt;
00483         if(fullExclCnt>0){
00484             fullOffset = new int[fullExclCnt];
00485             for(int i=0; i<fullExclCnt; i++)
00486                 fullOffset[i] = sig.fullOffset[i];
00487         }
00488         
00489         modExclCnt = sig.modExclCnt;
00490         if(modExclCnt>0){
00491             modOffset = new int[modExclCnt];
00492             for(int i=0; i<modExclCnt; i++)
00493                 modOffset[i] = sig.modOffset[i];
00494         }
00495 #ifdef NAMD_CUDA
00496         allTuples = NULL;
00497         allExclCnt = sig.allExclCnt;
00498         if(allExclCnt>0){
00499             allTuples = new TupleSignature[allExclCnt];
00500             for(int i=0; i<allExclCnt; i++)
00501                 allTuples[i] = sig.allTuples[i];
00502         }
00503 #endif
00504     }

ExclusionSignature::~ExclusionSignature (   )  [inline]
 

Definition at line 505 of file structures.h.

00505                          {
00506         if(fullOffset) delete [] fullOffset;
00507         if(modOffset) delete [] modOffset;
00508 #ifdef NAMD_CUDA
00509         if(allTuples) delete [] allTuples;
00510 #endif
00511     }

Member Function Documentation

void ExclusionSignature::buildTuples (   )  [inline]
 

Definition at line 574 of file structures.h.

References EXCLUSION, j, and TupleSignature::offset.

00574                        {
00575         delete [] allTuples;
00576         allTuples = NULL;
00577         allExclCnt = 0;
00578         for(int i=0; i<fullExclCnt; i++)
00579             if ( fullOffset[i] > 0 ) ++allExclCnt;
00580         for(int i=0; i<modExclCnt; i++)
00581             if ( modOffset[i] > 0 ) ++allExclCnt;
00582         if(allExclCnt>0){
00583             allTuples = new TupleSignature[allExclCnt];
00584             int j = 0;
00585             for(int i=0; i<fullExclCnt; i++){
00586                 if ( fullOffset[i] <= 0 ) continue;
00587                 TupleSignature oneSig(1,EXCLUSION,0);
00588                 oneSig.offset[0] = fullOffset[i];
00589                 allTuples[j++] = oneSig;
00590             }
00591             for(int i=0; i<modExclCnt; i++){
00592                 if ( modOffset[i] <= 0 ) continue;
00593                 TupleSignature oneSig(1,EXCLUSION,1);
00594                 oneSig.offset[0] = modOffset[i];
00595                 allTuples[j++] = oneSig;
00596             }
00597         }
00598 #endif
00599     }

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

int ExclusionSignature::hash (  void   )  const [inline]
 

Definition at line 601 of file structures.h.

References circShift().

00601                      {
00602       unsigned int numOffset = fullExclCnt + modExclCnt;
00603       unsigned int code = 0x12345678;
00604       unsigned int codesz = 8 * sizeof(int);
00605       unsigned int shift = codesz / numOffset;
00606     
00607       if (shift == 0) shift=1;
00608       unsigned int i;
00609       for(i=0; i < fullExclCnt; i++) {
00610         code = circShift(code,shift);
00611         code ^= fullOffset[i];
00612       }
00613       for(i=0; i < modExclCnt; i++) {
00614         code = circShift(code,shift);
00615         code ^= modOffset[i];
00616       }
00617       return code;
00618     }

ExclusionSignature& ExclusionSignature::operator= (  const ExclusionSignature &  sig  )  [inline]
 

Definition at line 513 of file structures.h.

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

00513                                                                 {
00514         fullExclCnt = sig.fullExclCnt;
00515         if(fullOffset) delete [] fullOffset;
00516         if(fullExclCnt>0){
00517             fullOffset = new int[fullExclCnt];
00518             for(int i=0; i<fullExclCnt; i++)
00519                 fullOffset[i] = sig.fullOffset[i];
00520         }else
00521             fullOffset = NULL;
00522     
00523         modExclCnt = sig.modExclCnt;
00524         if(modOffset) delete [] modOffset;
00525         if(modExclCnt>0){
00526             modOffset = new int[modExclCnt];
00527             for(int i=0; i<modExclCnt; i++)
00528                 modOffset[i] = sig.modOffset[i];
00529         }else
00530             modOffset = NULL;
00531 #ifdef NAMD_CUDA
00532         allExclCnt = sig.allExclCnt;
00533         if(allTuples) delete [] allTuples;
00534         if(allExclCnt>0){
00535             allTuples = new TupleSignature[allExclCnt];
00536             for(int i=0; i<allExclCnt; i++)
00537                 allTuples[i] = sig.allTuples[i];
00538         }else
00539             allTuples = NULL;
00540 #endif
00541 
00542         return *this;
00543     }

int ExclusionSignature::operator== (  const ExclusionSignature &  sig  )  const [inline]
 

Definition at line 544 of file structures.h.

References fullExclCnt, fullOffset, modExclCnt, and modOffset.

00544                                                            {
00545             if(fullExclCnt!=sig.fullExclCnt) return 0;
00546             if(modExclCnt!=sig.modExclCnt) return 0;
00547             
00548             for(int i=0; i<fullExclCnt; i++){
00549                         if(fullOffset[i]!=sig.fullOffset[i]) return 0;
00550             }
00551             for(int i=0; i<modExclCnt; i++){
00552                         if(modOffset[i]!=sig.modOffset[i]) return 0;
00553             }
00554             return 1;
00555         }

void ExclusionSignature::pack (  MOStream *  msg  ) 
 

void ExclusionSignature::removeEmptyOffset (   ) 
 

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

Definition at line 557 of file structures.h.

00557                                                                     {
00558         fullExclCnt = fullVec.size();
00559         modExclCnt = modVec.size();
00560         if(fullExclCnt>0) {        
00561             fullOffset = new int[fullExclCnt];
00562             for(int i=0; i<fullExclCnt; i++)
00563                 fullOffset[i] = fullVec[i];
00564         }
00565 
00566         if(modExclCnt>0) {        
00567             modOffset = new int[modExclCnt];
00568             for(int i=0; i<modExclCnt; i++)
00569                 modOffset[i] = modVec[i];       
00570         }
00571 #ifdef NAMD_CUDA
00572         buildTuples();
00573     }

void ExclusionSignature::unpack (  MIStream *  msg  ) 
 

Member Data Documentation

int ExclusionSignature::allExclCnt
 

Definition at line 468 of file structures.h.

Referenced by ExclusionSignature(), ExclElem::getTupleInfo(), and operator=().

TupleSignature* ExclusionSignature::allTuples
 

Definition at line 469 of file structures.h.

Referenced by ExclusionSignature(), ExclElem::getTupleInfo(), and operator=().

int ExclusionSignature::fullExclCnt
 

Definition at line 463 of file structures.h.

Referenced by ComputeNonbondedCUDA::build_exclusions(), ExclusionSignature(), operator=(), operator==(), and ParallelIOMgr::updateMolInfo().

int* ExclusionSignature::fullOffset
 

Definition at line 464 of file structures.h.

Referenced by ComputeNonbondedCUDA::build_exclusions(), ExclusionSignature(), operator=(), operator==(), and ParallelIOMgr::updateMolInfo().

int ExclusionSignature::modExclCnt
 

Definition at line 465 of file structures.h.

Referenced by ExclusionSignature(), operator=(), operator==(), and ParallelIOMgr::updateMolInfo().

int* ExclusionSignature::modOffset
 

Definition at line 466 of file structures.h.

Referenced by ExclusionSignature(), operator=(), operator==(), and ParallelIOMgr::updateMolInfo().

The documentation for this struct was generated from the following file:
Generated on Thu May 23 04:07:23 2013 for NAMD by  doxygen 1.3.9.1