test/brains/StuntDouble.hpp

/*
 * Copyright (C) 2000-2004  Object Oriented Parallel Simulation Engine (OOPSE) project
 * 
 * Contact: oopse@oopse.org
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 * All we ask is that proper credit is given for our work, which includes
 * - but is not limited to - adding the above copyright notice to the beginning
 * of your source code files, and to any copyright notice that you may distribute
 * with programs based on this work.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */
 #ifndef _STUNTDOUBLE_HPP_
 #define _STUNTDOUBLE_HPP_

#include <vector>

#include <core/BaseVisitor.hpp>
#include <math/Quaternion.hpp>
#include <math/Mat3x3d.hpp>
#include <math/Vector3d.hpp>
#include <util/PropertyMap.hpp>

namespace oopse{

  /**
   * The base class for atom types. Typically, atom types are used to descibe the behavior of an atom
   * of a element in differnet enviroment. In OOPSE, atom types are also used to represent the coarse-
   * grainded atom
   * @author    tlin
   * @date  09/08/2004
   * @version 1.0
   */

  /*
   * Design Decision:
   * the member data of stuntdouble will be stored outside of the class
   */
   class StuntDouble{
    public:    

        /**
         * Returns the global index of this stuntdouble.
         * @return  the global index of this stuntdouble 
         */
        int getGlobalIndex() {
            return globalIndex_;
        }

        /**
         * Sets the global index of this stuntdouble.
         * @param new global index to be set
         */
        void setGlobalIndex(int index) {
            return globalIndex_;
        }
        
        /** 
         * Returns the local index of this stuntdouble 
         * @return the local index of this stuntdouble
         */
        int getLocalIndex() {
            return localIndex_;
        }

        /**
         * Sets the local index of this stuntdouble
         * @param index new index to be set
         */        
        void setLocalIndex(int index) {
            localIndex_ = index;
        }

       /**
         * Returns  the previous position of this stuntdouble
         * @return the position of this stuntdouble
         */    
        void Vector3d getPrevPos() {
            return (snapshotMan_->getPrevSnapshot())->storage->position[localId_];
        }
       
        /**
         * Returns  the current position of this stuntdouble
         * @return the position of this stuntdouble
         */    
        void Vector3d getPos() {
            return (snapshotMan_->getCurrentSnapshot())->storage->position[localId_];
        }

       /**
         * Returns  the position of this stuntdouble in specified snapshot 
         *
         * @return the position of this stuntdouble
         * @param snapshotNo
         */    
        Vector3d getPos(int snapshotNo) {
            return (snapshotMan_->getSnapshot(snapShotNo))->storage->position[localId_];
        }

       /**
         * Sets  the previous position of this stuntdouble
         *
         * @param pos  new position 
         * @see #getPos
         */         
       void setPrevPos(const Vector3d& pos) {
            (snapshotMan_->getPrevSnapshot())->storage->position[localId_] = pos;
       }
       
       /**
         * Sets  the current position of this stuntdouble
         * @param pos  new position 
         */         
        void setPos(const Vector3d& pos) {
            (snapshotMan_->getCurrentSnapshot())->storage->position[localId_] = pos;
        }

       /**
         * Sets  the position of this stuntdouble in specified snapshot
         *
         * @param pos position to be set 
         * @param snapshotNo 
         * @see #getPos
         */         
        void setPos(const Vector3d& pos, int snapshotNo) {
            (snapshotMan_->getSnapshot(snapshotNo))->storage->position[localId_] = pos;
        }
       
       /**
         * Returns  the previous velocity of this stuntdouble
         * @return the velocity of this stuntdouble
         */    
        Vector3d getPrevVel() {
            return (snapshotMan_->getPrevSnapshot())->storage->velocity[localId_];
        }
       
        /**
         * Returns  the current velocity of this stuntdouble
         * @return the velocity of this stuntdouble
         */    
        Vector3d getVel() {
            return (snapshotMan_->getCurrentSnapshot())->storage->velocity[localId_];
        }

       /**
         * Returns  the velocity of this stuntdouble in specified snapshot 
         *
         * @return the velocity of this stuntdouble
         * @param snapshotNo
         */    
         Vector3d getVel(int snapshotNo) {
            return (snapshotMan_->getSnapshot(snapShotNo))->storage->velocity[localId_];
        }

