OOPSE/libmdtools/ConstraintElement.hpp

#ifndef _CONSTRAINTELEMENT_H_
#define _CONSTRAINTELEMENT_H_

#include "RigidBody.hpp"
#include "Atom.hpp"


//class ConstraintElement is designed to not only provide the interface of StuntDouble, but also 
//neccessary functionality to retrieve old position, old velocity and etc.
//First of all, those old data should be stored inside StuntDouble. We decide to store it on StuntDouble's
//generic property.
////////////////////////////////////////////////////////////////////////////////
//Declaration of ConstraintElement
////////////////////////////////////////////////////////////////////////////////
class ConstraintElement{
  public:

    virtual ~ConstraintElement() {}

    //Interface of stunt double
    bool isAtom() {return refSd->isAtom();}
    bool isDirectionalAtom() {return refSd->isDirectional();}
    bool isRigidBody() {return refSd->isRigidBody();}

    double getMass(void) {return refSd->getMass();}
  
    void   getPos(double pos[3]) {refSd->getPos(pos);}
    void   setPos(double pos[3]) {refSd->setPos(pos);}

    void   getVel(double vel[3]) {refSd->getVel(vel);}
    void   setVel(double vel[3]) {refSd->setVel(vel);}

    void   getFrc(double frc[3]) {refSd->getFrc(frc);}
    void   addFrc(double frc[3]) {refSd->addFrc(frc);}

    void   getA(double A[3][3]) {refSd->getA(A);}
    void   setA(double A[3][3]) {refSd->setA(A);}

    void   getJ(double j[3]) {refSd->getJ(j);}
    void   setJ(double j[3]) {refSd->setJ(j);}

    void getQ( double q[4] ) {refSd->getQ(q);}
    void setQ( double q[4] ) {refSd->setQ(q);}

    void setType(char* type){refSd->setType(type);}
    char* getType() {return refSd->getType();}
    
    void   getTrq(double trq[3]) {refSd->getTrq(trq);}
    void   addTrq(double trq[3]) {refSd->addTrq(trq);}

    void   getI(double I[3][3]) {refSd->getI(I);}
    void   lab2Body(double vec[3]) {refSd->lab2Body(vec);}

    void   getGrad(double grad[6]) {refSd->getGrad(grad);}
    void   setEuler(double phi, double theta, double psi) {refSd->setEuler(phi, theta, psi);}
    void   getEulerAngles(double eulers[3]) {refSd->getEulerAngles(eulers);}

    bool isLinear() {return refSd->isLinear();}
    int linearAxis() {return refSd->linearAxis();}

    double   getZangle() {return refSd->getZangle();}
    void   setZangle(double zAngle) {refSd->setZangle(zAngle);}
    void   addZangle(double zAngle) {refSd->addZangle(zAngle);}


    virtual void getOldPos(double pos[3])=0;
    virtual void getOldVel(double vel[3])=0;
    virtual void getOldJ(double j[3])=0; 
    virtual void getOldA(double a[3][3])=0;
    virtual void getOldQ(double q[4])=0; 
    
    bool getMoved() {return movedData->getData();}
    void setMoved(bool status) {movedData->setData(status);}

    bool getMoving() {return movingData->getData();}
    void setMoving(bool status) {movingData->setData(status);}

    virtual void saveOldState() = 0;
    
  protected:
    ConstraintElement(StuntDouble* rhs);
    
    StuntDouble* refSd;
    
  private:
    BoolData* movedData;
    BoolData* movingData;

};


////////////////////////////////////////////////////////////////////////////////
//Declaration of ConsAtomData
////////////////////////////////////////////////////////////////////////////////
struct ConsAtomInfo{
  double pos[3];
  double vel[3];
  double a[3][3];
  double j[3];
  double q[4];
};

class ConsAtomData : public GenericData{
  public:
    ConsAtomData() : data(NULL){}
    ~ConsAtomData(){
      if(data != NULL)
        delete data;
    }

    ConsAtomInfo* getData() {return data;}
    void setData(ConsAtomInfo* info) {
      if (data != NULL)
        delete data;
      
      data = info;      
    }    
    
  private:
    ConsAtomInfo* data;
};
////////////////////////////////////////////////////////////////////////////////
//Declaration of ConstraintElement
////////////////////////////////////////////////////////////////////////////////
class ConstraintAtom : public ConstraintElement{
  public:
    ConstraintAtom(Atom* rhs);

    void getOldPos(double pos[3]);
    void getOldVel(double vel[3]); 
    void getOldJ(double j[3]);
    void getOldA(double a[3][3]);
    void getOldQ(double q[4]); 

