src/visitors/ZconsVisitor.cpp


#include <cmath>
#include "visitors/ZconsVisitor.hpp"
#include "primitives/Molecule.hpp"

namespace oopse {

ZConsVisitor::ZConsVisitor(SimInfo* info) : BaseVisitor(), zconsReader(NULL){
  GenericData* data;
  DoubleGenericData* tolerance;  
  ZConsParaData* zConsParaData;
  StringGenericData* filename; 
  DoubleGenericData* sampleTime;
  std::vector<ZConsParaItem>* parameters;

  this->info = info;
  visitorName = "ZConsVisitor";
  
  //retrieve tolerance for z-constraint molecuels
  data = info->getPropertyByName(ZCONSTOL_ID);

  if (!data){
    cerr << "Can not get zconstraint tolerance from SimInfo" << endl;
    haveZcons = false;  
    return;
  }
  else{
    tolerance = dynamic_cast<DoubleGenericData*>(data);

    if (!tolerance){
      cerr << "Can not get zconstraint tolerance  from SimInfo" << endl;
      haveZcons = false;    
      return;
    }
    else{
      zconsTol = tolerance->getData();
    }
  }

  //retrieve sample time of z-contraint 
  data = info->getPropertyByName(ZCONSTIME_ID);

  if (!data){
    cerr << "Can not get zcons time  from SimInfo" << endl;
    haveZcons = false;    
    return;
  }
  else{
    sampleTime = dynamic_cast<DoubleGenericData*>(data);

    if (!sampleTime){
      cerr << "Can not get zcons time  from SimInfo" << endl;
      haveZcons = false;    
      return;
    }
    else{
     zconsTime = sampleTime->getData();
    }
  }

  //retrieve index of z-constraint molecules
  data = info->getPropertyByName(ZCONSPARADATA_ID);
  if (!data){
    cerr << "Can not get index of z-constraint molecules from SimInfo" << endl;
    haveZcons = false;
    return;
  }
  else{
    zConsParaData = dynamic_cast<ZConsParaData*>(data);

    if (!zConsParaData){
      cerr << "Can not get index of z-constraint molecules from SimInfo" << endl;
      haveZcons = false;
      return;
    }
    else{
      vector<ZConsParaItem>::iterator i;
      Molecule* mol;

      parameters = zConsParaData->getData();
      for(i = parameters->begin(); i != parameters->end(); ++i){

        mol = info->getMoleculeByGlobalIndex(i->zconsIndex);
        if(mol != NULL)
          zconsMol.push_back(mol);

      }

      if(zconsMol.size() < 1){
        cerr << "number of zconstraint molecules is less than one" << endl;
        haveZcons = false;
        return;
      }
      
    }//end if (!zConsParaData)

  }//end  if (!data  
  
  //retrieve output filename of z force
  data = info->getPropertyByName(ZCONSFILENAME_ID);
  if (!data){
    cerr << "Can not get filename of z-constraint output from SimInfo" << endl;
    haveZcons = false;
    return;
  }
  else{
    filename = dynamic_cast<StringGenericData*>(data);

    if (!filename){
      cerr << "Can not get filename of z-constraint output from SimInfo" << endl;
      haveZcons = false;
      return;
    }
    else{
      zconsFilename = filename->getData();
    }
  }

  zconsReader = new ZConsReader(info);

  if (zconsReader->hasNextFrame())
  zconsReader->readNextFrame();
  
  haveZcons = true;
}

ZConsVisitor::~ZConsVisitor(){
  if(!zconsReader) 
    delete zconsReader;
  
}

void ZConsVisitor::visit(Atom* atom){
  std::string prefix;
  if(isZconstraint(atom->getLocalIndex(), prefix))
    internalVisit(atom, prefix);
}

void ZConsVisitor::visit(DirectionalAtom* datom){
  std::string prefix;
  
  if(isZconstraint(datom->getLocalIndex(), prefix))
    internalVisit(datom, prefix);
}

void ZConsVisitor::visit(RigidBody* rb){
  std::string prefix;
  std::vector<Atom*> atoms;
  
  atoms = rb->getAtoms();
    
  if(isZconstraint(atoms[0]->getLocalIndex(), prefix))
    internalVisit(rb, prefix);
}

void ZConsVisitor::update(){
  Molecule* mol;
  Vector3d com;
  ZConsState state;
  
  Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();        
  getZconsPos(currSnapshot->getTime());
  
  for(size_t i = 0; i < zconsMol.size(); i++){
    com = zconsMol[i]->getCom();

    if(fabs(com[2] - zconsPos[i]) < zconsTol)
      state = zsFixed;
    else
      state = zsMoving;

    //update the state of zconstraint atom
    //natoms = zconsMol[i]->getNAtoms();
    //atoms = zconsMol[i]->getMyAtoms();    
    //for(int j =0; j < natoms; j++)
    //  zconsState[atoms[j]->getLocalIndex()] = state;

    std::vector<Atom*>::iterator j;
    for (Atom* atom = zconsMol[i]->beginAtom(j); atom != NULL; atom =  zconsMol[i]->nextAtom(j)) {
        zconsState[atom->getLocalIndex()] = state;
    }
  }
  
}

void ZConsVisitor::getZconsPos(double time){

  std::vector<double> tempPos;
  std::vector<double> prevPos;
  double tempTime;

  while(true){
    tempTime = zconsReader->getCurTime();

    zconsPos = zconsReader->getZConsPos();
    
    if(tempTime >= time)
      return;
    
    zconsReader->readNextFrame();

  } 

}

void ZConsVisitor::internalVisit(StuntDouble* sd, const string& prefix){
  GenericData* data;
  AtomData* atomData;
  AtomInfo* atomInfo;
  std::vector<AtomInfo*>::iterator iter;

  
  //if there is not atom data, just skip it
  data = sd->getPropertyByName("ATOMDATA");
  if(data != NULL){
    atomData = dynamic_cast<AtomData*>(data);  
    if(atomData == NULL)
      return;
  }
  else
    return;

  for(atomInfo  = atomData->beginAtomInfo(iter); atomInfo; atomInfo = atomData->nextAtomInfo(iter))
    (atomInfo->AtomType).insert(0, prefix);
}


bool ZConsVisitor::isZconstraint(int index, string& prefix){
  std::map<int, ZConsState>::iterator i;
  std::string prefixString[] = {"ZF", "ZM"};
  
  i = zconsState.find(index);
  if(i !=zconsState.end()){
    prefix = prefixString[(*i).second];
    return true;
  }
  else{
    prefix = "";
    return false;
  }
}

const std::string ZConsVisitor::toString(){
  char buffer[65535];
  std::string result;
  
  sprintf(buffer ,"------------------------------------------------------------------\n");
  result += buffer;

  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
  result += buffer;
  
  sprintf(buffer , "number of zconstraint molecule: %d\n", zconsMol.size());
  result += buffer;

  sprintf(buffer , "zconstraint tolerance = %lf\n", zconsTol);
  result += buffer;

  sprintf(buffer , "zconstraint sample time = %lf\n", zconsTime);
  result += buffer;

  sprintf(buffer , "zconstraint output filename = %s\n", zconsFilename.c_str());
  result += buffer;
  
  for(size_t i = 0; i < zconsMol.size(); ++i){
    sprintf(buffer ,"zconstraint molecule[%d] = %d\n", i, zconsMol[i]->getGlobalIndex());
    result += buffer;

  }

  
  sprintf(buffer ,"------------------------------------------------------------------\n");
  result += buffer;

  return result;
}


}//namespace oopse
Revision:	1818
Committed:	Wed Dec 1 20:05:49 2004 UTC (19 years, 7 months ago) by tim
File size:	6612 byte(s)
Log Message:	visitors get built
#	User	Rev	Content
1	tim	1818
2			#include <cmath>
3	tim	1492	#include "visitors/ZconsVisitor.hpp"
4	tim	1818	#include "primitives/Molecule.hpp"
5	gezelter	1490
6	tim	1625	namespace oopse {
7
8	gezelter	1490	ZConsVisitor::ZConsVisitor(SimInfo* info) : BaseVisitor(), zconsReader(NULL){
9			GenericData* data;
10	tim	1625	DoubleGenericData* tolerance;
11	gezelter	1490	ZConsParaData* zConsParaData;
12	tim	1625	StringGenericData* filename;
13			DoubleGenericData* sampleTime;
14	tim	1818	std::vector<ZConsParaItem>* parameters;
15	gezelter	1490
16			this->info = info;
17			visitorName = "ZConsVisitor";
18
19			//retrieve tolerance for z-constraint molecuels
20	tim	1701	data = info->getPropertyByName(ZCONSTOL_ID);
21	gezelter	1490
22			if (!data){
23			cerr << "Can not get zconstraint tolerance from SimInfo" << endl;
24			haveZcons = false;
25			return;
26			}
27			else{
28	tim	1625	tolerance = dynamic_cast<DoubleGenericData*>(data);
29	gezelter	1490
30			if (!tolerance){
31			cerr << "Can not get zconstraint tolerance from SimInfo" << endl;
32			haveZcons = false;
33			return;
34			}
35			else{
36			zconsTol = tolerance->getData();
37			}
38			}
39
40			//retrieve sample time of z-contraint
41	tim	1701	data = info->getPropertyByName(ZCONSTIME_ID);
42	gezelter	1490
43			if (!data){
44			cerr << "Can not get zcons time from SimInfo" << endl;
45			haveZcons = false;
46			return;
47			}
48			else{
49	tim	1625	sampleTime = dynamic_cast<DoubleGenericData*>(data);
50	gezelter	1490
51			if (!sampleTime){
52			cerr << "Can not get zcons time from SimInfo" << endl;
53			haveZcons = false;
54			return;
55			}
56			else{
57			zconsTime = sampleTime->getData();
58			}
59			}
60
61			//retrieve index of z-constraint molecules
62	tim	1701	data = info->getPropertyByName(ZCONSPARADATA_ID);
63	gezelter	1490	if (!data){
64			cerr << "Can not get index of z-constraint molecules from SimInfo" << endl;
65			haveZcons = false;
66			return;
67			}
68			else{
69			zConsParaData = dynamic_cast<ZConsParaData*>(data);
70
71			if (!zConsParaData){
72			cerr << "Can not get index of z-constraint molecules from SimInfo" << endl;
73			haveZcons = false;
74			return;
75			}
76			else{
77			vector<ZConsParaItem>::iterator i;
78			Molecule* mol;
79
80			parameters = zConsParaData->getData();
81			for(i = parameters->begin(); i != parameters->end(); ++i){
82
83	tim	1818	mol = info->getMoleculeByGlobalIndex(i->zconsIndex);
84	gezelter	1490	if(mol != NULL)
85			zconsMol.push_back(mol);
86
87			}
88
89			if(zconsMol.size() < 1){
90			cerr << "number of zconstraint molecules is less than one" << endl;
91			haveZcons = false;
92			return;
93			}
94
95			}//end if (!zConsParaData)
96
97			}//end if (!data
98
99			//retrieve output filename of z force
100	tim	1701	data = info->getPropertyByName(ZCONSFILENAME_ID);
101	gezelter	1490	if (!data){
102			cerr << "Can not get filename of z-constraint output from SimInfo" << endl;
103			haveZcons = false;
104			return;
105			}
106			else{
107	tim	1625	filename = dynamic_cast<StringGenericData*>(data);
108	gezelter	1490
109			if (!filename){
110			cerr << "Can not get filename of z-constraint output from SimInfo" << endl;
111			haveZcons = false;
112			return;
113			}
114			else{
115			zconsFilename = filename->getData();
116			}
117			}
118
119			zconsReader = new ZConsReader(info);
120
121			if (zconsReader->hasNextFrame())
122			zconsReader->readNextFrame();
123
124			haveZcons = true;
125			}
126
127			ZConsVisitor::~ZConsVisitor(){
128			if(!zconsReader)
129			delete zconsReader;
130
131			}
132
133			void ZConsVisitor::visit(Atom* atom){
134	tim	1818	std::string prefix;
135	tim	1702	if(isZconstraint(atom->getLocalIndex(), prefix))
136	gezelter	1490	internalVisit(atom, prefix);
137			}
138
139			void ZConsVisitor::visit(DirectionalAtom* datom){
140	tim	1818	std::string prefix;
141	gezelter	1490
142	tim	1702	if(isZconstraint(datom->getLocalIndex(), prefix))
143	gezelter	1490	internalVisit(datom, prefix);
144			}
145
146			void ZConsVisitor::visit(RigidBody* rb){
147	tim	1818	std::string prefix;
148			std::vector<Atom*> atoms;
149	gezelter	1490
150			atoms = rb->getAtoms();
151
152	tim	1702	if(isZconstraint(atoms[0]->getLocalIndex(), prefix))
153	gezelter	1490	internalVisit(rb, prefix);
154			}
155
156			void ZConsVisitor::update(){
157			Molecule* mol;
158	tim	1702	Vector3d com;
159	gezelter	1490	ZConsState state;
160
161	tim	1818	Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
162			getZconsPos(currSnapshot->getTime());
163
164	gezelter	1490	for(size_t i = 0; i < zconsMol.size(); i++){
165	tim	1702	com = zconsMol[i]->getCom();
166	gezelter	1490
167			if(fabs(com[2] - zconsPos[i]) < zconsTol)
168			state = zsFixed;
169			else
170			state = zsMoving;
171
172			//update the state of zconstraint atom
173	tim	1702	//natoms = zconsMol[i]->getNAtoms();
174			//atoms = zconsMol[i]->getMyAtoms();
175			//for(int j =0; j < natoms; j++)
176			// zconsState[atoms[j]->getLocalIndex()] = state;
177
178			std::vector<Atom*>::iterator j;
179			for (Atom* atom = zconsMol[i]->beginAtom(j); atom != NULL; atom = zconsMol[i]->nextAtom(j)) {
180			zconsState[atom->getLocalIndex()] = state;
181			}
182	gezelter	1490	}
183
184			}
185
186			void ZConsVisitor::getZconsPos(double time){
187
188	tim	1818	std::vector<double> tempPos;
189			std::vector<double> prevPos;
190	gezelter	1490	double tempTime;
191
192			while(true){
193			tempTime = zconsReader->getCurTime();
194
195			zconsPos = zconsReader->getZConsPos();
196
197			if(tempTime >= time)
198			return;
199
200			zconsReader->readNextFrame();
201
202			}
203
204			}
205
206			void ZConsVisitor::internalVisit(StuntDouble* sd, const string& prefix){
207			GenericData* data;
208			AtomData* atomData;
209			AtomInfo* atomInfo;
210	tim	1818	std::vector<AtomInfo*>::iterator iter;
211	gezelter	1490
212
213			//if there is not atom data, just skip it
214	tim	1701	data = sd->getPropertyByName("ATOMDATA");
215	gezelter	1490	if(data != NULL){
216			atomData = dynamic_cast<AtomData*>(data);
217			if(atomData == NULL)
218			return;
219			}
220			else
221			return;
222
223			for(atomInfo = atomData->beginAtomInfo(iter); atomInfo; atomInfo = atomData->nextAtomInfo(iter))
224			(atomInfo->AtomType).insert(0, prefix);
225			}
226
227
228			bool ZConsVisitor::isZconstraint(int index, string& prefix){
229	tim	1818	std::map<int, ZConsState>::iterator i;
230			std::string prefixString[] = {"ZF", "ZM"};
231	gezelter	1490
232			i = zconsState.find(index);
233			if(i !=zconsState.end()){
234			prefix = prefixString[(*i).second];
235			return true;
236			}
237			else{
238			prefix = "";
239			return false;
240			}
241			}
242
243	tim	1818	const std::string ZConsVisitor::toString(){
244	gezelter	1490	char buffer[65535];
245	tim	1818	std::string result;
246	gezelter	1490
247			sprintf(buffer ,"------------------------------------------------------------------\n");
248			result += buffer;
249
250			sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
251			result += buffer;
252
253			sprintf(buffer , "number of zconstraint molecule: %d\n", zconsMol.size());
254			result += buffer;
255
256			sprintf(buffer , "zconstraint tolerance = %lf\n", zconsTol);
257			result += buffer;
258
259			sprintf(buffer , "zconstraint sample time = %lf\n", zconsTime);
260			result += buffer;
261
262			sprintf(buffer , "zconstraint output filename = %s\n", zconsFilename.c_str());
263			result += buffer;
264
265			for(size_t i = 0; i < zconsMol.size(); ++i){
266	tim	1702	sprintf(buffer ,"zconstraint molecule[%d] = %d\n", i, zconsMol[i]->getGlobalIndex());
267	gezelter	1490	result += buffer;
268
269			}
270
271
272			sprintf(buffer ,"------------------------------------------------------------------\n");
273			result += buffer;
274
275			return result;
276			}
277	tim	1625
278
279			}//namespace oopse