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

Comparing branches/new_design/OOPSE-4/src/visitors/AtomVisitor.cpp (file contents):
Revision 1695 by tim, Mon Nov 1 22:52:57 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->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 <  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 <  double rotMatrix[3][3];
59 <  double rotTrans[3][3];
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->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 <  pos = datom->getPos();
91 <  q = datom->getQ();
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 <  pos = atom->getPos();
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 <  pos = datom->getPos();
218 <  u = datom->getU();
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 > 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