ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/branches/new_design/OOPSE-3.0/src/visitors/AtomVisitor.cpp
(Generate patch)

Comparing branches/new_design/OOPSE-3.0/src/visitors/AtomVisitor.cpp (file contents):
Revision 1683, Thu Oct 28 22:34:02 2004 UTC vs.
Revision 1701 by tim, Wed Nov 3 16:08:43 2004 UTC

# Line 1 | Line 1
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->getProperty("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->getProperty("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 <  double h1[3] = {0.0, -0.75695, 0.5206};
55 <  double h2[3] = {0.0, 0.75695, 0.5206};
56 <  double ox[3] = {0.0, 0.0, -0.0654};
57 <  double u[3] = {0, 0, 1};
58 <  double rotMatrix[3][3];
59 <  double rotTrans[3][3];
60 <  AtomInfo* atomInfo;
61 <  double pos[3];
62 <  double newVec[3];
63 <  double q[4];
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->getProperty("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 <  datom->getPos(pos);
91 <  datom->getQ(q);
92 <  datom->getA(rotMatrix);
93 <
94 <  // We need A^T to convert from body-fixed to space-fixed:
95 <  transposeMat3(rotMatrix, rotTrans);
96 <  
97 <  //center of mass of the water molecule
98 <  matVecMul3(rotTrans, u, newVec);
99 <  atomInfo = new AtomInfo;
100 <  atomInfo->AtomType = "X";
101 <  atomInfo->pos[0] = pos[0];
102 <  atomInfo->pos[1] = pos[1];
103 <  atomInfo->pos[2] = pos[2];
104 <  atomInfo->dipole[0] = newVec[0];
105 <  atomInfo->dipole[1] = newVec[1];
106 <  atomInfo->dipole[2] = newVec[2];
107 <
108 <  atomData->addAtomInfo(atomInfo);
109 <
110 <  //oxygen
111 <  matVecMul3(rotTrans, ox, newVec);
112 <  atomInfo = new AtomInfo;
113 <  atomInfo->AtomType = "O";
114 <  atomInfo->pos[0] = pos[0] + newVec[0];
115 <  atomInfo->pos[1] = pos[1] + newVec[1];
116 <  atomInfo->pos[2] = pos[2] + newVec[2];
117 <  atomInfo->dipole[0] = 0.0;
118 <  atomInfo->dipole[1] = 0.0;
119 <  atomInfo->dipole[2] = 0.0;
120 <  atomData->addAtomInfo(atomInfo);
121 <
122 <
123 <  //hydrogen1
124 <    matVecMul3(rotTrans, h1, newVec);
125 <  atomInfo = new AtomInfo;
126 <  atomInfo->AtomType = "H";
127 <  atomInfo->pos[0] = pos[0] + newVec[0];
128 <  atomInfo->pos[1] = pos[1] + newVec[1];
129 <  atomInfo->pos[2] = pos[2] + newVec[2];
130 <  atomInfo->dipole[0] = 0.0;
131 <  atomInfo->dipole[1] = 0.0;
132 <  atomInfo->dipole[2] = 0.0;
133 <  atomData->addAtomInfo(atomInfo);
134 <
135 <  //hydrogen2
136 <  matVecMul3(rotTrans, h2, newVec);
137 <  atomInfo = new AtomInfo;
138 <  atomInfo->AtomType = "H";
139 <  atomInfo->pos[0] = pos[0] + newVec[0];
140 <  atomInfo->pos[1] = pos[1] + newVec[1];
141 <  atomInfo->pos[2] = pos[2] + newVec[2];
142 <  atomInfo->dipole[0] = 0.0;
143 <  atomInfo->dipole[1] = 0.0;
144 <  atomInfo->dipole[2] = 0.0;
145 <  atomData->addAtomInfo(atomInfo);
146 <
147 <  //add atom data into atom's property
148 <
149 <  if(!haveAtomData){
150 <    atomData->setID("ATOMDATA");
151 <    datom->addProperty(atomData);
152 <  }
153 <
154 <  setVisited(datom);
155 <
156 < }
157 <
158 < const string SSDAtomVisitor::toString(){
159 <  char buffer[65535];
160 <  string result;
161 <  
162 <  sprintf(buffer ,"------------------------------------------------------------------\n");
163 <  result += buffer;
164 <
165 <  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
166 <  result += buffer;
167 <
168 <  sprintf(buffer , "Visitor Description: Convert SSD into 4 different atoms\n");
169 <  result += buffer;
170 <
171 <  sprintf(buffer ,"------------------------------------------------------------------\n");
172 <  result += buffer;
173 <
174 <  return result;
175 < }
176 <
177 < //----------------------------------------------------------------------------//
178 <
179 < void DefaultAtomVisitor::visit(Atom* atom){
180 <  AtomData* atomData;
181 <  AtomInfo* atomInfo;
182 <  double pos[3];
183 <
184 <  if(isVisited(atom))
185 <    return;
186 <
187 < atomInfo =new AtomInfo;
188 <
189 <  atomData = new AtomData;
190 <  atomData->setID("ATOMDATA");
191 <
192 <  atom->getPos(pos);
193 <  atomInfo->AtomType = atom->getType();
194 <  atomInfo->pos[0] = pos[0];
195 <  atomInfo->pos[1] = pos[1];
196 <  atomInfo->pos[2] = pos[2];
197 <  atomInfo->dipole[0] = 0.0;
198 <  atomInfo->dipole[1] = 0.0;
199 <  atomInfo->dipole[2] = 0.0;
200 <
201 <
202 <  atomData->addAtomInfo(atomInfo);
203 <  
204 <  atom->addProperty(atomData);
205 <
206 <  setVisited(atom);
207 < }
208 < void DefaultAtomVisitor::visit(DirectionalAtom* datom){
209 <  AtomData* atomData;
210 <  AtomInfo* atomInfo;
211 <  double pos[3];
212 <  double u[3];
213 <
214 <  if(isVisited(datom))
215 <    return;
216 <  
217 <  datom->getPos(pos);
218 <  datom->getU(u);
219 <
220 <  atomData = new AtomData;
221 <  atomData->setID("ATOMDATA");
222 <  atomInfo =new AtomInfo;
223 <  
224 <  atomInfo->AtomType = datom->getType();
225 <  atomInfo->pos[0] = pos[0];
226 <  atomInfo->pos[1] = pos[1];
227 <  atomInfo->pos[2] = pos[2];
228 <  atomInfo->dipole[0] = u[0];
229 <  atomInfo->dipole[1] = u[1];
230 <  atomInfo->dipole[2] = u[2];  
231 <
232 <  atomData->addAtomInfo(atomInfo);
233 <
234 <  datom->addProperty(atomData);
235 <
236 <  setVisited(datom);
237 < }
238 <
239 <
240 < const string DefaultAtomVisitor::toString(){
241 <  char buffer[65535];
242 <  string result;
243 <  
244 <  sprintf(buffer ,"------------------------------------------------------------------\n");
245 <  result += buffer;
246 <
247 <  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
248 <  result += buffer;
249 <
250 <  sprintf(buffer , "Visitor Description: copy atom infomation into atom data\n");
251 <  result += buffer;
252 <
253 <  sprintf(buffer ,"------------------------------------------------------------------\n");
254 <  result += buffer;
255 <
256 <  return result;
257 < }    
258 <
259 < }//namespace oopse
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

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines