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 323 of file structures.h.


Constructor & Destructor Documentation

AtomSignature::AtomSignature (  )  [inline]

Definition at line 341 of file structures.h.

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

00341                    {
00342         bondCnt=angleCnt=dihedralCnt=improperCnt=crosstermCnt=0;
00343         // JLai
00344         gromacsPairCnt=0;
00345         bondSigs = NULL;
00346         angleSigs = NULL;
00347         dihedralSigs = NULL;
00348         improperSigs = NULL;
00349         crosstermSigs = NULL;
00350         // JLai
00351         gromacsPairSigs = NULL;
00352     }

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

Definition at line 353 of file structures.h.

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

00353                                            {
00354         bondSigs = NULL;
00355         angleSigs = NULL;
00356         dihedralSigs = NULL;
00357         improperSigs = NULL;
00358         crosstermSigs = NULL;
00359         // JLai
00360         gromacsPairSigs = NULL;
00361 
00362         bondCnt = sig.bondCnt;
00363         if(bondCnt>0){            
00364             bondSigs = new TupleSignature[bondCnt];
00365             for(int i=0; i<bondCnt; i++)
00366                 bondSigs[i] = sig.bondSigs[i];
00367         }
00368 
00369         angleCnt = sig.angleCnt;
00370         if(angleCnt>0){            
00371             angleSigs = new TupleSignature[angleCnt];
00372             for(int i=0; i<angleCnt; i++)
00373                 angleSigs[i] = sig.angleSigs[i];
00374         }
00375         
00376         dihedralCnt = sig.dihedralCnt;
00377         if(dihedralCnt>0){            
00378             dihedralSigs = new TupleSignature[dihedralCnt];
00379             for(int i=0; i<dihedralCnt; i++)
00380                 dihedralSigs[i] = sig.dihedralSigs[i];
00381         }
00382         
00383         improperCnt = sig.improperCnt;
00384         if(improperCnt>0){
00385             improperSigs = new TupleSignature[improperCnt];
00386             for(int i=0; i<improperCnt; i++)
00387                 improperSigs[i] = sig.improperSigs[i];
00388         }      
00389 
00390         crosstermCnt = sig.crosstermCnt;
00391         if(crosstermCnt>0){
00392             crosstermSigs = new TupleSignature[crosstermCnt];
00393             for(int i=0; i<crosstermCnt; i++)
00394                 crosstermSigs[i] = sig.crosstermSigs[i];
00395         }        
00396 
00397         // JLai
00398         gromacsPairCnt = sig.gromacsPairCnt;
00399         if(gromacsPairCnt>0){
00400             gromacsPairSigs = new TupleSignature[gromacsPairCnt];
00401             for(int i=0; i<gromacsPairCnt; i++) {
00402                 gromacsPairSigs[i] = sig.gromacsPairSigs[i];
00403             }
00404         }
00405     }

AtomSignature::~AtomSignature (  )  [inline]

Definition at line 488 of file structures.h.

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

00488                     {
00489         if(bondSigs) delete[] bondSigs;
00490         if(angleSigs) delete[] angleSigs;
00491         if(dihedralSigs) delete[] dihedralSigs;
00492         if(improperSigs) delete[] improperSigs;
00493         if(crosstermSigs) delete[] crosstermSigs;
00494         // JLai
00495         if(gromacsPairSigs) delete[] gromacsPairSigs;
00496     }    


Member Function Documentation

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

Definition at line 406 of file structures.h.

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

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

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

Definition at line 464 of file structures.h.

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

00464                                                   {
00465             if(bondCnt!=sig.bondCnt) return 0;
00466             if(angleCnt!=sig.angleCnt) return 0;
00467             if(dihedralCnt!=sig.dihedralCnt) return 0;
00468             if(improperCnt!=sig.improperCnt) return 0;
00469             if(crosstermCnt!=sig.crosstermCnt) return 0;
00470             //JLai
00471             if(gromacsPairCnt!=sig.gromacsPairCnt) return 0;
00472         
00473         #define CMPSIGS(TUPLE) \
00474         for(int i=0; i<sig.TUPLE##Cnt; i++){ \
00475             if(!(TUPLE##Sigs[i]==sig.TUPLE##Sigs[i])) return 0; \
00476         } \
00477         
00478             CMPSIGS(bond)
00479             CMPSIGS(angle)
00480             CMPSIGS(dihedral)
00481             CMPSIGS(improper)
00482             CMPSIGS(crossterm)
00483             // JLai
00484             CMPSIGS(gromacsPair)
00485         
00486             return 1;
00487         }

void AtomSignature::pack ( MOStream msg  ) 

void AtomSignature::removeEmptyTupleSigs (  ) 

void AtomSignature::unpack ( MIStream msg  ) 


Member Data Documentation

int AtomSignature::angleCnt

Definition at line 326 of file structures.h.

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

TupleSignature* AtomSignature::angleSigs

Definition at line 334 of file structures.h.

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

int AtomSignature::bondCnt

Definition at line 325 of file structures.h.

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

TupleSignature* AtomSignature::bondSigs

Definition at line 333 of file structures.h.

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

int AtomSignature::crosstermCnt

Definition at line 329 of file structures.h.

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

TupleSignature* AtomSignature::crosstermSigs

Definition at line 337 of file structures.h.

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

int AtomSignature::dihedralCnt

Definition at line 327 of file structures.h.

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

TupleSignature* AtomSignature::dihedralSigs

Definition at line 335 of file structures.h.

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

int AtomSignature::gromacsPairCnt

Definition at line 331 of file structures.h.

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

TupleSignature* AtomSignature::gromacsPairSigs

Definition at line 339 of file structures.h.

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

int AtomSignature::improperCnt

Definition at line 328 of file structures.h.

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

TupleSignature* AtomSignature::improperSigs

Definition at line 336 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 Sun Oct 21 01:17:17 2018 for NAMD by  doxygen 1.4.7