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

AtomSignature Class Reference

#include <structures.h>

List of all members.

Public Member Functions

 AtomSignature ()
 AtomSignature (const AtomSignature &sig)
AtomSignature & operator= (const AtomSignature &sig)
int operator== (const AtomSignature &sig) const
 ~AtomSignature ()
void removeEmptyTupleSigs ()
void pack (MOStream *msg)
void unpack (MIStream *msg)

Public Attributes

int bondCnt
int angleCnt
int dihedralCnt
int improperCnt
int crosstermCnt
TupleSignature * bondSigs
TupleSignature * angleSigs
TupleSignature * dihedralSigs
TupleSignature * improperSigs
TupleSignature * crosstermSigs

Constructor & Destructor Documentation

AtomSignature::AtomSignature (   )  [inline]
 

Definition at line 319 of file structures.h.

00319                    {
00320         bondCnt=angleCnt=dihedralCnt=improperCnt=crosstermCnt=0;
00321         bondSigs = NULL;
00322         angleSigs = NULL;
00323         dihedralSigs = NULL;
00324         improperSigs = NULL;
00325         crosstermSigs = NULL;
00326     }

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

Definition at line 327 of file structures.h.

References angleCnt, angleSigs, bondCnt, bondSigs, crosstermCnt, crosstermSigs, dihedralCnt, dihedralSigs, improperCnt, and improperSigs.

00327                                            {
00328         bondSigs = NULL;
00329         angleSigs = NULL;
00330         dihedralSigs = NULL;
00331         improperSigs = NULL;
00332         crosstermSigs = NULL;
00333 
00334         bondCnt = sig.bondCnt;
00335         if(bondCnt>0){            
00336             bondSigs = new TupleSignature[bondCnt];
00337             for(int i=0; i<bondCnt; i++)
00338                 bondSigs[i] = sig.bondSigs[i];
00339         }
00340 
00341         angleCnt = sig.angleCnt;
00342         if(angleCnt>0){            
00343             angleSigs = new TupleSignature[angleCnt];
00344             for(int i=0; i<angleCnt; i++)
00345                 angleSigs[i] = sig.angleSigs[i];
00346         }
00347         
00348         dihedralCnt = sig.dihedralCnt;
00349         if(dihedralCnt>0){            
00350             dihedralSigs = new TupleSignature[dihedralCnt];
00351             for(int i=0; i<dihedralCnt; i++)
00352                 dihedralSigs[i] = sig.dihedralSigs[i];
00353         }
00354         
00355         improperCnt = sig.improperCnt;
00356         if(improperCnt>0){
00357             improperSigs = new TupleSignature[improperCnt];
00358             for(int i=0; i<improperCnt; i++)
00359                 improperSigs[i] = sig.improperSigs[i];
00360         }      
00361 
00362         crosstermCnt = sig.crosstermCnt;
00363         if(crosstermCnt>0){
00364             crosstermSigs = new TupleSignature[crosstermCnt];
00365             for(int i=0; i<crosstermCnt; i++)
00366                 crosstermSigs[i] = sig.crosstermSigs[i];
00367         }        
00368     }

AtomSignature::~AtomSignature (   )  [inline]
 

Definition at line 437 of file structures.h.

00437                     {
00438         if(bondSigs) delete[] bondSigs;
00439         if(angleSigs) delete[] angleSigs;
00440         if(dihedralSigs) delete[] dihedralSigs;
00441         if(improperSigs) delete[] improperSigs;
00442         if(crosstermSigs) delete[] crosstermSigs;
00443     }

Member Function Documentation

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

Definition at line 369 of file structures.h.

References angleCnt, angleSigs, bondCnt, bondSigs, crosstermCnt, crosstermSigs, dihedralCnt, dihedralSigs, improperCnt, and improperSigs.

00369                                                       {        
00370         bondCnt = sig.bondCnt;
00371         if(bondSigs) delete [] bondSigs;
00372         if(bondCnt>0){
00373             bondSigs = new TupleSignature[bondCnt];
00374             for(int i=0; i<bondCnt; i++)
00375                 bondSigs[i] = sig.bondSigs[i];
00376         }else
00377             bondSigs = NULL;
00378 
00379         angleCnt = sig.angleCnt;
00380         if(angleSigs) delete [] angleSigs;
00381         if(angleCnt>0){
00382             angleSigs = new TupleSignature[angleCnt];
00383             for(int i=0; i<angleCnt; i++)
00384                 angleSigs[i] = sig.angleSigs[i];
00385         }else
00386             angleSigs = NULL;
00387         
00388         dihedralCnt = sig.dihedralCnt;
00389         if(dihedralSigs) delete [] dihedralSigs;
00390         if(dihedralCnt>0){
00391             dihedralSigs = new TupleSignature[dihedralCnt];
00392             for(int i=0; i<dihedralCnt; i++)
00393                 dihedralSigs[i] = sig.dihedralSigs[i];
00394         }else
00395             dihedralSigs = NULL;
00396         
00397         improperCnt = sig.improperCnt;
00398         if(improperSigs) delete [] improperSigs;
00399         if(improperCnt>0){
00400             improperSigs = new TupleSignature[improperCnt];
00401             for(int i=0; i<improperCnt; i++)
00402                 improperSigs[i] = sig.improperSigs[i];
00403         }else
00404             improperSigs = NULL;      
00405 
00406         crosstermCnt = sig.crosstermCnt;
00407         if(crosstermSigs) delete [] crosstermSigs;
00408         if(crosstermCnt>0){
00409             crosstermSigs = new TupleSignature[crosstermCnt];
00410             for(int i=0; i<crosstermCnt; i++)
00411                 crosstermSigs[i] = sig.crosstermSigs[i];
00412         }else
00413             crosstermSigs = NULL;
00414 
00415         return *this;
00416     }

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

