OOPSE/libmdtools/ConstraintAlgorithm.cpp

#include "ConstraintAlgorithm.hpp"
#include "ConstraintPair.hpp"
#include "SimInfo.hpp"
#include "ConstraintManager.hpp"
#include "simError.h"

////////////////////////////////////////////////////////////////////////////////
//Implementation of ConstraintAlgorithm
////////////////////////////////////////////////////////////////////////////////
ConstraintAlgorithm::ConstraintAlgorithm(SimInfo* rhs){
  info = rhs;
  cpIter = info->consMan->creatPairIterator();
  ceIter = info->consMan->creatElementIterator();  
}

ConstraintAlgorithm::~ConstraintAlgorithm(){
  map<TypeInfo, CallbackFunctor*>::iterator callbackIter;

  //destroy callbackMap
  for(callbackIter = callbackMap.begin(); callbackIter != callbackMap.end(); ++callbackIter){
    delete callbackIter->second;
  }
  callbackMap.erase(callbackMap.begin(), callbackMap.end());

  //destroy iterators of constraint element and constraint pair
  delete cpIter;
  delete ceIter;  
}

void ConstraintAlgorithm::doConstrain(){
  const int maxConsIteration = 300;
  bool done;
  int iteration;
  int maxIteration;
  double tolerance;
  ConstraintElement* consElem;
  ConstraintPair* consPair;
  int exeStatus;


  error = false;
  
  for(ceIter->first(); !ceIter->isEnd(); ceIter->next()){
    consElem =  ceIter->currentItem();
    consElem->setMoved(true);
    consElem->setMoving(false);
  }

  done = false;
  iteration = 0;

  //main loop of constraint algorithm
  while(!done && iteration < maxConsIteration){
    done = true;

    //loop over every constraint pair
    for(cpIter->first(); !cpIter->isEnd(); cpIter->next()){

      consPair = cpIter->currentItem();

      //dispatch constraint algorithm
      if(consPair->isMoved())
        exeStatus = doConstrainPair(consPair);

      switch(exeStatus){
        case consFail:
          cerr << "ConstraintAlgorithm::doConstrain() Error: Constraint Fail" << endl;         
          error = true;
          break;
        case consSuccess:
          //constrain the pair by moving two elements
          done = false;
          consPair->firstElem->setMoving(true);
          consPair->secondElem->setMoving(true);
          break;
        case consAlready:
          //current pair is already constrained, do not need to move the elements
          break;
        case consPairHandlerFail:
          //can not found call back functor for constraint pair 
          cerr << "ConstraintAlgorithm::doConstrain() Error: can not found callback functor for constraint pair " << endl;
          error = true;
          break;          
        case consElemHandlerFail:
          //can not found callback functor for constraint element 
          cerr << "ConstraintAlgorithm::doConstrain() Error: can not found callback functor for constraint element " << endl;
          error = true;
          break;
        default:          
          cerr << "ConstraintAlgorithm::doConstrain() Error: unrecognized status" << endl;
          error = true;
          break;
      }      
    }//end for(iter->first())
      
   for(ceIter->first(); !ceIter->isEnd(); ceIter->next()){
      consElem = ceIter->currentItem();
      consElem->setMoved(consElem->getMoving());
      consElem->setMoving(false);
   }

    iteration++;
  }//end while

  //if (!done){
  //  error = true;
  //  sprintf(painCave.errMsg,
  //          "Constraint failure in constrainB, too many iterations: %d\n",
  //          iteration);
  //  painCave.isFatal = 1;
  //  simError();    
  //}
}


int ConstraintAlgorithm::doConstrainPair(ConstraintPair* consPair){
  map<TypeInfo, CallbackFunctor*>::iterator foundResult;
  CallbackFunctor* functor;
  
  //typeid must operate on deferenced, otherwise it will return the type_info of base class
  foundResult = callbackMap.find(TypeInfo(typeid(*consPair)));
  if (foundResult != callbackMap.end()){
    functor = foundResult->second;
    return (*functor)(consPair);    
  }
  else{
    //can not found appropriate functor to handle constraint pair in callbackMap
    return consPairHandlerFail;
  }
  
}