       /**
         * Sets  the previous velocity of this stuntdouble
         *
         * @param vel  new velocity 
         * @see #getVel
         */         
       void setPrevVel(const Vector3d& vel) {
            (snapshotMan_->getPrevSnapshot())->storage->velocity[localId_] = vel;
       }
       
       /**
         * Sets  the current velocity of this stuntdouble
         * @param vel  new velocity 
         */         
        void setVel(const Vector3d& vel) {
            (snapshotMan_->getCurrentSnapshot())->storage->velocity[localId_] = vel;
        }

       /**
         * Sets  the velocity of this stuntdouble in specified snapshot
         *
         * @param vel velocity to be set 
         * @param snapshotNo 
         * @see #getVel
         */         
        void setVel(const Vector3d& vel, int snapshotNo) {
            (snapshotMan_->getSnapshot(snapshotNo))->storage->velocity[localId_] = vel;
        }

       /**
         * Returns  the previous rotation matrix of this stuntdouble
         * @return the rotation matrix of this stuntdouble
         */    
        RotMat3x3d getPrevA() {
            return (snapshotMan_->getPrevSnapshot())->storage->aMat[localId_];
        }
       
        /**
         * Returns  the current rotation matrix of this stuntdouble
         * @return the rotation matrix of this stuntdouble
         */    
        RotMat3x3d getA() {
            return (snapshotMan_->getCurrentSnapshot())->storage->aMat[localId_];
        }

       /**
         * Returns  the rotation matrix of this stuntdouble in specified snapshot 
         *
         * @return the rotation matrix of this stuntdouble
         * @param snapshotNo
         */    
         RotMat3x3d getA(int snapshotNo) {
            return (snapshotMan_->getSnapshot(snapShotNo))->storage->aMat[localId_];
        }

       /**
         * Sets  the previous rotation matrix of this stuntdouble
         *
         * @param a  new rotation matrix 
         * @see #getA
         */         
       void setPrevA(const RotMat3x3d& a) {
            (snapshotMan_->getPrevSnapshot())->storage->aMat[localId_] = a;
       }
       
       /**
         * Sets  the current rotation matrix of this stuntdouble
         * @param a  new rotation matrix 
         */         
        void setA(const RotMat3x3d& a) {
            (snapshotMan_->getCurrentSnapshot())->storage->aMat[localId_] = a;
        }

       /**
         * Sets  the rotation matrix of this stuntdouble in specified snapshot
         *
         * @param a rotation matrix to be set 
         * @param snapshotNo 
         * @see #getA
         */         
        void setA(const RotMat3x3d& a, int snapshotNo) {
            (snapshotMan_->getSnapshot(snapshotNo))->storage->a[localId_] = a;
        }       

       /**
         * Returns  the previous angular momentum of this stuntdouble
         * @return the angular momentum of this stuntdouble
         */    
        Vector3d getPrevJ() {
            return (snapshotMan_->getPrevSnapshot())->storage->angularMomentum[localId_];
        }
       
        /**
         * Returns  the current angular momentum of this stuntdouble
         * @return the angular momentum of this stuntdouble
         */    
        Vector3d getJ() {
            return (snapshotMan_->getCurrentSnapshot())->storage->angularMomentum[localId_];
        }

       /**
         * Returns  the angular momentum of this stuntdouble in specified snapshot 
         *
         * @return the angular momentum of this stuntdouble
         * @param snapshotNo
         */    
         Vector3d getJ(int snapshotNo) {
            return (snapshotMan_->getSnapshot(snapShotNo))->storage->angularMomentum[localId_];
        }

       /**
         * Sets  the previous angular momentum of this stuntdouble
         *
         * @param angMom  new angular momentum 
         * @see #getJ
         */         
       void setPrevJ(const Vector3d& angMom) {
            (snapshotMan_->getPrevSnapshot())->storage->angularMomentum[localId_] = angMom;
       }
       
       /**
         * Sets  the current angular momentum of this stuntdouble
         * @param angMom  new angular momentum 
         */         
        void setJ(const Vector3d& angMom) {
            (snapshotMan_->getCurrentSnapshot())->storage->angularMomentum[localId_] = angMom;
        }

