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

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

Diff Legend

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