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 246 by gezelter, Wed Jan 12 22:41:40 2005 UTC vs.
Revision 963 by tim, Wed May 17 21:51:42 2006 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;
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();
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 <        }
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 molecule stamp instead of its
99 <         * stamp id. However, the pointer will become invalid, if the molecule migrate to other processor.
100 <         */
101 <        int getStampId() {
102 <            return stampId_;
103 <        }
96 >    /**
97 >     * Returns the stamp id of this molecule
98 >     * @note Ideally, every molecule should keep a pointer of its molecule stamp instead of its
99 >     * stamp id. However, the pointer will become invalid, if the molecule migrate to other processor.
100 >     */
101 >    int getStampId() {
102 >      return stampId_;
103 >    }
104  
105 <        /** Returns the name of the molecule */
106 <        std::string getType() {
107 <            return moleculeName_;
108 <        }
105 >    /** Returns the name of the molecule */
106 >    std::string getType() {
107 >      return moleculeName_;
108 >    }
109          
110 <        /**
111 <         * Sets the global index of this molecule.
112 <         * @param new global index to be set
113 <         */
114 <        int setGlobalIndex(int index) {
115 <            return globalIndex_;
116 <        }
110 >    /**
111 >     * Sets the global index of this molecule.
112 >     * @param new global index to be set
113 >     */
114 >    void setGlobalIndex(int index) {
115 >      globalIndex_ = index;
116 >    }
117  
118          
119 <        /** add an atom into this molecule */
120 <        void addAtom(Atom* atom);
119 >    /** add an atom into this molecule */
120 >    void addAtom(Atom* atom);
121  
122 <        /** add a bond into this molecule */
123 <        void addBond(Bond* bond);
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);
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);
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);
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);    
134 >    /** add a cutoff group into this molecule */
135 >    void addCutoffGroup(CutoffGroup* cp);    
136  
137 <        void addConstraintPair(ConstraintPair* consPair);
137 >    void addConstraintPair(ConstraintPair* consPair);
138          
139 <        void addConstraintElem(ConstraintElem* consElem);
139 >    void addConstraintElem(ConstraintElem* consElem);
140  
141 <        /** */
142 <        void complete();
141 >    /** */
142 >    void complete();
143  
144 <        /** Returns the total number of atoms in this molecule */
145 <        unsigned int getNAtoms() {
146 <            return atoms_.size();
147 <        }
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 <        }
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 <        }
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 <        }
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 <        }
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 <        }
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 <        }
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 <        }
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 <        }
184 >    Atom* getAtomAt(unsigned int i) {
185 >      assert(i < atoms_.size());
186 >      return atoms_[i];
187 >    }
188  
189 <        Atom* beginAtom(std::vector<Atom*>::iterator& i) {
190 <            i = atoms_.begin();
191 <            return (i == atoms_.end()) ? NULL : *i;
192 <        }
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 <        }
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 <        }
203 <
204 <        Bond* nextBond(std::vector<Bond*>::iterator& i) {
205 <            ++i;
206 <            return (i == bonds_.end()) ? NULL : *i;    
204 >    Bond* beginBond(std::vector<Bond*>::iterator& i) {
205 >      i = bonds_.begin();
206 >      return (i == bonds_.end()) ? NULL : *i;
207 >    }
208  
209 <        }
209 >    Bond* nextBond(std::vector<Bond*>::iterator& i) {
210 >      ++i;
211 >      return (i == bonds_.end()) ? NULL : *i;    
212  
213 <        Bend* beginBend(std::vector<Bend*>::iterator& i) {
211 <            i = bends_.begin();
212 <            return (i == bends_.end()) ? NULL : *i;
213 <        }
213 >    }
214  
215 <        Bend* nextBend(std::vector<Bend*>::iterator& i) {
216 <            ++i;
217 <            return (i == bends_.end()) ? NULL : *i;    
218 <        }
215 >    Bend* beginBend(std::vector<Bend*>::iterator& i) {
216 >      i = bends_.begin();
217 >      return (i == bends_.end()) ? NULL : *i;
218 >    }
219  
220 <        Torsion* beginTorsion(std::vector<Torsion*>::iterator& i) {
221 <            i = torsions_.begin();
222 <            return (i == torsions_.end()) ? NULL : *i;
223 <        }
220 >    Bend* nextBend(std::vector<Bend*>::iterator& i) {
221 >      ++i;
222 >      return (i == bends_.end()) ? NULL : *i;    
223 >    }
224  
225 <        Torsion* nextTorsion(std::vector<Torsion*>::iterator& i) {
226 <            ++i;
227 <            return (i == torsions_.end()) ? NULL : *i;    
228 <        }    
225 >    Torsion* beginTorsion(std::vector<Torsion*>::iterator& i) {
226 >      i = torsions_.begin();
227 >      return (i == torsions_.end()) ? NULL : *i;
228 >    }
229  
230 <        RigidBody* beginRigidBody(std::vector<RigidBody*>::iterator& i) {
231 <            i = rigidBodies_.begin();
232 <            return (i == rigidBodies_.end()) ? NULL : *i;
233 <        }
230 >    Torsion* nextTorsion(std::vector<Torsion*>::iterator& i) {
231 >      ++i;
232 >      return (i == torsions_.end()) ? NULL : *i;    
233 >    }    
234  
235 <        RigidBody* nextRigidBody(std::vector<RigidBody*>::iterator& i) {
236 <            ++i;
237 <            return (i == rigidBodies_.end()) ? NULL : *i;    
238 <        }
235 >    RigidBody* beginRigidBody(std::vector<RigidBody*>::iterator& i) {
236 >      i = rigidBodies_.begin();
237 >      return (i == rigidBodies_.end()) ? NULL : *i;
238 >    }
239  
240 <        StuntDouble* beginIntegrableObject(std::vector<StuntDouble*>::iterator& i) {
241 <            i = integrableObjects_.begin();
242 <            return (i == integrableObjects_.end()) ? NULL : *i;
243 <        }
240 >    RigidBody* nextRigidBody(std::vector<RigidBody*>::iterator& i) {
241 >      ++i;
242 >      return (i == rigidBodies_.end()) ? NULL : *i;    
243 >    }
244  
245 <        StuntDouble* nextIntegrableObject(std::vector<StuntDouble*>::iterator& i) {
246 <            ++i;
247 <            return (i == integrableObjects_.end()) ? NULL : *i;    
248 <        }    
245 >    StuntDouble* beginIntegrableObject(std::vector<StuntDouble*>::iterator& i) {
246 >      i = integrableObjects_.begin();
247 >      return (i == integrableObjects_.end()) ? NULL : *i;
248 >    }
249  
250 <        CutoffGroup* beginCutoffGroup(std::vector<CutoffGroup*>::iterator& i) {
251 <            i = cutoffGroups_.begin();
252 <            return (i == cutoffGroups_.end()) ? NULL : *i;
253 <        }
250 >    StuntDouble* nextIntegrableObject(std::vector<StuntDouble*>::iterator& i) {
251 >      ++i;
252 >      return (i == integrableObjects_.end()) ? NULL : *i;    
253 >    }    
254  
255 <        CutoffGroup* nextCutoffGroup(std::vector<CutoffGroup*>::iterator& i) {            
256 <            ++i;
257 <            return (i == cutoffGroups_.end()) ? NULL : *i;    
258 <        }
255 >    CutoffGroup* beginCutoffGroup(std::vector<CutoffGroup*>::iterator& i) {
256 >      i = cutoffGroups_.begin();
257 >      return (i == cutoffGroups_.end()) ? NULL : *i;
258 >    }
259  
260 <        ConstraintPair* beginConstraintPair(std::vector<ConstraintPair*>::iterator& i) {
261 <            i = constraintPairs_.begin();
262 <            return (i == constraintPairs_.end()) ? NULL : *i;
263 <        }
260 >    CutoffGroup* nextCutoffGroup(std::vector<CutoffGroup*>::iterator& i) {            
261 >      ++i;
262 >      return (i == cutoffGroups_.end()) ? NULL : *i;    
263 >    }
264  
265 <        ConstraintPair* nextConstraintPair(std::vector<ConstraintPair*>::iterator& i) {            
266 <            ++i;
267 <            return (i == constraintPairs_.end()) ? NULL : *i;    
268 <        }        
265 >    ConstraintPair* beginConstraintPair(std::vector<ConstraintPair*>::iterator& i) {
266 >      i = constraintPairs_.begin();
267 >      return (i == constraintPairs_.end()) ? NULL : *i;
268 >    }
269  
270 <        ConstraintElem* beginConstraintElem(std::vector<ConstraintElem*>::iterator& i) {
271 <            i = constraintElems_.begin();
272 <            return (i == constraintElems_.end()) ? NULL : *i;
273 <        }
270 >    ConstraintPair* nextConstraintPair(std::vector<ConstraintPair*>::iterator& i) {            
271 >      ++i;
272 >      return (i == constraintPairs_.end()) ? NULL : *i;    
273 >    }        
274  
275 <        ConstraintElem* nextConstraintElem(std::vector<ConstraintElem*>::iterator& i) {            
276 <            ++i;
277 <            return (i == constraintElems_.end()) ? NULL : *i;    
278 <        }
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();
285 >    /** return the total potential energy of short range interaction of this molecule */
286 >    RealType getPotential();
287  
288 <        /** get total mass of this molecule */        
289 <        double getMass();
288 >    /** get total mass of this molecule */        
289 >    RealType getMass();
290  
291 <        /** return the center of mass of this molecule */
292 <        Vector3d getCom();
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);
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();
297 >    /** Returns the velocity of center of mass of this molecule */
298 >    Vector3d getComVel();
299  
300 <        friend std::ostream& operator <<(std::ostream& o, Molecule& mol);
300 >    std::string getMoleculeName() {
301 >      return moleculeName_;
302 >    }
303          
304 <    private:
304 >    friend std::ostream& operator <<(std::ostream& o, Molecule& mol);
305          
306 <        int globalIndex_;
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 < };
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
324   #endif //

Diff Legend

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