ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/primitives/Molecule.hpp
(Generate patch)

Comparing trunk/src/primitives/Molecule.hpp (file contents):
Revision 305 by tim, Mon Feb 7 22:39:19 2005 UTC vs.
Revision 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC

# Line 1 | Line 1
1 < /*
1 > /*
2   * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3   *
4   * The University of Notre Dame grants you ("Licensee") a
# Line 58 | Line 58
58   #include "primitives/Bond.hpp"
59   #include "primitives/Bend.hpp"
60   #include "primitives/Torsion.hpp"
61 + #include "primitives/Inversion.hpp"
62   #include "primitives/CutoffGroup.hpp"
63  
64   namespace oopse{
65  
66 < class Constraint;
66 >  class Constraint;
67  
68 < /**
69 < * @class Molecule Molecule.hpp "primitives/Molecule.hpp"
70 < * @brief
71 < */
72 < class Molecule {
73 <    public:
68 >  /**
69 >   * @class Molecule Molecule.hpp "primitives/Molecule.hpp"
70 >   * @brief
71 >   */
72 >  class Molecule {
73 >  public:
74  
75 <        typedef std::vector<Atom*>::iterator AtomIterator;
76 <        typedef std::vector<Bond*>::iterator BondIterator;
77 <        typedef std::vector<Bend*>::iterator BendIterator;
78 <        typedef std::vector<Torsion*>::iterator TorsionIterator;
79 <        typedef std::vector<RigidBody*>::iterator RigidBodyIterator;
80 <        typedef std::vector<CutoffGroup*>::iterator CutoffGroupIterator;
81 <        typedef std::vector<StuntDouble*>::iterator IntegrableObjectIterator;        
82 <        typedef std::vector<ConstraintPair*>::iterator ConstraintPairIterator;
83 <        typedef std::vector<ConstraintElem*>::iterator ConstraintElemIterator;
84 <        
75 >    typedef std::vector<Atom*>::iterator AtomIterator;
76 >    typedef std::vector<Bond*>::iterator BondIterator;
77 >    typedef std::vector<Bend*>::iterator BendIterator;
78 >    typedef std::vector<Torsion*>::iterator TorsionIterator;
79 >    typedef std::vector<Inversion*>::iterator InversionIterator;
80 >    typedef std::vector<RigidBody*>::iterator RigidBodyIterator;
81 >    typedef std::vector<CutoffGroup*>::iterator CutoffGroupIterator;
82 >    typedef std::vector<StuntDouble*>::iterator IntegrableObjectIterator;
83 >    typedef std::vector<ConstraintPair*>::iterator ConstraintPairIterator;
84 >    typedef std::vector<ConstraintElem*>::iterator ConstraintElemIterator;
85 >    
86 >    
87 >    Molecule(int stampId, int globalIndex, const std::string& molName);
88 >    virtual ~Molecule();
89 >    
90 >    /**
91 >     * Returns the global index of this molecule.
92 >     * @return  the global index of this molecule
93 >     */
94 >    int getGlobalIndex() {
95 >      return globalIndex_;
96 >    }
97 >    
98 >    /**
99 >     * Returns the stamp id of this molecule
100 >     * @note Ideally, every molecule should keep a pointer of its
101 >     * molecule stamp instead of its stamp id. However, the pointer
102 >     * will become invalid, if the molecule migrate to other
103 >     * processor.
104 >     */
105 >    int getStampId() {
106 >      return stampId_;
107 >    }
108 >    
109 >    /** Returns the name of the molecule */
110 >    std::string getType() {
111 >      return moleculeName_;
112 >    }
113 >    
114 >    /**
115 >     * Sets the global index of this molecule.
116 >     * @param new global index to be set
117 >     */
118 >    void setGlobalIndex(int index) {
119 >      globalIndex_ = index;
120 >    }
121 >    
122 >    
123 >    /** add an atom into this molecule */
124 >    void addAtom(Atom* atom);
125 >    
126 >    /** add a bond into this molecule */
127 >    void addBond(Bond* bond);
128 >    
129 >    /** add a bend into this molecule */
130 >    void addBend(Bend* bend);
131 >    
132 >    /** add a torsion into this molecule*/
133 >    void addTorsion(Torsion* torsion);
134  
135 <        Molecule(int stampId, int globalIndex, const std::string& molName);
136 <        virtual ~Molecule();
135 >    /** add an improper torsion into this molecule*/
136 >    void addInversion(Inversion* inversion);
137 >    
138 >    /** add a rigidbody into this molecule */
139 >    void addRigidBody(RigidBody *rb);
140 >    
141 >    /** add a cutoff group into this molecule */
142 >    void addCutoffGroup(CutoffGroup* cp);    
143 >    
144 >    void addConstraintPair(ConstraintPair* consPair);
145 >    
146 >    void addConstraintElem(ConstraintElem* consElem);
147 >    
148 >    /** */
149 >    void complete();
150 >    
151 >    /** Returns the total number of atoms in this molecule */
152 >    unsigned int getNAtoms() {
153 >      return atoms_.size();
154 >    }
155 >    
156 >    /** Returns the total number of bonds in this molecule */        
157 >    unsigned int getNBonds(){
158 >      return bonds_.size();
159 >    }
160 >    
161 >    /** Returns the total number of bends in this molecule */        
162 >    unsigned int getNBends() {
163 >      return bends_.size();
164 >    }
165 >    
166 >    /** Returns the total number of torsions in this molecule */        
167 >    unsigned int getNTorsions() {
168 >      return torsions_.size();
169 >    }
170  
171 <        /**
172 <         * Returns the global index of this molecule.
173 <         * @return  the global index of this molecule
174 <         */
175 <        int getGlobalIndex() {
176 <            return globalIndex_;
177 <        }
171 >    /** Returns the total number of improper torsions in this molecule */
172 >    unsigned int getNInversions() {
173 >      return inversions_.size();
174 >    }
175 >    
176 >    /** Returns the total number of rigid bodies in this molecule */        
177 >    unsigned int getNRigidBodies() {
178 >      return rigidBodies_.size();
179 >    }
180 >    
181 >    /** Returns the total number of integrable objects in this molecule */
182 >    unsigned int getNIntegrableObjects() {
183 >      return integrableObjects_.size();
184 >    }
185 >    
186 >    /** Returns the total number of cutoff groups in this molecule */
187 >    unsigned int getNCutoffGroups() {
188 >      return cutoffGroups_.size();
189 >    }
190 >    
191 >    /** Returns the total number of constraints in this molecule */
192 >    unsigned int getNConstraintPairs() {
193 >      return constraintPairs_.size();
194 >    }
195 >    
196 >    Atom* getAtomAt(unsigned int i) {
197 >      assert(i < atoms_.size());
198 >      return atoms_[i];
199 >    }
200 >    
201 >    RigidBody* getRigidBodyAt(unsigned int i) {
202 >      assert(i < rigidBodies_.size());
203 >      return rigidBodies_[i];
204 >    }
205 >    
206 >    Atom* beginAtom(std::vector<Atom*>::iterator& i) {
207 >      i = atoms_.begin();
208 >      return (i == atoms_.end()) ? NULL : *i;
209 >    }
210 >    
211 >    Atom* nextAtom(std::vector<Atom*>::iterator& i) {
212 >      ++i;
213 >      return (i == atoms_.end()) ? NULL : *i;    
214 >    }
215 >    
216 >    Bond* beginBond(std::vector<Bond*>::iterator& i) {
217 >      i = bonds_.begin();
218 >      return (i == bonds_.end()) ? NULL : *i;
219 >    }
220 >    
221 >    Bond* nextBond(std::vector<Bond*>::iterator& i) {
222 >      ++i;
223 >      return (i == bonds_.end()) ? NULL : *i;    
224 >      
225 >    }
226 >    
227 >    Bend* beginBend(std::vector<Bend*>::iterator& i) {
228 >      i = bends_.begin();
229 >      return (i == bends_.end()) ? NULL : *i;
230 >    }
231 >    
232 >    Bend* nextBend(std::vector<Bend*>::iterator& i) {
233 >      ++i;
234 >      return (i == bends_.end()) ? NULL : *i;    
235 >    }
236 >    
237 >    Torsion* beginTorsion(std::vector<Torsion*>::iterator& i) {
238 >      i = torsions_.begin();
239 >      return (i == torsions_.end()) ? NULL : *i;
240 >    }
241 >    
242 >    Torsion* nextTorsion(std::vector<Torsion*>::iterator& i) {
243 >      ++i;
244 >      return (i == torsions_.end()) ? NULL : *i;    
245 >    }    
246  
247 <        /**
248 <         * Returns the stamp id of this molecule
249 <         * @note Ideally, every molecule should keep a pointer of its molecule stamp instead of its
250 <         * stamp id. However, the pointer will become invalid, if the molecule migrate to other processor.
251 <         */
252 <        int getStampId() {
253 <            return stampId_;
254 <        }
247 >    Inversion* beginInversion(std::vector<Inversion*>::iterator& i) {
248 >      i = inversions_.begin();
249 >      return (i == inversions_.end()) ? NULL : *i;
250 >    }
251 >    
252 >    Inversion* nextInversion(std::vector<Inversion*>::iterator& i) {
253 >      ++i;
254 >      return (i == inversions_.end()) ? NULL : *i;    
255 >    }    
256 >    
257 >    RigidBody* beginRigidBody(std::vector<RigidBody*>::iterator& i) {
258 >      i = rigidBodies_.begin();
259 >      return (i == rigidBodies_.end()) ? NULL : *i;
260 >    }
261 >    
262 >    RigidBody* nextRigidBody(std::vector<RigidBody*>::iterator& i) {
263 >      ++i;
264 >      return (i == rigidBodies_.end()) ? NULL : *i;    
265 >    }
266 >    
267 >    StuntDouble* beginIntegrableObject(std::vector<StuntDouble*>::iterator& i) {
268 >      i = integrableObjects_.begin();
269 >      return (i == integrableObjects_.end()) ? NULL : *i;
270 >    }
271 >    
272 >    StuntDouble* nextIntegrableObject(std::vector<StuntDouble*>::iterator& i) {
273 >      ++i;
274 >      return (i == integrableObjects_.end()) ? NULL : *i;    
275 >    }    
276 >    
277 >    CutoffGroup* beginCutoffGroup(std::vector<CutoffGroup*>::iterator& i) {
278 >      i = cutoffGroups_.begin();
279 >      return (i == cutoffGroups_.end()) ? NULL : *i;
280 >    }
281  
282 <        /** Returns the name of the molecule */
283 <        std::string getType() {
284 <            return moleculeName_;
285 <        }
286 <        
287 <        /**
288 <         * Sets the global index of this molecule.
289 <         * @param new global index to be set
290 <         */
291 <        void setGlobalIndex(int index) {
292 <            globalIndex_ = index;
293 <        }
282 >    CutoffGroup* nextCutoffGroup(std::vector<CutoffGroup*>::iterator& i) {
283 >      ++i;
284 >      return (i == cutoffGroups_.end()) ? NULL : *i;    
285 >    }
286 >    
287 >    ConstraintPair* beginConstraintPair(std::vector<ConstraintPair*>::iterator& i) {
288 >      i = constraintPairs_.begin();
289 >      return (i == constraintPairs_.end()) ? NULL : *i;
290 >    }
291 >    
292 >    ConstraintPair* nextConstraintPair(std::vector<ConstraintPair*>::iterator& i) {            
293 >      ++i;
294 >      return (i == constraintPairs_.end()) ? NULL : *i;    
295 >    }        
296 >    
297 >    ConstraintElem* beginConstraintElem(std::vector<ConstraintElem*>::iterator& i) {
298 >      i = constraintElems_.begin();
299 >      return (i == constraintElems_.end()) ? NULL : *i;
300 >    }
301 >    
302 >    ConstraintElem* nextConstraintElem(std::vector<ConstraintElem*>::iterator& i) {            
303 >      ++i;
304 >      return (i == constraintElems_.end()) ? NULL : *i;    
305 >    }
306 >    
307 >    /**
308 >     * Returns the total potential energy of short range interaction
309 >     * of this molecule
310 >     */    
311 >    RealType getPotential();
312 >    
313 >    /** get total mass of this molecule */        
314 >    RealType getMass();
315 >    
316 >    /** return the center of mass of this molecule */
317 >    Vector3d getCom();
318 >    
319 >    /** Moves the center of this molecule */
320 >    void moveCom(const Vector3d& delta);
321 >    
322 >    /** Returns the velocity of center of mass of this molecule */
323 >    Vector3d getComVel();
324  
325 +    std::string getMoleculeName() {
326 +      return moleculeName_;
327 +    }
328          
329 <        /** add an atom into this molecule */
330 <        void addAtom(Atom* atom);
329 >    friend std::ostream& operator <<(std::ostream& o, Molecule& mol);
330 >    
331 >  private:
332 >    
333 >    int globalIndex_;
334 >    
335 >    std::vector<Atom*> atoms_;
336 >    std::vector<Bond*> bonds_;
337 >    std::vector<Bend*> bends_;
338 >    std::vector<Torsion*> torsions_;
339 >    std::vector<Inversion*> inversions_;
340 >    std::vector<RigidBody*> rigidBodies_;
341 >    std::vector<StuntDouble*> integrableObjects_;
342 >    std::vector<CutoffGroup*> cutoffGroups_;
343 >    std::vector<ConstraintPair*> constraintPairs_;
344 >    std::vector<ConstraintElem*> constraintElems_;
345 >    int stampId_;
346 >    std::string moleculeName_;
347 >  };
348  
122 –        /** add a bond into this molecule */
123 –        void addBond(Bond* bond);
124 –
125 –        /** add a bend into this molecule */
126 –        void addBend(Bend* bend);
127 –
128 –        /** add a torsion into this molecule*/
129 –        void addTorsion(Torsion* torsion);
130 –
131 –        /** add a rigidbody into this molecule */
132 –        void addRigidBody(RigidBody *rb);
133 –
134 –        /** add a cutoff group into this molecule */
135 –        void addCutoffGroup(CutoffGroup* cp);    
136 –
137 –        void addConstraintPair(ConstraintPair* consPair);
138 –        
139 –        void addConstraintElem(ConstraintElem* consElem);
140 –
141 –        /** */
142 –        void complete();
143 –
144 –        /** Returns the total number of atoms in this molecule */
145 –        unsigned int getNAtoms() {
146 –            return atoms_.size();
147 –        }
148 –
149 –        /** Returns the total number of bonds in this molecule */        
150 –        unsigned int getNBonds(){
151 –            return bonds_.size();
152 –        }
153 –
154 –        /** Returns the total number of bends in this molecule */        
155 –        unsigned int getNBends() {
156 –            return bends_.size();
157 –        }
158 –
159 –        /** Returns the total number of torsions in this molecule */        
160 –        unsigned int getNTorsions() {
161 –            return torsions_.size();
162 –        }
163 –
164 –        /** Returns the total number of rigid bodies in this molecule */        
165 –        unsigned int getNRigidBodies() {
166 –            return rigidBodies_.size();
167 –        }
168 –
169 –        /** Returns the total number of integrable objects in this molecule */
170 –        unsigned int getNIntegrableObjects() {
171 –            return integrableObjects_.size();
172 –        }
173 –
174 –        /** Returns the total number of cutoff groups in this molecule */
175 –        unsigned int getNCutoffGroups() {
176 –            return cutoffGroups_.size();
177 –        }
178 –
179 –        /** Returns the total number of constraints in this molecule */
180 –        unsigned int getNConstraintPairs() {
181 –            return constraintPairs_.size();
182 –        }
183 –
184 –        Atom* getAtomAt(unsigned int i) {
185 –            assert(i < atoms_.size());
186 –            return atoms_[i];
187 –        }
188 –
189 –        RigidBody* getRigidBodyAt(unsigned int i) {
190 –            assert(i < rigidBodies_.size());
191 –            return rigidBodies_[i];
192 –        }
193 –        
194 –        Atom* beginAtom(std::vector<Atom*>::iterator& i) {
195 –            i = atoms_.begin();
196 –            return (i == atoms_.end()) ? NULL : *i;
197 –        }
198 –
199 –        Atom* nextAtom(std::vector<Atom*>::iterator& i) {
200 –            ++i;
201 –            return (i == atoms_.end()) ? NULL : *i;    
202 –        }
203 –
204 –        Bond* beginBond(std::vector<Bond*>::iterator& i) {
205 –            i = bonds_.begin();
206 –            return (i == bonds_.end()) ? NULL : *i;
207 –        }
208 –
209 –        Bond* nextBond(std::vector<Bond*>::iterator& i) {
210 –            ++i;
211 –            return (i == bonds_.end()) ? NULL : *i;    
212 –
213 –        }
214 –
215 –        Bend* beginBend(std::vector<Bend*>::iterator& i) {
216 –            i = bends_.begin();
217 –            return (i == bends_.end()) ? NULL : *i;
218 –        }
219 –
220 –        Bend* nextBend(std::vector<Bend*>::iterator& i) {
221 –            ++i;
222 –            return (i == bends_.end()) ? NULL : *i;    
223 –        }
224 –
225 –        Torsion* beginTorsion(std::vector<Torsion*>::iterator& i) {
226 –            i = torsions_.begin();
227 –            return (i == torsions_.end()) ? NULL : *i;
228 –        }
229 –
230 –        Torsion* nextTorsion(std::vector<Torsion*>::iterator& i) {
231 –            ++i;
232 –            return (i == torsions_.end()) ? NULL : *i;    
233 –        }    
234 –
235 –        RigidBody* beginRigidBody(std::vector<RigidBody*>::iterator& i) {
236 –            i = rigidBodies_.begin();
237 –            return (i == rigidBodies_.end()) ? NULL : *i;
238 –        }
239 –
240 –        RigidBody* nextRigidBody(std::vector<RigidBody*>::iterator& i) {
241 –            ++i;
242 –            return (i == rigidBodies_.end()) ? NULL : *i;    
243 –        }
244 –
245 –        StuntDouble* beginIntegrableObject(std::vector<StuntDouble*>::iterator& i) {
246 –            i = integrableObjects_.begin();
247 –            return (i == integrableObjects_.end()) ? NULL : *i;
248 –        }
249 –
250 –        StuntDouble* nextIntegrableObject(std::vector<StuntDouble*>::iterator& i) {
251 –            ++i;
252 –            return (i == integrableObjects_.end()) ? NULL : *i;    
253 –        }    
254 –
255 –        CutoffGroup* beginCutoffGroup(std::vector<CutoffGroup*>::iterator& i) {
256 –            i = cutoffGroups_.begin();
257 –            return (i == cutoffGroups_.end()) ? NULL : *i;
258 –        }
259 –
260 –        CutoffGroup* nextCutoffGroup(std::vector<CutoffGroup*>::iterator& i) {            
261 –            ++i;
262 –            return (i == cutoffGroups_.end()) ? NULL : *i;    
263 –        }
264 –
265 –        ConstraintPair* beginConstraintPair(std::vector<ConstraintPair*>::iterator& i) {
266 –            i = constraintPairs_.begin();
267 –            return (i == constraintPairs_.end()) ? NULL : *i;
268 –        }
269 –
270 –        ConstraintPair* nextConstraintPair(std::vector<ConstraintPair*>::iterator& i) {            
271 –            ++i;
272 –            return (i == constraintPairs_.end()) ? NULL : *i;    
273 –        }        
274 –
275 –        ConstraintElem* beginConstraintElem(std::vector<ConstraintElem*>::iterator& i) {
276 –            i = constraintElems_.begin();
277 –            return (i == constraintElems_.end()) ? NULL : *i;
278 –        }
279 –
280 –        ConstraintElem* nextConstraintElem(std::vector<ConstraintElem*>::iterator& i) {            
281 –            ++i;
282 –            return (i == constraintElems_.end()) ? NULL : *i;    
283 –        }
284 –        
285 –        /** return the total potential energy of short range interaction of this molecule */
286 –        double getPotential();
287 –
288 –        /** get total mass of this molecule */        
289 –        double getMass();
290 –
291 –        /** return the center of mass of this molecule */
292 –        Vector3d getCom();
293 –
294 –        /** Moves the center of this molecule */
295 –        void moveCom(const Vector3d& delta);
296 –
297 –        /** Returns the velocity of center of mass of this molecule */
298 –        Vector3d getComVel();
299 –
300 –        std::string getMoleculeName() {
301 –            return moleculeName_;
302 –        }
303 –        
304 –        friend std::ostream& operator <<(std::ostream& o, Molecule& mol);
305 –        
306 –    private:
307 –        
308 –        int globalIndex_;
309 –
310 –        std::vector<Atom*> atoms_;
311 –        std::vector<Bond*> bonds_;
312 –        std::vector<Bend*> bends_;
313 –        std::vector<Torsion*> torsions_;
314 –        std::vector<RigidBody*> rigidBodies_;
315 –        std::vector<StuntDouble*> integrableObjects_;
316 –        std::vector<CutoffGroup*> cutoffGroups_;
317 –        std::vector<ConstraintPair*> constraintPairs_;
318 –        std::vector<ConstraintElem*> constraintElems_;
319 –        int stampId_;
320 –        std::string moleculeName_;
321 – };
322 –
349   } //namespace oopse
350   #endif //

Diff Legend

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