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:	3520
Committed:	Mon Sep 7 16:31:51 2009 UTC (15 years, 10 months ago) by cli2
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	2204	/*
2	gezelter	1930	* 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	1490
49	gezelter	1930	#ifndef PRIMITIVES_MOLECULE_HPP
50			#define PRIMITIVES_MOLECULE_HPP
51	gezelter	1490	#include <vector>
52	gezelter	1930	#include <iostream>
53	gezelter	1490
54	gezelter	1930	#include "constraints/ConstraintPair.hpp"
55			#include "math/Vector3.hpp"
56	tim	1492	#include "primitives/Atom.hpp"
57			#include "primitives/RigidBody.hpp"
58	gezelter	1930	#include "primitives/Bond.hpp"
59			#include "primitives/Bend.hpp"
60			#include "primitives/Torsion.hpp"
61	cli2	3430	#include "primitives/Inversion.hpp"
62	tim	1492	#include "primitives/CutoffGroup.hpp"
63	cli2	3520	#include "utils/PropertyMap.hpp"
64	gezelter	1490
65	gezelter	1930	namespace oopse{
66	gezelter	1490
67	gezelter	2204	class Constraint;
68	gezelter	1490
69	gezelter	2204	/**
70			* @class Molecule Molecule.hpp "primitives/Molecule.hpp"
71			* @brief
72			*/
73			class Molecule {
74			public:
75	gezelter	1490
76	gezelter	2204	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	3430	typedef std::vector<Inversion*>::iterator InversionIterator;
81	gezelter	2204	typedef std::vector<RigidBody*>::iterator RigidBodyIterator;
82			typedef std::vector<CutoffGroup*>::iterator CutoffGroupIterator;
83	gezelter	3320	typedef std::vector<StuntDouble*>::iterator IntegrableObjectIterator;
84	gezelter	2204	typedef std::vector<ConstraintPair*>::iterator ConstraintPairIterator;
85			typedef std::vector<ConstraintElem*>::iterator ConstraintElemIterator;
86	gezelter	3320
87
88	gezelter	2204	Molecule(int stampId, int globalIndex, const std::string& molName);
89			virtual ~Molecule();
90	gezelter	3320
91	gezelter	2204	/**
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	3320
99	gezelter	2204	/**
100			* Returns the stamp id of this molecule
101	gezelter	3320	* @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	2204	*/
106			int getStampId() {
107			return stampId_;
108			}
109	gezelter	3320
110	gezelter	2204	/** Returns the name of the molecule */
111			std::string getType() {
112			return moleculeName_;
113			}
114	gezelter	3320
115	gezelter	2204	/**
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	3320
123
124	gezelter	2204	/** add an atom into this molecule */
125			void addAtom(Atom* atom);
126	gezelter	3320
127	gezelter	2204	/** add a bond into this molecule */
128			void addBond(Bond* bond);
129	gezelter	3320
130	gezelter	2204	/** add a bend into this molecule */
131			void addBend(Bend* bend);
132	gezelter	3320
133	gezelter	2204	/** add a torsion into this molecule*/
134			void addTorsion(Torsion* torsion);
135	cli2	3430
136			/** add an improper torsion into this molecule*/
137			void addInversion(Inversion* inversion);
138	gezelter	3320
139	gezelter	2204	/** add a rigidbody into this molecule */
140			void addRigidBody(RigidBody *rb);
141	gezelter	3320
142	gezelter	2204	/** add a cutoff group into this molecule */
143			void addCutoffGroup(CutoffGroup* cp);
144	gezelter	3320
145	gezelter	2204	void addConstraintPair(ConstraintPair* consPair);
146	gezelter	3320
147	gezelter	2204	void addConstraintElem(ConstraintElem* consElem);
148	gezelter	3320
149	gezelter	2204	/** */
150			void complete();
151	gezelter	3320
152	gezelter	2204	/** Returns the total number of atoms in this molecule */
153			unsigned int getNAtoms() {
154			return atoms_.size();
155			}
156	gezelter	3320
157	gezelter	2204	/** Returns the total number of bonds in this molecule */
158			unsigned int getNBonds(){
159			return bonds_.size();
160			}
161	gezelter	3320
162	gezelter	2204	/** Returns the total number of bends in this molecule */
163			unsigned int getNBends() {
164			return bends_.size();
165			}
166	gezelter	3320
167	gezelter	2204	/** Returns the total number of torsions in this molecule */
168			unsigned int getNTorsions() {
169			return torsions_.size();
170			}
171	cli2	3430
172			/** Returns the total number of improper torsions in this molecule */
173			unsigned int getNInversions() {
174			return inversions_.size();
175			}
176	gezelter	3320
177	gezelter	2204	/** Returns the total number of rigid bodies in this molecule */
178			unsigned int getNRigidBodies() {
179			return rigidBodies_.size();
180			}
181	gezelter	3320
182	gezelter	2204	/** Returns the total number of integrable objects in this molecule */
183			unsigned int getNIntegrableObjects() {
184			return integrableObjects_.size();
185			}
186	gezelter	3320
187	gezelter	2204	/** Returns the total number of cutoff groups in this molecule */
188			unsigned int getNCutoffGroups() {
189			return cutoffGroups_.size();
190			}
191	gezelter	3320
192	gezelter	2204	/** Returns the total number of constraints in this molecule */
193			unsigned int getNConstraintPairs() {
194			return constraintPairs_.size();
195			}
196	gezelter	3320
197	gezelter	2204	Atom* getAtomAt(unsigned int i) {
198			assert(i < atoms_.size());
199			return atoms_[i];
200			}
201	gezelter	3320
202	gezelter	2204	RigidBody* getRigidBodyAt(unsigned int i) {
203			assert(i < rigidBodies_.size());
204			return rigidBodies_[i];
205			}
206	gezelter	3320
207	gezelter	2204	Atom* beginAtom(std::vector<Atom*>::iterator& i) {
208			i = atoms_.begin();
209			return (i == atoms_.end()) ? NULL : *i;
210			}
211	gezelter	3320
212	gezelter	2204	Atom* nextAtom(std::vector<Atom*>::iterator& i) {
213			++i;
214			return (i == atoms_.end()) ? NULL : *i;
215			}
216	gezelter	3320
217	gezelter	2204	Bond* beginBond(std::vector<Bond*>::iterator& i) {
218			i = bonds_.begin();
219			return (i == bonds_.end()) ? NULL : *i;
220			}
221	gezelter	3320
222	gezelter	2204	Bond* nextBond(std::vector<Bond*>::iterator& i) {
223			++i;
224			return (i == bonds_.end()) ? NULL : *i;
225	gezelter	3320
226	gezelter	2204	}
227	gezelter	3320
228	gezelter	2204	Bend* beginBend(std::vector<Bend*>::iterator& i) {
229			i = bends_.begin();
230			return (i == bends_.end()) ? NULL : *i;
231			}
232	gezelter	3320
233	gezelter	2204	Bend* nextBend(std::vector<Bend*>::iterator& i) {
234			++i;
235			return (i == bends_.end()) ? NULL : *i;
236			}
237	gezelter	3320
238	gezelter	2204	Torsion* beginTorsion(std::vector<Torsion*>::iterator& i) {
239			i = torsions_.begin();
240			return (i == torsions_.end()) ? NULL : *i;
241			}
242	gezelter	3320
243	gezelter	2204	Torsion* nextTorsion(std::vector<Torsion*>::iterator& i) {
244			++i;
245			return (i == torsions_.end()) ? NULL : *i;
246			}
247	cli2	3430
248			Inversion* beginInversion(std::vector<Inversion*>::iterator& i) {
249			i = inversions_.begin();
250			return (i == inversions_.end()) ? NULL : *i;
251			}
252	gezelter	3320
253	cli2	3430	Inversion* nextInversion(std::vector<Inversion*>::iterator& i) {
254			++i;
255			return (i == inversions_.end()) ? NULL : *i;
256			}
257
258	gezelter	2204	RigidBody* beginRigidBody(std::vector<RigidBody*>::iterator& i) {
259			i = rigidBodies_.begin();
260			return (i == rigidBodies_.end()) ? NULL : *i;
261			}
262	gezelter	3320
263	gezelter	2204	RigidBody* nextRigidBody(std::vector<RigidBody*>::iterator& i) {
264			++i;
265			return (i == rigidBodies_.end()) ? NULL : *i;
266			}
267	gezelter	3320
268	gezelter	2204	StuntDouble* beginIntegrableObject(std::vector<StuntDouble*>::iterator& i) {
269			i = integrableObjects_.begin();
270			return (i == integrableObjects_.end()) ? NULL : *i;
271			}
272	gezelter	3320
273	gezelter	2204	StuntDouble* nextIntegrableObject(std::vector<StuntDouble*>::iterator& i) {
274			++i;
275			return (i == integrableObjects_.end()) ? NULL : *i;
276			}
277	gezelter	3320
278	gezelter	2204	CutoffGroup* beginCutoffGroup(std::vector<CutoffGroup*>::iterator& i) {
279			i = cutoffGroups_.begin();
280			return (i == cutoffGroups_.end()) ? NULL : *i;
281			}
282	gezelter	1930
283	gezelter	3320	CutoffGroup* nextCutoffGroup(std::vector<CutoffGroup*>::iterator& i) {
284	gezelter	2204	++i;
285			return (i == cutoffGroups_.end()) ? NULL : *i;
286			}
287	gezelter	3320
288	gezelter	2204	ConstraintPair* beginConstraintPair(std::vector<ConstraintPair*>::iterator& i) {
289			i = constraintPairs_.begin();
290			return (i == constraintPairs_.end()) ? NULL : *i;
291			}
292	gezelter	3320
293	gezelter	2204	ConstraintPair* nextConstraintPair(std::vector<ConstraintPair*>::iterator& i) {
294			++i;
295			return (i == constraintPairs_.end()) ? NULL : *i;
296			}
297	gezelter	3320
298	gezelter	2204	ConstraintElem* beginConstraintElem(std::vector<ConstraintElem*>::iterator& i) {
299			i = constraintElems_.begin();
300			return (i == constraintElems_.end()) ? NULL : *i;
301			}
302	gezelter	3320
303	gezelter	2204	ConstraintElem* nextConstraintElem(std::vector<ConstraintElem*>::iterator& i) {
304			++i;
305			return (i == constraintElems_.end()) ? NULL : *i;
306			}
307	cli2	3520
308	gezelter	3320	/**
309			* Returns the total potential energy of short range interaction
310			* of this molecule
311			*/
312	tim	2759	RealType getPotential();
313	gezelter	3320
314	gezelter	2204	/** get total mass of this molecule */
315	tim	2759	RealType getMass();
316	gezelter	3320
317	gezelter	2204	/** return the center of mass of this molecule */
318			Vector3d getCom();
319	gezelter	3320
320	gezelter	2204	/** Moves the center of this molecule */
321			void moveCom(const Vector3d& delta);
322	gezelter	3320
323	gezelter	2204	/** Returns the velocity of center of mass of this molecule */
324			Vector3d getComVel();
325	gezelter	1930
326	gezelter	2204	std::string getMoleculeName() {
327			return moleculeName_;
328			}
329	tim	1973
330	gezelter	2204	friend std::ostream& operator <<(std::ostream& o, Molecule& mol);
331	cli2	3520
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	3320
370	gezelter	2204	private:
371	gezelter	3320
372	gezelter	2204	int globalIndex_;
373	gezelter	3320
374	gezelter	2204	std::vector<Atom*> atoms_;
375			std::vector<Bond*> bonds_;
376			std::vector<Bend*> bends_;
377			std::vector<Torsion*> torsions_;
378	cli2	3430	std::vector<Inversion*> inversions_;
379	gezelter	2204	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	3520	PropertyMap properties_;
387
388	gezelter	2204	};
389	gezelter	1490
390	gezelter	1930	} //namespace oopse
391			#endif //