    Atom* getAtom() {return dynamic_cast<Atom*>(refSd);}

    virtual void saveOldState();

  protected:
    ConsAtomInfo* oldConsAtomInfo;
    
};


////////////////////////////////////////////////////////////////////////////////
//Declaration of ConsRbData
////////////////////////////////////////////////////////////////////////////////
class ConsRbData : public GenericData{
  public:
    ConsRbData() : rb(NULL){}
    ~ConsRbData(){
      if (rb != NULL)
        delete rb;
    }    

    RigidBody* getData() {return rb;}
    void setData(RigidBody* rhs) {
      if (rb != NULL)
        delete rb;
      rb = rhs;
    }
    
  private:
    RigidBody* rb;
};

////////////////////////////////////////////////////////////////////////////////
//Declaration of ConstraintElement
////////////////////////////////////////////////////////////////////////////////
class ConstraintRigidBody : public ConstraintElement{
  public:
    ConstraintRigidBody(RigidBody*rhs, int index);

    void getOldPos(double pos[3]) {oldRb->getPos(pos);}
    void getOldVel(double vel[3]) {oldRb->getVel(vel);}    
    void getOldJ(double j[3]) {oldRb->getJ(j);}
    void getOldA(double a[3][3]) {oldRb->getA(a);}
    void getOldQ(double q[4]) {oldRb->getQ(q);}
    
    void getOldAtomPos(double pos[3]) {oldRb->getAtomPos(pos, consAtomIndex);}
    void getCurAtomPos(double pos[3]) {((RigidBody*)refSd)->getAtomPos(pos, consAtomIndex);}
    
    RigidBody* getRigidBody() { return dynamic_cast<RigidBody*>(refSd);}

    virtual void saveOldState();
    