       /**
         * Sets the angular momentum of this stuntdouble in specified snapshot
         *
         * @param angMom angular momentum to be set 
         * @param snapshotNo 
         * @see #getJ
         */         
        void setJ(const Vector3d& angMom, int snapshotNo) {
            (snapshotMan_->getSnapshot(snapshotNo))->storage->angularMomentum[localId_] = angMom;
        }
         
       /**
         * Returns  the previous quaternion of this stuntdouble
         * @return the quaternion of this stuntdouble
         */    
        Quat4d getPrevQ() {
            return (snapshotMan_->getPrevSnapshot())->storage->aMat[localId_].toQuaternion();
        }
       
        /**
         * Returns  the current quaternion of this stuntdouble
         * @return the quaternion of this stuntdouble
         */    
        Quat4d getQ() {
            return (snapshotMan_->getCurrentSnapshot())->storage->aMat[localId_].toQuaternion();
        }

       /**
         * Returns  the quaternion of this stuntdouble in specified snapshot 
         *
         * @return the quaternion of this stuntdouble
         * @param snapshotNo
         */    
         Quat4d getQ(int snapshotNo) {
            return (snapshotMan_->getSnapshot(snapShotNo))->storage->aMat[localId_].toQuaternion();
        }

       /**
         * Sets  the previous quaternion of this stuntdouble
         *
         * @param q  new quaternion 
         * @see #getQ
         */         
       void setPrevQ(const Quat4d& q) {
            (snapshotMan_->getPrevSnapshot())->storage->aMat[localId_] = q;
       }
       
       /**
         * Sets  the current quaternion of this stuntdouble
         * @param q  new quaternion 
         */         
        void setQ(const Quat4d& q) {
            (snapshotMan_->getCurrentSnapshot())->storage->aMat[localId_] = q;
        }

       /**
         * Sets  the quaternion of this stuntdouble in specified snapshot
         *
         * @param q quaternion to be set 
         * @param snapshotNo 
         * @see #getQ
         */         
        void setQ(const Quat4d& q, int snapshotNo) {
            (snapshotMan_->getSnapshot(snapshotNo))->storage->aMat[localId_] = q;
        }
       
       /**
         * Returns the force of this stuntdouble
         *
         * @return the quaternion of this stuntdouble
         *
         * @see #setFrc
         * @see #addFrc
         */
        virtual Vector3d getFrc() = 0;

       /**
         * Sets the force of this stuntdouble
         *
         * @param frc new force
         *
         * @see #getFrc
         * @see #addFrc
         */     
        virtual void setFrc(Vector3d& frc) = 0;

       /**
         * Adds the force into this stuntdouble
         *
         * @param frc  force to be added
         *
         * @see #getFrc
         * @see #setFrc
         */          
        virtual void addFrc(Vector3d& frc) = 0;

       /**
         * Returns the torque of this stuntdouble
         *
         * @return the torque of this stuntdouble
         *
         * @see #setTrq
         * @see #addTrq
         */
        virtual Vector3d getTrq() = 0;

       /**
         * Sets the torque of this stuntdouble
         *
         * @param trq new torque
         *
         * @see #getTrq
         * @see #addTrq
         */      
        virtual void setTrq(Vector3d& trq) = 0;

       /**
         * Adds the torque into this stuntdouble
         *
         * @param trq  torque to be added
         *
         * @see #getTrq
         * @see #setTrq
         */
        virtual void addTrq(Vector3d& trq) = 0;

       /**
         * Returns the inertia tensor of this stuntdouble
         *
         * @return the inertia tensor of this stuntdouble
         *
         * @see #setI
         */ 
        virtual Mat3x3d getI() = 0;

       /**
         * Sets the inertia tensor of this stuntdouble
         *
         * @param trq new inertia tensor
         *
         * @see #getI
         */      
        virtual void setI(Mat3x3d& I) = 0;

       /**
         * Returns the gradient of this stuntdouble
         *
         * @return the inertia tensor of this stuntdouble
         *
         * @see #setI
         */ 
        virtual std::vector<double> getGrad() = 0;

       /**
         * Returns the euler angles of this stuntdouble
         * <p>
         *   <ol>
         *   <il>
         *   <il>
         *   <il>
         *   </ol>
         * </p>
         * @return the euler angles of this stuntdouble
         *
         * @see #setEuler
         */ 
        virtual Vector3d getEuler() = 0;

