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 1390 by gezelter, Wed Nov 25 20:02:06 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 6 | Line 6
6   * redistribute this software in source and binary code form, provided
7   * that the following conditions are met:
8   *
9 < * 1. Acknowledgement of the program authors must be made in any
10 < *    publication of scientific results based in part on use of the
11 < *    program.  An acceptable form of acknowledgement is citation of
12 < *    the article in which the program was described (Matthew
13 < *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 < *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 < *    Parallel Simulation Engine for Molecular Dynamics,"
16 < *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 < *
18 < * 2. Redistributions of source code must retain the above copyright
9 > * 1. Redistributions of source code must retain the above copyright
10   *    notice, this list of conditions and the following disclaimer.
11   *
12 < * 3. Redistributions in binary form must reproduce the above copyright
12 > * 2. Redistributions in binary form must reproduce the above copyright
13   *    notice, this list of conditions and the following disclaimer in the
14   *    documentation and/or other materials provided with the
15   *    distribution.
# Line 37 | Line 28
28   * arising out of the use of or inability to use software, even if the
29   * University of Notre Dame has been advised of the possibility of
30   * such damages.
31 + *
32 + * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33 + * research, please cite the appropriate papers when you publish your
34 + * work.  Good starting points are:
35 + *                                                                      
36 + * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37 + * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38 + * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39 + * [4]  Vardeman & Gezelter, in progress (2009).                        
40   */
41  
42   /**
# 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{
65 > namespace OpenMD{
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 <        }
287 <        
288 <        /**
289 <         * Sets the global index of this molecule.
290 <         * @param new global index to be set
291 <         */
292 <        void setGlobalIndex(int index) {
293 <            globalIndex_ = index;
294 <        }
295 <
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 <        /** add an atom into this molecule */
309 <        void addAtom(Atom* atom);
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 <        /** add a bond into this molecule */
327 <        void addBond(Bond* bond);
328 <
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);
326 >    std::string getMoleculeName() {
327 >      return moleculeName_;
328 >    }
329          
330 <        void addConstraintElem(ConstraintElem* consElem);
330 >    friend std::ostream& operator <<(std::ostream& o, Molecule& mol);
331  
332 <        /** */
333 <        void complete();
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 <        /** Returns the total number of atoms in this molecule */
340 <        unsigned int getNAtoms() {
341 <            return atoms_.size();
342 <        }
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 <        /** Returns the total number of bonds in this molecule */        
346 <        unsigned int getNBonds(){
347 <            return bonds_.size();
348 <        }
345 >    /**
346 >     * clear all of the properties
347 >     */
348 >    void clearProperties();
349  
350 <        /** Returns the total number of bends in this molecule */        
351 <        unsigned int getNBends() {
352 <            return bends_.size();
353 <        }
350 >    /**
351 >     * Returns all names of properties
352 >     * @return all names of properties
353 >     */
354 >    std::vector<std::string> getPropertyNames();
355  
356 <        /** Returns the total number of torsions in this molecule */        
357 <        unsigned int getNTorsions() {
358 <            return torsions_.size();
359 <        }
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 <        /** Returns the total number of rigid bodies in this molecule */        
363 <        unsigned int getNRigidBodies() {
364 <            return rigidBodies_.size();
365 <        }
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 <        /** Returns the total number of integrable objects in this molecule */
170 <        unsigned int getNIntegrableObjects() {
171 <            return integrableObjects_.size();
172 <        }
388 >  };
389  
390 <        /** 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 <
323 < } //namespace oopse
390 > } //namespace OpenMD
391   #endif //

Diff Legend

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