src/primitives/Molecule.hpp

/*
 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Acknowledgement of the program authors must be made in any
 *    publication of scientific results based in part on use of the
 *    program.  An acceptable form of acknowledgement is citation of
 *    the article in which the program was described (Matthew
 *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
 *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
 *    Parallel Simulation Engine for Molecular Dynamics,"
 *    J. Comput. Chem. 26, pp. 252-271 (2005))
 *
 * 2. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 3. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * arising out of the use of or inability to use software, even if the
 * University of Notre Dame has been advised of the possibility of
 * such damages.
 */
 
/**
 * @file Molecule.hpp
 * @author    tlin
 * @date  10/25/2004
 * @version 1.0
 */ 

#ifndef PRIMITIVES_MOLECULE_HPP
#define PRIMITIVES_MOLECULE_HPP
#include <vector>
#include <iostream>

#include "constraints/ConstraintPair.hpp"
#include "math/Vector3.hpp"
#include "primitives/Atom.hpp"
#include "primitives/RigidBody.hpp"
#include "primitives/Bond.hpp"
#include "primitives/Bend.hpp"
#include "primitives/Torsion.hpp"
#include "primitives/Inversion.hpp"
#include "primitives/CutoffGroup.hpp"
#include "utils/PropertyMap.hpp"

namespace oopse{

  class Constraint;

  /**
   * @class Molecule Molecule.hpp "primitives/Molecule.hpp"
   * @brief
   */
  class Molecule {
  public:

    typedef std::vector<Atom*>::iterator AtomIterator;
    typedef std::vector<Bond*>::iterator BondIterator;
    typedef std::vector<Bend*>::iterator BendIterator;
    typedef std::vector<Torsion*>::iterator TorsionIterator;
    typedef std::vector<Inversion*>::iterator InversionIterator;
    typedef std::vector<RigidBody*>::iterator RigidBodyIterator;
    typedef std::vector<CutoffGroup*>::iterator CutoffGroupIterator;
    typedef std::vector<StuntDouble*>::iterator IntegrableObjectIterator;
    typedef std::vector<ConstraintPair*>::iterator ConstraintPairIterator;
    typedef std::vector<ConstraintElem*>::iterator ConstraintElemIterator;
    
    
    Molecule(int stampId, int globalIndex, const std::string& molName);
    virtual ~Molecule();
    
    /**
     * Returns the global index of this molecule.
     * @return  the global index of this molecule 
     */
    int getGlobalIndex() {
      return globalIndex_;
    }
    
    /**
     * Returns the stamp id of this molecule
     * @note Ideally, every molecule should keep a pointer of its
     * molecule stamp instead of its stamp id. However, the pointer
     * will become invalid, if the molecule migrate to other
     * processor.
     */
    int getStampId() {
      return stampId_;
    }
    
    /** Returns the name of the molecule */
    std::string getType() {
      return moleculeName_;
    }
    
    /**
     * Sets the global index of this molecule.
     * @param new global index to be set
     */
    void setGlobalIndex(int index) {
      globalIndex_ = index;
    }
    
    
    /** add an atom into this molecule */
    void addAtom(Atom* atom);
    
    /** add a bond into this molecule */
    void addBond(Bond* bond);
    
    /** add a bend into this molecule */
    void addBend(Bend* bend);
    
    /** add a torsion into this molecule*/
    void addTorsion(Torsion* torsion);

    /** add an improper torsion into this molecule*/
    void addInversion(Inversion* inversion);
    
    /** add a rigidbody into this molecule */
    void addRigidBody(RigidBody *rb);
    
    /** add a cutoff group into this molecule */
    void addCutoffGroup(CutoffGroup* cp);     
    
    void addConstraintPair(ConstraintPair* consPair);
    
    void addConstraintElem(ConstraintElem* consElem);
    
    /** */
    void complete();
    
    /** Returns the total number of atoms in this molecule */
    unsigned int getNAtoms() {
      return atoms_.size();
    }
    
    /** Returns the total number of bonds in this molecule */        
    unsigned int getNBonds(){
      return bonds_.size();
    }
    
    /** Returns the total number of bends in this molecule */        
    unsigned int getNBends() {
      return bends_.size();
    }
    