  private:
    int consAtomIndex;
    RigidBody* oldRb;
};
#endif // endif _CONSTRAINTELEMENT_H_
Revision:	1232
Committed:	Thu Jun 3 21:51:55 2004 UTC (20 years, 1 month ago) by tim
File size:	5799 byte(s)
Log Message:	new implementation of constraint
#	User	Rev	Content
1	tim	1232	#ifndef _CONSTRAINTELEMENT_H_
2			#define _CONSTRAINTELEMENT_H_
3
4			#include "RigidBody.hpp"
5			#include "Atom.hpp"
6
7
8			//class ConstraintElement is designed to not only provide the interface of StuntDouble, but also
9			//neccessary functionality to retrieve old position, old velocity and etc.
10			//First of all, those old data should be stored inside StuntDouble. We decide to store it on StuntDouble's
11			//generic property.
12			////////////////////////////////////////////////////////////////////////////////
13			//Declaration of ConstraintElement
14			////////////////////////////////////////////////////////////////////////////////
15			class ConstraintElement{
16			public:
17
18			virtual ~ConstraintElement() {}
19
20			//Interface of stunt double
21			bool isAtom() {return refSd->isAtom();}
22			bool isDirectionalAtom() {return refSd->isDirectional();}
23			bool isRigidBody() {return refSd->isRigidBody();}
24
25			double getMass(void) {return refSd->getMass();}
26
27			void getPos(double pos[3]) {refSd->getPos(pos);}
28			void setPos(double pos[3]) {refSd->setPos(pos);}
29
30			void getVel(double vel[3]) {refSd->getVel(vel);}
31			void setVel(double vel[3]) {refSd->setVel(vel);}
32
33			void getFrc(double frc[3]) {refSd->getFrc(frc);}
34			void addFrc(double frc[3]) {refSd->addFrc(frc);}
35
36			void getA(double A[3][3]) {refSd->getA(A);}
37			void setA(double A[3][3]) {refSd->setA(A);}
38
39			void getJ(double j[3]) {refSd->getJ(j);}
40			void setJ(double j[3]) {refSd->setJ(j);}
41
42			void getQ( double q[4] ) {refSd->getQ(q);}
43			void setQ( double q[4] ) {refSd->setQ(q);}
44
45			void setType(char* type){refSd->setType(type);}
46			char* getType() {return refSd->getType();}
47
48			void getTrq(double trq[3]) {refSd->getTrq(trq);}
49			void addTrq(double trq[3]) {refSd->addTrq(trq);}
50
51			void getI(double I[3][3]) {refSd->getI(I);}
52			void lab2Body(double vec[3]) {refSd->lab2Body(vec);}
53
54			void getGrad(double grad[6]) {refSd->getGrad(grad);}
55			void setEuler(double phi, double theta, double psi) {refSd->setEuler(phi, theta, psi);}
56			void getEulerAngles(double eulers[3]) {refSd->getEulerAngles(eulers);}
57
58			bool isLinear() {return refSd->isLinear();}
59			int linearAxis() {return refSd->linearAxis();}
60
61			double getZangle() {return refSd->getZangle();}
62			void setZangle(double zAngle) {refSd->setZangle(zAngle);}
63			void addZangle(double zAngle) {refSd->addZangle(zAngle);}
64
65
66			virtual void getOldPos(double pos[3])=0;
67			virtual void getOldVel(double vel[3])=0;
68			virtual void getOldJ(double j[3])=0;
69			virtual void getOldA(double a[3][3])=0;
70			virtual void getOldQ(double q[4])=0;
71
72			bool getMoved() {return movedData->getData();}
73			void setMoved(bool status) {movedData->setData(status);}
74
75			bool getMoving() {return movingData->getData();}
76			void setMoving(bool status) {movingData->setData(status);}
77
78			virtual void saveOldState() = 0;
79
80			protected:
81			ConstraintElement(StuntDouble* rhs);
82
83			StuntDouble* refSd;
84
85			private:
86			BoolData* movedData;
87			BoolData* movingData;
88
89			};
90
91
92			////////////////////////////////////////////////////////////////////////////////
93			//Declaration of ConsAtomData
94			////////////////////////////////////////////////////////////////////////////////
95			struct ConsAtomInfo{
96			double pos[3];
97			double vel[3];
98			double a[3][3];
99			double j[3];
100			double q[4];
101			};
102
103			class ConsAtomData : public GenericData{
104			public:
105			ConsAtomData() : data(NULL){}
106			~ConsAtomData(){
107			if(data != NULL)
108			delete data;
109			}
110
111			ConsAtomInfo* getData() {return data;}
112			void setData(ConsAtomInfo* info) {
113			if (data != NULL)
114			delete data;
115
116			data = info;
117			}
118
119			private:
120			ConsAtomInfo* data;
121			};
122			////////////////////////////////////////////////////////////////////////////////
123			//Declaration of ConstraintElement
124			////////////////////////////////////////////////////////////////////////////////
125			class ConstraintAtom : public ConstraintElement{
126			public:
127			ConstraintAtom(Atom* rhs);
128
129			void getOldPos(double pos[3]);
130			void getOldVel(double vel[3]);
131			void getOldJ(double j[3]);
132			void getOldA(double a[3][3]);
133			void getOldQ(double q[4]);
134
135			Atom* getAtom() {return dynamic_cast<Atom*>(refSd);}
136
137			virtual void saveOldState();
138
139			protected:
140			ConsAtomInfo* oldConsAtomInfo;
141
142			};
143
144
145
146			////////////////////////////////////////////////////////////////////////////////
147			//Declaration of ConsRbData
148			////////////////////////////////////////////////////////////////////////////////
149			class ConsRbData : public GenericData{
150			public:
151			ConsRbData() : rb(NULL){}
152			~ConsRbData(){
153			if (rb != NULL)
154			delete rb;
155			}
156
157			RigidBody* getData() {return rb;}
158			void setData(RigidBody* rhs) {
159			if (rb != NULL)
160			delete rb;
161			rb = rhs;
162			}
163
164			private:
165			RigidBody* rb;
166			};
167
168			////////////////////////////////////////////////////////////////////////////////
169			//Declaration of ConstraintElement
170			////////////////////////////////////////////////////////////////////////////////
171			class ConstraintRigidBody : public ConstraintElement{
172			public:
173			ConstraintRigidBody(RigidBody*rhs, int index);
174
175			void getOldPos(double pos[3]) {oldRb->getPos(pos);}
176			void getOldVel(double vel[3]) {oldRb->getVel(vel);}
177			void getOldJ(double j[3]) {oldRb->getJ(j);}
178			void getOldA(double a[3][3]) {oldRb->getA(a);}
179			void getOldQ(double q[4]) {oldRb->getQ(q);}
180
181			void getOldAtomPos(double pos[3]) {oldRb->getAtomPos(pos, consAtomIndex);}
182			void getCurAtomPos(double pos[3]) {((RigidBody*)refSd)->getAtomPos(pos, consAtomIndex);}
183
184			RigidBody* getRigidBody() { return dynamic_cast<RigidBody*>(refSd);}
185
186			virtual void saveOldState();
187
188			private:
189			int consAtomIndex;
190			RigidBody* oldRb;
191			};
192			#endif // endif _CONSTRAINTELEMENT_H_