OOPSE/libmdtools/Roll.hpp

#ifndef _ROLL_H_
#define _ROLL_H_
#include "Rattle.hpp"
#include "Vector3d.hpp"
////////////////////////////////////////////////////////////////////////////////
//Declaration of DCRollAFunctor
////////////////////////////////////////////////////////////////////////////////
class DCRollAFunctor : public DCRattleAFunctor{
  public:
    DCRollAFunctor(SimInfo* info) : DCRattleAFunctor(info) {}
    virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
    virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB) {return consElemHandlerFail;}
    virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
  private:

    void calcZeta(ConstraintAtom* consAtom, const Vector3d& bondDir, Vector3d&zeta);
    void integrate(ConstraintAtom* consAtom, const Vector3d& force);
    
    void calcZeta(ConstraintRigidBody* consRB, const Vector3d& bondDir, Vector3d& zeta);
    void integrate(ConstraintRigidBody* consRB, const Vector3d& consForce);
    void rotationPropagation(StuntDouble* sd, double ji[3]);
    void rotate(int axes1, int axes2, double angle, double ji[3], double A[3][3]);
};

////////////////////////////////////////////////////////////////////////////////
//Declaration of JCRollAFunctor
////////////////////////////////////////////////////////////////////////////////
class JCRollAFunctor : public JCRattleAFunctor{
  public:
    JCRollAFunctor(SimInfo* info) : JCRattleAFunctor(info) {}
    //virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
    //virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB); 
    //virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);    
};

////////////////////////////////////////////////////////////////////////////////
//Declaration of RollA
////////////////////////////////////////////////////////////////////////////////
class RollA : public ConstraintAlgorithm{
  public:
    RollA(SimInfo* rhs) : ConstraintAlgorithm(rhs){
      registerCallback(typeid(DistanceConstraintPair), new DCRollAFunctor(rhs));  
      registerCallback(typeid(JointConstraintPair), new JCRollAFunctor(rhs));  
    } 
};

////////////////////////////////////////////////////////////////////////////////
//Declaration of DCRollBFunctor
////////////////////////////////////////////////////////////////////////////////
class DCRollBFunctor : public DCRattleBFunctor{
  public:
    DCRollBFunctor(SimInfo* info) : DCRattleBFunctor(info) {}
    virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2){return consElemHandlerFail;}
    virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB){return consElemHandlerFail;}
    virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
  private:
    //void getZeta(ConstraintAtom* consAtom, const Vector3d& bondDir, Vector3d& zeta);
    //void integrate(ConstraintAtom* consAtom, const Vector3d& consForce);
    
    void getZeta(ConstraintRigidBody* consRB, const Vector3d& bondDir, Vector3d& zeta);
    void integrate(ConstraintRigidBody* consRB, const Vector3d& consForce);
};

////////////////////////////////////////////////////////////////////////////////
//Declaration of JCRollBFunctor
////////////////////////////////////////////////////////////////////////////////
class JCRollBFunctor : public JCRattleBFunctor{
  public:
    JCRollBFunctor(SimInfo* info) : JCRattleBFunctor(info) {}
    //virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
    //virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB); 
    //virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);    
};

////////////////////////////////////////////////////////////////////////////////
//Declaration of RollB
////////////////////////////////////////////////////////////////////////////////
class RollB : public ConstraintAlgorithm{
  public:
    RollB(SimInfo* rhs) : ConstraintAlgorithm(rhs){
      registerCallback(typeid(DistanceConstraintPair), new DCRollBFunctor(rhs));  
      registerCallback(typeid(JointConstraintPair), new JCRollBFunctor(rhs));  
    } 
};

////////////////////////////////////////////////////////////////////////////////
//Declaration of RollFramework
////////////////////////////////////////////////////////////////////////////////
//class RattleAlgorithm will encapsulate preConstraint, RattleA and RattleB
//actually, we could use factory pattern to seperate the creation process
class RollFramework : public VelVerletConsFramework{
  public:
    RollFramework(SimInfo* rhs) : VelVerletConsFramework(rhs){
      raAlgo = new RollA(rhs);
      rbAlgo = new RollB(rhs);      
    }
    
    ~RollFramework(){
      delete raAlgo;
      delete rbAlgo;
    }
    
    virtual int doConstrainA(){
      raAlgo->doConstrain();
      return raAlgo->haveError()? -1 : 1;

    }
    