    /** Returns the total number of torsions in this molecule */        
    unsigned int getNTorsions() {
      return torsions_.size();
    }

    /** Returns the total number of improper torsions in this molecule */
    unsigned int getNInversions() {
      return inversions_.size();
    }
    
    /** Returns the total number of rigid bodies in this molecule */        
    unsigned int getNRigidBodies() {
      return rigidBodies_.size();
    }
    
    /** Returns the total number of integrable objects in this molecule */
    unsigned int getNIntegrableObjects() {
      return integrableObjects_.size();
    }
    
    /** Returns the total number of cutoff groups in this molecule */
    unsigned int getNCutoffGroups() {
      return cutoffGroups_.size();
    }
    
    /** Returns the total number of constraints in this molecule */
    unsigned int getNConstraintPairs() {
      return constraintPairs_.size();
    }
    
    Atom* getAtomAt(unsigned int i) {
      assert(i < atoms_.size());
      return atoms_[i];
    }
    
    RigidBody* getRigidBodyAt(unsigned int i) {
      assert(i < rigidBodies_.size());
      return rigidBodies_[i];
    }
    
    Atom* beginAtom(std::vector<Atom*>::iterator& i) {
      i = atoms_.begin();
      return (i == atoms_.end()) ? NULL : *i;
    }
    
    Atom* nextAtom(std::vector<Atom*>::iterator& i) {
      ++i;
      return (i == atoms_.end()) ? NULL : *i;    
    }
    
    Bond* beginBond(std::vector<Bond*>::iterator& i) {
      i = bonds_.begin();
      return (i == bonds_.end()) ? NULL : *i;
    }
    
    Bond* nextBond(std::vector<Bond*>::iterator& i) {
      ++i;
      return (i == bonds_.end()) ? NULL : *i;    
      
    }
    
    Bend* beginBend(std::vector<Bend*>::iterator& i) {
      i = bends_.begin();
      return (i == bends_.end()) ? NULL : *i;
    }
    
    Bend* nextBend(std::vector<Bend*>::iterator& i) {
      ++i;
      return (i == bends_.end()) ? NULL : *i;    
    }
    
    Torsion* beginTorsion(std::vector<Torsion*>::iterator& i) {
      i = torsions_.begin();
      return (i == torsions_.end()) ? NULL : *i;
    }
    
    Torsion* nextTorsion(std::vector<Torsion*>::iterator& i) {
      ++i;
      return (i == torsions_.end()) ? NULL : *i;    
    }    

    Inversion* beginInversion(std::vector<Inversion*>::iterator& i) {
      i = inversions_.begin();
      return (i == inversions_.end()) ? NULL : *i;
    }
    
    Inversion* nextInversion(std::vector<Inversion*>::iterator& i) {
      ++i;
      return (i == inversions_.end()) ? NULL : *i;    
    }    
    
    RigidBody* beginRigidBody(std::vector<RigidBody*>::iterator& i) {
      i = rigidBodies_.begin();
      return (i == rigidBodies_.end()) ? NULL : *i;
    }
    
    RigidBody* nextRigidBody(std::vector<RigidBody*>::iterator& i) {
      ++i;
      return (i == rigidBodies_.end()) ? NULL : *i;    
    }
    
    StuntDouble* beginIntegrableObject(std::vector<StuntDouble*>::iterator& i) {
      i = integrableObjects_.begin();
      return (i == integrableObjects_.end()) ? NULL : *i;
    }
    
    StuntDouble* nextIntegrableObject(std::vector<StuntDouble*>::iterator& i) {
      ++i;
      return (i == integrableObjects_.end()) ? NULL : *i;    
    }    
    
    CutoffGroup* beginCutoffGroup(std::vector<CutoffGroup*>::iterator& i) {
      i = cutoffGroups_.begin();
      return (i == cutoffGroups_.end()) ? NULL : *i;
    }

    CutoffGroup* nextCutoffGroup(std::vector<CutoffGroup*>::iterator& i) {
      ++i;
      return (i == cutoffGroups_.end()) ? NULL : *i;    
    } 
    
    ConstraintPair* beginConstraintPair(std::vector<ConstraintPair*>::iterator& i) {
      i = constraintPairs_.begin();
      return (i == constraintPairs_.end()) ? NULL : *i;
    }
    
