OOPSE/libmdtools/ConstraintAlgorithm.hpp

#ifndef _CONSTRAINTALGORITHM_H_
#define _CONSTRAINTALGORITHM_H_

#include <iostream>
#include <map>
#include "CallbackFunctor.hpp"
#include "TypeInfo.hpp"
#include "ConstraintIterator.hpp"
using namespace std;

class ConstraintManager;
class ConstraintPair;
class JointConstraintPair;
class DistanceConstraintPair;
class SimInfo;

enum ConsAlgoStatus{
  consExceedMaxIter = -4, //can not constrain the bond within maximum iteration
  consPairHandlerFail = -3, //can not found call back functor for constraint pair 
  consElemHandlerFail = -2, //can not found callback functor for constraint element 
  consFail = -1,  //Constraint Fail
  consSuccess = 0,  //constrain the pair by moving two elements
  consAlready = 1}; //current pair is already constrained, do not need to move the elements

////////////////////////////////////////////////////////////////////////////////
//Declaration of ConstraintAlgorithm
////////////////////////////////////////////////////////////////////////////////
//base class of constraint algorithm
//Actuallly we encount a triple dispatch problem here, something like 
//ConstrainPair(ConsPairType*, ConsElementType1*, ConsElementType2*)
//To solve this problem, we apply visitor pattern and standard double dispatch technique 
class ConstraintAlgorithm{

  public:
  virtual ~ConstraintAlgorithm();
  virtual void doConstrain();

    //using RTTI (Run Time Type Information) to dispatch 
    int doConstrainPair(ConstraintPair* consPair);
    void registerCallback(const TypeInfo& ti, CallbackFunctor* functor);
    void unRegister(TypeInfo& ti);
    bool haveError() { return error;}
  protected:
    ConstraintAlgorithm(SimInfo* rhs);

    SimInfo* info;
    ConstraintPairIterator* cpIter;
    ConstraintElementIterator* ceIter;

    map<TypeInfo, CallbackFunctor*> callbackMap;

    bool error;
};

////////////////////////////////////////////////////////////////////////////////
//Declaration of ConsAlgoFramework
////////////////////////////////////////////////////////////////////////////////
class ConsAlgoFramework{
  public:
    ~ConsAlgoFramework();
    
    void doPreConstraint();

  protected:
    ConsAlgoFramework(SimInfo* rhs);

  private:
    ConstraintElementIterator* ceIter;
    
};

//Velocity Verlet constraint algorithm frame work
class VelVerletConsFramework : public ConsAlgoFramework{
  public:
    virtual int doConstrainA() = 0;
    virtual int doConstrainB() = 0;
  protected:
    VelVerletConsFramework(SimInfo* rhs) : ConsAlgoFramework(rhs){}
};

#endif //endif _CONSTRAINTALGORITHM_H_
Revision:	1268
Committed:	Fri Jun 11 17:16:21 2004 UTC (20 years ago) by tim
File size:	2550 byte(s)
Log Message:	roll in progress
#	User	Rev	Content
1	tim	1232	#ifndef _CONSTRAINTALGORITHM_H_
2			#define _CONSTRAINTALGORITHM_H_
3
4			#include <iostream>
5			#include <map>
6			#include "CallbackFunctor.hpp"
7			#include "TypeInfo.hpp"
8			#include "ConstraintIterator.hpp"
9			using namespace std;
10
11			class ConstraintManager;
12			class ConstraintPair;
13			class JointConstraintPair;
14			class DistanceConstraintPair;
15			class SimInfo;
16
17	tim	1248	enum ConsAlgoStatus{
18	tim	1254	consExceedMaxIter = -4, //can not constrain the bond within maximum iteration
19			consPairHandlerFail = -3, //can not found call back functor for constraint pair
20			consElemHandlerFail = -2, //can not found callback functor for constraint element
21			consFail = -1, //Constraint Fail
22			consSuccess = 0, //constrain the pair by moving two elements
23			consAlready = 1}; //current pair is already constrained, do not need to move the elements
24	tim	1232
25			////////////////////////////////////////////////////////////////////////////////
26			//Declaration of ConstraintAlgorithm
27			////////////////////////////////////////////////////////////////////////////////
28			//base class of constraint algorithm
29			//Actuallly we encount a triple dispatch problem here, something like
30			//ConstrainPair(ConsPairType, ConsElementType1, ConsElementType2*)
31			//To solve this problem, we apply visitor pattern and standard double dispatch technique
32			class ConstraintAlgorithm{
33
34			public:
35	gezelter	1252	virtual ~ConstraintAlgorithm();
36			virtual void doConstrain();
37	tim	1232
38			//using RTTI (Run Time Type Information) to dispatch
39			int doConstrainPair(ConstraintPair* consPair);
40			void registerCallback(const TypeInfo& ti, CallbackFunctor* functor);
41			void unRegister(TypeInfo& ti);
42	tim	1248	bool haveError() { return error;}
43	tim	1232	protected:
44			ConstraintAlgorithm(SimInfo* rhs);
45
46			SimInfo* info;
47			ConstraintPairIterator* cpIter;
48			ConstraintElementIterator* ceIter;
49
50			map<TypeInfo, CallbackFunctor*> callbackMap;
51	tim	1248
52			bool error;
53	tim	1232	};
54
55			////////////////////////////////////////////////////////////////////////////////
56			//Declaration of ConsAlgoFramework
57			////////////////////////////////////////////////////////////////////////////////
58			class ConsAlgoFramework{
59			public:
60			~ConsAlgoFramework();
61
62			void doPreConstraint();
63
64			protected:
65			ConsAlgoFramework(SimInfo* rhs);
66
67			private:
68			ConstraintElementIterator* ceIter;
69
70			};
71
72	tim	1268	//Velocity Verlet constraint algorithm frame work
73			class VelVerletConsFramework : public ConsAlgoFramework{
74			public:
75			virtual int doConstrainA() = 0;
76			virtual int doConstrainB() = 0;
77			protected:
78			VelVerletConsFramework(SimInfo* rhs) : ConsAlgoFramework(rhs){}
79			};
80
81	tim	1232	#endif //endif _CONSTRAINTALGORITHM_H_