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 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
branches/development/src/primitives/StuntDouble.hpp (file contents), Revision 1540 by gezelter, Mon Jan 17 21:34:36 2011 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]  Vardeman & Gezelter, in progress (2009).
40	>	*/
41	>
42	>	/**
43	>	* @file StuntDouble.hpp
44	>	* @author    tlin
45	>	* @date  10/22/2004
46	>	* @version 1.0
47	>	*/
48	>
49	>	#ifndef PRIMITIVES_STUNTDOUBLE_HPP
50	>	#define PRIMITIVES_STUNTDOUBLE_HPP
51
52	<	#include <map>
5	<	#include "GenericData.hpp"
52	>	#include <vector>
53
54	<	#define OT_ATOM 0
55	<	#define OT_DATOM 1
56	<	#define OT_RIGIDBODY 2
54	>	#include "visitors/BaseVisitor.hpp"
55	>	#include "math/Quaternion.hpp"
56	>	#include "math/SquareMatrix3.hpp"
57	>	#include "math/Vector3.hpp"
58	>	#include "utils/PropertyMap.hpp"
59	>	#include "brains/Snapshot.hpp"
60	>	#include "brains/SnapshotManager.hpp"
61	>	namespace OpenMD{
62
11	–	using namespace std;
12	–	class BaseVisitor;
63
64	<	class StuntDouble {
65	<	public:
66	<	virtual ~StuntDouble();
67	<
68	<	int getObjType();
69	<
70	<	bool isAtom(){
71	<	return objType == OT_ATOM || objType == OT_DATOM;
72	<	}
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 (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:
90
91	<	bool isDirectionalAtom(){
92	<	return objType == OT_DATOM;
93	<	}
91	>	enum ObjectType{
92	>	otAtom,
93	>	otDAtom,
94	>	otRigidBody
95	>	};
96
97	<	bool isRigidBody(){
98	<	return objType == OT_RIGIDBODY;
99	<	}
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	>	}
106
107	<	bool isDirectional(){
108	<	return isDirectionalAtom() || isRigidBody();
109	<	}
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	<	virtual double getMass(void);
124	<
125	<	virtual void   getPos(double pos[3]);
126	<	virtual void   setPos(double pos[3]);
127	<
128	<	virtual void   getVel(double vel[3]);
129	<	virtual void   setVel(double vel[3]);
130	<
131	<	virtual void   getFrc(double frc[3]);
132	<	virtual void   addFrc(double frc[3]);
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	<	virtual void   getA(double A[3][3]);
139	<	virtual void   setA(double A[3][3]);
138	>	/**
139	>	* Sets the Snapshot Manager of this stuntDouble
140	>	*/
141	>	void setSnapshotManager(SnapshotManager* sman) {
142	>	snapshotMan_ = sman;
143	>	}
144
145	<	virtual void   getJ(double j[3]);
146	<	virtual void   setJ(double j[3]);
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	<	virtual void getQ( double q[4] ); // get the quanternions
154	<	virtual void setQ( double q[4] );
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	<	virtual void setType(char* type) = 0;
162	<	virtual char* getType() = 0;
163	<
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	<	virtual void   getTrq(double trq[3]);
170	<	virtual void   addTrq(double trq[3]);
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	<	virtual void   getI(double I[3][3]);
178	<	virtual void   lab2Body(double vec[3]);
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	<	virtual void   getGrad(double grad[6]);
188	<	virtual void   setEuler(double phi, double theta, double psi);
189	<	virtual void   getEulerAngles(double eulers[3]);
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	<	virtual bool isLinear() {return false;}
201	<	virtual int linearAxis() {return -1;}
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	>	* 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	<	virtual double   getZangle();
217	<	virtual void   setZangle(double zAngle);
218	<	virtual void   addZangle(double zAngle);
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	<	virtual void accept(BaseVisitor* v) = 0;
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	<	void addProperty(GenericData* data);
245	<	void removeProperty(const string& propName);
246	<	GenericData* getProperty(const string& propName);
247	<
248	<	protected:
249	<	StuntDouble(){}
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	<	//prevent default copy constructor copy information from properties which will cause problem
87	<	StuntDouble(const StuntDouble& sd){
88	<	objType = sd.objType;
89	<	}
90	<
91	<	int objType;
252	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).position[localIndex_] = pos;
253
254	<	map<string, GenericData*> properties;
255	<	};
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	>	}
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	>	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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 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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
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	+	}
764	+
765	+
766	+
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	+	* 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	+	* 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	+	* 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	+	* 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	+	* 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	+	/**
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	+	* 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	+
851	+
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	+	/**
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 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	+	/**
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) {}
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	+	}
995	+
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	+	}
1008	+
1009	+	Vector3d body2Lab(const Vector3d& v, int frame){
1010	+	return getA(frame).transpose() * v;
1011	+	}
1012	+
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	+	//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	+	* 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	+	* clear all of the properties
1042	+	*/
1043	+	void clearProperties();
1044	+
1045	+	/**
1046	+	* Returns all names of properties
1047	+	* @return all names of properties
1048	+	*/
1049	+	std::vector<std::string> getPropertyNames();
1050	+
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	+	/**
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);
1068	+
1069	+	StuntDouble(const StuntDouble& sd);
1070	+	StuntDouble& operator=(const StuntDouble& sd);
1071	+
1072	+	ObjectType objType_;
1073	+	DataStoragePointer storage_;
1074	+	#ifdef IS_MPI
1075	+	DataStoragePointer storageI_;
1076	+	DataStoragePointer storageJ_;
1077		#endif
1078	+	SnapshotManager* snapshotMan_;
1079	+
1080	+	bool linear_;
1081	+	int linearAxis_;
1082	+
1083	+
1084	+	int globalIndex_;
1085	+	int globalIntegrableObjectIndex_;
1086	+	int localIndex_;
1087	+
1088	+
1089	+	RealType mass_;
1090	+
1091	+	private:
1092	+
1093	+	PropertyMap properties_;
1094	+	};
1095	+
1096	+	}//end namespace OpenMD
1097	+	#endif //PRIMITIVES_STUNTDOUBLE_HPP

Comparing:
trunk/src/primitives/StuntDouble.hpp (property svn:keywords), Revision 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
branches/development/src/primitives/StuntDouble.hpp (property svn:keywords), Revision 1540 by gezelter, Mon Jan 17 21:34:36 2011 UTC

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

Diff Legend

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