AtomSignature Class Reference

#include <structures.h>

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
int	gromacsPairCnt
TupleSignature *	bondSigs
TupleSignature *	angleSigs
TupleSignature *	dihedralSigs
TupleSignature *	improperSigs
TupleSignature *	crosstermSigs
TupleSignature *	gromacsPairSigs

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.

                   {
        bondCnt=angleCnt=dihedralCnt=improperCnt=crosstermCnt=0;
        // JLai
        gromacsPairCnt=0;
        bondSigs = NULL;
        angleSigs = NULL;
        dihedralSigs = NULL;
        improperSigs = NULL;
        crosstermSigs = NULL;
        // JLai
        gromacsPairSigs = NULL;
    }

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.

                                           {
        bondSigs = NULL;
        angleSigs = NULL;
        dihedralSigs = NULL;
        improperSigs = NULL;
        crosstermSigs = NULL;
        // JLai
        gromacsPairSigs = NULL;

        bondCnt = sig.bondCnt;
        if(bondCnt>0){            
            bondSigs = new TupleSignature[bondCnt];
            for(int i=0; i<bondCnt; i++)
                bondSigs[i] = sig.bondSigs[i];
        }

        angleCnt = sig.angleCnt;
        if(angleCnt>0){            
            angleSigs = new TupleSignature[angleCnt];
            for(int i=0; i<angleCnt; i++)
                angleSigs[i] = sig.angleSigs[i];
        }
        
        dihedralCnt = sig.dihedralCnt;
        if(dihedralCnt>0){            
            dihedralSigs = new TupleSignature[dihedralCnt];
            for(int i=0; i<dihedralCnt; i++)
                dihedralSigs[i] = sig.dihedralSigs[i];
        }
        
        improperCnt = sig.improperCnt;
        if(improperCnt>0){
            improperSigs = new TupleSignature[improperCnt];
            for(int i=0; i<improperCnt; i++)
                improperSigs[i] = sig.improperSigs[i];
        }      

        crosstermCnt = sig.crosstermCnt;
        if(crosstermCnt>0){
            crosstermSigs = new TupleSignature[crosstermCnt];
            for(int i=0; i<crosstermCnt; i++)
                crosstermSigs[i] = sig.crosstermSigs[i];
        }        

        // JLai
        gromacsPairCnt = sig.gromacsPairCnt;
        if(gromacsPairCnt>0){
            gromacsPairSigs = new TupleSignature[gromacsPairCnt];
            for(int i=0; i<gromacsPairCnt; i++) {
                gromacsPairSigs[i] = sig.gromacsPairSigs[i];
            }
        }
    }

AtomSignature::~AtomSignature ( )

inline

Definition at line 488 of file structures.h.

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

                    {
        if(bondSigs) delete[] bondSigs;
        if(angleSigs) delete[] angleSigs;
        if(dihedralSigs) delete[] dihedralSigs;
        if(improperSigs) delete[] improperSigs;
        if(crosstermSigs) delete[] crosstermSigs;
        // JLai
        if(gromacsPairSigs) delete[] gromacsPairSigs;
    }    

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.

                                                      {        
        bondCnt = sig.bondCnt;
        if(bondSigs) delete [] bondSigs;
        if(bondCnt>0){
            bondSigs = new TupleSignature[bondCnt];
            for(int i=0; i<bondCnt; i++)
                bondSigs[i] = sig.bondSigs[i];
        }else
            bondSigs = NULL;

        angleCnt = sig.angleCnt;
        if(angleSigs) delete [] angleSigs;
        if(angleCnt>0){
            angleSigs = new TupleSignature[angleCnt];
            for(int i=0; i<angleCnt; i++)
                angleSigs[i] = sig.angleSigs[i];
        }else
            angleSigs = NULL;
        
        dihedralCnt = sig.dihedralCnt;
        if(dihedralSigs) delete [] dihedralSigs;
        if(dihedralCnt>0){
            dihedralSigs = new TupleSignature[dihedralCnt];
            for(int i=0; i<dihedralCnt; i++)
                dihedralSigs[i] = sig.dihedralSigs[i];
        }else
            dihedralSigs = NULL;
        
        improperCnt = sig.improperCnt;
        if(improperSigs) delete [] improperSigs;
        if(improperCnt>0){
            improperSigs = new TupleSignature[improperCnt];
            for(int i=0; i<improperCnt; i++)
                improperSigs[i] = sig.improperSigs[i];
        }else
            improperSigs = NULL;      

        crosstermCnt = sig.crosstermCnt;
        if(crosstermSigs) delete [] crosstermSigs;
        if(crosstermCnt>0){
            crosstermSigs = new TupleSignature[crosstermCnt];
            for(int i=0; i<crosstermCnt; i++)
                crosstermSigs[i] = sig.crosstermSigs[i];
        }else
            crosstermSigs = NULL;

        // JLai
        gromacsPairCnt = sig.gromacsPairCnt;
        if(gromacsPairSigs) delete [] gromacsPairSigs;
        if(gromacsPairCnt>0){
            gromacsPairSigs = new TupleSignature[gromacsPairCnt];
            for(int i=0; i<gromacsPairCnt; i++)
                gromacsPairSigs[i] = sig.gromacsPairSigs[i];
        }else
            gromacsPairSigs = NULL;

        return *this;
    }

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.

                                                  {
            if(bondCnt!=sig.bondCnt) return 0;
            if(angleCnt!=sig.angleCnt) return 0;
            if(dihedralCnt!=sig.dihedralCnt) return 0;
            if(improperCnt!=sig.improperCnt) return 0;
            if(crosstermCnt!=sig.crosstermCnt) return 0;
            //JLai
            if(gromacsPairCnt!=sig.gromacsPairCnt) return 0;
        
        #define CMPSIGS(TUPLE) \
        for(int i=0; i<sig.TUPLE##Cnt; i++){ \
            if(!(TUPLE##Sigs[i]==sig.TUPLE##Sigs[i])) return 0; \
        } \
        
            CMPSIGS(bond)
            CMPSIGS(angle)
            CMPSIGS(dihedral)
            CMPSIGS(improper)
            CMPSIGS(crossterm)
            // JLai
            CMPSIGS(gromacsPair)
        
            return 1;
        }

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:

• structures.h