       /**
         * Sets the euler angles of this stuntdouble
         *
         * @param e new euler angles
         * <p>
         *   <ol>
         *   <il>e[0] = phi </il>
         *   <il>e[1] = theta <il>
         *   <il>e[2] = psi </il>
         *   </ol>
         * </p>
         *
         * @see #setEuler
         */ 
        virtual void setEuler(Vector3d& e) = 0;
        
        virtual bool isLinear() {return false;}

       /**
         * Returns the linear axis of the rigidbody, atom and directional atom will always return -1
         *
         * @return the linear axis of the rigidbody
         * 
         * @see #isLinear
         */ 
        virtual int linearAxis() {return -1;}

       /**
        * Returns the zangle
        *
        * @return the zangle
        *
        * @see #setZangle
        * @see #addZangle
        */
        virtual double   getZangle() = 0;

       /**
        *
        */
        virtual void   setZangle(double zAngle) = 0;

       /**
        *
        */
        virtual void   addZangle(double zAngle) = 0;

       /**
         * 
         * <p>
         * The purpose of the Visitor Pattern is to encapsulate an operation that you want to perform on
         * the elements of a data structure. In this way, you can change the operation being performed 
         * on a structure without the need of changing the classes of the elements that you are operating
         * on. Using a Visitor pattern allows you to decouple the classes for the data structure and the 
         * algorithms used upon them
         * </p>
         * @param v visitor
         */      
        virtual void accept(BaseVisitor* v) = 0;

        StorageMethod getStorageMethd(){return stMethod;}
        void setStorageMethod(StorageMethod method) {stMethod = method;}

        //below functions are just forward functions
        /**
         * Adds property into property map
         *
         * @param genData GenericData to be added into PropertyMap
         *
         * @see #removeProperty
         * @see #clearProperties
         */
        void addProperty(GenericData* genData) {  properties.addProperty(genData);  }

        /**
         * Removes property from PropertyMap by name
         *
         * @param propName the name of property to be removed
         *
         * @see #addProperty
         * @see #clearProperties
         */
        void removeProperty(std::string& propName) {  properties.removeProperty();  }

        /**
         * clear all of the properties
         *
         * @see #addProperty
         * @see #removeProperty
         */
        void clearProperties() {  properties.clearProperties(); }

        /**
         * Returns all names of properties
         *
         * @return all names of properties
         */
        std::vector<std::string> getPropertyNames() {return properties.getPropertyNames();  }

        /**
         * Returns all of the properties in PropertyMap
         *
         * @return all of the properties in PropertyMap
         *
         * @see #getPropertyByName
         */      
        std::vector<GenericData*> getProperties() { return properties.getProperties(); }

        /**
         * Returns property 
         *
         * @param propName name of property
         *
         * @return a pointer point to property with propName. If no property named propName
         * exists, return NULL
         *
         * @see #getProperties
         */      
        GenericData* getPropertyByName(std:string& propName) {  return properties.getPropertyByName(propName); }

      private:
        
