ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/types/MoleculeStamp.hpp
(Generate patch)

Comparing trunk/OOPSE-4/src/types/MoleculeStamp.hpp (file contents):
Revision 2204 by gezelter, Fri Apr 15 22:04:00 2005 UTC vs.
Revision 2469 by tim, Fri Dec 2 15:38:03 2005 UTC

# Line 49 | Line 49
49   #include "types/TorsionStamp.hpp"
50   #include "types/RigidBodyStamp.hpp"
51   #include "types/CutoffGroupStamp.hpp"
52 < #include "io/LinkedAssign.hpp"
52 > #include "types/FragmentStamp.hpp"
53  
54 + namespace oopse {
55 + class MoleculeStamp : public DataHolder {
56 +    DeclareParameter(Name, std::string);
57 +  public:
58 +    MoleculeStamp();
59 +    virtual ~MoleculeStamp();
60 +    
61 +    bool addAtomStamp( AtomStamp* atom);
62 +    bool addBondStamp( BondStamp* bond);
63 +    bool addBendStamp( BendStamp* bend);
64 +    bool addTorsionStamp( TorsionStamp* torsion);  
65 +    bool addRigidBodyStamp( RigidBodyStamp* rigidbody);
66 +    bool addCutoffGroupStamp( CutoffGroupStamp* cutoffgroup);
67 +    bool addFragmentStamp( FragmentStamp* fragment);
68 +  
69 +    int  getNAtoms() { return atomStamps_.size(); }
70 +    int  getNBonds() { return bondStamps_.size(); }
71 +    int  getNBends() { return bendStamps_.size(); }
72 +    int  getNTorsions() { return torsionStamps_.size(); }
73 +    int  getNRigidBodies() { return rigidBodyStamps_.size(); }
74 +    int  getNCutoffGroups() { return cutoffGroupStamps_.size(); }  
75 +    int getNIntegrable() { return nintegrable_;}
76 +    virtual void validate();
77 +    
78 +    AtomStamp* getAtomStamp(int index) { return atomStamps_[index]; }
79 +    BondStamp* getBondStamp(int index) { return bondStamps_[index]; }
80 +    BendStamp* getBendStamp(int index) { return bendStamps_[index]; }
81 +    TorsionStamp* getTorsionStamp(int index) { return torsionStamps_[index]; }
82 +    RigidBodyStamp* getRigidBodyStamp(int index) { return rigidBodyStamps_[index]; }
83 +    CutoffGroupStamp* getCutoffGroupStamp(int index) { return cutoffGroupStamps_[index]; }
84 +    FragmentStamp* getFragmentStamp(int index) { return fragmentStamps_[index]; }
85  
86 < class MoleculeStamp{
87 <
88 < public:
89 <  MoleculeStamp();
59 <  ~MoleculeStamp();
60 <
61 <  char* assignString( char* lhs, char* rhs );
62 <  char* assignDouble( char* lhs, double rhs );
63 <  char* assignInt( char* lhs, int rhs );
64 <  char* checkMe( void );
65 <
66 <  char* addAtom( AtomStamp* the_atom, int atomIndex );
67 <  char* addRigidBody( RigidBodyStamp* the_rigidbody, int rigidBodyIndex );
68 <  char* addCutoffGroup( CutoffGroupStamp* the_cutoffgroup, int cutoffGroupIndex );
69 <  char* addBond( BondStamp* the_bond, int bondIndex );
70 <  char* addBend( BendStamp* the_bend, int bendIndex );
71 <  char* addTorsion( TorsionStamp* the_torsion, int torsionIndex );  
72 <
73 <  char* getID( void )         { return name; }
74 <  int   getNAtoms( void )     { return n_atoms; }
75 <  int   getNBonds( void )     { return n_bonds; }
76 <  int   getNBends( void )     { return n_bends; }
77 <  int   getNTorsions( void )  { return n_torsions; }
78 <  int   getNRigidBodies(void) { return n_rigidbodies; }
79 <  int   getNCutoffGroups(void){ return n_cutoffgroups; }  
80 <  int   getNIntegrable(void)  { return n_integrable; }
81 <
82 <  AtomStamp* getAtom( int index ) { return atoms[index]; }
83 <  BondStamp* getBond( int index ) { return bonds[index]; }
84 <  BendStamp* getBend( int index ) { return bends[index]; }
85 <  TorsionStamp* getTorsion( int index ) { return torsions[index]; }
86 <  RigidBodyStamp* getRigidBody( int index ) { return rigidBodies[index]; }
87 <  CutoffGroupStamp* getCutoffGroup( int index ) { return cutoffGroups[index]; }
88 <
89 <
90 <  bool isBondInSameRigidBody(BondStamp*bond);
91 <  bool isAtomInRigidBody(int atomIndex);  
92 <  bool isAtomInRigidBody(int atomIndex, int& whichRigidBody, int& consAtomIndex);  
93 <  std::vector<std::pair<int, int> > getJointAtoms(int rb1, int rb2);
86 >    bool isBondInSameRigidBody(BondStamp*bond);
87 >    bool isAtomInRigidBody(int atomIndex);  
88 >    bool isAtomInRigidBody(int atomIndex, int& whichRigidBody, int& consAtomIndex);  
89 >    std::vector<std::pair<int, int> > getJointAtoms(int rb1, int rb2);
90    
91 <  int haveExtras( void ) { return have_extras; }
96 <  LinkedAssign* getUnhandled( void ) { return unhandled; }
97 <  
98 <  static char errMsg[500];
99 < private:
100 <  
101 <  
102 <  char name[100];
103 <  int n_atoms;
104 <  int n_bonds;
105 <  int n_bends;
106 <  int n_torsions;
107 <  int n_rigidbodies;
108 <  int n_cutoffgroups;
109 <  int n_integrable;
110 <  
111 <  int have_name, have_atoms, have_bonds, have_bends, have_torsions;
112 <  int have_rigidbodies, have_cutoffgroups;
91 >  private:
92  
93 <  AtomStamp** atoms;
94 <  BondStamp** bonds;
95 <  BendStamp** bends;
96 <  TorsionStamp** torsions;  
97 <  RigidBodyStamp** rigidBodies;  
98 <  CutoffGroupStamp** cutoffGroups;  
99 <
100 <  LinkedAssign* unhandled; // the unhandled assignments
101 <  short int have_extras;
93 >    void fillBondInfo();
94 >    void findBends();
95 >    void findTorsions();
96 >    
97 >    template <class Cont, class T>
98 >    bool addIndexSensitiveStamp(Cont& cont, T* stamp) {
99 >    typename Cont::iterator i;
100 >    int index = stamp->getIndex();
101 >    bool ret = false;
102 >    size_t size = cont.size();
103 >    
104 >    if (size >= index +1) {
105 >        if (cont[index]!= NULL) {
106 >            ret = false;
107 >        }else {
108 >            cont[index] = stamp;
109 >            ret = true;
110 >        }
111 >    } else {
112 >        cont.insert(cont.end(), index - cont.size() + 1, NULL);
113 >        cont[index] = stamp;
114 >        ret = true;
115 >    }
116 >    
117 >    return ret;
118 >    }
119 >    
120 >    std::vector<AtomStamp*> atomStamps_;
121 >    std::vector<BondStamp*> bondStamps_;
122 >    std::vector<BendStamp*> bendStamps_;
123 >    std::vector<TorsionStamp*> torsionStamps_;
124 >    std::vector<RigidBodyStamp*> rigidBodyStamps_;
125 >    std::vector<CutoffGroupStamp*> cutoffGroupStamps_;
126 >    std::vector<FragmentStamp*> fragmentStamps_;
127 >    std::vector<int> atom2Rigidbody;
128 >    int nintegrable_;
129   };
130  
131 + }
132   #endif

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines