src/visitors/AtomVisitor.cpp

#include <cstring>
#include "visitors/AtomVisitor.hpp"
#include "primitives/DirectionalAtom.hpp"
#include "math/MatVec3.h"
#include "primitives/RigidBody.hpp"

namespace oopse {

void BaseAtomVisitor::visit(RigidBody* rb){
  //vector<Atom*> myAtoms;
  //vector<Atom*>::iterator atomIter;

  //myAtoms = rb->getAtoms();
  
  //for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
  //  (*atomIter)->accept(this);
}

void BaseAtomVisitor::setVisited(Atom* atom){
  GenericData* data;
  data = atom->getPropertyByName("VISITED");

  //if visited property is not existed, add it as new property
  if(data == NULL){
    data = new GenericData();
    data->setID("VISITED");
    atom->addProperty(data);  
  }
}

bool BaseAtomVisitor::isVisited(Atom* atom){
  GenericData* data;
  data = atom->getPropertyByName("VISITED");
  return data == NULL ?  false : true;
}

bool SSDAtomVisitor::isSSDAtom(const string& atomType){
  vector<string>::iterator strIter;
  
  for(strIter = ssdAtomType.begin(); strIter != ssdAtomType.end(); ++strIter)
   if(*strIter == atomType)
    return true;
  
  return false;  
}

void SSDAtomVisitor::visit(DirectionalAtom* datom){

  vector<AtomInfo*> atoms;

  //we need to convert SSD into 4 differnet atoms
  //one oxygen atom, two hydrogen atoms and one pseudo atom which is the center of the mass
  //of the water with a dipole moment
  Vector3d h1(0.0, -0.75695, 0.5206);
  Vector3d h2(0.0, 0.75695, 0.5206);
  Vector3d ox(0.0, 0.0, -0.0654);
  Vector3d u(0, 0, 1);
  RotMat3x3d rotMatrix;
  RotMat3x3d rotTrans;
  AtomInfo* atomInfo;
  Vector3d pos;
  Vector3d newVec;
  Quat4d q;
  AtomData* atomData;
  GenericData* data;
  bool haveAtomData;
  
  //if atom is not SSD atom, just skip it
  if(!isSSDAtom(datom->getType()))
    return;

  data = datom->getPropertyByName("ATOMDATA");
  if(data != NULL){

    atomData = dynamic_cast<AtomData*>(data);  
    if(atomData == NULL){
      cerr << "can not get Atom Data from " << datom->getType() << endl;
      atomData = new AtomData; 
      haveAtomData = false;      
    }
    else
      haveAtomData = true;
  }
  else{
    atomData = new AtomData;
    haveAtomData = false;
  }
   
  
  pos = datom->getPos();
  q = datom->getQ();
  rotMatrix= datom->getA();

  // We need A^T to convert from body-fixed to space-fixed:
  //transposeMat3(rotMatrix, rotTrans);
  rotTrans = rotMatrix.transpose();
  
  //center of mass of the water molecule
  //matVecMul3(rotTrans, u, newVec);
  newVec = rotTrans * u;
  
  atomInfo = new AtomInfo;
  atomInfo->AtomType = "X";
  atomInfo->pos[0] = pos[0];
  atomInfo->pos[1] = pos[1];
  atomInfo->pos[2] = pos[2];
  atomInfo->dipole[0] = newVec[0];
  atomInfo->dipole[1] = newVec[1];
  atomInfo->dipole[2] = newVec[2];

  atomData->addAtomInfo(atomInfo);

  //oxygen
  //matVecMul3(rotTrans, ox, newVec);
  newVec = rotTrans * ox;

  atomInfo = new AtomInfo;
  atomInfo->AtomType = "O";
  atomInfo->pos[0] = pos[0] + newVec[0];
  atomInfo->pos[1] = pos[1] + newVec[1];
  atomInfo->pos[2] = pos[2] + newVec[2];
  atomInfo->dipole[0] = 0.0;
  atomInfo->dipole[1] = 0.0;
  atomInfo->dipole[2] = 0.0;
  atomData->addAtomInfo(atomInfo);


  //hydrogen1
  //matVecMul3(rotTrans, h1, newVec);
  newVec = rotTrans * h1;
  atomInfo = new AtomInfo;
  atomInfo->AtomType = "H";
  atomInfo->pos[0] = pos[0] + newVec[0];
  atomInfo->pos[1] = pos[1] + newVec[1];
  atomInfo->pos[2] = pos[2] + newVec[2];
  atomInfo->dipole[0] = 0.0;
  atomInfo->dipole[1] = 0.0;
  atomInfo->dipole[2] = 0.0;
  atomData->addAtomInfo(atomInfo);

  //hydrogen2
  //matVecMul3(rotTrans, h2, newVec);
  newVec = rotTrans * h2;
  atomInfo = new AtomInfo;
  atomInfo->AtomType = "H";
  atomInfo->pos[0] = pos[0] + newVec[0];
  atomInfo->pos[1] = pos[1] + newVec[1];
  atomInfo->pos[2] = pos[2] + newVec[2];
  atomInfo->dipole[0] = 0.0;
  atomInfo->dipole[1] = 0.0;
  atomInfo->dipole[2] = 0.0;
  atomData->addAtomInfo(atomInfo);

  //add atom data into atom's property

  if(!haveAtomData){
    atomData->setID("ATOMDATA");
    datom->addProperty(atomData);
  }

  setVisited(datom);

}

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

  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
  result += buffer;