   virtual int doConstrainB(){
      rbAlgo->doConstrain();
      return rbAlgo->haveError()? -1 : 1;

   }
  private:
    RollA* raAlgo;
    RollB* rbAlgo;
};
#endif //end ifndef _ROLL_H_
Revision:	1452
Committed:	Mon Aug 23 15:11:36 2004 UTC (19 years, 10 months ago) by tim
File size:	5142 byte(s)
Log Message:	* empty log message *
#	User	Rev	Content
1	tim	1254	#ifndef _ROLL_H_
2			#define _ROLL_H_
3			#include "Rattle.hpp"
4			#include "Vector3d.hpp"
5			////////////////////////////////////////////////////////////////////////////////
6			//Declaration of DCRollAFunctor
7			////////////////////////////////////////////////////////////////////////////////
8			class DCRollAFunctor : public DCRattleAFunctor{
9			public:
10			DCRollAFunctor(SimInfo* info) : DCRattleAFunctor(info) {}
11	tim	1268	virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
12	tim	1452	virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB) {return consElemHandlerFail;}
13	tim	1254	virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
14			private:
15	tim	1268
16			void calcZeta(ConstraintAtom* consAtom, const Vector3d& bondDir, Vector3d&zeta);
17			void integrate(ConstraintAtom* consAtom, const Vector3d& force);
18
19			void calcZeta(ConstraintRigidBody* consRB, const Vector3d& bondDir, Vector3d& zeta);
20	tim	1452	void integrate(ConstraintRigidBody* consRB, const Vector3d& consForce);
21	tim	1254	void rotationPropagation(StuntDouble* sd, double ji[3]);
22			void rotate(int axes1, int axes2, double angle, double ji[3], double A[3][3]);
23			};
24
25			////////////////////////////////////////////////////////////////////////////////
26			//Declaration of JCRollAFunctor
27			////////////////////////////////////////////////////////////////////////////////
28			class JCRollAFunctor : public JCRattleAFunctor{
29			public:
30			JCRollAFunctor(SimInfo* info) : JCRattleAFunctor(info) {}
31			//virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
32			//virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB);
33			//virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
34			};
35
36			////////////////////////////////////////////////////////////////////////////////
37			//Declaration of RollA
38			////////////////////////////////////////////////////////////////////////////////
39			class RollA : public ConstraintAlgorithm{
40			public:
41			RollA(SimInfo* rhs) : ConstraintAlgorithm(rhs){
42			registerCallback(typeid(DistanceConstraintPair), new DCRollAFunctor(rhs));
43			registerCallback(typeid(JointConstraintPair), new JCRollAFunctor(rhs));
44			}
45			};
46
47			////////////////////////////////////////////////////////////////////////////////
48			//Declaration of DCRollBFunctor
49			////////////////////////////////////////////////////////////////////////////////
50			class DCRollBFunctor : public DCRattleBFunctor{
51			public:
52			DCRollBFunctor(SimInfo* info) : DCRattleBFunctor(info) {}
53	tim	1452	virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2){return consElemHandlerFail;}
54			virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB){return consElemHandlerFail;}
55	tim	1254	virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
56			private:
57	tim	1452	//void getZeta(ConstraintAtom* consAtom, const Vector3d& bondDir, Vector3d& zeta);
58			//void integrate(ConstraintAtom* consAtom, const Vector3d& consForce);
59
60	tim	1284	void getZeta(ConstraintRigidBody* consRB, const Vector3d& bondDir, Vector3d& zeta);
61	tim	1452	void integrate(ConstraintRigidBody* consRB, const Vector3d& consForce);
62	tim	1254	};
63
64			////////////////////////////////////////////////////////////////////////////////
65			//Declaration of JCRollBFunctor
66			////////////////////////////////////////////////////////////////////////////////
67			class JCRollBFunctor : public JCRattleBFunctor{
68			public:
69			JCRollBFunctor(SimInfo* info) : JCRattleBFunctor(info) {}
70			//virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
71			//virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB);
72			//virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
73			};
74
75			////////////////////////////////////////////////////////////////////////////////
76			//Declaration of RollB
77			////////////////////////////////////////////////////////////////////////////////
78			class RollB : public ConstraintAlgorithm{
79			public:
80			RollB(SimInfo* rhs) : ConstraintAlgorithm(rhs){
81			registerCallback(typeid(DistanceConstraintPair), new DCRollBFunctor(rhs));
82			registerCallback(typeid(JointConstraintPair), new JCRollBFunctor(rhs));
83			}
84			};
85
86			////////////////////////////////////////////////////////////////////////////////
87			//Declaration of RollFramework
88			////////////////////////////////////////////////////////////////////////////////
89			//class RattleAlgorithm will encapsulate preConstraint, RattleA and RattleB
90			//actually, we could use factory pattern to seperate the creation process
91	tim	1268	class RollFramework : public VelVerletConsFramework{
92	tim	1254	public:
93	tim	1268	RollFramework(SimInfo* rhs) : VelVerletConsFramework(rhs){
94	tim	1254	raAlgo = new RollA(rhs);
95			rbAlgo = new RollB(rhs);
96			}
97
98			~RollFramework(){
99			delete raAlgo;
100			delete rbAlgo;
101			}
102
103	tim	1268	virtual int doConstrainA(){
104	tim	1254	raAlgo->doConstrain();
105			return raAlgo->haveError()? -1 : 1;
106
107			}
108
109	tim	1268	virtual int doConstrainB(){
110	tim	1254	rbAlgo->doConstrain();
111			return rbAlgo->haveError()? -1 : 1;
112
113			}
114			private:
115			RollA* raAlgo;
116			RollB* rbAlgo;
117			};
118			#endif //end ifndef _ROLL_H_