AtomSignature Class Reference

#include <structures.h>

List of all members.

Public Member Functions

 AtomSignature ()
 AtomSignature (const AtomSignature &sig)
AtomSignatureoperator= (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
int gromacsPairCnt
TupleSignaturebondSigs
TupleSignatureangleSigs
TupleSignaturedihedralSigs
TupleSignatureimproperSigs
TupleSignaturecrosstermSigs
TupleSignaturegromacsPairSigs


Detailed Description

Definition at line 313 of file structures.h.


Constructor & Destructor Documentation

AtomSignature::AtomSignature (  )  [inline]

Definition at line 331 of file structures.h.

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

00331                    {
00332         bondCnt=angleCnt=dihedralCnt=improperCnt=crosstermCnt=0;
00333         // JLai
00334         gromacsPairCnt=0;
00335         bondSigs = NULL;
00336         angleSigs = NULL;
00337         dihedralSigs = NULL;
00338         improperSigs = NULL;
00339         crosstermSigs = NULL;
00340         // JLai
00341         gromacsPairSigs = NULL;
00342     }

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

Definition at line 343 of file structures.h.

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

00343                                            {
00344         bondSigs = NULL;
00345         angleSigs = NULL;
00346         dihedralSigs = NULL;
00347         improperSigs = NULL;
00348         crosstermSigs = NULL;
00349         // JLai
00350         gromacsPairSigs = NULL;
00351 
00352         bondCnt = sig.bondCnt;
00353         if(bondCnt>0){            
00354             bondSigs = new TupleSignature[bondCnt];
00355             for(int i=0; i<bondCnt; i++)
00356                 bondSigs[i] = sig.bondSigs[i];
00357         }
00358 
00359         angleCnt = sig.angleCnt;
00360         if(angleCnt>0){            
00361             angleSigs = new TupleSignature[angleCnt];
00362             for(int i=0; i<angleCnt; i++)
00363                 angleSigs[i] = sig.angleSigs[i];
00364         }
00365         
00366         dihedralCnt = sig.dihedralCnt;
00367         if(dihedralCnt>0){            
00368             dihedralSigs = new TupleSignature[dihedralCnt];
00369             for(int i=0; i<dihedralCnt; i++)
00370                 dihedralSigs[i] = sig.dihedralSigs[i];
00371         }
00372         
00373         improperCnt = sig.improperCnt;
00374         if(improperCnt>0){
00375             improperSigs = new TupleSignature[improperCnt];
00376             for(int i=0; i<improperCnt; i++)
00377                 improperSigs[i] = sig.improperSigs[i];
00378         }      
00379 
00380         crosstermCnt = sig.crosstermCnt;
00381         if(crosstermCnt>0){
00382             crosstermSigs = new TupleSignature[crosstermCnt];
00383             for(int i=0; i<crosstermCnt; i++)
00384                 crosstermSigs[i] = sig.crosstermSigs[i];
00385         }        
00386 
00387         // JLai
00388         gromacsPairCnt = sig.gromacsPairCnt;
00389         if(gromacsPairCnt>0){
00390             gromacsPairSigs = new TupleSignature[gromacsPairCnt];
00391             for(int i=0; i<gromacsPairCnt; i++) {
00392                 gromacsPairSigs[i] = sig.gromacsPairSigs[i];
00393             }
00394         }
00395     }

AtomSignature::~AtomSignature (  )  [inline]

Definition at line 478 of file structures.h.

References angleSigs, bondSigs, crosstermSigs, dihedralSigs, gromacsPairSigs, and improperSigs.

00478                     {
00479         if(bondSigs) delete[] bondSigs;
00480         if(angleSigs) delete[] angleSigs;
00481         if(dihedralSigs) delete[] dihedralSigs;
00482         if(improperSigs) delete[] improperSigs;
00483         if(crosstermSigs) delete[] crosstermSigs;
00484         // JLai
00485         if(gromacsPairSigs) delete[] gromacsPairSigs;
00486     }    


Member Function Documentation

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

Definition at line 396 of file structures.h.

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

00396                                                       {        
00397         bondCnt = sig.bondCnt;
00398         if(bondSigs) delete [] bondSigs;
00399         if(bondCnt>0){
00400             bondSigs = new TupleSignature[bondCnt];
00401             for(int i=0; i<bondCnt; i++)
00402                 bondSigs[i] = sig.bondSigs[i];
00403         }else
00404             bondSigs = NULL;
00405 
00406         angleCnt = sig.angleCnt;
00407         if(angleSigs) delete [] angleSigs;
00408         if(angleCnt>0){
00409             angleSigs = new TupleSignature[angleCnt];
00410             for(int i=0; i<angleCnt; i++)
00411                 angleSigs[i] = sig.angleSigs[i];
00412         }else
00413             angleSigs = NULL;
00414         
00415         dihedralCnt = sig.dihedralCnt;
00416         if(dihedralSigs) delete [] dihedralSigs;
00417         if(dihedralCnt>0){
00418             dihedralSigs = new TupleSignature[dihedralCnt];
00419             for(int i=0; i<dihedralCnt; i++)
00420                 dihedralSigs[i] = sig.dihedralSigs[i];
00421         }else
00422             dihedralSigs = NULL;
00423         
00424         improperCnt = sig.improperCnt;
00425         if(improperSigs) delete [] improperSigs;
00426         if(improperCnt>0){
00427             improperSigs = new TupleSignature[improperCnt];
00428             for(int i=0; i<improperCnt; i++)
00429                 improperSigs[i] = sig.improperSigs[i];
00430         }else
00431             improperSigs = NULL;      
00432 
00433         crosstermCnt = sig.crosstermCnt;
00434         if(crosstermSigs) delete [] crosstermSigs;
00435         if(crosstermCnt>0){
00436             crosstermSigs = new TupleSignature[crosstermCnt];
00437             for(int i=0; i<crosstermCnt; i++)
00438                 crosstermSigs[i] = sig.crosstermSigs[i];
00439         }else
00440             crosstermSigs = NULL;
00441 
00442         // JLai
00443         gromacsPairCnt = sig.gromacsPairCnt;
00444         if(gromacsPairSigs) delete [] gromacsPairSigs;
00445         if(gromacsPairCnt>0){
00446             gromacsPairSigs = new TupleSignature[gromacsPairCnt];
00447             for(int i=0; i<gromacsPairCnt; i++)
00448                 gromacsPairSigs[i] = sig.gromacsPairSigs[i];
00449         }else
00450             gromacsPairSigs = NULL;
00451 
00452         return *this;
00453     }

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

Definition at line 454 of file structures.h.

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

00454                                                   {
00455             if(bondCnt!=sig.bondCnt) return 0;
00456             if(angleCnt!=sig.angleCnt) return 0;
00457             if(dihedralCnt!=sig.dihedralCnt) return 0;
00458             if(improperCnt!=sig.improperCnt) return 0;
00459             if(crosstermCnt!=sig.crosstermCnt) return 0;
00460             //JLai
00461             if(gromacsPairCnt!=sig.gromacsPairCnt) return 0;
00462         
00463         #define CMPSIGS(TUPLE) \
00464         for(int i=0; i<sig.TUPLE##Cnt; i++){ \
00465             if(!(TUPLE##Sigs[i]==sig.TUPLE##Sigs[i])) return 0; \
00466         } \
00467         
00468             CMPSIGS(bond)
00469             CMPSIGS(angle)
00470             CMPSIGS(dihedral)
00471             CMPSIGS(improper)
00472             CMPSIGS(crossterm)
00473             // JLai
00474             CMPSIGS(gromacsPair)
00475         
00476             return 1;
00477         }

void AtomSignature::pack ( MOStream msg  ) 

void AtomSignature::removeEmptyTupleSigs (  ) 

void AtomSignature::unpack ( MIStream msg  ) 


Member Data Documentation

int AtomSignature::angleCnt

Definition at line 316 of file structures.h.

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

TupleSignature* AtomSignature::angleSigs

Definition at line 324 of file structures.h.

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

int AtomSignature::bondCnt

Definition at line 315 of file structures.h.

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

TupleSignature* AtomSignature::bondSigs

Definition at line 323 of file structures.h.

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

int AtomSignature::crosstermCnt

Definition at line 319 of file structures.h.

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

TupleSignature* AtomSignature::crosstermSigs

Definition at line 327 of file structures.h.

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

int AtomSignature::dihedralCnt

Definition at line 317 of file structures.h.

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

TupleSignature* AtomSignature::dihedralSigs

Definition at line 325 of file structures.h.

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

int AtomSignature::gromacsPairCnt

Definition at line 321 of file structures.h.

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

TupleSignature* AtomSignature::gromacsPairSigs

Definition at line 329 of file structures.h.

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

int AtomSignature::improperCnt

Definition at line 318 of file structures.h.

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

TupleSignature* AtomSignature::improperSigs

Definition at line 326 of file structures.h.

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


The documentation for this class was generated from the following file:
Generated on Mon Sep 25 01:17:16 2017 for NAMD by  doxygen 1.4.7