ViewVC Help

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

root/OpenMD/branches/development/src/primitives/StuntDouble.hpp

Comparing:
trunk/src/primitives/StuntDouble.hpp (file contents), Revision 334 by tim, Mon Feb 14 17:57:01 2005 UTC vs.
branches/development/src/primitives/StuntDouble.hpp (file contents), Revision 1627 by gezelter, Tue Sep 13 22:05:04 2011 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 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, 24107 (2008).
39	+	* [4]  Vardeman & Gezelter, in progress (2009).
40		*/
41
42		/**
#	Line 46 | Line 46
46		* @version 1.0
47		*/
48
49	<	#ifndef PRIMITIVES_STUNTDOUBLE_HPP
50	<	#define PRIMITIVES_STUNTDOUBLE_HPP
49	>	#ifndef PRIMITIVES_STUNTDOUBLE_HPP
50	>	#define PRIMITIVES_STUNTDOUBLE_HPP
51
52		#include <vector>
53
#	Line 58 | Line 58
58		#include "utils/PropertyMap.hpp"
59		#include "brains/Snapshot.hpp"
60		#include "brains/SnapshotManager.hpp"
61	<	namespace oopse{
61	>	namespace OpenMD{
62
63
64
65		/**
66		* @class StuntDouble StuntDouble.hpp "Primitives/StuntDouble.hpp"
67		* @brief
68	+	*     "Don't move, or you're dead! Stand up! Captain, we've got them!"
69	+	*
70	+	*     "Spectacular stunt, my friends, but all for naught. Turn around
71	+	*      please. Ha. What a pity. What a pity. So, Princess, you thought
72	+	*      you could outwit the imperious forces of...."
73	+	*
74	+	*     "You idiots! These are not them. You've captured their stunt
75	+	*      doubles! Search the area. Find them! Find them!"
76	+	*
77		* StuntDouble is a very strange idea.  A StuntDouble stands in for
78		* some object that can be manipulated by the Integrators or
79		* Minimizers.  Some of the manipulable objects are Atoms, some are
80		* DirectionalAtoms, and some are RigidBodies.  StuntDouble
81		* provides an interface for the Integrators and Minimizers to use,
82		* and does some preliminary sanity checking so that the program
83	<	* doesn't try to do something stupid like torque an Atom
84	<	* @note the dynamic data of stuntdouble will be stored outside of the class
83	>	* doesn't try to do something stupid like torque an Atom (The
84	>	* quotes above are from Spaceballs...)
85	>	*
86	>	* @note the dynamic data of stuntDouble will be stored outside of the class
87		*/
88	<	class StuntDouble{
89	<	public:
88	>	class StuntDouble{
89	>	public:
90
91	<	enum ObjectType{
92	<	otAtom,
93	<	otDAtom,
94	<	otRigidBody
95	<	};
91	>	enum ObjectType{
92	>	otAtom,
93	>	otDAtom,
94	>	otRigidBody
95	>	};
96
97	<	virtual ~StuntDouble();
97	>	virtual ~StuntDouble();
98
99	<	/**
100	<	* Returns the global index of this stuntdouble.
101	<	* @return  the global index of this stuntdouble
102	<	*/
103	<	int getGlobalIndex() {
104	<	return globalIndex_;
105	<	}
99	>	/**
100	>	* Returns the global index of this stuntDouble.
101	>	* @return  the global index of this stuntDouble
102	>	*/
103	>	int getGlobalIndex() {
104	>	return globalIndex_;
105	>	}
106
107	<	/**
108	<	* Sets the global index of this stuntdouble.
109	<	* @param new global index to be set
110	<	*/
111	<	void setGlobalIndex(int index) {
112	<	globalIndex_ = index;
113	<	}
114	<
115	<	/**
116	<	* Returns the local index of this stuntdouble
117	<	* @return the local index of this stuntdouble
118	<	*/
119	<	int getLocalIndex() {
120	<	return localIndex_;
121	<	}
107	>	/**
108	>	* Sets the global index of this stuntDouble.
109	>	* @param new global index to be set
110	>	*/
111	>	void setGlobalIndex(int index) {
112	>	globalIndex_ = index;
113	>	}
114	>
115	>	/**
116	>	* Returns the local index of this stuntDouble
117	>	* @return the local index of this stuntDouble
118	>	*/
119	>	int getLocalIndex() {
120	>	return localIndex_;
121	>	}
122
123	<	/**
124	<	* Sets the local index of this stuntdouble
125	<	* @param index new index to be set
126	<	*/
127	<	void setLocalIndex(int index) {
128	<	localIndex_ = index;
129	<	}
123	>	/**
124	>	* Sets the local index of this stuntDouble
125	>	* @param index new index to be set
126	>	*/
127	>	void setLocalIndex(int index) {
128	>	localIndex_ = index;
129	>	}
130	>
131	>	int getGlobalIntegrableObjectIndex(){
132	>	return globalIntegrableObjectIndex_;
133	>	}
134	>	void setGlobalIntegrableObjectIndex(int index) {
135	>	globalIntegrableObjectIndex_ = index;
136	>	}
137
138	<	/**
139	<	* Sets the Snapshot Manager of this stuntdouble
140	<	*/
141	<	void setSnapshotManager(SnapshotManager* sman) {
142	<	snapshotMan_ = sman;
143	<	}
138	>	/**
139	>	* Sets the Snapshot Manager of this stuntDouble
140	>	*/
141	>	void setSnapshotManager(SnapshotManager* sman) {
142	>	snapshotMan_ = sman;
143	>	}
144
145	<	/**
146	<	* Tests if this stuntdouble is an atom
147	<	* @return true is this stuntdouble is an atom(or a directional atom), return false otherwise
148	<	*/
149	<	bool isAtom(){
150	<	return objType_ == otAtom || objType_ == otDAtom;
151	<	}
145	>	/**
146	>	* Tests if this stuntDouble is an atom
147	>	* @return true is this stuntDouble is an atom(or a directional atom), return false otherwise
148	>	*/
149	>	bool isAtom(){
150	>	return objType_ == otAtom || objType_ == otDAtom;
151	>	}
152
153	<	/**
154	<	* Tests if this stuntdouble is an directional atom
155	<	* @return true if this stuntdouble is an directional atom, return false otherwise
156	<	*/
157	<	bool isDirectionalAtom(){
158	<	return objType_ == otDAtom;
159	<	}
153	>	/**
154	>	* Tests if this stuntDouble is an directional atom
155	>	* @return true if this stuntDouble is an directional atom, return false otherwise
156	>	*/
157	>	bool isDirectionalAtom(){
158	>	return objType_ == otDAtom;
159	>	}
160
161	<	/**
162	<	* Tests if this stuntdouble is a rigid body.
163	<	* @return true if this stuntdouble is a rigid body, otherwise return false
164	<	*/
165	<	bool isRigidBody(){
166	<	return objType_ == otRigidBody;
167	<	}
161	>	/**
162	>	* Tests if this stuntDouble is a rigid body.
163	>	* @return true if this stuntDouble is a rigid body, otherwise return false
164	>	*/
165	>	bool isRigidBody(){
166	>	return objType_ == otRigidBody;
167	>	}
168
169	<	/**
170	<	* Tests if this stuntdouble is a directional one.
171	<	* @return true is this stuntdouble is a directional atom or a rigid body, return false otherwise
172	<	*/
173	<	bool isDirectional(){
174	<	return isDirectionalAtom() || isRigidBody();
175	<	}
169	>	/**
170	>	* Tests if this stuntDouble is a directional one.
171	>	* @return true is this stuntDouble is a directional atom or a rigid body, return false otherwise
172	>	*/
173	>	bool isDirectional(){
174	>	return isDirectionalAtom() || isRigidBody();
175	>	}
176
177	<	/**
178	<	* Returns the previous position of this stuntdouble
179	<	* @return the position of this stuntdouble
180	<	*/
181	<	Vector3d getPrevPos() {
182	<	return ((snapshotMan_->getPrevSnapshot())->*storage_).position[localIndex_];
183	<	}
184	<
185	<	/**
168	<	* Returns the current position of this stuntdouble
169	<	* @return the position of this stuntdouble
170	<	*/
171	<	Vector3d getPos() {
172	<	return ((snapshotMan_->getCurrentSnapshot())->*storage_).position[localIndex_];
173	<	}
177	>	/**
178	>	* Freezes out all velocity, angular velocity, forces and torques
179	>	* on this StuntDouble.  Also computes the number of frozen degrees
180	>	* of freedom.
181	>	* @return the total number of frozen degrees of freedom
182	>	*/
183	>	int freeze() {
184	>
185	>	int fdf = 3;
186
187	<	/**
188	<	* Returns the position of this stuntdouble in specified snapshot
189	<	* @return the position of this stuntdouble
190	<	* @param snapshotNo
191	<	*/
192	<	Vector3d getPos(int snapshotNo) {
193	<	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).position[localIndex_];
194	<	}
187	>	setVel(V3Zero);
188	>	setFrc(V3Zero);
189	>	if (isDirectional()){
190	>	setJ(V3Zero);
191	>	setTrq(V3Zero);
192	>	if (isLinear())
193	>	fdf +=2;
194	>	else
195	>	fdf +=3;
196	>	}
197	>	return fdf;
198	>	}
199
200	<	/**
201	<	* Sets  the previous position of this stuntdouble
202	<	* @param pos  new position
203	<	* @see #getPos
204	<	*/
205	<	void setPrevPos(const Vector3d& pos) {
206	<	((snapshotMan_->getPrevSnapshot())->*storage_).position[localIndex_] = pos;
191	<	}
200	>	/**
201	>	* Returns the previous position of this stuntDouble
202	>	* @return the position of this stuntDouble
203	>	*/
204	>	Vector3d getPrevPos() {
205	>	return ((snapshotMan_->getPrevSnapshot())->*storage_).position[localIndex_];
206	>	}
207
208	<	/**
209	<	* Sets  the current position of this stuntdouble
210	<	* @param pos  new position
211	<	*/
212	<	void setPos(const Vector3d& pos) {
213	<	DataStorage&  data = snapshotMan_->getCurrentSnapshot()->*storage_;
214	<	data.position[localIndex_] = pos;
200	<	//((snapshotMan_->getCurrentSnapshot())->*storage_).position[localIndex_] = pos;
201	<	}
208	>	/**
209	>	* Returns the current position of this stuntDouble
210	>	* @return the position of this stuntDouble
211	>	*/
212	>	Vector3d getPos() {
213	>	return ((snapshotMan_->getCurrentSnapshot())->*storage_).position[localIndex_];
214	>	}
215
216	<	/**
217	<	* Sets  the position of this stuntdouble in specified snapshot
218	<	* @param pos position to be set
219	<	* @param snapshotNo
220	<	* @see #getPos
221	<	*/
222	<	void setPos(const Vector3d& pos, int snapshotNo) {
216	>	/**
217	>	* Returns the position of this stuntDouble in specified snapshot
218	>	* @return the position of this stuntDouble
219	>	* @param snapshotNo
220	>	*/
221	>	Vector3d getPos(int snapshotNo) {
222	>	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).position[localIndex_];
223	>	}
224
225	<	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).position[localIndex_] = pos;
225	>	/**
226	>	* Sets  the previous position of this stuntDouble
227	>	* @param pos  new position
228	>	* @see #getPos
229	>	*/
230	>	void setPrevPos(const Vector3d& pos) {
231	>	((snapshotMan_->getPrevSnapshot())->*storage_).position[localIndex_] = pos;
232	>	}
233	>
234	>	/**
235	>	* Sets  the current position of this stuntDouble
236	>	* @param pos  new position
237	>	*/
238	>	void setPos(const Vector3d& pos) {
239	>	DataStorage&  data = snapshotMan_->getCurrentSnapshot()->*storage_;
240	>	data.position[localIndex_] = pos;
241	>	//((snapshotMan_->getCurrentSnapshot())->*storage_).position[localIndex_] = pos;
242	>	}
243
244	<	}
244	>	/**
245	>	* Sets  the position of this stuntDouble in specified snapshot
246	>	* @param pos position to be set
247	>	* @param snapshotNo
248	>	* @see #getPos
249	>	*/
250	>	void setPos(const Vector3d& pos, int snapshotNo) {
251	>
252	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).position[localIndex_] = pos;
253	>
254	>	}
255
256	<	/**
257	<	* Returns the previous velocity of this stuntdouble
258	<	* @return the velocity of this stuntdouble
259	<	*/
260	<	Vector3d getPrevVel() {
261	<	return ((snapshotMan_->getPrevSnapshot())->*storage_).velocity[localIndex_];
262	<	}
256	>	/**
257	>	* Returns the previous velocity of this stuntDouble
258	>	* @return the velocity of this stuntDouble
259	>	*/
260	>	Vector3d getPrevVel() {
261	>	return ((snapshotMan_->getPrevSnapshot())->*storage_).velocity[localIndex_];
262	>	}
263
264	<	/**
265	<	* Returns the current velocity of this stuntdouble
266	<	* @return the velocity of this stuntdouble
267	<	*/
268	<	Vector3d getVel() {
269	<	return ((snapshotMan_->getCurrentSnapshot())->*storage_).velocity[localIndex_];
270	<	}
264	>	/**
265	>	* Returns the current velocity of this stuntDouble
266	>	* @return the velocity of this stuntDouble
267	>	*/
268	>	Vector3d getVel() {
269	>	return ((snapshotMan_->getCurrentSnapshot())->*storage_).velocity[localIndex_];
270	>	}
271
272	<	/**
273	<	* Returns the velocity of this stuntdouble in specified snapshot
274	<	* @return the velocity of this stuntdouble
275	<	* @param snapshotNo
276	<	*/
277	<	Vector3d getVel(int snapshotNo) {
278	<	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).velocity[localIndex_];
279	<	}
272	>	/**
273	>	* Returns the velocity of this stuntDouble in specified snapshot
274	>	* @return the velocity of this stuntDouble
275	>	* @param snapshotNo
276	>	*/
277	>	Vector3d getVel(int snapshotNo) {
278	>	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).velocity[localIndex_];
279	>	}
280
281	<	/**
282	<	* Sets  the previous velocity of this stuntdouble
283	<	* @param vel  new velocity
284	<	* @see #getVel
285	<	*/
286	<	void setPrevVel(const Vector3d& vel) {
287	<	((snapshotMan_->getPrevSnapshot())->*storage_).velocity[localIndex_] = vel;
288	<	}
281	>	/**
282	>	* Sets  the previous velocity of this stuntDouble
283	>	* @param vel  new velocity
284	>	* @see #getVel
285	>	*/
286	>	void setPrevVel(const Vector3d& vel) {
287	>	((snapshotMan_->getPrevSnapshot())->*storage_).velocity[localIndex_] = vel;
288	>	}
289
290	<	/**
291	<	* Sets  the current velocity of this stuntdouble
292	<	* @param vel  new velocity
293	<	*/
294	<	void setVel(const Vector3d& vel) {
295	<	((snapshotMan_->getCurrentSnapshot())->*storage_).velocity[localIndex_] = vel;
296	<	}
290	>	/**
291	>	* Sets  the current velocity of this stuntDouble
292	>	* @param vel  new velocity
293	>	*/
294	>	void setVel(const Vector3d& vel) {
295	>	((snapshotMan_->getCurrentSnapshot())->*storage_).velocity[localIndex_] = vel;
296	>	}
297
298	<	/**
299	<	* Sets  the velocity of this stuntdouble in specified snapshot
300	<	* @param vel velocity to be set
301	<	* @param snapshotNo
302	<	* @see #getVel
303	<	*/
304	<	void setVel(const Vector3d& vel, int snapshotNo) {
305	<	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).velocity[localIndex_] = vel;
306	<	}
298	>	/**
299	>	* Sets  the velocity of this stuntDouble in specified snapshot
300	>	* @param vel velocity to be set
301	>	* @param snapshotNo
302	>	* @see #getVel
303	>	*/
304	>	void setVel(const Vector3d& vel, int snapshotNo) {
305	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).velocity[localIndex_] = vel;
306	>	}
307
308	<	/**
309	<	* Returns the previous rotation matrix of this stuntdouble
310	<	* @return the rotation matrix of this stuntdouble
311	<	*/
312	<	RotMat3x3d getPrevA() {
313	<	return ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_];
314	<	}
308	>	/**
309	>	* Returns the previous rotation matrix of this stuntDouble
310	>	* @return the rotation matrix of this stuntDouble
311	>	*/
312	>	RotMat3x3d getPrevA() {
313	>	return ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_];
314	>	}
315
316	<	/**
317	<	* Returns the current rotation matrix of this stuntdouble
318	<	* @return the rotation matrix of this stuntdouble
319	<	*/
320	<	RotMat3x3d getA() {
321	<	return ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_];
322	<	}
316	>	/**
317	>	* Returns the current rotation matrix of this stuntDouble
318	>	* @return the rotation matrix of this stuntDouble
319	>	*/
320	>	RotMat3x3d getA() {
321	>	return ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_];
322	>	}
323
324	<	/**
325	<	* Returns the rotation matrix of this stuntdouble in specified snapshot
326	<	*
327	<	* @return the rotation matrix of this stuntdouble
328	<	* @param snapshotNo
329	<	*/
330	<	RotMat3x3d getA(int snapshotNo) {
331	<	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_];
332	<	}
324	>	/**
325	>	* Returns the rotation matrix of this stuntDouble in specified snapshot
326	>	*
327	>	* @return the rotation matrix of this stuntDouble
328	>	* @param snapshotNo
329	>	*/
330	>	RotMat3x3d getA(int snapshotNo) {
331	>	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_];
332	>	}
333
334	<	/**
335	<	* Sets  the previous rotation matrix of this stuntdouble
336	<	* @param a  new rotation matrix
337	<	* @see #getA
338	<	*/
339	<	virtual void setPrevA(const RotMat3x3d& a) {
340	<	((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_] = a;
341	<	}
342	<
343	<	/**
344	<	* Sets  the current rotation matrix of this stuntdouble
345	<	* @param a  new rotation matrix
346	<	*/
347	<	virtual void setA(const RotMat3x3d& a) {
348	<	((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_] = a;
349	<	}
334	>	/**
335	>	* Sets  the previous rotation matrix of this stuntDouble
336	>	* @param a  new rotation matrix
337	>	* @see #getA
338	>	*/
339	>	virtual void setPrevA(const RotMat3x3d& a) {
340	>	((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_] = a;
341	>	}
342	>
343	>	/**
344	>	* Sets  the current rotation matrix of this stuntDouble
345	>	* @param a  new rotation matrix
346	>	*/
347	>	virtual void setA(const RotMat3x3d& a) {
348	>	((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_] = a;
349	>	}
350
351	<	/**
352	<	* Sets  the rotation matrix of this stuntdouble in specified snapshot
353	<	* @param a rotation matrix to be set
354	<	* @param snapshotNo
355	<	* @see #getA
356	<	*/
357	<	virtual void setA(const RotMat3x3d& a, int snapshotNo) {
358	<	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_] = a;
359	<	}
351	>	/**
352	>	* Sets  the rotation matrix of this stuntDouble in specified snapshot
353	>	* @param a rotation matrix to be set
354	>	* @param snapshotNo
355	>	* @see #getA
356	>	*/
357	>	virtual void setA(const RotMat3x3d& a, int snapshotNo) {
358	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_] = a;
359	>	}
360
361	<	/**
362	<	* Returns the previous angular momentum of this stuntdouble (body-fixed).
363	<	* @return the angular momentum of this stuntdouble
364	<	*/
365	<	Vector3d getPrevJ() {
366	<	return ((snapshotMan_->getPrevSnapshot())->*storage_).angularMomentum[localIndex_];
367	<	}
361	>	/**
362	>	* Returns the previous angular momentum of this stuntDouble (body-fixed).
363	>	* @return the angular momentum of this stuntDouble
364	>	*/
365	>	Vector3d getPrevJ() {
366	>	return ((snapshotMan_->getPrevSnapshot())->*storage_).angularMomentum[localIndex_];
367	>	}
368
369	<	/**
370	<	* Returns the current angular momentum of this stuntdouble (body -fixed).
371	<	* @return the angular momentum of this stuntdouble
372	<	*/
373	<	Vector3d getJ() {
374	<	return ((snapshotMan_->getCurrentSnapshot())->*storage_).angularMomentum[localIndex_];
375	<	}
369	>	/**
370	>	* Returns the current angular momentum of this stuntDouble (body -fixed).
371	>	* @return the angular momentum of this stuntDouble
372	>	*/
373	>	Vector3d getJ() {
374	>	return ((snapshotMan_->getCurrentSnapshot())->*storage_).angularMomentum[localIndex_];
375	>	}
376
377	<	/**
378	<	* Returns the angular momentum of this stuntdouble in specified snapshot (body-fixed).
379	<	* @return the angular momentum of this stuntdouble
380	<	* @param snapshotNo
381	<	*/
382	<	Vector3d getJ(int snapshotNo) {
383	<	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).angularMomentum[localIndex_];
384	<	}
377	>	/**
378	>	* Returns the angular momentum of this stuntDouble in specified snapshot (body-fixed).
379	>	* @return the angular momentum of this stuntDouble
380	>	* @param snapshotNo
381	>	*/
382	>	Vector3d getJ(int snapshotNo) {
383	>	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).angularMomentum[localIndex_];
384	>	}
385
386	<	/**
387	<	* Sets  the previous angular momentum of this stuntdouble (body-fixed).
388	<	* @param angMom  new angular momentum
389	<	* @see #getJ
390	<	*/
391	<	void setPrevJ(const Vector3d& angMom) {
392	<	((snapshotMan_->getPrevSnapshot())->*storage_).angularMomentum[localIndex_] = angMom;
393	<	}
386	>	/**
387	>	* Sets  the previous angular momentum of this stuntDouble (body-fixed).
388	>	* @param angMom  new angular momentum
389	>	* @see #getJ
390	>	*/
391	>	void setPrevJ(const Vector3d& angMom) {
392	>	((snapshotMan_->getPrevSnapshot())->*storage_).angularMomentum[localIndex_] = angMom;
393	>	}
394
395	<	/**
396	<	* Sets  the current angular momentum of this stuntdouble (body-fixed).
397	<	* @param angMom  new angular momentum
398	<	*/
399	<	void setJ(const Vector3d& angMom) {
400	<	((snapshotMan_->getCurrentSnapshot())->*storage_).angularMomentum[localIndex_] = angMom;
401	<	}
395	>	/**
396	>	* Sets  the current angular momentum of this stuntDouble (body-fixed).
397	>	* @param angMom  new angular momentum
398	>	*/
399	>	void setJ(const Vector3d& angMom) {
400	>	((snapshotMan_->getCurrentSnapshot())->*storage_).angularMomentum[localIndex_] = angMom;
401	>	}
402
403	<	/**
404	<	* Sets the angular momentum of this stuntdouble in specified snapshot(body-fixed).
405	<	* @param angMom angular momentum to be set
406	<	* @param snapshotNo
407	<	* @see #getJ
408	<	*/
409	<	void setJ(const Vector3d& angMom, int snapshotNo) {
410	<	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).angularMomentum[localIndex_] = angMom;
411	<	}
412	<
413	<	/**
414	<	* Returns the previous quaternion of this stuntdouble
415	<	* @return the quaternion of this stuntdouble
416	<	*/
417	<	Quat4d getPrevQ() {
418	<	return ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_].toQuaternion();
419	<	}
403	>	/**
404	>	* Sets the angular momentum of this stuntDouble in specified snapshot(body-fixed).
405	>	* @param angMom angular momentum to be set
406	>	* @param snapshotNo
407	>	* @see #getJ
408	>	*/
409	>	void setJ(const Vector3d& angMom, int snapshotNo) {
410	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).angularMomentum[localIndex_] = angMom;
411	>	}
412	>
413	>	/**
414	>	* Returns system Center of Mass for stuntDouble frame from snapshot
415	>	*
416	>	*/
417	>	Vector3d getCOM(){
418	>	return (snapshotMan_->getCurrentSnapshot())->getCOM();
419	>	}
420	>
421	>	/**
422	>	* Returns system Center of Mass velocity for stuntDouble frame from snapshot
423	>	*
424	>	*/
425	>
426	>	Vector3d getCOMvel(){
427	>	return (snapshotMan_->getCurrentSnapshot())->getCOMvel();
428	>	}
429	>
430	>	/**
431	>	* Returns system Center of Mass angular momentum for stuntDouble frame from snapshot
432	>	*
433	>	*/
434	>	Vector3d getCOMw(){
435	>	return (snapshotMan_->getCurrentSnapshot())->getCOMw();
436	>	}
437	>
438	>	/**
439	>	* Returns system Center of Mass for stuntDouble frame from snapshot
440	>	*
441	>	*/
442	>	Vector3d getCOM(int snapshotNo){
443	>	return (snapshotMan_->getSnapshot(snapshotNo))->getCOM();
444	>	}
445	>
446	>	/**
447	>	* Returns system Center of Mass velocity for stuntDouble frame from snapshot
448	>	*
449	>	*/
450	>
451	>	Vector3d getCOMvel(int snapshotNo){
452	>	return (snapshotMan_->getSnapshot(snapshotNo))->getCOMvel();
453	>	}
454	>
455	>	/**
456	>	* Returns system Center of Mass angular momentum for stuntDouble frame from snapshot
457	>	*
458	>	*/
459	>	Vector3d getCOMw(int snapshotNo){
460	>	return (snapshotMan_->getSnapshot(snapshotNo))->getCOMw();
461	>	}
462	>
463	>	/**
464	>	* Returns the previous quaternion of this stuntDouble
465	>	* @return the quaternion of this stuntDouble
466	>	*/
467	>	Quat4d getPrevQ() {
468	>	return ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_].toQuaternion();
469	>	}
470
471	<	/**
472	<	* Returns the current quaternion of this stuntdouble
473	<	* @return the quaternion of this stuntdouble
474	<	*/
475	<	Quat4d getQ() {
476	<	return ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_].toQuaternion();
477	<	}
471	>	/**
472	>	* Returns the current quaternion of this stuntDouble
473	>	* @return the quaternion of this stuntDouble
474	>	*/
475	>	Quat4d getQ() {
476	>	return ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_].toQuaternion();
477	>	}
478
479	<	/**
480	<	* Returns the quaternion of this stuntdouble in specified snapshot
481	<	* @return the quaternion of this stuntdouble
482	<	* @param snapshotNo
483	<	*/
484	<	Quat4d getQ(int snapshotNo) {
485	<	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_].toQuaternion();
486	<	}
479	>	/**
480	>	* Returns the quaternion of this stuntDouble in specified snapshot
481	>	* @return the quaternion of this stuntDouble
482	>	* @param snapshotNo
483	>	*/
484	>	Quat4d getQ(int snapshotNo) {
485	>	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_].toQuaternion();
486	>	}
487
488	<	/**
489	<	* Sets  the previous quaternion of this stuntdouble
490	<	* @param q  new quaternion
491	<	* @note actual storage data is rotation matrix
492	<	*/
493	<	void setPrevQ(const Quat4d& q) {
494	<	setPrevA(q);
495	<	}
488	>	/**
489	>	* Sets  the previous quaternion of this stuntDouble
490	>	* @param q  new quaternion
491	>	* @note actual storage data is rotation matrix
492	>	*/
493	>	void setPrevQ(const Quat4d& q) {
494	>	setPrevA(q);
495	>	}
496
497	<	/**
498	<	* Sets  the current quaternion of this stuntdouble
499	<	* @param q  new quaternion
500	<	* @note actual storage data is rotation matrix
501	<	*/
502	<	void setQ(const Quat4d& q) {
503	<	setA(q);
504	<	}
497	>	/**
498	>	* Sets  the current quaternion of this stuntDouble
499	>	* @param q  new quaternion
500	>	* @note actual storage data is rotation matrix
501	>	*/
502	>	void setQ(const Quat4d& q) {
503	>	setA(q);
504	>	}
505
506	<	/**
507	<	* Sets  the quaternion of this stuntdouble in specified snapshot
508	<	*
509	<	* @param q quaternion to be set
510	<	* @param snapshotNo
511	<	* @note actual storage data is rotation matrix
512	<	*/
513	<	void setQ(const Quat4d& q, int snapshotNo) {
514	<	setA(q, snapshotNo);
515	<	}
506	>	/**
507	>	* Sets  the quaternion of this stuntDouble in specified snapshot
508	>	*
509	>	* @param q quaternion to be set
510	>	* @param snapshotNo
511	>	* @note actual storage data is rotation matrix
512	>	*/
513	>	void setQ(const Quat4d& q, int snapshotNo) {
514	>	setA(q, snapshotNo);
515	>	}
516
517	<	/**
518	<	* Returns the previous euler angles of this stuntdouble
519	<	* @return the euler angles of this stuntdouble
520	<	*/
521	<	Vector3d getPrevEuler() {
522	<	return ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_].toEulerAngles();
523	<	}
517	>	/**
518	>	* Returns the previous euler angles of this stuntDouble
519	>	* @return the euler angles of this stuntDouble
520	>	*/
521	>	Vector3d getPrevEuler() {
522	>	return ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_].toEulerAngles();
523	>	}
524
525	<	/**
526	<	* Returns the current euler angles of this stuntdouble
527	<	* @return the euler angles of this stuntdouble
528	<	*/
529	<	Vector3d getEuler() {
530	<	return ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_].toEulerAngles();
531	<	}
525	>	/**
526	>	* Returns the current euler angles of this stuntDouble
527	>	* @return the euler angles of this stuntDouble
528	>	*/
529	>	Vector3d getEuler() {
530	>	return ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_].toEulerAngles();
531	>	}
532
533	<	/**
534	<	* Returns the euler angles of this stuntdouble in specified snapshot.
535	<	* @return the euler angles of this stuntdouble
536	<	* @param snapshotNo
537	<	*/
538	<	Vector3d getEuler(int snapshotNo) {
539	<	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_].toEulerAngles();
540	<	}
533	>	/**
534	>	* Returns the euler angles of this stuntDouble in specified snapshot.
535	>	* @return the euler angles of this stuntDouble
536	>	* @param snapshotNo
537	>	*/
538	>	Vector3d getEuler(int snapshotNo) {
539	>	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_].toEulerAngles();
540	>	}
541
542	<	/**
543	<	* Sets  the previous euler angles of this stuntdouble.
544	<	* @param euler  new euler angles
545	<	* @see #getEuler
546	<	* @note actual storage data is rotation matrix
547	<	*/
548	<	void setPrevEuler(const Vector3d& euler) {
549	<	((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_] = euler;
550	<	}
542	>	/**
543	>	* Sets  the previous euler angles of this stuntDouble.
544	>	* @param euler  new euler angles
545	>	* @see #getEuler
546	>	* @note actual storage data is rotation matrix
547	>	*/
548	>	void setPrevEuler(const Vector3d& euler) {
549	>	((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_] = euler;
550	>	}
551
552	<	/**
553	<	* Sets  the current euler angles of this stuntdouble
554	<	* @param euler  new euler angles
555	<	*/
556	<	void setEuler(const Vector3d& euler) {
557	<	((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_] = euler;
558	<	}
552	>	/**
553	>	* Sets  the current euler angles of this stuntDouble
554	>	* @param euler  new euler angles
555	>	*/
556	>	void setEuler(const Vector3d& euler) {
557	>	((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_] = euler;
558	>	}
559
560	<	/**
561	<	* Sets  the euler angles  of this stuntdouble in specified snapshot
562	<	*
563	<	* @param euler euler angles to be set
564	<	* @param snapshotNo
565	<	* @note actual storage data is rotation matrix
566	<	*/
567	<	void setEuler(const Vector3d& euler, int snapshotNo) {
568	<	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_] = euler;
569	<	}
560	>	/**
561	>	* Sets  the euler angles  of this stuntDouble in specified snapshot
562	>	*
563	>	* @param euler euler angles to be set
564	>	* @param snapshotNo
565	>	* @note actual storage data is rotation matrix
566	>	*/
567	>	void setEuler(const Vector3d& euler, int snapshotNo) {
568	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_] = euler;
569	>	}
570
571	<	/**
572	<	* Returns the previous unit vectors of this stuntdouble
573	<	* @return the unit vectors of this stuntdouble
574	<	*/
575	<	RotMat3x3d getPrevElectroFrame() {
576	<	return ((snapshotMan_->getPrevSnapshot())->*storage_).electroFrame[localIndex_];
577	<	}
571	>	/**
572	>	* Returns the previous unit vectors of this stuntDouble
573	>	* @return the unit vectors of this stuntDouble
574	>	*/
575	>	RotMat3x3d getPrevElectroFrame() {
576	>	return ((snapshotMan_->getPrevSnapshot())->*storage_).electroFrame[localIndex_];
577	>	}
578
579	<	/**
580	<	* Returns the current unit vectors of this stuntdouble
581	<	* @return the unit vectors of this stuntdouble
582	<	*/
583	<	RotMat3x3d getElectroFrame() {
584	<	return ((snapshotMan_->getCurrentSnapshot())->*storage_).electroFrame[localIndex_];
585	<	}
579	>	/**
580	>	* Returns the current unit vectors of this stuntDouble
581	>	* @return the unit vectors of this stuntDouble
582	>	*/
583	>	RotMat3x3d getElectroFrame() {
584	>	return ((snapshotMan_->getCurrentSnapshot())->*storage_).electroFrame[localIndex_];
585	>	}
586
587	<	/**
588	<	* Returns the unit vectors of this stuntdouble in specified snapshot
589	<	*
590	<	* @return the unit vectors of this stuntdouble
591	<	* @param snapshotNo
592	<	*/
593	<	RotMat3x3d getElectroFrame(int snapshotNo) {
594	<	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).electroFrame[localIndex_];
595	<	}
587	>	/**
588	>	* Returns the unit vectors of this stuntDouble in specified snapshot
589	>	*
590	>	* @return the unit vectors of this stuntDouble
591	>	* @param snapshotNo
592	>	*/
593	>	RotMat3x3d getElectroFrame(int snapshotNo) {
594	>	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).electroFrame[localIndex_];
595	>	}
596
597	<	/**
598	<	* Returns the previous force of this stuntdouble
599	<	* @return the force of this stuntdouble
600	<	*/
601	<	Vector3d getPrevFrc() {
602	<	return ((snapshotMan_->getPrevSnapshot())->*storage_).force[localIndex_];
603	<	}
597	>	/**
598	>	* Returns the previous force of this stuntDouble
599	>	* @return the force of this stuntDouble
600	>	*/
601	>	Vector3d getPrevFrc() {
602	>	return ((snapshotMan_->getPrevSnapshot())->*storage_).force[localIndex_];
603	>	}
604
605	<	/**
606	<	* Returns the current force of this stuntdouble
607	<	* @return the force of this stuntdouble
608	<	*/
609	<	Vector3d getFrc() {
610	<	return ((snapshotMan_->getCurrentSnapshot())->*storage_).force[localIndex_];
611	<	}
605	>	/**
606	>	* Returns the current force of this stuntDouble
607	>	* @return the force of this stuntDouble
608	>	*/
609	>	Vector3d getFrc() {
610	>	return ((snapshotMan_->getCurrentSnapshot())->*storage_).force[localIndex_];
611	>	}
612
613	<	/**
614	<	* Returns the force of this stuntdouble in specified snapshot
615	<	*
616	<	* @return the force of this stuntdouble
617	<	* @param snapshotNo
618	<	*/
619	<	Vector3d getFrc(int snapshotNo) {
620	<	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).force[localIndex_];
621	<	}
613	>	/**
614	>	* Returns the force of this stuntDouble in specified snapshot
615	>	*
616	>	* @return the force of this stuntDouble
617	>	* @param snapshotNo
618	>	*/
619	>	Vector3d getFrc(int snapshotNo) {
620	>	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).force[localIndex_];
621	>	}
622
623	<	/**
624	<	* Sets  the previous force of this stuntdouble
625	<	*
626	<	* @param frc  new force
627	<	* @see #getFrc
628	<	*/
629	<	void setPrevFrc(const Vector3d& frc) {
630	<	((snapshotMan_->getPrevSnapshot())->*storage_).force[localIndex_] = frc;
631	<	}
623	>	/**
624	>	* Sets  the previous force of this stuntDouble
625	>	*
626	>	* @param frc  new force
627	>	* @see #getFrc
628	>	*/
629	>	void setPrevFrc(const Vector3d& frc) {
630	>	((snapshotMan_->getPrevSnapshot())->*storage_).force[localIndex_] = frc;
631	>	}
632
633	<	/**
634	<	* Sets  the current force of this stuntdouble
635	<	* @param frc  new force
636	<	*/
637	<	void setFrc(const Vector3d& frc) {
638	<	((snapshotMan_->getCurrentSnapshot())->*storage_).force[localIndex_] = frc;
639	<	}
633	>	/**
634	>	* Sets  the current force of this stuntDouble
635	>	* @param frc  new force
636	>	*/
637	>	void setFrc(const Vector3d& frc) {
638	>	((snapshotMan_->getCurrentSnapshot())->*storage_).force[localIndex_] = frc;
639	>	}
640
641	<	/**
642	<	* Sets  the force of this stuntdouble in specified snapshot
643	<	*
644	<	* @param frc force to be set
645	<	* @param snapshotNo
646	<	* @see #getFrc
647	<	*/
648	<	void setFrc(const Vector3d& frc, int snapshotNo) {
649	<	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).force[localIndex_] = frc;
650	<	}
641	>	/**
642	>	* Sets  the force of this stuntDouble in specified snapshot
643	>	*
644	>	* @param frc force to be set
645	>	* @param snapshotNo
646	>	* @see #getFrc
647	>	*/
648	>	void setFrc(const Vector3d& frc, int snapshotNo) {
649	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).force[localIndex_] = frc;
650	>	}
651
652	<	/**
653	<	* Adds force into the previous force of this stuntdouble
654	<	*
655	<	* @param frc  new force
656	<	* @see #getFrc
657	<	*/
658	<	void addPrevFrc(const Vector3d& frc) {
659	<	((snapshotMan_->getPrevSnapshot())->*storage_).force[localIndex_] += frc;
660	<	}
652	>	/**
653	>	* Adds force into the previous force of this stuntDouble
654	>	*
655	>	* @param frc  new force
656	>	* @see #getFrc
657	>	*/
658	>	void addPrevFrc(const Vector3d& frc) {
659	>	((snapshotMan_->getPrevSnapshot())->*storage_).force[localIndex_] += frc;
660	>	}
661
662	<	/**
663	<	* Adds force into the current force of this stuntdouble
664	<	* @param frc  new force
665	<	*/
666	<	void addFrc(const Vector3d& frc) {
667	<	((snapshotMan_->getCurrentSnapshot())->*storage_).force[localIndex_] += frc;
668	<	}
662	>	/**
663	>	* Adds force into the current force of this stuntDouble
664	>	* @param frc  new force
665	>	*/
666	>	void addFrc(const Vector3d& frc) {
667	>	((snapshotMan_->getCurrentSnapshot())->*storage_).force[localIndex_] += frc;
668	>	}
669
670	<	/**
671	<	* Adds force into the force of this stuntdouble in specified snapshot
672	<	*
673	<	* @param frc force to be set
674	<	* @param snapshotNo
675	<	* @see #getFrc
676	<	*/
677	<	void addFrc(const Vector3d& frc, int snapshotNo) {
678	<	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).force[localIndex_] += frc;
679	<	}
670	>	/**
671	>	* Adds force into the force of this stuntDouble in specified snapshot
672	>	*
673	>	* @param frc force to be set
674	>	* @param snapshotNo
675	>	* @see #getFrc
676	>	*/
677	>	void addFrc(const Vector3d& frc, int snapshotNo) {
678	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).force[localIndex_] += frc;
679	>	}
680
681	<	/**
682	<	* Returns the previous torque of this stuntdouble
683	<	* @return the torque of this stuntdouble
684	<	*/
685	<	Vector3d getPrevTrq() {
686	<	return ((snapshotMan_->getPrevSnapshot())->*storage_).torque[localIndex_];
687	<	}
681	>	/**
682	>	* Returns the previous torque of this stuntDouble
683	>	* @return the torque of this stuntDouble
684	>	*/
685	>	Vector3d getPrevTrq() {
686	>	return ((snapshotMan_->getPrevSnapshot())->*storage_).torque[localIndex_];
687	>	}
688
689	<	/**
690	<	* Returns the current torque of this stuntdouble
691	<	* @return the torque of this stuntdouble
692	<	*/
693	<	Vector3d getTrq() {
694	<	return ((snapshotMan_->getCurrentSnapshot())->*storage_).torque[localIndex_];
695	<	}
689	>	/**
690	>	* Returns the current torque of this stuntDouble
691	>	* @return the torque of this stuntDouble
692	>	*/
693	>	Vector3d getTrq() {
694	>	return ((snapshotMan_->getCurrentSnapshot())->*storage_).torque[localIndex_];
695	>	}
696
697	<	/**
698	<	* Returns the torque of this stuntdouble in specified snapshot
699	<	*
700	<	* @return the torque of this stuntdouble
701	<	* @param snapshotNo
702	<	*/
703	<	Vector3d getTrq(int snapshotNo) {
704	<	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).torque[localIndex_];
705	<	}
697	>	/**
698	>	* Returns the torque of this stuntDouble in specified snapshot
699	>	*
700	>	* @return the torque of this stuntDouble
701	>	* @param snapshotNo
702	>	*/
703	>	Vector3d getTrq(int snapshotNo) {
704	>	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).torque[localIndex_];
705	>	}
706
707	<	/**
708	<	* Sets  the previous torque of this stuntdouble
709	<	*
710	<	* @param trq  new torque
711	<	* @see #getTrq
712	<	*/
713	<	void setPrevTrq(const Vector3d& trq) {
714	<	((snapshotMan_->getPrevSnapshot())->*storage_).torque[localIndex_] = trq;
715	<	}
707	>	/**
708	>	* Sets  the previous torque of this stuntDouble
709	>	*
710	>	* @param trq  new torque
711	>	* @see #getTrq
712	>	*/
713	>	void setPrevTrq(const Vector3d& trq) {
714	>	((snapshotMan_->getPrevSnapshot())->*storage_).torque[localIndex_] = trq;
715	>	}
716
717	<	/**
718	<	* Sets  the current torque of this stuntdouble
719	<	* @param trq  new torque
720	<	*/
721	<	void setTrq(const Vector3d& trq) {
722	<	((snapshotMan_->getCurrentSnapshot())->*storage_).torque[localIndex_] = trq;
723	<	}
717	>	/**
718	>	* Sets  the current torque of this stuntDouble
719	>	* @param trq  new torque
720	>	*/
721	>	void setTrq(const Vector3d& trq) {
722	>	((snapshotMan_->getCurrentSnapshot())->*storage_).torque[localIndex_] = trq;
723	>	}
724
725	<	/**
726	<	* Sets  the torque of this stuntdouble in specified snapshot
727	<	*
728	<	* @param trq torque to be set
729	<	* @param snapshotNo
730	<	* @see #getTrq
731	<	*/
732	<	void setTrq(const Vector3d& trq, int snapshotNo) {
733	<	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).torque[localIndex_] = trq;
734	<	}
725	>	/**
726	>	* Sets  the torque of this stuntDouble in specified snapshot
727	>	*
728	>	* @param trq torque to be set
729	>	* @param snapshotNo
730	>	* @see #getTrq
731	>	*/
732	>	void setTrq(const Vector3d& trq, int snapshotNo) {
733	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).torque[localIndex_] = trq;
734	>	}
735
736	<	/**
737	<	* Adds torque into the previous torque of this stuntdouble
738	<	*
739	<	* @param trq  new torque
740	<	* @see #getTrq
741	<	*/
742	<	void addPrevTrq(const Vector3d& trq) {
743	<	((snapshotMan_->getPrevSnapshot())->*storage_).torque[localIndex_] += trq;
744	<	}
736	>	/**
737	>	* Adds torque into the previous torque of this stuntDouble
738	>	*
739	>	* @param trq  new torque
740	>	* @see #getTrq
741	>	*/
742	>	void addPrevTrq(const Vector3d& trq) {
743	>	((snapshotMan_->getPrevSnapshot())->*storage_).torque[localIndex_] += trq;
744	>	}
745
746	<	/**
747	<	* Adds torque into the current torque of this stuntdouble
748	<	* @param trq  new torque
749	<	*/
750	<	void addTrq(const Vector3d& trq) {
751	<	((snapshotMan_->getCurrentSnapshot())->*storage_).torque[localIndex_] += trq;
752	<	}
746	>	/**
747	>	* Adds torque into the current torque of this stuntDouble
748	>	* @param trq  new torque
749	>	*/
750	>	void addTrq(const Vector3d& trq) {
751	>	((snapshotMan_->getCurrentSnapshot())->*storage_).torque[localIndex_] += trq;
752	>	}
753
754	<	/**
755	<	* Adds torque into the torque of this stuntdouble in specified snapshot
756	<	*
757	<	* @param trq torque to be add
758	<	* @param snapshotNo
759	<	* @see #getTrq
760	<	*/
761	<	void addTrq(const Vector3d& trq, int snapshotNo) {
762	<	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).torque[localIndex_] += trq;
763	<	}
754	>	/**
755	>	* Adds torque into the torque of this stuntDouble in specified snapshot
756	>	*
757	>	* @param trq torque to be add
758	>	* @param snapshotNo
759	>	* @see #getTrq
760	>	*/
761	>	void addTrq(const Vector3d& trq, int snapshotNo) {
762	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).torque[localIndex_] += trq;
763	>	}
764
765
675	–	/**
676	–	* Returns the previous z-angle of this stuntdouble
677	–	* @return the z-angle of this stuntdouble
678	–	*/
679	–	double getPrevZangle() {
680	–	return ((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_];
681	–	}
682	–
683	–	/**
684	–	* Returns the current z-angle of this stuntdouble
685	–	* @return the z-angle of this stuntdouble
686	–	*/
687	–	double getZangle() {
688	–	return ((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_];
689	–	}
766
767	<	/**
768	<	* Returns the z-angle of this stuntdouble in specified snapshot
769	<	* @return the z-angle of this stuntdouble
770	<	* @param snapshotNo
771	<	*/
772	<	double getZangle(int snapshotNo) {
773	<	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_];
698	<	}
699	<
700	<	/**
701	<	* Sets  the previous z-angle of this stuntdouble
702	<	* @param angle  new z-angle
703	<	* @see #getZangle
704	<	*/
705	<	void setPrevZangle(double angle) {
706	<	((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_] = angle;
707	<	}
767	>	/**
768	>	* Returns the previous particlePot of this stuntDouble
769	>	* @return the particlePot of this stuntDouble
770	>	*/
771	>	RealType getPrevParticlePot() {
772	>	return ((snapshotMan_->getPrevSnapshot())->*storage_).particlePot[localIndex_];
773	>	}
774
775	<	/**
776	<	* Sets  the current z-angle of this stuntdouble
777	<	* @param angle  new z-angle
778	<	*/
779	<	void setZangle(double angle) {
780	<	((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_] = angle;
781	<	}
775	>	/**
776	>	* Returns the current particlePot of this stuntDouble
777	>	* @return the particlePot of this stuntDouble
778	>	*/
779	>	RealType getParticlePot() {
780	>	return ((snapshotMan_->getCurrentSnapshot())->*storage_).particlePot[localIndex_];
781	>	}
782
783	<	/**
784	<	* Sets  the z-angle of this stuntdouble in specified snapshot
785	<	* @param angle z-angle to be set
786	<	* @param snapshotNo
787	<	* @see #getZangle
788	<	*/
789	<	void setZangle(double angle, int snapshotNo) {
790	<	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_] = angle;
791	<	}
783	>	/**
784	>	* Returns the particlePot of this stuntDouble in specified snapshot
785	>	*
786	>	* @return the particlePot of this stuntDouble
787	>	* @param snapshotNo
788	>	*/
789	>	RealType getParticlePot(int snapshotNo) {
790	>	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_];
791	>	}
792
793	<	/**
794	<	* Adds z-angle into the previous z-angle of this stuntdouble
795	<	* @param angle  new z-angle
796	<	* @see #getZangle
797	<	*/
798	<	void addPrevZangle(double angle) {
799	<	((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_] += angle;
800	<	}
793	>	/**
794	>	* Sets  the previous particlePot of this stuntDouble
795	>	*
796	>	* @param particlePot  new particlePot
797	>	* @see #getParticlePot
798	>	*/
799	>	void setPrevParticlePot(const RealType& particlePot) {
800	>	((snapshotMan_->getPrevSnapshot())->*storage_).particlePot[localIndex_] = particlePot;
801	>	}
802
803	<	/**
804	<	* Adds z-angle into the current z-angle of this stuntdouble
805	<	* @param angle  new z-angle
806	<	*/
807	<	void addZangle(double angle) {
808	<	((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_] += angle;
809	<	}
803	>	/**
804	>	* Sets  the current particlePot of this stuntDouble
805	>	* @param particlePot  new particlePot
806	>	*/
807	>	void setParticlePot(const RealType& particlePot) {
808	>	((snapshotMan_->getCurrentSnapshot())->*storage_).particlePot[localIndex_] = particlePot;
809	>	}
810
811	<	/**
812	<	* Adds z-angle into the z-angle of this stuntdouble in specified snapshot
813	<	* @param angle z-angle to be add
814	<	* @param snapshotNo
815	<	* @see #getZangle
816	<	*/
817	<	void addZangle(double angle, int snapshotNo) {
818	<	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_] += angle;
819	<	}
811	>	/**
812	>	* Sets  the particlePot of this stuntDouble in specified snapshot
813	>	*
814	>	* @param particlePot particlePot to be set
815	>	* @param snapshotNo
816	>	* @see #getParticlePot
817	>	*/
818	>	void setParticlePot(const RealType& particlePot, int snapshotNo) {
819	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_] = particlePot;
820	>	}
821
822	<	/** Set the force of this stuntdouble to zero */
823	<	void zeroForcesAndTorques();
824	<	/**
825	<	* Returns the inertia tensor of this stuntdouble
826	<	* @return the inertia tensor of this stuntdouble
827	<	*/
828	<	virtual Mat3x3d getI() = 0;
822	>	/**
823	>	* Adds particlePot into the previous particlePot of this stuntDouble
824	>	*
825	>	* @param particlePot  new particlePot
826	>	* @see #getParticlePot
827	>	*/
828	>	void addPrevParticlePot(const RealType& particlePot) {
829	>	((snapshotMan_->getPrevSnapshot())->*storage_).particlePot[localIndex_] += particlePot;
830	>	}
831	>
832	>	/**
833	>	* Adds particlePot into the current particlePot of this stuntDouble
834	>	* @param particlePot  new particlePot
835	>	*/
836	>	void addParticlePot(const RealType& particlePot) {
837	>	((snapshotMan_->getCurrentSnapshot())->*storage_).particlePot[localIndex_] += particlePot;
838	>	}
839
840	<	/**
841	<	* Returns the gradient of this stuntdouble
842	<	* @return the gradient of this stuntdouble
843	<	*/
844	<	virtual std::vector<double> getGrad() = 0;
840	>	/**
841	>	* Adds particlePot into the particlePot of this stuntDouble in specified snapshot
842	>	*
843	>	* @param particlePot particlePot to be add
844	>	* @param snapshotNo
845	>	* @see #getParticlePot
846	>	*/
847	>	void addParticlePot(const RealType& particlePot, int snapshotNo) {
848	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_] += particlePot;
849	>	}
850
768	–	/**
769	–	* Tests the  if this stuntdouble is a  linear rigidbody
770	–	*
771	–	* @return true if this stuntdouble is a  linear rigidbody, otherwise return false
772	–	* @note atom and directional atom will always return false
773	–	*
774	–	* @see #linearAxis
775	–	*/
776	–	bool isLinear() {
777	–	return linear_;
778	–	}
851
852	<	/**
853	<	* Returns the linear axis of the rigidbody, atom and directional atom will always return -1
854	<	*
855	<	* @return the linear axis of the rigidbody
856	<	*
857	<	* @see #isLinear
858	<	*/
859	<	int linearAxis() {
860	<	return linearAxis_;
861	<	}
852	>	/**
853	>	* Returns the previous z-angle of this stuntDouble
854	>	* @return the z-angle of this stuntDouble
855	>	*/
856	>	RealType getPrevZangle() {
857	>	return ((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_];
858	>	}
859	>
860	>	/**
861	>	* Returns the current z-angle of this stuntDouble
862	>	* @return the z-angle of this stuntDouble
863	>	*/
864	>	RealType getZangle() {
865	>	return ((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_];
866	>	}
867
868	<	/** Returns the mass of this stuntdouble */
869	<	double getMass() {
870	<	return mass_;
871	<	}
868	>	/**
869	>	* Returns the z-angle of this stuntDouble in specified snapshot
870	>	* @return the z-angle of this stuntDouble
871	>	* @param snapshotNo
872	>	*/
873	>	RealType getZangle(int snapshotNo) {
874	>	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_];
875	>	}
876
877	<	/**
878	<	* Sets the mass of this stuntdoulbe
879	<	* @param mass the mass to be set
880	<	*/
881	<	void setMass(double mass) {
882	<	mass_ = mass;
883	<	}
877	>	/**
878	>	* Sets  the previous z-angle of this stuntDouble
879	>	* @param angle  new z-angle
880	>	* @see #getZangle
881	>	*/
882	>	void setPrevZangle(RealType angle) {
883	>	((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_] = angle;
884	>	}
885	>
886	>	/**
887	>	* Sets  the current z-angle of this stuntDouble
888	>	* @param angle  new z-angle
889	>	*/
890	>	void setZangle(RealType angle) {
891	>	((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_] = angle;
892	>	}
893
894	<	/** Returns the name of this stuntdouble */
895	<	virtual std::string getType() = 0;
894	>	/**
895	>	* Sets  the z-angle of this stuntDouble in specified snapshot
896	>	* @param angle z-angle to be set
897	>	* @param snapshotNo
898	>	* @see #getZangle
899	>	*/
900	>	void setZangle(RealType angle, int snapshotNo) {
901	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_] = angle;
902	>	}
903	>
904	>	/**
905	>	* Adds z-angle into the previous z-angle of this stuntDouble
906	>	* @param angle  new z-angle
907	>	* @see #getZangle
908	>	*/
909	>	void addPrevZangle(RealType angle) {
910	>	((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_] += angle;
911	>	}
912	>
913	>	/**
914	>	* Adds z-angle into the current z-angle of this stuntDouble
915	>	* @param angle  new z-angle
916	>	*/
917	>	void addZangle(RealType angle) {
918	>	((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_] += angle;
919	>	}
920	>
921	>	/**
922	>	* Adds z-angle into the z-angle of this stuntDouble in specified snapshot
923	>	* @param angle z-angle to be add
924	>	* @param snapshotNo
925	>	* @see #getZangle
926	>	*/
927	>	void addZangle(RealType angle, int snapshotNo) {
928	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_] += angle;
929	>	}
930	>
931	>	/** Set the force of this stuntDouble to zero */
932	>	void zeroForcesAndTorques();
933	>	/**
934	>	* Returns the inertia tensor of this stuntDouble
935	>	* @return the inertia tensor of this stuntDouble
936	>	*/
937	>	virtual Mat3x3d getI() = 0;
938	>
939	>	/**
940	>	* Returns the gradient of this stuntDouble
941	>	* @return the gradient of this stuntDouble
942	>	*/
943	>	virtual std::vector<RealType> getGrad() = 0;
944	>
945	>	/**
946	>	* Tests the  if this stuntDouble is a  linear rigidbody
947	>	*
948	>	* @return true if this stuntDouble is a  linear rigidbody, otherwise return false
949	>	* @note atom and directional atom will always return false
950	>	*
951	>	* @see #linearAxis
952	>	*/
953	>	bool isLinear() {
954	>	return linear_;
955	>	}
956	>
957	>	/**
958	>	* Returns the linear axis of the rigidbody, atom and directional atom will always return -1
959	>	*
960	>	* @return the linear axis of the rigidbody
961	>	*
962	>	* @see #isLinear
963	>	*/
964	>	int linearAxis() {
965	>	return linearAxis_;
966	>	}
967	>
968	>	/** Returns the mass of this stuntDouble */
969	>	RealType getMass() {
970	>	return mass_;
971	>	}
972	>
973	>	/**
974	>	* Sets the mass of this stuntdoulbe
975	>	* @param mass the mass to be set
976	>	*/
977	>	void setMass(RealType mass) {
978	>	mass_ = mass;
979	>	}
980	>
981	>	/** Returns the name of this stuntDouble */
982	>	virtual std::string getType() = 0;
983
984	<	/** Sets the name of this stuntdouble*/
985	<	virtual void setType(const std::string& name) {}
984	>	/** Sets the name of this stuntDouble*/
985	>	virtual void setType(const std::string& name) {}
986
987	<	/**
988	<	* Converts a lab fixed vector to a body fixed vector.
989	<	* @return body fixed vector
990	<	* @param v lab fixed vector
991	<	*/
992	<	Vector3d lab2Body(const Vector3d& v) {
993	<	return getA() * v;
994	<	}
987	>	/**
988	>	* Converts a lab fixed vector to a body fixed vector.
989	>	* @return body fixed vector
990	>	* @param v lab fixed vector
991	>	*/
992	>	Vector3d lab2Body(const Vector3d& v) {
993	>	return getA() * v;
994	>	}
995
996	<	Vector3d lab2Body(const Vector3d& v, int frame) {
997	<	return getA(frame) * v;
998	<	}
996	>	Vector3d lab2Body(const Vector3d& v, int frame) {
997	>	return getA(frame) * v;
998	>	}
999
1000	<	/**
1001	<	* Converts a body fixed vector to a lab fixed vector.
1002	<	* @return corresponding lab fixed vector
1003	<	* @param v body fixed vector
1004	<	*/
1005	<	Vector3d body2Lab(const Vector3d& v){
1006	<	return getA().transpose() * v;
1007	<	}
1000	>	/**
1001	>	* Converts a body fixed vector to a lab fixed vector.
1002	>	* @return corresponding lab fixed vector
1003	>	* @param v body fixed vector
1004	>	*/
1005	>	Vector3d body2Lab(const Vector3d& v){
1006	>	return getA().transpose() * v;
1007	>	}
1008
1009	<	Vector3d body2Lab(const Vector3d& v, int frame){
1010	<	return getA(frame).transpose() * v;
1011	<	}
835	<	/**
836	<	* <p>
837	<	* The purpose of the Visitor Pattern is to encapsulate an operation that you want to perform on
838	<	* the elements of a data structure. In this way, you can change the operation being performed
839	<	* on a structure without the need of changing the classes of the elements that you are operating
840	<	* on. Using a Visitor pattern allows you to decouple the classes for the data structure and the
841	<	* algorithms used upon them
842	<	* </p>
843	<	* @param v visitor
844	<	*/
845	<	virtual void accept(BaseVisitor* v) = 0;
1009	>	Vector3d body2Lab(const Vector3d& v, int frame){
1010	>	return getA(frame).transpose() * v;
1011	>	}
1012
1013	<	//below functions are just forward functions
1014	<	/**
1015	<	* Adds property into property map
1016	<	* @param genData GenericData to be added into PropertyMap
1017	<	*/
1018	<	void addProperty(GenericData* genData);
1013	>	/**
1014	>	* <p>
1015	>	* The purpose of the Visitor Pattern is to encapsulate an
1016	>	* operation that you want to perform on the elements of a data
1017	>	* structure. In this way, you can change the operation being
1018	>	* performed on a structure without the need of changing the
1019	>	* classes of the elements that you are operating on. Using a
1020	>	* Visitor pattern allows you to decouple the classes for the data
1021	>	* structure and the algorithms used upon them
1022	>	* </p>
1023	>	* @param v visitor
1024	>	*/
1025	>	virtual void accept(BaseVisitor* v) = 0;
1026
1027	<	/**
1028	<	* Removes property from PropertyMap by name
1029	<	* @param propName the name of property to be removed
1030	<	*/
1031	<	void removeProperty(const std::string& propName);
1027	>	//below functions are just forward functions
1028	>	/**
1029	>	* Adds property into property map
1030	>	* @param genData GenericData to be added into PropertyMap
1031	>	*/
1032	>	void addProperty(GenericData* genData);
1033
1034	<	/**
1035	<	* clear all of the properties
1036	<	*/
1037	<	void clearProperties();
1034	>	/**
1035	>	* Removes property from PropertyMap by name
1036	>	* @param propName the name of property to be removed
1037	>	*/
1038	>	void removeProperty(const std::string& propName);
1039
1040	<	/**
1041	<	* Returns all names of properties
1042	<	* @return all names of properties
1043	<	*/
869	<	std::vector<std::string> getPropertyNames();
1040	>	/**
1041	>	* clear all of the properties
1042	>	*/
1043	>	void clearProperties();
1044
1045	<	/**
1046	<	* Returns all of the properties in PropertyMap
1047	<	* @return all of the properties in PropertyMap
1048	<	*/
1049	<	std::vector<GenericData*> getProperties();
1045	>	/**
1046	>	* Returns all names of properties
1047	>	* @return all names of properties
1048	>	*/
1049	>	std::vector<std::string> getPropertyNames();
1050
1051	<	/**
1052	<	* Returns property
1053	<	* @param propName name of property
1054	<	* @return a pointer point to property with propName. If no property named propName
1055	<	* exists, return NULL
882	<	*/
883	<	GenericData* getPropertyByName(const std::string& propName);
1051	>	/**
1052	>	* Returns all of the properties in PropertyMap
1053	>	* @return all of the properties in PropertyMap
1054	>	*/
1055	>	std::vector<GenericData*> getProperties();
1056
1057	<	protected:
1057	>	/**
1058	>	* Returns property
1059	>	* @param propName name of property
1060	>	* @return a pointer point to property with propName. If no property named propName
1061	>	* exists, return NULL
1062	>	*/
1063	>	GenericData* getPropertyByName(const std::string& propName);
1064	>
1065	>	protected:
1066
1067	<	StuntDouble(ObjectType objType, DataStoragePointer storage);
1067	>	StuntDouble(ObjectType objType, DataStoragePointer storage);
1068
1069	<	StuntDouble(const StuntDouble& sd);
1070	<	StuntDouble& operator=(const StuntDouble& sd);
1069	>	StuntDouble(const StuntDouble& sd);
1070	>	StuntDouble& operator=(const StuntDouble& sd);
1071
1072	<	ObjectType objType_;
1073	<	DataStoragePointer storage_;
1074	<	SnapshotManager* snapshotMan_;
1072	>	ObjectType objType_;
1073	>	DataStoragePointer storage_;
1074	>	SnapshotManager* snapshotMan_;
1075
1076	<	bool linear_;
1077	<	int linearAxis_;
1076	>	bool linear_;
1077	>	int linearAxis_;
1078
1079
1080	<	int globalIndex_;
1081	<	int localIndex_;
1080	>	int globalIndex_;
1081	>	int globalIntegrableObjectIndex_;
1082	>	int localIndex_;
1083
1084
1085	<	double mass_;
1085	>	RealType mass_;
1086
1087	<	private:
1087	>	private:
1088
1089	<	PropertyMap properties_;
1090	<	};
1089	>	PropertyMap properties_;
1090	>	};
1091
1092	<	}//end namespace oopse
1092	>	}//end namespace OpenMD
1093		#endif //PRIMITIVES_STUNTDOUBLE_HPP

Comparing:
trunk/src/primitives/StuntDouble.hpp (property svn:keywords), Revision 334 by tim, Mon Feb 14 17:57:01 2005 UTC vs.
branches/development/src/primitives/StuntDouble.hpp (property svn:keywords), Revision 1627 by gezelter, Tue Sep 13 22:05:04 2011 UTC

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

Diff Legend

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