    ConstraintPair* nextConstraintPair(std::vector<ConstraintPair*>::iterator& i) {            
      ++i;
      return (i == constraintPairs_.end()) ? NULL : *i;    
    }         
    
    ConstraintElem* beginConstraintElem(std::vector<ConstraintElem*>::iterator& i) {
      i = constraintElems_.begin();
      return (i == constraintElems_.end()) ? NULL : *i;
    }
    
    ConstraintElem* nextConstraintElem(std::vector<ConstraintElem*>::iterator& i) {            
      ++i;
      return (i == constraintElems_.end()) ? NULL : *i;    
    }
        
    /** 
     * Returns the total potential energy of short range interaction
     * of this molecule 
     */    
    RealType getPotential();
    
    /** get total mass of this molecule */        
    RealType getMass();
    
    /** return the center of mass of this molecule */
    Vector3d getCom();
    
    /** Moves the center of this molecule */
    void moveCom(const Vector3d& delta);
    
    /** Returns the velocity of center of mass of this molecule */
    Vector3d getComVel();

    std::string getMoleculeName() { 
      return moleculeName_;
    }
        
    friend std::ostream& operator <<(std::ostream& o, Molecule& mol);

    //below functions are just forward functions
    /**
     * Adds property into property map
     * @param genData GenericData to be added into PropertyMap
     */
    void addProperty(GenericData* genData);

    /**
     * Removes property from PropertyMap by name
     * @param propName the name of property to be removed
     */
    void removeProperty(const std::string& propName);

    /**
     * clear all of the properties
     */
    void clearProperties();

    /**
     * Returns all names of properties
     * @return all names of properties
     */
    std::vector<std::string> getPropertyNames();

    /**
     * Returns all of the properties in PropertyMap
     * @return all of the properties in PropertyMap
     */      
    std::vector<GenericData*> getProperties();

    /**
     * Returns property 
     * @param propName name of property
     * @return a pointer point to property with propName. If no property named propName
     * exists, return NULL
     */      
    GenericData* getPropertyByName(const std::string& propName);
    
  private:
    
    int globalIndex_;
    
