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 3 by tim, Fri Sep 24 16:27:58 2004 UTC vs.
branches/development/src/primitives/StuntDouble.hpp (file contents), Revision 1702 by kstocke1, Thu Apr 5 19:49:59 2012 UTC

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

Comparing:
trunk/src/primitives/StuntDouble.hpp (property svn:keywords), Revision 3 by tim, Fri Sep 24 16:27:58 2004 UTC vs.
branches/development/src/primitives/StuntDouble.hpp (property svn:keywords), Revision 1702 by kstocke1, Thu Apr 5 19:49:59 2012 UTC

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

Diff Legend

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