src/constraints/ConstraintElem.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 CONSTRAINTS_CONTRAINTELEM_HPP
#define CONSTRAINTS_CONTRAINTELEM_HPP

#include "primitives/StuntDouble.hpp"
#include "utils/GenericData.hpp"
#include "utils/simError.h"
namespace oopse {

/**
 * @class ConstraintElem ConstraintElem.hpp "constraints/ConstraintElem.hpp"
 * An adapter class of StuntDouble which is used at constraint algorithm
 */
 
class ConstraintElem{
    public:
        ConstraintElem(StuntDouble* sd) : sd_(sd) {
            GenericData* movedData = sd_->getPropertyByName("Moved");
            if (movedData !=NULL) { //if generic data with keyword "moved" exists, assign it to moved_
                moved_ = dynamic_cast<BoolGenericData*>(movedData);
                if (moved_ == NULL) {
                    sprintf(painCave.errMsg,
                        "Generic Data with keyword Moved exists, however, it can not be casted to a BoolGenericData.\n");
                        painCave.isFatal = 1;;
                    simError();
                }
            }else { //if generic data with keyword "moved" does not exist, create it
                moved_ = new BoolGenericData("Moved");
                sd_->addProperty(moved_);
            }

            GenericData* movingData = sd_->getPropertyByName("Moving");
            if (movingData !=NULL) {
                moving_ = dynamic_cast<BoolGenericData*>(movingData);
                if (moving_ == NULL) {
                    sprintf(painCave.errMsg,
                        "Generic Data with keyword Moving exists, however, it can not be casted to a BoolGenericData.\n");
                        painCave.isFatal = 1;;
                    simError();
                }
            }else {
                moving_ = new BoolGenericData("Moving");
                sd_->addProperty(moving_);                
            }
            
        }

        bool getMoved() { return moved_->getData(); }
        void setMoved(bool moved) { moved_->setData(moved);}

        bool getMoving() { return moving_->getData(); }
        void setMoving(bool moving) { moving_->setData(moving); }

        StuntDouble* getStuntDouble() { return sd_; }
        
        /**
         * Returns the global index of this stuntdouble.
         * @return  the global index of this stuntdouble 
         */
        int getGlobalIndex() {
            return sd_->getGlobalIndex();
        }

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

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

        /**
         * Sets the Snapshot Manager of this stuntdouble
         */
        void setSnapshotManager(SnapshotManager* sman) {
            sd_->setSnapshotManager(sman);
        }

        /**
         * Tests if this stuntdouble is an atom 
         * @return true is this stuntdouble is an atom(or a directional atom), return false otherwise
         */
        bool isAtom(){
            return sd_->isAtom();
        }

        /** 
         * Tests if this stuntdouble is an directional atom 
         * @return true if this stuntdouble is an directional atom, return false otherwise
         */
        bool isDirectionalAtom(){
            return sd_->isDirectional();
       }

        /**
         * Tests if this stuntdouble is a rigid body. 
         * @return true if this stuntdouble is a rigid body, otherwise return false
         */
        bool isRigidBody(){
            return sd_->isRigidBody();
        }

        /**
         * Tests if this stuntdouble is a directional one. 
         * @return true is this stuntdouble is a directional atom or a rigid body, return false otherwise
         */
        bool isDirectional(){
            return sd_->isDirectional();
        }

       /**
         * Returns the previous position of this stuntdouble
         * @return the position of this stuntdouble
         */    
        Vector3d getPrevPos() {
            return sd_->getPrevPos();
        }
       
        /**
         * Returns the current position of this stuntdouble
         * @return the position of this stuntdouble
         */    
        Vector3d getPos() {
            return sd_->getPos();
        }

       /**
         * Returns the position of this stuntdouble in specified snapshot 
         * @return the position of this stuntdouble
         * @param snapshotNo
         */    
        Vector3d getPos(int snapshotNo) {
            return sd_->getPos(snapshotNo);
        }

       /**
         * Sets  the previous position of this stuntdouble
         * @param pos  new position 
         * @see #getPos
         */         
       void setPrevPos(const Vector3d& pos) {
            sd_->setPrevPos(pos);
       }
       