void ConstraintAlgorithm::registerCallback(const TypeInfo& ti, CallbackFunctor* functor){
  map<TypeInfo, CallbackFunctor*>::iterator foundResult;
  
  foundResult = callbackMap.find(ti);
  if (foundResult == callbackMap.end())
    callbackMap[ti] = functor;
  else{
    delete foundResult->second;
    foundResult->second = functor;
  }
    
}
void ConstraintAlgorithm::unRegister(TypeInfo& ti){
  map<TypeInfo, CallbackFunctor*>::iterator foundResult;
  
  foundResult = callbackMap.find(ti);
  if (foundResult != callbackMap.end()){
    delete foundResult->second;
    callbackMap.erase(foundResult);
  }
}

////////////////////////////////////////////////////////////////////////////////
//Implementation of ConsAlgoFramework
////////////////////////////////////////////////////////////////////////////////
ConsAlgoFramework::ConsAlgoFramework(SimInfo* rhs){
  ceIter = rhs->consMan->creatElementIterator();  
}

ConsAlgoFramework::~ConsAlgoFramework(){
  delete ceIter;
}

void ConsAlgoFramework::doPreConstraint(){
  ConstraintElement* consElem;
  
  for(ceIter->first(); !ceIter->isEnd(); ceIter->next()){
    consElem =  ceIter->currentItem();
    consElem->saveOldState();
  }
}  
Revision:	1248
Committed:	Fri Jun 4 19:30:05 2004 UTC (20 years, 1 month ago) by tim
File size:	5224 byte(s)
Log Message:	constraint algorithm for minimization is working
#	Content
1	#include "ConstraintAlgorithm.hpp"
2	#include "ConstraintPair.hpp"
3	#include "SimInfo.hpp"
4	#include "ConstraintManager.hpp"
5	#include "simError.h"
6
7	////////////////////////////////////////////////////////////////////////////////
8	//Implementation of ConstraintAlgorithm
9	////////////////////////////////////////////////////////////////////////////////
10	ConstraintAlgorithm::ConstraintAlgorithm(SimInfo* rhs){
11	info = rhs;
12	cpIter = info->consMan->creatPairIterator();
13	ceIter = info->consMan->creatElementIterator();
14	}
15
16	ConstraintAlgorithm::~ConstraintAlgorithm(){
17	map<TypeInfo, CallbackFunctor*>::iterator callbackIter;
18
19	//destroy callbackMap
20	for(callbackIter = callbackMap.begin(); callbackIter != callbackMap.end(); ++callbackIter){
21	delete callbackIter->second;
22	}
23	callbackMap.erase(callbackMap.begin(), callbackMap.end());
24
25	//destroy iterators of constraint element and constraint pair
26	delete cpIter;
27	delete ceIter;
28	}
29
30	void ConstraintAlgorithm::doConstrain(){
31	const int maxConsIteration = 300;
32	bool done;
33	int iteration;
34	int maxIteration;
35	double tolerance;
36	ConstraintElement* consElem;
37	ConstraintPair* consPair;
38	int exeStatus;
39
40
41	error = false;
42
43	for(ceIter->first(); !ceIter->isEnd(); ceIter->next()){
44	consElem = ceIter->currentItem();
45	consElem->setMoved(true);
46	consElem->setMoving(false);
47	}
48
49	done = false;
50	iteration = 0;
51
52	//main loop of constraint algorithm
53	while(!done && iteration < maxConsIteration){
54	done = true;
55
56	//loop over every constraint pair
57	for(cpIter->first(); !cpIter->isEnd(); cpIter->next()){
58
59	consPair = cpIter->currentItem();
60
61	//dispatch constraint algorithm
62	if(consPair->isMoved())
63	exeStatus = doConstrainPair(consPair);
64
65	switch(exeStatus){
66	case consFail:
67	cerr << "ConstraintAlgorithm::doConstrain() Error: Constraint Fail" << endl;
68	error = true;
69	break;
70	case consSuccess:
71	//constrain the pair by moving two elements
72	done = false;
73	consPair->firstElem->setMoving(true);
74	consPair->secondElem->setMoving(true);
75	break;
76	case consAlready:
77	//current pair is already constrained, do not need to move the elements
78	break;
79	case consPairHandlerFail:
80	//can not found call back functor for constraint pair
81	cerr << "ConstraintAlgorithm::doConstrain() Error: can not found callback functor for constraint pair " << endl;
82	error = true;
83	break;
84	case consElemHandlerFail:
85	//can not found callback functor for constraint element
86	cerr << "ConstraintAlgorithm::doConstrain() Error: can not found callback functor for constraint element " << endl;
87	error = true;
88	break;
89	default:
90	cerr << "ConstraintAlgorithm::doConstrain() Error: unrecognized status" << endl;
91	error = true;
92	break;
93	}
94	}//end for(iter->first())
95
96	for(ceIter->first(); !ceIter->isEnd(); ceIter->next()){
97	consElem = ceIter->currentItem();
98	consElem->setMoved(consElem->getMoving());
99	consElem->setMoving(false);
100	}
101
102	iteration++;
103	}//end while
104
105	//if (!done){
106	// error = true;
107	// sprintf(painCave.errMsg,
108	// "Constraint failure in constrainB, too many iterations: %d\n",
109	// iteration);
110	// painCave.isFatal = 1;
111	// simError();
112	//}
113	}
114
115
116	int ConstraintAlgorithm::doConstrainPair(ConstraintPair* consPair){
117	map<TypeInfo, CallbackFunctor*>::iterator foundResult;
118	CallbackFunctor* functor;
119
120	//typeid must operate on deferenced, otherwise it will return the type_info of base class
121	foundResult = callbackMap.find(TypeInfo(typeid(*consPair)));
122	if (foundResult != callbackMap.end()){
123	functor = foundResult->second;
124	return (*functor)(consPair);
125	}
126	else{
127	//can not found appropriate functor to handle constraint pair in callbackMap
128	return consPairHandlerFail;
129	}
130
131	}
132
133	void ConstraintAlgorithm::registerCallback(const TypeInfo& ti, CallbackFunctor* functor){
134	map<TypeInfo, CallbackFunctor*>::iterator foundResult;
135
136	foundResult = callbackMap.find(ti);
137	if (foundResult == callbackMap.end())
138	callbackMap[ti] = functor;
139	else{
140	delete foundResult->second;
141	foundResult->second = functor;
142	}
143
144	}
145	void ConstraintAlgorithm::unRegister(TypeInfo& ti){
146	map<TypeInfo, CallbackFunctor*>::iterator foundResult;
147
148	foundResult = callbackMap.find(ti);
149	if (foundResult != callbackMap.end()){
150	delete foundResult->second;
151	callbackMap.erase(foundResult);
152	}
153	}
154
155	////////////////////////////////////////////////////////////////////////////////
156	//Implementation of ConsAlgoFramework
157	////////////////////////////////////////////////////////////////////////////////
158	ConsAlgoFramework::ConsAlgoFramework(SimInfo* rhs){
159	ceIter = rhs->consMan->creatElementIterator();
160	}
161
162	ConsAlgoFramework::~ConsAlgoFramework(){
163	delete ceIter;
164	}
165
166	void ConsAlgoFramework::doPreConstraint(){
167	ConstraintElement* consElem;
168
169	for(ceIter->first(); !ceIter->isEnd(); ceIter->next()){
170	consElem = ceIter->currentItem();
171	consElem->saveOldState();
172	}
173	}