        int globalIndex_;
        int localIndex_;
        PropertyMap properties;
        DataStoragePointer storage_;
        SnapshotManager* snapshotMan_;
 };

}//end namespace oopse
#endif //ifndef _STUNTDOUBLE_HPP_
Revision:	1639
Committed:	Fri Oct 22 23:09:57 2004 UTC (19 years, 8 months ago) by tim
File size:	18254 byte(s)
Log Message:	more work in Snapshot
#	Content
1	/*
2	* Copyright (C) 2000-2004 Object Oriented Parallel Simulation Engine (OOPSE) project
3	*
4	* Contact: oopse@oopse.org
5	*
6	* This program is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU Lesser General Public License
8	* as published by the Free Software Foundation; either version 2.1
9	* of the License, or (at your option) any later version.
10	* All we ask is that proper credit is given for our work, which includes
11	* - but is not limited to - adding the above copyright notice to the beginning
12	* of your source code files, and to any copyright notice that you may distribute
13	* with programs based on this work.
14	*
15	* This program is distributed in the hope that it will be useful,
16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18	* GNU Lesser General Public License for more details.
19	*
20	* You should have received a copy of the GNU Lesser General Public License
21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23	*
24	*/
25	#ifndef _STUNTDOUBLE_HPP_
26	#define _STUNTDOUBLE_HPP_
27
28	#include <vector>
29
30	#include <core/BaseVisitor.hpp>
31	#include <math/Quaternion.hpp>
32	#include <math/Mat3x3d.hpp>
33	#include <math/Vector3d.hpp>
34	#include <util/PropertyMap.hpp>
35
36	namespace oopse{
37
38	/**
39	* The base class for atom types. Typically, atom types are used to descibe the behavior of an atom
40	* of a element in differnet enviroment. In OOPSE, atom types are also used to represent the coarse-
41	* grainded atom
42	* @author tlin
43	* @date 09/08/2004
44	* @version 1.0
45	*/
46
47	/*
48	* Design Decision:
49	* the member data of stuntdouble will be stored outside of the class
50	*/
51	class StuntDouble{
52	public:
53
54	/**
55	* Returns the global index of this stuntdouble.
56	* @return the global index of this stuntdouble
57	*/
58	int getGlobalIndex() {
59	return globalIndex_;
60	}
61
62	/**
63	* Sets the global index of this stuntdouble.
64	* @param new global index to be set
65	*/
66	void setGlobalIndex(int index) {
67	return globalIndex_;
68	}
69
70	/**
71	* Returns the local index of this stuntdouble
72	* @return the local index of this stuntdouble
73	*/
74	int getLocalIndex() {
75	return localIndex_;
76	}
77
78	/**
79	* Sets the local index of this stuntdouble
80	* @param index new index to be set
81	*/
82	void setLocalIndex(int index) {
83	localIndex_ = index;
84	}
85
86	/**
87	* Returns the previous position of this stuntdouble
88	* @return the position of this stuntdouble
89	*/
90	void Vector3d getPrevPos() {
91	return (snapshotMan_->getPrevSnapshot())->storage->position[localId_];
92	}
93
94	/**
95	* Returns the current position of this stuntdouble
96	* @return the position of this stuntdouble
97	*/
98	void Vector3d getPos() {
99	return (snapshotMan_->getCurrentSnapshot())->storage->position[localId_];
100	}
101
102	/**
103	* Returns the position of this stuntdouble in specified snapshot
104	*
105	* @return the position of this stuntdouble
106	* @param snapshotNo
107	*/
108	Vector3d getPos(int snapshotNo) {
109	return (snapshotMan_->getSnapshot(snapShotNo))->storage->position[localId_];
110	}
111
112	/**
113	* Sets the previous position of this stuntdouble
114	*
115	* @param pos new position
116	* @see #getPos
117	*/
118	void setPrevPos(const Vector3d& pos) {
119	(snapshotMan_->getPrevSnapshot())->storage->position[localId_] = pos;
120	}
121
122	/**
123	* Sets the current position of this stuntdouble
124	* @param pos new position
125	*/
126	void setPos(const Vector3d& pos) {
127	(snapshotMan_->getCurrentSnapshot())->storage->position[localId_] = pos;
128	}
129
130	/**
131	* Sets the position of this stuntdouble in specified snapshot
132	*
133	* @param pos position to be set
134	* @param snapshotNo
135	* @see #getPos
136	*/
137	void setPos(const Vector3d& pos, int snapshotNo) {
138	(snapshotMan_->getSnapshot(snapshotNo))->storage->position[localId_] = pos;
139	}
140
141	/**
142	* Returns the previous velocity of this stuntdouble
143	* @return the velocity of this stuntdouble
144	*/
145	Vector3d getPrevVel() {
146	return (snapshotMan_->getPrevSnapshot())->storage->velocity[localId_];
147	}
148
149	/**
150	* Returns the current velocity of this stuntdouble
151	* @return the velocity of this stuntdouble
152	*/
153	Vector3d getVel() {
154	return (snapshotMan_->getCurrentSnapshot())->storage->velocity[localId_];
155	}
156
157	/**
158	* Returns the velocity of this stuntdouble in specified snapshot
159	*
160	* @return the velocity of this stuntdouble
161	* @param snapshotNo
162	*/
163	Vector3d getVel(int snapshotNo) {
164	return (snapshotMan_->getSnapshot(snapShotNo))->storage->velocity[localId_];
165	}
166
167	/**
168	* Sets the previous velocity of this stuntdouble
169	*
170	* @param vel new velocity
171	* @see #getVel
172	*/
173	void setPrevVel(const Vector3d& vel) {
174	(snapshotMan_->getPrevSnapshot())->storage->velocity[localId_] = vel;
175	}
176
177	/**
178	* Sets the current velocity of this stuntdouble
179	* @param vel new velocity
180	*/
181	void setVel(const Vector3d& vel) {
182	(snapshotMan_->getCurrentSnapshot())->storage->velocity[localId_] = vel;
183	}
184
185	/**
186	* Sets the velocity of this stuntdouble in specified snapshot
187	*
188	* @param vel velocity to be set
189	* @param snapshotNo
190	* @see #getVel
191	*/
192	void setVel(const Vector3d& vel, int snapshotNo) {
193	(snapshotMan_->getSnapshot(snapshotNo))->storage->velocity[localId_] = vel;
194	}
195
196	/**
197	* Returns the previous rotation matrix of this stuntdouble
198	* @return the rotation matrix of this stuntdouble
199	*/
200	RotMat3x3d getPrevA() {
201	return (snapshotMan_->getPrevSnapshot())->storage->aMat[localId_];
202	}
203
204	/**
205	* Returns the current rotation matrix of this stuntdouble
206	* @return the rotation matrix of this stuntdouble
207	*/
208	RotMat3x3d getA() {
209	return (snapshotMan_->getCurrentSnapshot())->storage->aMat[localId_];
210	}
211
212	/**
213	* Returns the rotation matrix of this stuntdouble in specified snapshot
214	*
215	* @return the rotation matrix of this stuntdouble
216	* @param snapshotNo
217	*/
218	RotMat3x3d getA(int snapshotNo) {
219	return (snapshotMan_->getSnapshot(snapShotNo))->storage->aMat[localId_];
220	}
221
222	/**
223	* Sets the previous rotation matrix of this stuntdouble
224	*
225	* @param a new rotation matrix
226	* @see #getA
227	*/
228	void setPrevA(const RotMat3x3d& a) {
229	(snapshotMan_->getPrevSnapshot())->storage->aMat[localId_] = a;
230	}
231
232	/**
233	* Sets the current rotation matrix of this stuntdouble
234	* @param a new rotation matrix
235	*/
236	void setA(const RotMat3x3d& a) {
237	(snapshotMan_->getCurrentSnapshot())->storage->aMat[localId_] = a;
238	}
239
240	/**
241	* Sets the rotation matrix of this stuntdouble in specified snapshot
242	*
243	* @param a rotation matrix to be set
244	* @param snapshotNo
245	* @see #getA
246	*/
247	void setA(const RotMat3x3d& a, int snapshotNo) {
248	(snapshotMan_->getSnapshot(snapshotNo))->storage->a[localId_] = a;
249	}
250
251	/**
252	* Returns the previous angular momentum of this stuntdouble
253	* @return the angular momentum of this stuntdouble
254	*/
255	Vector3d getPrevJ() {
256	return (snapshotMan_->getPrevSnapshot())->storage->angularMomentum[localId_];
257	}
258
259	/**
260	* Returns the current angular momentum of this stuntdouble
261	* @return the angular momentum of this stuntdouble
262	*/
263	Vector3d getJ() {
264	return (snapshotMan_->getCurrentSnapshot())->storage->angularMomentum[localId_];
265	}
266
267	/**
268	* Returns the angular momentum of this stuntdouble in specified snapshot
269	*
270	* @return the angular momentum of this stuntdouble
271	* @param snapshotNo
272	*/
273	Vector3d getJ(int snapshotNo) {
274	return (snapshotMan_->getSnapshot(snapShotNo))->storage->angularMomentum[localId_];
275	}
276
277	/**
278	* Sets the previous angular momentum of this stuntdouble
279	*
280	* @param angMom new angular momentum
281	* @see #getJ
282	*/
283	void setPrevJ(const Vector3d& angMom) {
284	(snapshotMan_->getPrevSnapshot())->storage->angularMomentum[localId_] = angMom;
285	}
286
287	/**
288	* Sets the current angular momentum of this stuntdouble
289	* @param angMom new angular momentum
290	*/
291	void setJ(const Vector3d& angMom) {
292	(snapshotMan_->getCurrentSnapshot())->storage->angularMomentum[localId_] = angMom;
293	}
294
295	/**
296	* Sets the angular momentum of this stuntdouble in specified snapshot
297	*
298	* @param angMom angular momentum to be set
299	* @param snapshotNo
300	* @see #getJ
301	*/
302	void setJ(const Vector3d& angMom, int snapshotNo) {
303	(snapshotMan_->getSnapshot(snapshotNo))->storage->angularMomentum[localId_] = angMom;
304	}
305
306	/**
307	* Returns the previous quaternion of this stuntdouble
308	* @return the quaternion of this stuntdouble
309	*/
310	Quat4d getPrevQ() {
311	return (snapshotMan_->getPrevSnapshot())->storage->aMat[localId_].toQuaternion();
312	}
313
314	/**
315	* Returns the current quaternion of this stuntdouble
316	* @return the quaternion of this stuntdouble
317	*/
318	Quat4d getQ() {
319	return (snapshotMan_->getCurrentSnapshot())->storage->aMat[localId_].toQuaternion();
320	}
321
322	/**
323	* Returns the quaternion of this stuntdouble in specified snapshot
324	*
325	* @return the quaternion of this stuntdouble
326	* @param snapshotNo
327	*/
328	Quat4d getQ(int snapshotNo) {
329	return (snapshotMan_->getSnapshot(snapShotNo))->storage->aMat[localId_].toQuaternion();
330	}
331
332	/**
333	* Sets the previous quaternion of this stuntdouble
334	*
335	* @param q new quaternion
336	* @see #getQ
337	*/
338	void setPrevQ(const Quat4d& q) {
339	(snapshotMan_->getPrevSnapshot())->storage->aMat[localId_] = q;
340	}
341
342	/**
343	* Sets the current quaternion of this stuntdouble
344	* @param q new quaternion
345	*/
346	void setQ(const Quat4d& q) {
347	(snapshotMan_->getCurrentSnapshot())->storage->aMat[localId_] = q;
348	}
349
350	/**
351	* Sets the quaternion of this stuntdouble in specified snapshot
352	*
353	* @param q quaternion to be set
354	* @param snapshotNo
355	* @see #getQ
356	*/
357	void setQ(const Quat4d& q, int snapshotNo) {
358	(snapshotMan_->getSnapshot(snapshotNo))->storage->aMat[localId_] = q;
359	}
360
361	/**
362	* Returns the force of this stuntdouble
363	*
364	* @return the quaternion of this stuntdouble
365	*
366	* @see #setFrc
367	* @see #addFrc
368	*/
369	virtual Vector3d getFrc() = 0;
370
371	/**
372	* Sets the force of this stuntdouble
373	*
374	* @param frc new force
375	*
376	* @see #getFrc
377	* @see #addFrc
378	*/
379	virtual void setFrc(Vector3d& frc) = 0;
380
381	/**
382	* Adds the force into this stuntdouble
383	*
384	* @param frc force to be added
385	*
386	* @see #getFrc
387	* @see #setFrc
388	*/
389	virtual void addFrc(Vector3d& frc) = 0;
390
391	/**
392	* Returns the torque of this stuntdouble
393	*
394	* @return the torque of this stuntdouble
395	*
396	* @see #setTrq
397	* @see #addTrq
398	*/
399	virtual Vector3d getTrq() = 0;
400
401	/**
402	* Sets the torque of this stuntdouble
403	*
404	* @param trq new torque
405	*
406	* @see #getTrq
407	* @see #addTrq
408	*/
409	virtual void setTrq(Vector3d& trq) = 0;
410
411	/**
412	* Adds the torque into this stuntdouble
413	*
414	* @param trq torque to be added
415	*
416	* @see #getTrq
417	* @see #setTrq
418	*/
419	virtual void addTrq(Vector3d& trq) = 0;
420
421	/**
422	* Returns the inertia tensor of this stuntdouble
423	*
424	* @return the inertia tensor of this stuntdouble
425	*
426	* @see #setI
427	*/
428	virtual Mat3x3d getI() = 0;
429
430	/**
431	* Sets the inertia tensor of this stuntdouble
432	*
433	* @param trq new inertia tensor
434	*
435	* @see #getI
436	*/
437	virtual void setI(Mat3x3d& I) = 0;
438
439	/**
440	* Returns the gradient of this stuntdouble
441	*
442	* @return the inertia tensor of this stuntdouble
443	*
444	* @see #setI
445	*/
446	virtual std::vector<double> getGrad() = 0;
447
448	/**
449	* Returns the euler angles of this stuntdouble
450	* <p>
451	* <ol>
452	* <il>
453	* <il>
454	* <il>
455	* </ol>
456	* </p>
457	* @return the euler angles of this stuntdouble
458	*
459	* @see #setEuler
460	*/
461	virtual Vector3d getEuler() = 0;
462
463	/**
464	* Sets the euler angles of this stuntdouble
465	*
466	* @param e new euler angles
467	* <p>
468	* <ol>
469	* <il>e[0] = phi </il>
470	* <il>e[1] = theta <il>
471	* <il>e[2] = psi </il>
472	* </ol>
473	* </p>
474	*
475	* @see #setEuler
476	*/
477	virtual void setEuler(Vector3d& e) = 0;
478
479	virtual bool isLinear() {return false;}
480
481	/**
482	* Returns the linear axis of the rigidbody, atom and directional atom will always return -1
483	*
484	* @return the linear axis of the rigidbody
485	*
486	* @see #isLinear
487	*/
488	virtual int linearAxis() {return -1;}
489
490	/**
491	* Returns the zangle
492	*
493	* @return the zangle
494	*
495	* @see #setZangle
496	* @see #addZangle
497	*/
498	virtual double getZangle() = 0;
499
500	/**
501	*
502	*/
503	virtual void setZangle(double zAngle) = 0;
504
505	/**
506	*
507	*/
508	virtual void addZangle(double zAngle) = 0;
509
510	/**
511	*
512	* <p>
513	* The purpose of the Visitor Pattern is to encapsulate an operation that you want to perform on
514	* the elements of a data structure. In this way, you can change the operation being performed
515	* on a structure without the need of changing the classes of the elements that you are operating
516	* on. Using a Visitor pattern allows you to decouple the classes for the data structure and the
517	* algorithms used upon them
518	* </p>
519	* @param v visitor
520	*/
521	virtual void accept(BaseVisitor* v) = 0;
522
523	StorageMethod getStorageMethd(){return stMethod;}
524	void setStorageMethod(StorageMethod method) {stMethod = method;}
525
526	//below functions are just forward functions
527	/**
528	* Adds property into property map
529	*
530	* @param genData GenericData to be added into PropertyMap
531	*
532	* @see #removeProperty
533	* @see #clearProperties
534	*/
535	void addProperty(GenericData* genData) { properties.addProperty(genData); }
536
537	/**
538	* Removes property from PropertyMap by name
539	*
540	* @param propName the name of property to be removed
541	*
542	* @see #addProperty
543	* @see #clearProperties
544	*/
545	void removeProperty(std::string& propName) { properties.removeProperty(); }
546
547	/**
548	* clear all of the properties
549	*
550	* @see #addProperty
551	* @see #removeProperty
552	*/
553	void clearProperties() { properties.clearProperties(); }
554
555	/**
556	* Returns all names of properties
557	*
558	* @return all names of properties
559	*/
560	std::vector<std::string> getPropertyNames() {return properties.getPropertyNames(); }
561
562	/**
563	* Returns all of the properties in PropertyMap
564	*
565	* @return all of the properties in PropertyMap
566	*
567	* @see #getPropertyByName
568	*/
569	std::vector<GenericData*> getProperties() { return properties.getProperties(); }
570
571	/**
572	* Returns property
573	*
574	* @param propName name of property
575	*
576	* @return a pointer point to property with propName. If no property named propName
577	* exists, return NULL
578	*
579	* @see #getProperties
580	*/
581	GenericData* getPropertyByName(std:string& propName) { return properties.getPropertyByName(propName); }
582
583	private:
584
585	int globalIndex_;
586	int localIndex_;
587	PropertyMap properties;
588	DataStoragePointer storage_;
589	SnapshotManager* snapshotMan_;
590	};
591
592	}//end namespace oopse
593	#endif //ifndef _STUNTDOUBLE_HPP_