       /**
         * Sets  the current position of this stuntdouble
         * @param pos  new position 
         */         
        void setPos(const Vector3d& pos) {
            sd_->setPos(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) {
            sd_->setPos(pos, snapshotNo);
        }
       
       /**
         * Returns the previous velocity of this stuntdouble
         * @return the velocity of this stuntdouble
         */    
        Vector3d getPrevVel() {
            return sd_->getPrevVel();
        }
       
        /**
         * Returns the current velocity of this stuntdouble
         * @return the velocity of this stuntdouble
         */    
        Vector3d getVel() {
            return sd_->getVel();
        }

       /**
         * Returns the velocity of this stuntdouble in specified snapshot 
         * @return the velocity of this stuntdouble
         * @param snapshotNo
         */    

         Vector3d getVel(int snapshotNo) {
            return sd_->getVel(snapshotNo);
        }

       /**
         * Sets  the previous velocity of this stuntdouble
         * @param vel  new velocity 
         * @see #getVel
         */         
       void setPrevVel(const Vector3d& vel) {
            sd_->setPrevVel(vel);
       }
       
       /**
         * Sets  the current velocity of this stuntdouble
         * @param vel  new velocity 
         */         
        void setVel(const Vector3d& vel) {
            sd_->setVel(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) {
            sd_->setVel(vel, snapshotNo);
        }

       /**
         * Returns the previous rotation matrix of this stuntdouble
         * @return the rotation matrix of this stuntdouble
         */    
        RotMat3x3d getPrevA() {
            return sd_->getPrevA();
        }
       
        /**
         * Returns the current rotation matrix of this stuntdouble
         * @return the rotation matrix of this stuntdouble
         */    
        RotMat3x3d getA() {
            return sd_->getA();
        }

       /**
         * Returns the rotation matrix of this stuntdouble in specified snapshot 
         *
         * @return the rotation matrix of this stuntdouble
         * @param snapshotNo
         */    
         RotMat3x3d getA(int snapshotNo) {
            return sd_->getA(snapshotNo);
        }

       /**
         * Sets  the previous rotation matrix of this stuntdouble
         * @param a  new rotation matrix 
         * @see #getA
         */         
       void setPrevA(const RotMat3x3d& a) {
            sd_->setPrevA(a);
       }
       
       /**
         * Sets  the current rotation matrix of this stuntdouble
         * @param a  new rotation matrix 
         */         
        void setA(const RotMat3x3d& a) {
            sd_->setA(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) {
            sd_->setA(a, snapshotNo);
        }       

       /**
         * Returns the previous angular momentum of this stuntdouble (body-fixed).
         * @return the angular momentum of this stuntdouble
         */    
        Vector3d getPrevJ() {
            return sd_->getPrevJ();
        }
       
        /**
         * Returns the current angular momentum of this stuntdouble (body -fixed).
         * @return the angular momentum of this stuntdouble
         */    
        Vector3d getJ() {
            return sd_->getJ();
        }

       /**
         * Returns the angular momentum of this stuntdouble in specified snapshot (body-fixed).
         * @return the angular momentum of this stuntdouble
         * @param snapshotNo
         */    
         Vector3d getJ(int snapshotNo) {
            return sd_->getJ(snapshotNo);
        }

       /**
         * Sets  the previous angular momentum of this stuntdouble (body-fixed).
         * @param angMom  new angular momentum 
         * @see #getJ
         */         
       void setPrevJ(const Vector3d& angMom) {
            sd_->setPrevJ(angMom);
       }
       
       /**
         * Sets  the current angular momentum of this stuntdouble (body-fixed).
         * @param angMom  new angular momentum 
         */         
        void setJ(const Vector3d& angMom) {
            sd_->setJ(angMom);
        }

       /**
         * Sets the angular momentum of this stuntdouble in specified snapshot(body-fixed).
         * @param angMom angular momentum to be set 
         * @param snapshotNo 
         * @see #getJ
         */         
        void setJ(const Vector3d& angMom, int snapshotNo) {
            sd_->setJ(angMom, snapshotNo);
        }
         
       /**
         * Returns the previous quaternion of this stuntdouble
         * @return the quaternion of this stuntdouble
         */    
        Quat4d getPrevQ() {
            return sd_->getPrevQ();
        }
       
        /**
         * Returns the current quaternion of this stuntdouble
         * @return the quaternion of this stuntdouble
         */    
        Quat4d getQ() {
            return sd_->getQ();
        }

       /**
         * Returns the quaternion of this stuntdouble in specified snapshot 
         * @return the quaternion of this stuntdouble
         * @param snapshotNo
         */    
         Quat4d getQ(int snapshotNo) {
            return sd_->getQ(snapshotNo);
        }

       /**
         * Sets  the previous quaternion of this stuntdouble
         * @param q  new quaternion 
         * @note actual storage data is rotation matrix
         */         
       void setPrevQ(const Quat4d& q) {
            sd_->setPrevQ(q);
       }
       
       /**
         * Sets  the current quaternion of this stuntdouble
         * @param q  new quaternion 
         * @note actual storage data is rotation matrix
         */         
        void setQ(const Quat4d& q) {
            sd_->setQ(q);
        }

       /**
         * Sets  the quaternion of this stuntdouble in specified snapshot
         *
         * @param q quaternion to be set 
         * @param snapshotNo 
         * @note actual storage data is rotation matrix
         */         
        void setQ(const Quat4d& q, int snapshotNo) {
            sd_->setQ(q, snapshotNo);
        }

       /**
         * Returns the previous euler angles of this stuntdouble
         * @return the euler angles of this stuntdouble
         */    
        Vector3d getPrevEuler() {
            return sd_->getPrevEuler();
        }
       
        /**
         * Returns the current euler angles of this stuntdouble
         * @return the euler angles of this stuntdouble
         */    
        Vector3d getEuler() {
            return sd_->getEuler();
        }

       /**
         * Returns the euler angles of this stuntdouble in specified snapshot.
         * @return the euler angles of this stuntdouble
         * @param snapshotNo
         */    
         Vector3d getEuler(int snapshotNo) {
            return sd_->getEuler(snapshotNo);
        }

       /**
         * Sets  the previous euler angles of this stuntdouble.
         * @param euler  new euler angles 
         * @see #getEuler
         * @note actual storage data is rotation matrix         
         */         
        void setPrevEuler(const Vector3d& euler) {
            sd_->setPrevEuler(euler);
        }
       
       /**
         * Sets  the current euler angles of this stuntdouble
         * @param euler  new euler angles 
         */         
        void setEuler(const Vector3d& euler) {
            sd_->setEuler(euler);
        }

       /**
         * Sets  the euler angles  of this stuntdouble in specified snapshot
         *
         * @param euler euler angles to be set 
         * @param snapshotNo 
         * @note actual storage data is rotation matrix                  
         */         
        void setEuler(const Vector3d& euler, int snapshotNo) {
            sd_->setEuler(euler, snapshotNo);
        }
       
       /**
         * Returns the previous unit vectors of this stuntdouble
         * @return the unit vectors of this stuntdouble
         */    
        RotMat3x3d getPrevElectroFrame() {
            return sd_->getPrevElectroFrame();
        }
       
        /**
         * Returns the current unit vectors of this stuntdouble
         * @return the unit vectors of this stuntdouble
         */    
        RotMat3x3d getElectroFrame() {
            return sd_->getElectroFrame();
        }

       /**
         * Returns the unit vectors of this stuntdouble in specified snapshot 
         *
         * @return the unit vectors of this stuntdouble
         * @param snapshotNo
         */    
         RotMat3x3d getElectroFrame(int snapshotNo) {
            return sd_->getElectroFrame(snapshotNo);
        }

       /**
         * Returns the previous force of this stuntdouble
         * @return the force of this stuntdouble
         */    
        Vector3d getPrevFrc() {
            return sd_->getPrevFrc();
        }
       
        /**
         * Returns the current force of this stuntdouble
         * @return the force of this stuntdouble
         */    
        Vector3d getFrc() {
            return sd_->getFrc();
        }

       /**
         * Returns the force of this stuntdouble in specified snapshot 
         *
         * @return the force of this stuntdouble
         * @param snapshotNo
         */    
         Vector3d getFrc(int snapshotNo) {
            return sd_->getFrc(snapshotNo);
        }

       /**
         * Sets  the previous force of this stuntdouble
         *
         * @param frc  new force 
         * @see #getFrc
         */         
        void setPrevFrc(const Vector3d& frc) {
            sd_->setPrevFrc(frc);
        }
       
       /**
         * Sets  the current force of this stuntdouble
         * @param frc  new force 
         */         
        void setFrc(const Vector3d& frc) {
            sd_->setFrc(frc);
        }

       /**
         * Sets  the force of this stuntdouble in specified snapshot
         *
         * @param frc force to be set 
         * @param snapshotNo 
         * @see #getFrc
         */         
        void setFrc(const Vector3d& frc, int snapshotNo) {
            sd_->setFrc(frc, snapshotNo);
        }

       /**
         * Adds force into the previous force of this stuntdouble
         *
         * @param frc  new force 
         * @see #getFrc
         */         
       void addPrevFrc(const Vector3d& frc) {
            sd_->addPrevFrc(frc);
       }
       
       /**
         * Adds force into the current force of this stuntdouble
         * @param frc  new force 
         */         
        void addFrc(const Vector3d& frc) {
            sd_->addFrc(frc);
        }

       /**
         * Adds force into the force of this stuntdouble in specified snapshot
         *
         * @param frc force to be set 
         * @param snapshotNo 
         * @see #getFrc
         */         
        void addFrc(const Vector3d& frc, int snapshotNo) {
            sd_->addFrc(frc, snapshotNo);
        }

       /**
         * Returns the previous torque of this stuntdouble
         * @return the torque of this stuntdouble
         */    
        Vector3d getPrevTrq() {
            return sd_->getPrevTrq();
        }
       
        /**
         * Returns the current torque of this stuntdouble
         * @return the torque of this stuntdouble
         */    
        Vector3d getTrq() {
            return sd_->getTrq();
        }

       /**
         * Returns the torque of this stuntdouble in specified snapshot 
         *
         * @return the torque of this stuntdouble
         * @param snapshotNo
         */    
         Vector3d getTrq(int snapshotNo) {
            return sd_->getTrq(snapshotNo);
        }

       /**
         * Sets  the previous torque of this stuntdouble
         *
         * @param trq  new torque 
         * @see #getTrq
         */         
        void setPrevTrq(const Vector3d& trq) {
            sd_->setPrevTrq(trq);
        }
       
       /**
         * Sets  the current torque of this stuntdouble
         * @param trq  new torque 
         */         
        void setTrq(const Vector3d& trq) {
            sd_->setTrq(trq);
        }

       /**
         * Sets  the torque of this stuntdouble in specified snapshot
         *
         * @param trq torque to be set 
         * @param snapshotNo 
         * @see #getTrq
         */         
        void setTrq(const Vector3d& trq, int snapshotNo) {
            sd_->setTrq(trq, snapshotNo);
        }

       /**
         * Adds torque into the previous torque of this stuntdouble
         *
         * @param trq  new torque 
         * @see #getTrq
         */         
        void addPrevTrq(const Vector3d& trq) {
            sd_->addPrevTrq(trq);
        }
       
       /**
         * Adds torque into the current torque of this stuntdouble
         * @param trq  new torque 
         */         
        void addTrq(const Vector3d& trq) {
            sd_->addTrq(trq);
        }

       /**
         * Adds torque into the torque of this stuntdouble in specified snapshot
         *
         * @param trq torque to be add 
         * @param snapshotNo 
         * @see #getTrq
         */         
        void addTrq(const Vector3d& trq, int snapshotNo) {
            sd_->addTrq(trq, snapshotNo);
        }       
      
        /** Set the force of this stuntdouble to zero */
        void zeroForcesAndTorques() {
            sd_->zeroForcesAndTorques();
        }
       /**
         * Returns the inertia tensor of this stuntdouble
         * @return the inertia tensor of this stuntdouble
         */ 
        Mat3x3d getI() {
            return sd_->getI();
       }

       /**
         * Returns the gradient of this stuntdouble
         * @return the gradient of this stuntdouble
         */ 
        std::vector<double> getGrad() {
            return sd_->getGrad();
       }

       /**
         * Tests the  if this stuntdouble is a  linear rigidbody
         *
         * @return true if this stuntdouble is a  linear rigidbody, otherwise return false
         * @note atom and directional atom will always return false
         * 
         * @see #linearAxis
         */         
        bool isLinear() {
            return sd_->isLinear();
        }

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

        /** Returns the mass of this stuntdouble */
        double getMass() {
            return sd_->getMass();
        }

        /**
         * Sets the mass of this stuntdoulbe
         * @param mass the mass to be set
         */         
        void setMass(double mass) {
            sd_->setMass(mass);
        }

        /** Returns the name of this stuntdouble */
        std::string getType() {
            return sd_->getType();
        }
        
        /** Sets the name of this stuntdouble*/
        void setType(const std::string& name) {
            sd_->setType(name);
        }

        /**
         * Converts a lab fixed vector to a body fixed vector.
         * @return body fixed vector
         * @param v lab fixed vector
         */
        Vector3d lab2Body(const Vector3d& v) {
            return sd_->lab2Body(v);
        }

        /**
         * Converts a body fixed vector to a lab fixed vector.
         * @return corresponding lab fixed vector
         * @param v body fixed vector
         */
        Vector3d body2Lab(const Vector3d& v){
            return sd_->body2Lab(v);
        }
        /**
         * <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
         */      
        void accept(BaseVisitor* v) {
            sd_->accept(v);
        }

        //below functions are just forward functions
        /**
         * Adds property into property map
         * @param genData GenericData to be added into PropertyMap
         */
        void addProperty(GenericData* genData){
            sd_->addProperty(genData);
        }

        /**
         * Removes property from PropertyMap by name
         * @param propName the name of property to be removed
         */
        void removeProperty(const std::string& propName) {
            sd_->removeProperty(propName);
        }

        /**
         * clear all of the properties
         */
        void clearProperties() {
            sd_->clearProperties();
        }

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

        /**
         * Returns all of the properties in PropertyMap
         * @return all of the properties in PropertyMap
         */      
        std::vector<GenericData*> getProperties() {
            return sd_->getProperties();
        }

        /**
         * Returns property 
         * @param propName name of property
         * @return a pointer point to property with propName. If no property named propName
         * exists, return NULL
         */      
        GenericData* getPropertyByName(const std::string& propName) {
            return sd_->getPropertyByName(propName);
        }
        
    private:
        StuntDouble* sd_;
        BoolGenericData* moved_;
        BoolGenericData* moving_;
};

}

#endif
Revision:	1910
Committed:	Fri Jan 7 21:50:13 2005 UTC (19 years, 5 months ago) by tim
File size:	25016 byte(s)
Log Message:	ZConstraintForceManager in progress
#	User	Rev	Content
1	tim	1910	/*
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
26			#ifndef CONSTRAINTS_CONTRAINTELEM_HPP
27			#define CONSTRAINTS_CONTRAINTELEM_HPP
28
29			#include "primitives/StuntDouble.hpp"
30			#include "utils/GenericData.hpp"
31			#include "utils/simError.h"
32			namespace oopse {
33
34			/**
35			* @class ConstraintElem ConstraintElem.hpp "constraints/ConstraintElem.hpp"
36			* An adapter class of StuntDouble which is used at constraint algorithm
37			*/
38
39			class ConstraintElem{
40			public:
41			ConstraintElem(StuntDouble* sd) : sd_(sd) {
42			GenericData* movedData = sd_->getPropertyByName("Moved");
43			if (movedData !=NULL) { //if generic data with keyword "moved" exists, assign it to moved_
44			moved_ = dynamic_cast<BoolGenericData*>(movedData);
45			if (moved_ == NULL) {
46			sprintf(painCave.errMsg,
47			"Generic Data with keyword Moved exists, however, it can not be casted to a BoolGenericData.\n");
48			painCave.isFatal = 1;;
49			simError();
50			}
51			}else { //if generic data with keyword "moved" does not exist, create it
52			moved_ = new BoolGenericData("Moved");
53			sd_->addProperty(moved_);
54			}
55
56			GenericData* movingData = sd_->getPropertyByName("Moving");
57			if (movingData !=NULL) {
58			moving_ = dynamic_cast<BoolGenericData*>(movingData);
59			if (moving_ == NULL) {
60			sprintf(painCave.errMsg,
61			"Generic Data with keyword Moving exists, however, it can not be casted to a BoolGenericData.\n");
62			painCave.isFatal = 1;;
63			simError();
64			}
65			}else {
66			moving_ = new BoolGenericData("Moving");
67			sd_->addProperty(moving_);
68			}
69
70			}
71
72			bool getMoved() { return moved_->getData(); }
73			void setMoved(bool moved) { moved_->setData(moved);}
74
75			bool getMoving() { return moving_->getData(); }
76			void setMoving(bool moving) { moving_->setData(moving); }
77
78			StuntDouble* getStuntDouble() { return sd_; }
79
80			/**
81			* Returns the global index of this stuntdouble.
82			* @return the global index of this stuntdouble
83			*/
84			int getGlobalIndex() {
85			return sd_->getGlobalIndex();
86			}
87
88			/**
89			* Sets the global index of this stuntdouble.
90			* @param new global index to be set
91			*/
92			void setGlobalIndex(int index) {
93			sd_->setGlobalIndex(index);
94			}
95
96			/**
97			* Returns the local index of this stuntdouble
98			* @return the local index of this stuntdouble
99			*/
100			int getLocalIndex() {
101			return sd_->getLocalIndex();
102			}
103
104			/**
105			* Sets the local index of this stuntdouble
106			* @param index new index to be set
107			*/
108			void setLocalIndex(int index) {
109			sd_->setLocalIndex(index);
110			}
111
112			/**
113			* Sets the Snapshot Manager of this stuntdouble
114			*/
115			void setSnapshotManager(SnapshotManager* sman) {
116			sd_->setSnapshotManager(sman);
117			}
118
119			/**
120			* Tests if this stuntdouble is an atom
121			* @return true is this stuntdouble is an atom(or a directional atom), return false otherwise
122			*/
123			bool isAtom(){
124			return sd_->isAtom();
125			}
126
127			/**
128			* Tests if this stuntdouble is an directional atom
129			* @return true if this stuntdouble is an directional atom, return false otherwise
130			*/
131			bool isDirectionalAtom(){
132			return sd_->isDirectional();
133			}
134
135			/**
136			* Tests if this stuntdouble is a rigid body.
137			* @return true if this stuntdouble is a rigid body, otherwise return false
138			*/
139			bool isRigidBody(){
140			return sd_->isRigidBody();
141			}
142
143			/**
144			* Tests if this stuntdouble is a directional one.
145			* @return true is this stuntdouble is a directional atom or a rigid body, return false otherwise
146			*/
147			bool isDirectional(){
148			return sd_->isDirectional();
149			}
150
151			/**
152			* Returns the previous position of this stuntdouble
153			* @return the position of this stuntdouble
154			*/
155			Vector3d getPrevPos() {
156			return sd_->getPrevPos();
157			}
158
159			/**
160			* Returns the current position of this stuntdouble
161			* @return the position of this stuntdouble
162			*/
163			Vector3d getPos() {
164			return sd_->getPos();
165			}
166
167			/**
168			* Returns the position of this stuntdouble in specified snapshot
169			* @return the position of this stuntdouble
170			* @param snapshotNo
171			*/
172			Vector3d getPos(int snapshotNo) {
173			return sd_->getPos(snapshotNo);
174			}
175
176			/**
177			* Sets the previous position of this stuntdouble
178			* @param pos new position
179			* @see #getPos
180			*/
181			void setPrevPos(const Vector3d& pos) {
182			sd_->setPrevPos(pos);
183			}
184
185			/**
186			* Sets the current position of this stuntdouble
187			* @param pos new position
188			*/
189			void setPos(const Vector3d& pos) {
190			sd_->setPos(pos);
191			}
192
193			/**
194			* Sets the position of this stuntdouble in specified snapshot
195			* @param pos position to be set
196			* @param snapshotNo
197			* @see #getPos
198			*/
199			void setPos(const Vector3d& pos, int snapshotNo) {
200			sd_->setPos(pos, snapshotNo);
201			}
202
203			/**
204			* Returns the previous velocity of this stuntdouble
205			* @return the velocity of this stuntdouble
206			*/
207			Vector3d getPrevVel() {
208			return sd_->getPrevVel();
209			}
210
211			/**
212			* Returns the current velocity of this stuntdouble
213			* @return the velocity of this stuntdouble
214			*/
215			Vector3d getVel() {
216			return sd_->getVel();
217			}
218
219			/**
220			* Returns the velocity of this stuntdouble in specified snapshot
221			* @return the velocity of this stuntdouble
222			* @param snapshotNo
223			*/
224
225			Vector3d getVel(int snapshotNo) {
226			return sd_->getVel(snapshotNo);
227			}
228
229			/**
230			* Sets the previous velocity of this stuntdouble
231			* @param vel new velocity
232			* @see #getVel
233			*/
234			void setPrevVel(const Vector3d& vel) {
235			sd_->setPrevVel(vel);
236			}
237
238			/**
239			* Sets the current velocity of this stuntdouble
240			* @param vel new velocity
241			*/
242			void setVel(const Vector3d& vel) {
243			sd_->setVel(vel);
244			}
245
246			/**
247			* Sets the velocity of this stuntdouble in specified snapshot
248			* @param vel velocity to be set
249			* @param snapshotNo
250			* @see #getVel
251			*/
252			void setVel(const Vector3d& vel, int snapshotNo) {
253			sd_->setVel(vel, snapshotNo);
254			}
255
256			/**
257			* Returns the previous rotation matrix of this stuntdouble
258			* @return the rotation matrix of this stuntdouble
259			*/
260			RotMat3x3d getPrevA() {
261			return sd_->getPrevA();
262			}
263
264			/**
265			* Returns the current rotation matrix of this stuntdouble
266			* @return the rotation matrix of this stuntdouble
267			*/
268			RotMat3x3d getA() {
269			return sd_->getA();
270			}
271
272			/**
273			* Returns the rotation matrix of this stuntdouble in specified snapshot
274			*
275			* @return the rotation matrix of this stuntdouble
276			* @param snapshotNo
277			*/
278			RotMat3x3d getA(int snapshotNo) {
279			return sd_->getA(snapshotNo);
280			}
281
282			/**
283			* Sets the previous rotation matrix of this stuntdouble
284			* @param a new rotation matrix
285			* @see #getA
286			*/
287			void setPrevA(const RotMat3x3d& a) {
288			sd_->setPrevA(a);
289			}
290
291			/**
292			* Sets the current rotation matrix of this stuntdouble
293			* @param a new rotation matrix
294			*/
295			void setA(const RotMat3x3d& a) {
296			sd_->setA(a);
297			}
298
299			/**
300			* Sets the rotation matrix of this stuntdouble in specified snapshot
301			* @param a rotation matrix to be set
302			* @param snapshotNo
303			* @see #getA
304			*/
305			void setA(const RotMat3x3d& a, int snapshotNo) {
306			sd_->setA(a, snapshotNo);
307			}
308
309			/**
310			* Returns the previous angular momentum of this stuntdouble (body-fixed).
311			* @return the angular momentum of this stuntdouble
312			*/
313			Vector3d getPrevJ() {
314			return sd_->getPrevJ();
315			}
316
317			/**
318			* Returns the current angular momentum of this stuntdouble (body -fixed).
319			* @return the angular momentum of this stuntdouble
320			*/
321			Vector3d getJ() {
322			return sd_->getJ();
323			}
324
325			/**
326			* Returns the angular momentum of this stuntdouble in specified snapshot (body-fixed).
327			* @return the angular momentum of this stuntdouble
328			* @param snapshotNo
329			*/
330			Vector3d getJ(int snapshotNo) {
331			return sd_->getJ(snapshotNo);
332			}
333
334			/**
335			* Sets the previous angular momentum of this stuntdouble (body-fixed).
336			* @param angMom new angular momentum
337			* @see #getJ
338			*/
339			void setPrevJ(const Vector3d& angMom) {
340			sd_->setPrevJ(angMom);
341			}
342
343			/**
344			* Sets the current angular momentum of this stuntdouble (body-fixed).
345			* @param angMom new angular momentum
346			*/
347			void setJ(const Vector3d& angMom) {
348			sd_->setJ(angMom);
349			}
350
351			/**
352			* Sets the angular momentum of this stuntdouble in specified snapshot(body-fixed).
353			* @param angMom angular momentum to be set
354			* @param snapshotNo
355			* @see #getJ
356			*/
357			void setJ(const Vector3d& angMom, int snapshotNo) {
358			sd_->setJ(angMom, snapshotNo);
359			}
360
361			/**
362			* Returns the previous quaternion of this stuntdouble
363			* @return the quaternion of this stuntdouble
364			*/
365			Quat4d getPrevQ() {
366			return sd_->getPrevQ();
367			}
368
369			/**
370			* Returns the current quaternion of this stuntdouble
371			* @return the quaternion of this stuntdouble
372			*/
373			Quat4d getQ() {
374			return sd_->getQ();
375			}
376
377			/**
378			* Returns the quaternion of this stuntdouble in specified snapshot
379			* @return the quaternion of this stuntdouble
380			* @param snapshotNo
381			*/
382			Quat4d getQ(int snapshotNo) {
383			return sd_->getQ(snapshotNo);
384			}
385
386			/**
387			* Sets the previous quaternion of this stuntdouble
388			* @param q new quaternion
389			* @note actual storage data is rotation matrix
390			*/
391			void setPrevQ(const Quat4d& q) {
392			sd_->setPrevQ(q);
393			}
394
395			/**
396			* Sets the current quaternion of this stuntdouble
397			* @param q new quaternion
398			* @note actual storage data is rotation matrix
399			*/
400			void setQ(const Quat4d& q) {
401			sd_->setQ(q);
402			}
403
404			/**
405			* Sets the quaternion of this stuntdouble in specified snapshot
406			*
407			* @param q quaternion to be set
408			* @param snapshotNo
409			* @note actual storage data is rotation matrix
410			*/
411			void setQ(const Quat4d& q, int snapshotNo) {
412			sd_->setQ(q, snapshotNo);
413			}
414
415			/**
416			* Returns the previous euler angles of this stuntdouble
417			* @return the euler angles of this stuntdouble
418			*/
419			Vector3d getPrevEuler() {
420			return sd_->getPrevEuler();
421			}
422
423			/**
424			* Returns the current euler angles of this stuntdouble
425			* @return the euler angles of this stuntdouble
426			*/
427			Vector3d getEuler() {
428			return sd_->getEuler();
429			}
430
431			/**
432			* Returns the euler angles of this stuntdouble in specified snapshot.
433			* @return the euler angles of this stuntdouble
434			* @param snapshotNo
435			*/
436			Vector3d getEuler(int snapshotNo) {
437			return sd_->getEuler(snapshotNo);
438			}
439
440			/**
441			* Sets the previous euler angles of this stuntdouble.
442			* @param euler new euler angles
443			* @see #getEuler
444			* @note actual storage data is rotation matrix
445			*/
446			void setPrevEuler(const Vector3d& euler) {
447			sd_->setPrevEuler(euler);
448			}
449
450			/**
451			* Sets the current euler angles of this stuntdouble
452			* @param euler new euler angles
453			*/
454			void setEuler(const Vector3d& euler) {
455			sd_->setEuler(euler);
456			}
457
458			/**
459			* Sets the euler angles of this stuntdouble in specified snapshot
460			*
461			* @param euler euler angles to be set
462			* @param snapshotNo
463			* @note actual storage data is rotation matrix
464			*/
465			void setEuler(const Vector3d& euler, int snapshotNo) {
466			sd_->setEuler(euler, snapshotNo);
467			}
468
469			/**
470			* Returns the previous unit vectors of this stuntdouble
471			* @return the unit vectors of this stuntdouble
472			*/
473			RotMat3x3d getPrevElectroFrame() {
474			return sd_->getPrevElectroFrame();
475			}
476
477			/**
478			* Returns the current unit vectors of this stuntdouble
479			* @return the unit vectors of this stuntdouble
480			*/
481			RotMat3x3d getElectroFrame() {
482			return sd_->getElectroFrame();
483			}
484
485			/**
486			* Returns the unit vectors of this stuntdouble in specified snapshot
487			*
488			* @return the unit vectors of this stuntdouble
489			* @param snapshotNo
490			*/
491			RotMat3x3d getElectroFrame(int snapshotNo) {
492			return sd_->getElectroFrame(snapshotNo);
493			}
494
495			/**
496			* Returns the previous force of this stuntdouble
497			* @return the force of this stuntdouble
498			*/
499			Vector3d getPrevFrc() {
500			return sd_->getPrevFrc();
501			}
502
503			/**
504			* Returns the current force of this stuntdouble
505			* @return the force of this stuntdouble
506			*/
507			Vector3d getFrc() {
508			return sd_->getFrc();
509			}
510
511			/**
512			* Returns the force of this stuntdouble in specified snapshot
513			*
514			* @return the force of this stuntdouble
515			* @param snapshotNo
516			*/
517			Vector3d getFrc(int snapshotNo) {
518			return sd_->getFrc(snapshotNo);
519			}
520
521			/**
522			* Sets the previous force of this stuntdouble
523			*
524			* @param frc new force
525			* @see #getFrc
526			*/
527			void setPrevFrc(const Vector3d& frc) {
528			sd_->setPrevFrc(frc);
529			}
530
531			/**
532			* Sets the current force of this stuntdouble
533			* @param frc new force
534			*/
535			void setFrc(const Vector3d& frc) {
536			sd_->setFrc(frc);
537			}
538
539			/**
540			* Sets the force of this stuntdouble in specified snapshot
541			*
542			* @param frc force to be set
543			* @param snapshotNo
544			* @see #getFrc
545			*/
546			void setFrc(const Vector3d& frc, int snapshotNo) {
547			sd_->setFrc(frc, snapshotNo);
548			}
549
550			/**
551			* Adds force into the previous force of this stuntdouble
552			*
553			* @param frc new force
554			* @see #getFrc
555			*/
556			void addPrevFrc(const Vector3d& frc) {
557			sd_->addPrevFrc(frc);
558			}
559
560			/**
561			* Adds force into the current force of this stuntdouble
562			* @param frc new force
563			*/
564			void addFrc(const Vector3d& frc) {
565			sd_->addFrc(frc);
566			}
567
568			/**
569			* Adds force into the force of this stuntdouble in specified snapshot
570			*
571			* @param frc force to be set
572			* @param snapshotNo
573			* @see #getFrc
574			*/
575			void addFrc(const Vector3d& frc, int snapshotNo) {
576			sd_->addFrc(frc, snapshotNo);
577			}
578
579			/**
580			* Returns the previous torque of this stuntdouble
581			* @return the torque of this stuntdouble
582			*/
583			Vector3d getPrevTrq() {
584			return sd_->getPrevTrq();
585			}
586
587			/**
588			* Returns the current torque of this stuntdouble
589			* @return the torque of this stuntdouble
590			*/
591			Vector3d getTrq() {
592			return sd_->getTrq();
593			}
594
595			/**
596			* Returns the torque of this stuntdouble in specified snapshot
597			*
598			* @return the torque of this stuntdouble
599			* @param snapshotNo
600			*/
601			Vector3d getTrq(int snapshotNo) {
602			return sd_->getTrq(snapshotNo);
603			}
604
605			/**
606			* Sets the previous torque of this stuntdouble
607			*
608			* @param trq new torque
609			* @see #getTrq
610			*/
611			void setPrevTrq(const Vector3d& trq) {
612			sd_->setPrevTrq(trq);
613			}
614
615			/**
616			* Sets the current torque of this stuntdouble
617			* @param trq new torque
618			*/
619			void setTrq(const Vector3d& trq) {
620			sd_->setTrq(trq);
621			}
622
623			/**
624			* Sets the torque of this stuntdouble in specified snapshot
625			*
626			* @param trq torque to be set
627			* @param snapshotNo
628			* @see #getTrq
629			*/
630			void setTrq(const Vector3d& trq, int snapshotNo) {
631			sd_->setTrq(trq, snapshotNo);
632			}
633
634			/**
635			* Adds torque into the previous torque of this stuntdouble
636			*
637			* @param trq new torque
638			* @see #getTrq
639			*/
640			void addPrevTrq(const Vector3d& trq) {
641			sd_->addPrevTrq(trq);
642			}
643
644			/**
645			* Adds torque into the current torque of this stuntdouble
646			* @param trq new torque
647			*/
648			void addTrq(const Vector3d& trq) {
649			sd_->addTrq(trq);
650			}
651
652			/**
653			* Adds torque into the torque of this stuntdouble in specified snapshot
654			*
655			* @param trq torque to be add
656			* @param snapshotNo
657			* @see #getTrq
658			*/
659			void addTrq(const Vector3d& trq, int snapshotNo) {
660			sd_->addTrq(trq, snapshotNo);
661			}
662
663			/** Set the force of this stuntdouble to zero */
664			void zeroForcesAndTorques() {
665			sd_->zeroForcesAndTorques();
666			}
667			/**
668			* Returns the inertia tensor of this stuntdouble
669			* @return the inertia tensor of this stuntdouble
670			*/
671			Mat3x3d getI() {
672			return sd_->getI();
673			}
674
675			/**
676			* Returns the gradient of this stuntdouble
677			* @return the gradient of this stuntdouble
678			*/
679			std::vector<double> getGrad() {
680			return sd_->getGrad();
681			}
682
683			/**
684			* Tests the if this stuntdouble is a linear rigidbody
685			*
686			* @return true if this stuntdouble is a linear rigidbody, otherwise return false
687			* @note atom and directional atom will always return false
688			*
689			* @see #linearAxis
690			*/
691			bool isLinear() {
692			return sd_->isLinear();
693			}
694
695			/**
696			* Returns the linear axis of the rigidbody, atom and directional atom will always return -1
697			*
698			* @return the linear axis of the rigidbody
699			*
700			* @see #isLinear
701			*/
702			int linearAxis() {
703			return sd_->linearAxis();
704			}
705
706			/** Returns the mass of this stuntdouble */
707			double getMass() {
708			return sd_->getMass();
709			}
710
711			/**
712			* Sets the mass of this stuntdoulbe
713			* @param mass the mass to be set
714			*/
715			void setMass(double mass) {
716			sd_->setMass(mass);
717			}
718
719			/** Returns the name of this stuntdouble */
720			std::string getType() {
721			return sd_->getType();
722			}
723
724			/** Sets the name of this stuntdouble*/
725			void setType(const std::string& name) {
726			sd_->setType(name);
727			}
728
729			/**
730			* Converts a lab fixed vector to a body fixed vector.
731			* @return body fixed vector
732			* @param v lab fixed vector
733			*/
734			Vector3d lab2Body(const Vector3d& v) {
735			return sd_->lab2Body(v);
736			}
737
738			/**
739			* Converts a body fixed vector to a lab fixed vector.
740			* @return corresponding lab fixed vector
741			* @param v body fixed vector
742			*/
743			Vector3d body2Lab(const Vector3d& v){
744			return sd_->body2Lab(v);
745			}
746			/**
747			* <p>
748			* The purpose of the Visitor Pattern is to encapsulate an operation that you want to perform on
749			* the elements of a data structure. In this way, you can change the operation being performed
750			* on a structure without the need of changing the classes of the elements that you are operating
751			* on. Using a Visitor pattern allows you to decouple the classes for the data structure and the
752			* algorithms used upon them
753			* </p>
754			* @param v visitor
755			*/
756			void accept(BaseVisitor* v) {
757			sd_->accept(v);
758			}
759
760			//below functions are just forward functions
761			/**
762			* Adds property into property map
763			* @param genData GenericData to be added into PropertyMap
764			*/
765			void addProperty(GenericData* genData){
766			sd_->addProperty(genData);
767			}
768
769			/**
770			* Removes property from PropertyMap by name
771			* @param propName the name of property to be removed
772			*/
773			void removeProperty(const std::string& propName) {
774			sd_->removeProperty(propName);
775			}
776
777			/**
778			* clear all of the properties
779			*/
780			void clearProperties() {
781			sd_->clearProperties();
782			}
783
784			/**
785			* Returns all names of properties
786			* @return all names of properties
787			*/
788			std::vector<std::string> getPropertyNames() {
789			return sd_->getPropertyNames();
790			}
791
792			/**
793			* Returns all of the properties in PropertyMap
794			* @return all of the properties in PropertyMap
795			*/
796			std::vector<GenericData*> getProperties() {
797			return sd_->getProperties();
798			}
799
800			/**
801			* Returns property
802			* @param propName name of property
803			* @return a pointer point to property with propName. If no property named propName
804			* exists, return NULL
805			*/
806			GenericData* getPropertyByName(const std::string& propName) {
807			return sd_->getPropertyByName(propName);
808			}
809
810			private:
811			StuntDouble* sd_;
812			BoolGenericData* moved_;
813			BoolGenericData* moving_;
814			};
815
816			}
817
818			#endif