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

Diff Legend

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