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 963 by tim, Wed May 17 21:51:42 2006 UTC vs.
Revision 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC

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

Diff Legend

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