    std::vector<Atom*> atoms_;
    std::vector<Bond*> bonds_;
    std::vector<Bend*> bends_;
    std::vector<Torsion*> torsions_;
    std::vector<Inversion*> inversions_;
    std::vector<RigidBody*> rigidBodies_;
    std::vector<StuntDouble*> integrableObjects_;
    std::vector<CutoffGroup*> cutoffGroups_;
    std::vector<ConstraintPair*> constraintPairs_;
    std::vector<ConstraintElem*> constraintElems_;
    int stampId_;
    std::string moleculeName_;
    PropertyMap properties_;

  };

} //namespace oopse
#endif //
Revision:	1360
Committed:	Mon Sep 7 16:31:51 2009 UTC (15 years, 7 months ago) by cli2
Original Path:	*trunk/src/primitives/Molecule.hpp*
File size:	12090 byte(s)
Log Message:	Added new restraint infrastructure Added MolecularRestraints Added ObjectRestraints Added RestraintStamp Updated thermodynamic integration to use ObjectRestraints Added Quaternion mathematics for twist swing decompositions Significantly updated RestWriter and RestReader to use dump-like files Added selections for x, y, and z coordinates of atoms Removed monolithic Restraints class Fixed a few bugs in gradients of Euler angles in DirectionalAtom and RigidBody Added some rotational capabilities to prinicpalAxisCalculator
#	User	Rev	Content
1	gezelter	507	/*
2	gezelter	246	* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3			*
4			* The University of Notre Dame grants you ("Licensee") a
5			* non-exclusive, royalty free, license to use, modify and
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
19			* notice, this list of conditions and the following disclaimer.
20			*
21			* 3. Redistributions in binary form must reproduce the above copyright
22			* notice, this list of conditions and the following disclaimer in the
23			* documentation and/or other materials provided with the
24			* distribution.
25			*
26			* This software is provided "AS IS," without a warranty of any
27			* kind. All express or implied conditions, representations and
28			* warranties, including any implied warranty of merchantability,
29			* fitness for a particular purpose or non-infringement, are hereby
30			* excluded. The University of Notre Dame and its licensors shall not
31			* be liable for any damages suffered by licensee as a result of
32			* using, modifying or distributing the software or its
33			* derivatives. In no event will the University of Notre Dame or its
34			* licensors be liable for any lost revenue, profit or data, or for
35			* direct, indirect, special, consequential, incidental or punitive
36			* damages, however caused and regardless of the theory of liability,
37			* arising out of the use of or inability to use software, even if the
38			* University of Notre Dame has been advised of the possibility of
39			* such damages.
40			*/
41
42			/**
43			* @file Molecule.hpp
44			* @author tlin
45			* @date 10/25/2004
46			* @version 1.0
47			*/
48	gezelter	2
49	gezelter	246	#ifndef PRIMITIVES_MOLECULE_HPP
50			#define PRIMITIVES_MOLECULE_HPP
51	gezelter	2	#include <vector>
52	gezelter	246	#include <iostream>
53	gezelter	2
54	gezelter	246	#include "constraints/ConstraintPair.hpp"
55			#include "math/Vector3.hpp"
56	tim	3	#include "primitives/Atom.hpp"
57			#include "primitives/RigidBody.hpp"
58	gezelter	246	#include "primitives/Bond.hpp"
59			#include "primitives/Bend.hpp"
60			#include "primitives/Torsion.hpp"
61	cli2	1275	#include "primitives/Inversion.hpp"
62	tim	3	#include "primitives/CutoffGroup.hpp"
63	cli2	1360	#include "utils/PropertyMap.hpp"
64	gezelter	2
65	gezelter	246	namespace oopse{
66	gezelter	2
67	gezelter	507	class Constraint;
68	gezelter	2
69	gezelter	507	/**
70			* @class Molecule Molecule.hpp "primitives/Molecule.hpp"
71			* @brief
72			*/
73			class Molecule {
74			public:
75	gezelter	2
76	gezelter	507	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	cli2	1275	typedef std::vector<Inversion*>::iterator InversionIterator;
81	gezelter	507	typedef std::vector<RigidBody*>::iterator RigidBodyIterator;
82			typedef std::vector<CutoffGroup*>::iterator CutoffGroupIterator;
83	gezelter	1211	typedef std::vector<StuntDouble*>::iterator IntegrableObjectIterator;
84	gezelter	507	typedef std::vector<ConstraintPair*>::iterator ConstraintPairIterator;
85			typedef std::vector<ConstraintElem*>::iterator ConstraintElemIterator;
86	gezelter	1211
87
88	gezelter	507	Molecule(int stampId, int globalIndex, const std::string& molName);
89			virtual ~Molecule();
90	gezelter	1211
91	gezelter	507	/**
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	gezelter	1211
99	gezelter	507	/**
100			* Returns the stamp id of this molecule
101	gezelter	1211	* @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	gezelter	507	*/
106			int getStampId() {
107			return stampId_;
108			}
109	gezelter	1211
110	gezelter	507	/** Returns the name of the molecule */
111			std::string getType() {
112			return moleculeName_;
113			}
114	gezelter	1211
115	gezelter	507	/**
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	gezelter	1211
123
124	gezelter	507	/** add an atom into this molecule */
125			void addAtom(Atom* atom);
126	gezelter	1211
127	gezelter	507	/** add a bond into this molecule */
128			void addBond(Bond* bond);
129	gezelter	1211
130	gezelter	507	/** add a bend into this molecule */
131			void addBend(Bend* bend);
132	gezelter	1211
133	gezelter	507	/** add a torsion into this molecule*/
134			void addTorsion(Torsion* torsion);
135	cli2	1275
136			/** add an improper torsion into this molecule*/
137			void addInversion(Inversion* inversion);
138	gezelter	1211
139	gezelter	507	/** add a rigidbody into this molecule */
140			void addRigidBody(RigidBody *rb);
141	gezelter	1211
142	gezelter	507	/** add a cutoff group into this molecule */
143			void addCutoffGroup(CutoffGroup* cp);
144	gezelter	1211
145	gezelter	507	void addConstraintPair(ConstraintPair* consPair);
146	gezelter	1211
147	gezelter	507	void addConstraintElem(ConstraintElem* consElem);
148	gezelter	1211
149	gezelter	507	/** */
150			void complete();
151	gezelter	1211
152	gezelter	507	/** Returns the total number of atoms in this molecule */
153			unsigned int getNAtoms() {
154			return atoms_.size();
155			}
156	gezelter	1211
157	gezelter	507	/** Returns the total number of bonds in this molecule */
158			unsigned int getNBonds(){
159			return bonds_.size();
160			}
161	gezelter	1211
162	gezelter	507	/** Returns the total number of bends in this molecule */
163			unsigned int getNBends() {
164			return bends_.size();
165			}
166	gezelter	1211
167	gezelter	507	/** Returns the total number of torsions in this molecule */
168			unsigned int getNTorsions() {
169			return torsions_.size();
170			}
171	cli2	1275
172			/** Returns the total number of improper torsions in this molecule */
173			unsigned int getNInversions() {
174			return inversions_.size();
175			}
176	gezelter	1211
177	gezelter	507	/** Returns the total number of rigid bodies in this molecule */
178			unsigned int getNRigidBodies() {
179			return rigidBodies_.size();
180			}
181	gezelter	1211
182	gezelter	507	/** Returns the total number of integrable objects in this molecule */
183			unsigned int getNIntegrableObjects() {
184			return integrableObjects_.size();
185			}
186	gezelter	1211
187	gezelter	507	/** Returns the total number of cutoff groups in this molecule */
188			unsigned int getNCutoffGroups() {
189			return cutoffGroups_.size();
190			}
191	gezelter	1211
192	gezelter	507	/** Returns the total number of constraints in this molecule */
193			unsigned int getNConstraintPairs() {
194			return constraintPairs_.size();
195			}
196	gezelter	1211
197	gezelter	507	Atom* getAtomAt(unsigned int i) {
198			assert(i < atoms_.size());
199			return atoms_[i];
200			}
201	gezelter	1211
202	gezelter	507	RigidBody* getRigidBodyAt(unsigned int i) {
203			assert(i < rigidBodies_.size());
204			return rigidBodies_[i];
205			}
206	gezelter	1211
207	gezelter	507	Atom* beginAtom(std::vector<Atom*>::iterator& i) {
208			i = atoms_.begin();
209			return (i == atoms_.end()) ? NULL : *i;
210			}
211	gezelter	1211
212	gezelter	507	Atom* nextAtom(std::vector<Atom*>::iterator& i) {
213			++i;
214			return (i == atoms_.end()) ? NULL : *i;
215			}
216	gezelter	1211
217	gezelter	507	Bond* beginBond(std::vector<Bond*>::iterator& i) {
218			i = bonds_.begin();
219			return (i == bonds_.end()) ? NULL : *i;
220			}
221	gezelter	1211
222	gezelter	507	Bond* nextBond(std::vector<Bond*>::iterator& i) {
223			++i;
224			return (i == bonds_.end()) ? NULL : *i;
225	gezelter	1211
226	gezelter	507	}
227	gezelter	1211
228	gezelter	507	Bend* beginBend(std::vector<Bend*>::iterator& i) {
229			i = bends_.begin();
230			return (i == bends_.end()) ? NULL : *i;
231			}
232	gezelter	1211
233	gezelter	507	Bend* nextBend(std::vector<Bend*>::iterator& i) {
234			++i;
235			return (i == bends_.end()) ? NULL : *i;
236			}
237	gezelter	1211
238	gezelter	507	Torsion* beginTorsion(std::vector<Torsion*>::iterator& i) {
239			i = torsions_.begin();
240			return (i == torsions_.end()) ? NULL : *i;
241			}
242	gezelter	1211
243	gezelter	507	Torsion* nextTorsion(std::vector<Torsion*>::iterator& i) {
244			++i;
245			return (i == torsions_.end()) ? NULL : *i;
246			}
247	cli2	1275
248			Inversion* beginInversion(std::vector<Inversion*>::iterator& i) {
249			i = inversions_.begin();
250			return (i == inversions_.end()) ? NULL : *i;
251			}
252	gezelter	1211
253	cli2	1275	Inversion* nextInversion(std::vector<Inversion*>::iterator& i) {
254			++i;
255			return (i == inversions_.end()) ? NULL : *i;
256			}
257
258	gezelter	507	RigidBody* beginRigidBody(std::vector<RigidBody*>::iterator& i) {
259			i = rigidBodies_.begin();
260			return (i == rigidBodies_.end()) ? NULL : *i;
261			}
262	gezelter	1211
263	gezelter	507	RigidBody* nextRigidBody(std::vector<RigidBody*>::iterator& i) {
264			++i;
265			return (i == rigidBodies_.end()) ? NULL : *i;
266			}
267	gezelter	1211
268	gezelter	507	StuntDouble* beginIntegrableObject(std::vector<StuntDouble*>::iterator& i) {
269			i = integrableObjects_.begin();
270			return (i == integrableObjects_.end()) ? NULL : *i;
271			}
272	gezelter	1211
273	gezelter	507	StuntDouble* nextIntegrableObject(std::vector<StuntDouble*>::iterator& i) {
274			++i;
275			return (i == integrableObjects_.end()) ? NULL : *i;
276			}
277	gezelter	1211
278	gezelter	507	CutoffGroup* beginCutoffGroup(std::vector<CutoffGroup*>::iterator& i) {
279			i = cutoffGroups_.begin();
280			return (i == cutoffGroups_.end()) ? NULL : *i;
281			}
282	gezelter	246
283	gezelter	1211	CutoffGroup* nextCutoffGroup(std::vector<CutoffGroup*>::iterator& i) {
284	gezelter	507	++i;
285			return (i == cutoffGroups_.end()) ? NULL : *i;
286			}
287	gezelter	1211
288	gezelter	507	ConstraintPair* beginConstraintPair(std::vector<ConstraintPair*>::iterator& i) {
289			i = constraintPairs_.begin();
290			return (i == constraintPairs_.end()) ? NULL : *i;
291			}
292	gezelter	1211
293	gezelter	507	ConstraintPair* nextConstraintPair(std::vector<ConstraintPair*>::iterator& i) {
294			++i;
295			return (i == constraintPairs_.end()) ? NULL : *i;
296			}
297	gezelter	1211
298	gezelter	507	ConstraintElem* beginConstraintElem(std::vector<ConstraintElem*>::iterator& i) {
299			i = constraintElems_.begin();
300			return (i == constraintElems_.end()) ? NULL : *i;
301			}
302	gezelter	1211
303	gezelter	507	ConstraintElem* nextConstraintElem(std::vector<ConstraintElem*>::iterator& i) {
304			++i;
305			return (i == constraintElems_.end()) ? NULL : *i;
306			}
307	cli2	1360
308	gezelter	1211	/**
309			* Returns the total potential energy of short range interaction
310			* of this molecule
311			*/
312	tim	963	RealType getPotential();
313	gezelter	1211
314	gezelter	507	/** get total mass of this molecule */
315	tim	963	RealType getMass();
316	gezelter	1211
317	gezelter	507	/** return the center of mass of this molecule */
318			Vector3d getCom();
319	gezelter	1211
320	gezelter	507	/** Moves the center of this molecule */
321			void moveCom(const Vector3d& delta);
322	gezelter	1211
323	gezelter	507	/** Returns the velocity of center of mass of this molecule */
324			Vector3d getComVel();
325	gezelter	246
326	gezelter	507	std::string getMoleculeName() {
327			return moleculeName_;
328			}
329	tim	289
330	gezelter	507	friend std::ostream& operator <<(std::ostream& o, Molecule& mol);
331	cli2	1360
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			/**
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			/**
346			* clear all of the properties
347			*/
348			void clearProperties();
349
350			/**
351			* Returns all names of properties
352			* @return all names of properties
353			*/
354			std::vector<std::string> getPropertyNames();
355
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			/**
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	gezelter	1211
370	gezelter	507	private:
371	gezelter	1211
372	gezelter	507	int globalIndex_;
373	gezelter	1211
374	gezelter	507	std::vector<Atom*> atoms_;
375			std::vector<Bond*> bonds_;
376			std::vector<Bend*> bends_;
377			std::vector<Torsion*> torsions_;
378	cli2	1275	std::vector<Inversion*> inversions_;
379	gezelter	507	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	cli2	1360	PropertyMap properties_;
387
388	gezelter	507	};
389	gezelter	2
390	gezelter	246	} //namespace oopse
391			#endif //