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); 
    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& force);
    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);
    //virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB); 
    virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
  private:
    void getEffInvMassVec(ConstraintRigidBody* consRB, const Vector3d& bondDir, Vector3d& invMassVec);
    void integrate(ConstraintRigidBody* consRB, const Vector3d& force);
};

////////////////////////////////////////////////////////////////////////////////
//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:	1268
Committed:	Fri Jun 11 17:16:21 2004 UTC (20 years ago) by tim
File size:	4905 byte(s)
Log Message:	roll in progress
#	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	1254	//virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB);
13			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	1254	void integrate(ConstraintRigidBody* consRB, const Vector3d& force);
21			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			//virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
54			//virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB);
55			virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
56			private:
57			void getEffInvMassVec(ConstraintRigidBody* consRB, const Vector3d& bondDir, Vector3d& invMassVec);
58			void integrate(ConstraintRigidBody* consRB, const Vector3d& force);
59			};
60
61			////////////////////////////////////////////////////////////////////////////////
62			//Declaration of JCRollBFunctor
63			////////////////////////////////////////////////////////////////////////////////
64			class JCRollBFunctor : public JCRattleBFunctor{
65			public:
66			JCRollBFunctor(SimInfo* info) : JCRattleBFunctor(info) {}
67			//virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
68			//virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB);
69			//virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
70			};
71
72			////////////////////////////////////////////////////////////////////////////////
73			//Declaration of RollB
74			////////////////////////////////////////////////////////////////////////////////
75			class RollB : public ConstraintAlgorithm{
76			public:
77			RollB(SimInfo* rhs) : ConstraintAlgorithm(rhs){
78			registerCallback(typeid(DistanceConstraintPair), new DCRollBFunctor(rhs));
79			registerCallback(typeid(JointConstraintPair), new JCRollBFunctor(rhs));
80			}
81			};
82
83			////////////////////////////////////////////////////////////////////////////////
84			//Declaration of RollFramework
85			////////////////////////////////////////////////////////////////////////////////
86			//class RattleAlgorithm will encapsulate preConstraint, RattleA and RattleB
87			//actually, we could use factory pattern to seperate the creation process
88	tim	1268	class RollFramework : public VelVerletConsFramework{
89	tim	1254	public:
90	tim	1268	RollFramework(SimInfo* rhs) : VelVerletConsFramework(rhs){
91	tim	1254	raAlgo = new RollA(rhs);
92			rbAlgo = new RollB(rhs);
93			}
94
95			~RollFramework(){
96			delete raAlgo;
97			delete rbAlgo;
98			}
99
100	tim	1268	virtual int doConstrainA(){
101	tim	1254	raAlgo->doConstrain();
102			return raAlgo->haveError()? -1 : 1;
103
104			}
105
106	tim	1268	virtual int doConstrainB(){
107	tim	1254	rbAlgo->doConstrain();
108			return rbAlgo->haveError()? -1 : 1;
109
110			}
111			private:
112			RollA* raAlgo;
113			RollB* rbAlgo;
114			};
115			#endif //end ifndef _ROLL_H_