OOPSE/libmdtools/Rattle.hpp

#ifndef _RATTLE_H_
#define _RATTLE_H_

#include "Shake.hpp"
#include "ConstraintPair.hpp"

//Rattle Constraint Algorithn
//Reference
//H.C. Andersen, J. Comput. Phys. 54, 24(1983)

class DCRattleAFunctor : public CallbackFunctor{
  public:
    DCRattleAFunctor(SimInfo* rhs) : CallbackFunctor(rhs){}
  protected:
    virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
    virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB); 
    virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
};

class JCRattleAFunctor : public CallbackFunctor{
  public:
    JCRattleAFunctor(SimInfo* rhs) : CallbackFunctor(rhs){}  
  protected:
    virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
    virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB); 
    virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
};


//SHAKE constraint algorithm
//Reference:
//[1] J.P. Ryckaert, G.Ciccotti and H.J.C. Berendsen, J. Comput. Phys., 23, 327 (1977)
//[2] 
//[3]
class RattleA : public ConstraintAlgorithm{
  public:
    RattleA(SimInfo* rhs) : ConstraintAlgorithm(rhs){
      registerCallback(typeid(DistanceConstraintPair), new DCRattleAFunctor(rhs));  
      registerCallback(typeid(JointConstraintPair), new JCRattleAFunctor(rhs));  
    }  
};

////////////////////////////////////////////////////////////////////////////////
//Declaration of DCRattleBFunctor
////////////////////////////////////////////////////////////////////////////////
class DCRattleBFunctor : public CallbackFunctor{
  public:
    DCRattleBFunctor(SimInfo* rhs) : CallbackFunctor(rhs){}
  protected:
    virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
    virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB); 
    virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
};

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

////////////////////////////////////////////////////////////////////////////////
//Declaration of RattleB
////////////////////////////////////////////////////////////////////////////////
class RattleB : public ConstraintAlgorithm{
  public:
    RattleB(SimInfo* rhs) : ConstraintAlgorithm(rhs){
      registerCallback(typeid(DistanceConstraintPair), new DCRattleBFunctor(rhs));  
      registerCallback(typeid(JointConstraintPair), new JCRattleBFunctor(rhs));  
    } 
};

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

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

   }
  private:
    RattleA* raAlgo;
    RattleB* rbAlgo;
};
#endif //ifndef _RATTLE_H_
Revision:	1254
Committed:	Wed Jun 9 16:16:33 2004 UTC (21 years, 4 months ago) by tim
File size:	4026 byte(s)
Log Message:	1. adding some useful math classes(Mat3x3d, Vector3d, Quaternion, Euler3) these classes use anonymous union and struct to support double[3], double[3][3] and double[4] 2. adding roll constraint algorithm
#	Content
1	#ifndef _RATTLE_H_
2	#define _RATTLE_H_
3
4	#include "Shake.hpp"
5	#include "ConstraintPair.hpp"
6
7	//Rattle Constraint Algorithn
8	//Reference
9	//H.C. Andersen, J. Comput. Phys. 54, 24(1983)
10
11	class DCRattleAFunctor : public CallbackFunctor{
12	public:
13	DCRattleAFunctor(SimInfo* rhs) : CallbackFunctor(rhs){}
14	protected:
15	virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
16	virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB);
17	virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
18	};
19
20	class JCRattleAFunctor : public CallbackFunctor{
21	public:
22	JCRattleAFunctor(SimInfo* rhs) : CallbackFunctor(rhs){}
23	protected:
24	virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
25	virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB);
26	virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
27	};
28
29
30	//SHAKE constraint algorithm
31	//Reference:
32	//[1] J.P. Ryckaert, G.Ciccotti and H.J.C. Berendsen, J. Comput. Phys., 23, 327 (1977)
33	//[2]
34	//[3]
35	class RattleA : public ConstraintAlgorithm{
36	public:
37	RattleA(SimInfo* rhs) : ConstraintAlgorithm(rhs){
38	registerCallback(typeid(DistanceConstraintPair), new DCRattleAFunctor(rhs));
39	registerCallback(typeid(JointConstraintPair), new JCRattleAFunctor(rhs));
40	}
41	};
42
43	////////////////////////////////////////////////////////////////////////////////
44	//Declaration of DCRattleBFunctor
45	////////////////////////////////////////////////////////////////////////////////
46	class DCRattleBFunctor : public CallbackFunctor{
47	public:
48	DCRattleBFunctor(SimInfo* rhs) : CallbackFunctor(rhs){}
49	protected:
50	virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
51	virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB);
52	virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
53	};
54
55	////////////////////////////////////////////////////////////////////////////////
56	//Declaration of JCRattleBFunctor
57	////////////////////////////////////////////////////////////////////////////////
58	class JCRattleBFunctor : public CallbackFunctor{
59	public:
60	JCRattleBFunctor(SimInfo* rhs) : CallbackFunctor(rhs){}
61	protected:
62	virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2);
63	virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB);
64	virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2);
65	};
66
67	////////////////////////////////////////////////////////////////////////////////
68	//Declaration of RattleB
69	////////////////////////////////////////////////////////////////////////////////
70	class RattleB : public ConstraintAlgorithm{
71	public:
72	RattleB(SimInfo* rhs) : ConstraintAlgorithm(rhs){
73	registerCallback(typeid(DistanceConstraintPair), new DCRattleBFunctor(rhs));
74	registerCallback(typeid(JointConstraintPair), new JCRattleBFunctor(rhs));
75	}
76	};
77
78	////////////////////////////////////////////////////////////////////////////////
79	//Declaration of RattleAlgorithm
80	////////////////////////////////////////////////////////////////////////////////
81	//class RattleAlgorithm will encapsulate preConstraint, RattleA and RattleB
82	//actually, we could use factory pattern to seperate the creation process
83	class RattleFramework : public ConsAlgoFramework{
84	public:
85	RattleFramework(SimInfo* rhs) : ConsAlgoFramework(rhs){
86	raAlgo = new RattleA(rhs);
87	rbAlgo = new RattleB(rhs);
88	}
89
90	~RattleFramework(){
91	delete raAlgo;
92	delete rbAlgo;
93	}
94
95	int doRattleA(){
96	raAlgo->doConstrain();
97	return raAlgo->haveError()? -1 : 1;
98
99	}
100
101	int doRattleB(){
102	rbAlgo->doConstrain();
103	return rbAlgo->haveError()? -1 : 1;
104
105	}
106	private:
107	RattleA* raAlgo;
108	RattleB* rbAlgo;
109	};
110	#endif //ifndef _RATTLE_H_