ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/trunk/src/primitives/Molecule.hpp

Comparing trunk/src/primitives/Molecule.hpp (file contents):
Revision 1211 by gezelter, Wed Jan 23 16:38:22 2008 UTC vs.
Revision 2052 by gezelter, Fri Jan 9 19:06:35 2015 UTC

#	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, 234107 (2008).
39	+	* [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40	+	* [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41		*/
42
43		/**
#	Line 58 | Line 59
59		#include "primitives/Bond.hpp"
60		#include "primitives/Bend.hpp"
61		#include "primitives/Torsion.hpp"
62	+	#include "primitives/Inversion.hpp"
63		#include "primitives/CutoffGroup.hpp"
64	+	#include "utils/PropertyMap.hpp"
65
63	–	namespace oopse{
66
67	<	class Constraint;
67	>	namespace OpenMD{
68
69	+	class Constraint;
70	+
71		/**
72		* @class Molecule Molecule.hpp "primitives/Molecule.hpp"
73		* @brief
#	Line 71 | Line 75 | namespace oopse{
75		class Molecule {
76		public:
77
78	+	struct HBondDonor {
79	+	Atom* donorAtom;
80	+	Atom* donatedHydrogen;
81	+	};
82	+
83		typedef std::vector<Atom*>::iterator AtomIterator;
84		typedef std::vector<Bond*>::iterator BondIterator;
85		typedef std::vector<Bend*>::iterator BendIterator;
86		typedef std::vector<Torsion*>::iterator TorsionIterator;
87	+	typedef std::vector<Inversion*>::iterator InversionIterator;
88		typedef std::vector<RigidBody*>::iterator RigidBodyIterator;
89		typedef std::vector<CutoffGroup*>::iterator CutoffGroupIterator;
90		typedef std::vector<StuntDouble*>::iterator IntegrableObjectIterator;
91		typedef std::vector<ConstraintPair*>::iterator ConstraintPairIterator;
92		typedef std::vector<ConstraintElem*>::iterator ConstraintElemIterator;
93	<
94	<
95	<	Molecule(int stampId, int globalIndex, const std::string& molName);
93	>	typedef std::vector<Atom*>::iterator FluctuatingChargeIterator;
94	>	typedef std::vector<HBondDonor*>::iterator HBondDonorIterator;
95	>	typedef std::vector<Atom*>::iterator HBondAcceptorIterator;
96	>
97	>	Molecule(int stampId, int globalIndex, const std::string& molName, int region);
98		virtual ~Molecule();
99	<
99	>
100		/**
101		* Returns the global index of this molecule.
102		* @return  the global index of this molecule
#	Line 103 | Line 115 | namespace oopse{
115		int getStampId() {
116		return stampId_;
117		}
118	+	int getRegion() {
119	+	return region_;
120	+	}
121
122		/** Returns the name of the molecule */
123		std::string getType() {
#	Line 111 | Line 126 | namespace oopse{
126
127		/**
128		* Sets the global index of this molecule.
129	<	* @param new global index to be set
129	>	* @param index new global index to be set
130		*/
131		void setGlobalIndex(int index) {
132		globalIndex_ = index;
133		}
134	+
135	+	void setConstrainTotalCharge(bool ctc) {
136	+	constrainTotalCharge_ = ctc;
137	+	}
138
139	<
139	>	bool constrainTotalCharge() {
140	>	return constrainTotalCharge_;
141	>	}
142	>
143		/** add an atom into this molecule */
144		void addAtom(Atom* atom);
145
#	Line 129 | Line 151 | namespace oopse{
151
152		/** add a torsion into this molecule*/
153		void addTorsion(Torsion* torsion);
154	+
155	+	/** add an improper torsion into this molecule*/
156	+	void addInversion(Inversion* inversion);
157
158		/** add a rigidbody into this molecule */
159		void addRigidBody(RigidBody *rb);
#	Line 162 | Line 187 | namespace oopse{
187		unsigned int getNTorsions() {
188		return torsions_.size();
189		}
190	+
191	+	/** Returns the total number of improper torsions in this molecule */
192	+	unsigned int getNInversions() {
193	+	return inversions_.size();
194	+	}
195
196		/** Returns the total number of rigid bodies in this molecule */
197		unsigned int getNRigidBodies() {
#	Line 182 | Line 212 | namespace oopse{
212		unsigned int getNConstraintPairs() {
213		return constraintPairs_.size();
214		}
215	+
216	+	/** Returns the total number of fluctuating charges in this molecule */
217	+	unsigned int getNFluctuatingCharges() {
218	+	return fluctuatingCharges_.size();
219	+	}
220	+	/** Returns the total number of Hydrogen Bond donors in this molecule */
221	+	unsigned int getNHBondDonors() {
222	+	return hBondDonors_.size();
223	+	}
224
225	+	/** Returns the total number of Hydrogen Bond acceptors in this molecule */
226	+	unsigned int getNHBondAcceptors() {
227	+	return hBondAcceptors_.size();
228	+	}
229	+
230		Atom* getAtomAt(unsigned int i) {
231		assert(i < atoms_.size());
232		return atoms_[i];
#	Line 233 | Line 277 | namespace oopse{
277		++i;
278		return (i == torsions_.end()) ? NULL : *i;
279		}
280	+
281	+	Inversion* beginInversion(std::vector<Inversion*>::iterator& i) {
282	+	i = inversions_.begin();
283	+	return (i == inversions_.end()) ? NULL : *i;
284	+	}
285
286	+	Inversion* nextInversion(std::vector<Inversion*>::iterator& i) {
287	+	++i;
288	+	return (i == inversions_.end()) ? NULL : *i;
289	+	}
290	+
291		RigidBody* beginRigidBody(std::vector<RigidBody*>::iterator& i) {
292		i = rigidBodies_.begin();
293		return (i == rigidBodies_.end()) ? NULL : *i;
#	Line 282 | Line 336 | namespace oopse{
336		ConstraintElem* nextConstraintElem(std::vector<ConstraintElem*>::iterator& i) {
337		++i;
338		return (i == constraintElems_.end()) ? NULL : *i;
339	+	}
340	+
341	+	Atom* beginFluctuatingCharge(std::vector<Atom*>::iterator& i) {
342	+	i = fluctuatingCharges_.begin();
343	+	return (i == fluctuatingCharges_.end()) ? NULL : *i;
344		}
345
346	+	Atom* nextFluctuatingCharge(std::vector<Atom*>::iterator& i) {
347	+	++i;
348	+	return (i == fluctuatingCharges_.end()) ? NULL : *i;
349	+	}
350	+
351	+	HBondDonor* beginHBondDonor(std::vector<HBondDonor*>::iterator& i) {
352	+	i = hBondDonors_.begin();
353	+	return (i == hBondDonors_.end()) ? NULL : *i;
354	+	}
355	+
356	+	HBondDonor* nextHBondDonor(std::vector<HBondDonor*>::iterator& i) {
357	+	++i;
358	+	return (i == hBondDonors_.end()) ? NULL : *i;
359	+	}
360	+
361	+	Atom* beginHBondAcceptor(std::vector<Atom*>::iterator& i) {
362	+	i = hBondAcceptors_.begin();
363	+	return (i == hBondAcceptors_.end()) ? NULL : *i;
364	+	}
365	+
366	+	Atom* nextHBondAcceptor(std::vector<Atom*>::iterator& i) {
367	+	++i;
368	+	return (i == hBondAcceptors_.end()) ? NULL : *i;
369	+	}
370	+
371	+
372		/**
373		* Returns the total potential energy of short range interaction
374		* of this molecule
#	Line 293 | Line 378 | namespace oopse{
378		/** get total mass of this molecule */
379		RealType getMass();
380
381	<	/** return the center of mass of this molecule */
381	>	/**
382	>	* Returns the current center of mass position of this molecule.
383	>	*
384	>	* @return the center of mass position of this molecule.
385	>	*/
386		Vector3d getCom();
387
388	+	/**
389	+	* Returns the center of mass position of this molecule in
390	+	* specified snapshot
391	+	*
392	+	* @return the center of mass position of this molecule
393	+	* @param snapshotNo
394	+	*/
395	+	Vector3d getCom(int snapshotNo);
396	+
397	+
398		/** Moves the center of this molecule */
399		void moveCom(const Vector3d& delta);
400
#	Line 307 | Line 406 | namespace oopse{
406		}
407
408		friend std::ostream& operator <<(std::ostream& o, Molecule& mol);
409	+
410	+	//below functions are just forward functions
411	+	/**
412	+	* Adds property into property map
413	+	* @param genData GenericData to be added into PropertyMap
414	+	*/
415	+	void addProperty(GenericData* genData);
416	+
417	+	/**
418	+	* Removes property from PropertyMap by name
419	+	* @param propName the name of property to be removed
420	+	*/
421	+	void removeProperty(const std::string& propName);
422	+
423	+	/**
424	+	* clear all of the properties
425	+	*/
426	+	void clearProperties();
427	+
428	+	/**
429	+	* Returns all names of properties
430	+	* @return all names of properties
431	+	*/
432	+	std::vector<std::string> getPropertyNames();
433	+
434	+	/**
435	+	* Returns all of the properties in PropertyMap
436	+	* @return all of the properties in PropertyMap
437	+	*/
438	+	std::vector<GenericData*> getProperties();
439	+
440	+	/**
441	+	* Returns property
442	+	* @param propName name of property
443	+	* @return a pointer point to property with propName. If no property named propName
444	+	* exists, return NULL
445	+	*/
446	+	GenericData* getPropertyByName(const std::string& propName);
447
448		private:
449
#	Line 316 | Line 453 | namespace oopse{
453		std::vector<Bond*> bonds_;
454		std::vector<Bend*> bends_;
455		std::vector<Torsion*> torsions_;
456	+	std::vector<Inversion*> inversions_;
457		std::vector<RigidBody*> rigidBodies_;
458		std::vector<StuntDouble*> integrableObjects_;
459		std::vector<CutoffGroup*> cutoffGroups_;
460		std::vector<ConstraintPair*> constraintPairs_;
461		std::vector<ConstraintElem*> constraintElems_;
462	+	std::vector<Atom*> fluctuatingCharges_;
463	+	std::vector<HBondDonor*> hBondDonors_;
464	+	std::vector<Atom*> hBondAcceptors_;
465	+
466		int stampId_;
467	+	int region_;
468		std::string moleculeName_;
469	+	PropertyMap properties_;
470	+	bool constrainTotalCharge_;
471	+
472		};
473
474	<	} //namespace oopse
474	>	} //namespace OpenMD
475		#endif //

Comparing trunk/src/primitives/Molecule.hpp (property svn:keywords):
Revision 1211 by gezelter, Wed Jan 23 16:38:22 2008 UTC vs.
Revision 2052 by gezelter, Fri Jan 9 19:06:35 2015 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

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