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

Diff Legend

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