  sprintf(buffer , "Visitor Description: Convert SSD into 4 different atoms\n");
  result += buffer;

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

  return result;
}

//----------------------------------------------------------------------------//

void DefaultAtomVisitor::visit(Atom* atom){
  AtomData* atomData;
  AtomInfo* atomInfo;
  Vector3d pos;

  if(isVisited(atom))
    return;

 atomInfo =new AtomInfo;

  atomData = new AtomData; 
  atomData->setID("ATOMDATA");
 
  pos = atom->getPos();
  atomInfo->AtomType = atom->getType();
  atomInfo->pos[0] = pos[0];
  atomInfo->pos[1] = pos[1];
  atomInfo->pos[2] = pos[2];
  atomInfo->dipole[0] = 0.0;
  atomInfo->dipole[1] = 0.0;
  atomInfo->dipole[2] = 0.0;


  atomData->addAtomInfo(atomInfo);
  
  atom->addProperty(atomData);

  setVisited(atom);
}
void DefaultAtomVisitor::visit(DirectionalAtom* datom){
  AtomData* atomData;
  AtomInfo* atomInfo;
  Vector3d pos;
  Vector3d u;

  if(isVisited(datom))
    return;
  
  pos = datom->getPos();
  u = datom->getUnitVector();

  atomData = new AtomData; 
  atomData->setID("ATOMDATA");
  atomInfo =new AtomInfo;
  
  atomInfo->AtomType = datom->getType();
  atomInfo->pos[0] = pos[0];
  atomInfo->pos[1] = pos[1];
  atomInfo->pos[2] = pos[2];
  atomInfo->dipole[0] = u[0];
  atomInfo->dipole[1] = u[1];
  atomInfo->dipole[2] = u[2];  

  atomData->addAtomInfo(atomInfo);

  datom->addProperty(atomData);

  setVisited(datom);
}


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

  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
  result += buffer;

  sprintf(buffer , "Visitor Description: copy atom infomation into atom data\n");
  result += buffer;

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

  return result;
}    

}//namespace oopse
Revision:	1701
Committed:	Wed Nov 3 16:08:43 2004 UTC (19 years, 10 months ago) by tim
File size:	6672 byte(s)
Log Message:	mess up ......
#	User	Rev	Content
1	tim	1695	#include <cstring>
2			#include "visitors/AtomVisitor.hpp"
3			#include "primitives/DirectionalAtom.hpp"
4			#include "math/MatVec3.h"
5			#include "primitives/RigidBody.hpp"
6
7			namespace oopse {
8
9			void BaseAtomVisitor::visit(RigidBody* rb){
10			//vector<Atom*> myAtoms;
11			//vector<Atom*>::iterator atomIter;
12
13			//myAtoms = rb->getAtoms();
14
15			//for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
16			// (*atomIter)->accept(this);
17			}
18
19			void BaseAtomVisitor::setVisited(Atom* atom){
20			GenericData* data;
21	tim	1701	data = atom->getPropertyByName("VISITED");
22	tim	1695
23			//if visited property is not existed, add it as new property
24			if(data == NULL){
25			data = new GenericData();
26			data->setID("VISITED");
27			atom->addProperty(data);
28			}
29			}
30
31			bool BaseAtomVisitor::isVisited(Atom* atom){
32			GenericData* data;
33	tim	1701	data = atom->getPropertyByName("VISITED");
34	tim	1695	return data == NULL ? false : true;
35			}
36
37			bool SSDAtomVisitor::isSSDAtom(const string& atomType){
38			vector<string>::iterator strIter;
39
40			for(strIter = ssdAtomType.begin(); strIter != ssdAtomType.end(); ++strIter)
41			if(*strIter == atomType)
42			return true;
43
44			return false;
45			}
46
47			void SSDAtomVisitor::visit(DirectionalAtom* datom){
48
49			vector<AtomInfo*> atoms;
50
51			//we need to convert SSD into 4 differnet atoms
52			//one oxygen atom, two hydrogen atoms and one pseudo atom which is the center of the mass
53			//of the water with a dipole moment
54			Vector3d h1(0.0, -0.75695, 0.5206);
55			Vector3d h2(0.0, 0.75695, 0.5206);
56			Vector3d ox(0.0, 0.0, -0.0654);
57			Vector3d u(0, 0, 1);
58	tim	1701	RotMat3x3d rotMatrix;
59			RotMat3x3d rotTrans;
60	tim	1695	AtomInfo* atomInfo;
61			Vector3d pos;
62			Vector3d newVec;
63			Quat4d q;
64			AtomData* atomData;
65			GenericData* data;
66			bool haveAtomData;
67
68			//if atom is not SSD atom, just skip it
69			if(!isSSDAtom(datom->getType()))
70			return;
71
72	tim	1701	data = datom->getPropertyByName("ATOMDATA");
73	tim	1695	if(data != NULL){
74
75			atomData = dynamic_cast<AtomData*>(data);
76			if(atomData == NULL){
77			cerr << "can not get Atom Data from " << datom->getType() << endl;
78			atomData = new AtomData;
79			haveAtomData = false;
80			}
81			else
82			haveAtomData = true;
83			}
84			else{
85			atomData = new AtomData;
86			haveAtomData = false;
87			}
88
89
90			pos = datom->getPos();
91			q = datom->getQ();
92	tim	1701	rotMatrix= datom->getA();
93	tim	1695
94			// We need A^T to convert from body-fixed to space-fixed:
95	tim	1701	//transposeMat3(rotMatrix, rotTrans);
96			rotTrans = rotMatrix.transpose();
97	tim	1695
98			//center of mass of the water molecule
99	tim	1701	//matVecMul3(rotTrans, u, newVec);
100			newVec = rotTrans * u;
101
102	tim	1695	atomInfo = new AtomInfo;
103			atomInfo->AtomType = "X";
104			atomInfo->pos[0] = pos[0];
105			atomInfo->pos[1] = pos[1];
106			atomInfo->pos[2] = pos[2];
107			atomInfo->dipole[0] = newVec[0];
108			atomInfo->dipole[1] = newVec[1];
109			atomInfo->dipole[2] = newVec[2];
110
111			atomData->addAtomInfo(atomInfo);
112
113			//oxygen
114	tim	1701	//matVecMul3(rotTrans, ox, newVec);
115			newVec = rotTrans * ox;
116
117	tim	1695	atomInfo = new AtomInfo;
118			atomInfo->AtomType = "O";
119			atomInfo->pos[0] = pos[0] + newVec[0];
120			atomInfo->pos[1] = pos[1] + newVec[1];
121			atomInfo->pos[2] = pos[2] + newVec[2];
122			atomInfo->dipole[0] = 0.0;
123			atomInfo->dipole[1] = 0.0;
124			atomInfo->dipole[2] = 0.0;
125			atomData->addAtomInfo(atomInfo);
126
127
128			//hydrogen1
129	tim	1701	//matVecMul3(rotTrans, h1, newVec);
130			newVec = rotTrans * h1;
131	tim	1695	atomInfo = new AtomInfo;
132			atomInfo->AtomType = "H";
133			atomInfo->pos[0] = pos[0] + newVec[0];
134			atomInfo->pos[1] = pos[1] + newVec[1];
135			atomInfo->pos[2] = pos[2] + newVec[2];
136			atomInfo->dipole[0] = 0.0;
137			atomInfo->dipole[1] = 0.0;
138			atomInfo->dipole[2] = 0.0;
139			atomData->addAtomInfo(atomInfo);
140
141			//hydrogen2
142	tim	1701	//matVecMul3(rotTrans, h2, newVec);
143			newVec = rotTrans * h2;
144	tim	1695	atomInfo = new AtomInfo;
145			atomInfo->AtomType = "H";
146			atomInfo->pos[0] = pos[0] + newVec[0];
147			atomInfo->pos[1] = pos[1] + newVec[1];
148			atomInfo->pos[2] = pos[2] + newVec[2];
149			atomInfo->dipole[0] = 0.0;
150			atomInfo->dipole[1] = 0.0;
151			atomInfo->dipole[2] = 0.0;
152			atomData->addAtomInfo(atomInfo);
153
154			//add atom data into atom's property
155
156			if(!haveAtomData){
157			atomData->setID("ATOMDATA");
158			datom->addProperty(atomData);
159			}
160
161			setVisited(datom);
162
163			}
164
165			const string SSDAtomVisitor::toString(){
166			char buffer[65535];
167			string result;
168
169			sprintf(buffer ,"------------------------------------------------------------------\n");
170			result += buffer;
171
172			sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
173			result += buffer;
174
175			sprintf(buffer , "Visitor Description: Convert SSD into 4 different atoms\n");
176			result += buffer;
177
178			sprintf(buffer ,"------------------------------------------------------------------\n");
179			result += buffer;
180
181			return result;
182			}
183
184			//----------------------------------------------------------------------------//
185
186			void DefaultAtomVisitor::visit(Atom* atom){
187			AtomData* atomData;
188			AtomInfo* atomInfo;
189	tim	1701	Vector3d pos;
190	tim	1695
191			if(isVisited(atom))
192			return;
193
194			atomInfo =new AtomInfo;
195
196			atomData = new AtomData;
197			atomData->setID("ATOMDATA");
198
199			pos = atom->getPos();
200			atomInfo->AtomType = atom->getType();
201			atomInfo->pos[0] = pos[0];
202			atomInfo->pos[1] = pos[1];
203			atomInfo->pos[2] = pos[2];
204			atomInfo->dipole[0] = 0.0;
205			atomInfo->dipole[1] = 0.0;
206			atomInfo->dipole[2] = 0.0;
207
208
209			atomData->addAtomInfo(atomInfo);
210
211			atom->addProperty(atomData);
212
213			setVisited(atom);
214			}
215			void DefaultAtomVisitor::visit(DirectionalAtom* datom){
216			AtomData* atomData;
217			AtomInfo* atomInfo;
218	tim	1701	Vector3d pos;
219			Vector3d u;
220	tim	1695
221			if(isVisited(datom))
222			return;
223
224			pos = datom->getPos();
225	tim	1701	u = datom->getUnitVector();
226	tim	1695
227			atomData = new AtomData;
228			atomData->setID("ATOMDATA");
229			atomInfo =new AtomInfo;
230
231			atomInfo->AtomType = datom->getType();
232			atomInfo->pos[0] = pos[0];
233			atomInfo->pos[1] = pos[1];
234			atomInfo->pos[2] = pos[2];
235			atomInfo->dipole[0] = u[0];
236			atomInfo->dipole[1] = u[1];
237			atomInfo->dipole[2] = u[2];
238
239			atomData->addAtomInfo(atomInfo);
240
241			datom->addProperty(atomData);
242
243			setVisited(datom);
244			}
245
246
247			const string DefaultAtomVisitor::toString(){
248			char buffer[65535];
249			string result;
250
251			sprintf(buffer ,"------------------------------------------------------------------\n");
252			result += buffer;
253
254			sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
255			result += buffer;
256
257			sprintf(buffer , "Visitor Description: copy atom infomation into atom data\n");
258			result += buffer;
259
260			sprintf(buffer ,"------------------------------------------------------------------\n");
261			result += buffer;
262
263			return result;
264			}
265
266			}//namespace oopse