Definition at line 417 of file structures.h.

References angleCnt, bondCnt, CMPSIGS, crosstermCnt, dihedralCnt, and improperCnt.

00417                                                   {
00418             if(bondCnt!=sig.bondCnt) return 0;
00419             if(angleCnt!=sig.angleCnt) return 0;
00420             if(dihedralCnt!=sig.dihedralCnt) return 0;
00421             if(improperCnt!=sig.improperCnt) return 0;
00422             if(crosstermCnt!=sig.crosstermCnt) return 0;
00423         
00424         #define CMPSIGS(TUPLE) \
00425         for(int i=0; i<sig.TUPLE##Cnt; i++){ \
00426             if(!(TUPLE##Sigs[i]==sig.TUPLE##Sigs[i])) return 0; \
00427         } \
00428         
00429             CMPSIGS(bond)
00430             CMPSIGS(angle)
00431             CMPSIGS(dihedral)
00432             CMPSIGS(improper)
00433             CMPSIGS(crossterm)
00434         
00435             return 1;
00436         }

void AtomSignature::pack (  MOStream *  msg  ) 
 

void AtomSignature::removeEmptyTupleSigs (   ) 
 

void AtomSignature::unpack (  MIStream *  msg  ) 
 

Member Data Documentation

int AtomSignature::angleCnt
 

Definition at line 308 of file structures.h.

Referenced by AtomSignature(), dumpbench(), AngleElem::getTupleInfo(), operator=(), operator==(), and ParallelIOMgr::updateMolInfo().

TupleSignature* AtomSignature::angleSigs
 

Definition at line 314 of file structures.h.

Referenced by AtomSignature(), dumpbench(), AngleElem::getTupleInfo(), operator=(), and ParallelIOMgr::updateMolInfo().

int AtomSignature::bondCnt
 

Definition at line 307 of file structures.h.

Referenced by AtomSignature(), dumpbench(), BondElem::getTupleInfo(), operator=(), operator==(), and ParallelIOMgr::updateMolInfo().

TupleSignature* AtomSignature::bondSigs
 

Definition at line 313 of file structures.h.

Referenced by AtomSignature(), dumpbench(), BondElem::getTupleInfo(), operator=(), and ParallelIOMgr::updateMolInfo().

int AtomSignature::crosstermCnt
 

Definition at line 311 of file structures.h.

Referenced by AtomSignature(), CrosstermElem::getTupleInfo(), operator=(), operator==(), and ParallelIOMgr::updateMolInfo().

TupleSignature* AtomSignature::crosstermSigs
 

Definition at line 317 of file structures.h.

Referenced by AtomSignature(), CrosstermElem::getTupleInfo(), operator=(), and ParallelIOMgr::updateMolInfo().

int AtomSignature::dihedralCnt
 

Definition at line 309 of file structures.h.

Referenced by AtomSignature(), dumpbench(), DihedralElem::getTupleInfo(), operator=(), operator==(), and ParallelIOMgr::updateMolInfo().

TupleSignature* AtomSignature::dihedralSigs
 

Definition at line 315 of file structures.h.

Referenced by AtomSignature(), dumpbench(), DihedralElem::getTupleInfo(), operator=(), and ParallelIOMgr::updateMolInfo().

int AtomSignature::improperCnt
 

Definition at line 310 of file structures.h.

Referenced by AtomSignature(), dumpbench(), ImproperElem::getTupleInfo(), operator=(), operator==(), and ParallelIOMgr::updateMolInfo().

TupleSignature* AtomSignature::improperSigs
 

Definition at line 316 of file structures.h.

Referenced by AtomSignature(), dumpbench(), ImproperElem::getTupleInfo(), operator=(), and ParallelIOMgr::updateMolInfo().

The documentation for this class was generated from the following file:
Generated on Fri May 25 04:07:19 2012 for NAMD by  doxygen 1.3.9.1