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 ......
#	Content
1	#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	data = atom->getPropertyByName("VISITED");
22
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	data = atom->getPropertyByName("VISITED");
34	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	RotMat3x3d rotMatrix;
59	RotMat3x3d rotTrans;
60	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	data = datom->getPropertyByName("ATOMDATA");
73	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	rotMatrix= datom->getA();
93
94	// We need A^T to convert from body-fixed to space-fixed:
95	//transposeMat3(rotMatrix, rotTrans);
96	rotTrans = rotMatrix.transpose();
97
98	//center of mass of the water molecule
99	//matVecMul3(rotTrans, u, newVec);
100	newVec = rotTrans * u;
101
102	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	//matVecMul3(rotTrans, ox, newVec);
115	newVec = rotTrans * ox;
116
117	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	//matVecMul3(rotTrans, h1, newVec);
130	newVec = rotTrans * h1;
131	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	//matVecMul3(rotTrans, h2, newVec);
143	newVec = rotTrans * h2;
144	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	Vector3d pos;
190
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	Vector3d pos;
219	Vector3d u;
220
221	if(isVisited(datom))
222	return;
223
224	pos = datom->getPos();
225	u = datom->getUnitVector();
226
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