ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/visitors/AtomVisitor.cpp
(Generate patch)

Comparing:
trunk/src/visitors/AtomVisitor.cpp (file contents), Revision 407 by gezelter, Tue Mar 8 21:07:49 2005 UTC vs.
branches/development/src/visitors/AtomVisitor.cpp (file contents), Revision 1787 by gezelter, Wed Aug 29 18:13:11 2012 UTC

# Line 1 | Line 1
1 < /*
1 > /*
2   * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3   *
4   * The University of Notre Dame grants you ("Licensee") a
# Line 6 | Line 6
6   * redistribute this software in source and binary code form, provided
7   * that the following conditions are met:
8   *
9 < * 1. Acknowledgement of the program authors must be made in any
10 < *    publication of scientific results based in part on use of the
11 < *    program.  An acceptable form of acknowledgement is citation of
12 < *    the article in which the program was described (Matthew
13 < *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 < *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 < *    Parallel Simulation Engine for Molecular Dynamics,"
16 < *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 < *
18 < * 2. Redistributions of source code must retain the above copyright
9 > * 1. Redistributions of source code must retain the above copyright
10   *    notice, this list of conditions and the following disclaimer.
11   *
12 < * 3. Redistributions in binary form must reproduce the above copyright
12 > * 2. Redistributions in binary form must reproduce the above copyright
13   *    notice, this list of conditions and the following disclaimer in the
14   *    documentation and/or other materials provided with the
15   *    distribution.
# Line 37 | Line 28
28   * arising out of the use of or inability to use software, even if the
29   * University of Notre Dame has been advised of the possibility of
30   * such damages.
31 + *
32 + * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33 + * research, please cite the appropriate papers when you publish your
34 + * work.  Good starting points are:
35 + *                                                                      
36 + * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37 + * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38 + * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39 + * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40 + * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41   */
42  
43   #include <cstring>
44   #include "visitors/AtomVisitor.hpp"
45   #include "primitives/DirectionalAtom.hpp"
46   #include "primitives/RigidBody.hpp"
47 + #include "types/MultipoleAdapter.hpp"
48 + #include "types/GayBerneAdapter.hpp"
49  
50 < namespace oopse {
51 < void BaseAtomVisitor::visit(RigidBody *rb) {
52 < //vector<Atom*> myAtoms;
53 < //vector<Atom*>::iterator atomIter;
50 > namespace OpenMD {
51 >  void BaseAtomVisitor::visit(RigidBody *rb) {
52 >    //vector<Atom*> myAtoms;
53 >    //vector<Atom*>::iterator atomIter;
54  
55 < //myAtoms = rb->getAtoms();
55 >    //myAtoms = rb->getAtoms();
56  
57 < //for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
58 < //  (*atomIter)->accept(this);
59 <    }
57 >    //for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
58 >    //  (*atomIter)->accept(this);
59 >  }
60  
61 < void BaseAtomVisitor::setVisited(Atom *atom) {
61 >  void BaseAtomVisitor::setVisited(Atom *atom) {
62      GenericData *data;
63      data = atom->getPropertyByName("VISITED");
64  
65      //if visited property is not existed, add it as new property
66      if (data == NULL) {
67 <        data = new GenericData();
68 <        data->setID("VISITED");
69 <        atom->addProperty(data);
67 >      data = new GenericData();
68 >      data->setID("VISITED");
69 >      atom->addProperty(data);
70      }
71 < }
71 >  }
72  
73 < bool BaseAtomVisitor::isVisited(Atom *atom) {
73 >  bool BaseAtomVisitor::isVisited(Atom *atom) {
74      GenericData *data;
75      data = atom->getPropertyByName("VISITED");
76      return data == NULL ? false : true;
77 < }
77 >  }
78  
79 < bool SSDAtomVisitor::isSSDAtom(const std::string&atomType) {
80 <    std::set<std::string>::iterator strIter;
81 <    strIter = ssdAtomType.find(atomType);
79 <    return strIter != ssdAtomType.end() ? true : false;
80 < }
81 <
82 < void SSDAtomVisitor::visit(DirectionalAtom *datom) {
83 <    std::vector<AtomInfo*>atoms;
84 <
85 <    //we need to convert SSD into 4 differnet atoms
86 <    //one oxygen atom, two hydrogen atoms and one pseudo atom which is the center of the mass
87 <    //of the water with a dipole moment
88 <    Vector3d h1(0.0, -0.75695, 0.5206);
89 <    Vector3d h2(0.0, 0.75695, 0.5206);
90 <    Vector3d ox(0.0, 0.0, -0.0654);
91 <    Vector3d u(0, 0, 1);
92 <    RotMat3x3d   rotMatrix;
93 <    RotMat3x3d   rotTrans;
94 <    AtomInfo *   atomInfo;
95 <    Vector3d     pos;
96 <    Vector3d     newVec;
97 <    Quat4d       q;
98 <    AtomData *   atomData;
99 <    GenericData *data;
100 <    bool         haveAtomData;
101 <
102 <    //if atom is not SSD atom, just skip it
103 <    if (!isSSDAtom(datom->getType()))
104 <        return;
105 <
106 <    data = datom->getPropertyByName("ATOMDATA");
107 <
108 <    if (data != NULL) {
109 <        atomData = dynamic_cast<AtomData *>(data);
110 <
111 <        if (atomData == NULL) {
112 <            std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
113 <            atomData = new AtomData;
114 <            haveAtomData = false;
115 <        } else
116 <            haveAtomData = true;
117 <    } else {
118 <        atomData = new AtomData;
119 <        haveAtomData = false;
120 <    }
121 <
122 <    pos = datom->getPos();
123 <    q = datom->getQ();
124 <    rotMatrix = datom->getA();
125 <
126 <    // We need A^T to convert from body-fixed to space-fixed:
127 <    //transposeMat3(rotMatrix, rotTrans);
128 <    rotTrans = rotMatrix.transpose();
129 <
130 <    //center of mass of the water molecule
131 <    //matVecMul3(rotTrans, u, newVec);
132 <    newVec = rotTrans * u;
133 <
134 <    atomInfo = new AtomInfo;
135 <    atomInfo->atomTypeName = "X";
136 <    atomInfo->pos[0] = pos[0];
137 <    atomInfo->pos[1] = pos[1];
138 <    atomInfo->pos[2] = pos[2];
139 <    atomInfo->dipole[0] = newVec[0];
140 <    atomInfo->dipole[1] = newVec[1];
141 <    atomInfo->dipole[2] = newVec[2];
142 <
143 <    atomData->addAtomInfo(atomInfo);
144 <
145 <    //oxygen
146 <    //matVecMul3(rotTrans, ox, newVec);
147 <    newVec = rotTrans * ox;
148 <
149 <    atomInfo = new AtomInfo;
150 <    atomInfo->atomTypeName = "O";
151 <    atomInfo->pos[0] = pos[0] + newVec[0];
152 <    atomInfo->pos[1] = pos[1] + newVec[1];
153 <    atomInfo->pos[2] = pos[2] + newVec[2];
154 <    atomInfo->dipole[0] = 0.0;
155 <    atomInfo->dipole[1] = 0.0;
156 <    atomInfo->dipole[2] = 0.0;
157 <    atomData->addAtomInfo(atomInfo);
158 <
159 <    //hydrogen1
160 <    //matVecMul3(rotTrans, h1, newVec);
161 <    newVec = rotTrans * h1;
162 <    atomInfo = new AtomInfo;
163 <    atomInfo->atomTypeName = "H";
164 <    atomInfo->pos[0] = pos[0] + newVec[0];
165 <    atomInfo->pos[1] = pos[1] + newVec[1];
166 <    atomInfo->pos[2] = pos[2] + newVec[2];
167 <    atomInfo->dipole[0] = 0.0;
168 <    atomInfo->dipole[1] = 0.0;
169 <    atomInfo->dipole[2] = 0.0;
170 <    atomData->addAtomInfo(atomInfo);
171 <
172 <    //hydrogen2
173 <    //matVecMul3(rotTrans, h2, newVec);
174 <    newVec = rotTrans * h2;
175 <    atomInfo = new AtomInfo;
176 <    atomInfo->atomTypeName = "H";
177 <    atomInfo->pos[0] = pos[0] + newVec[0];
178 <    atomInfo->pos[1] = pos[1] + newVec[1];
179 <    atomInfo->pos[2] = pos[2] + newVec[2];
180 <    atomInfo->dipole[0] = 0.0;
181 <    atomInfo->dipole[1] = 0.0;
182 <    atomInfo->dipole[2] = 0.0;
183 <    atomData->addAtomInfo(atomInfo);
184 <
185 <    //add atom data into atom's property
186 <
187 <    if (!haveAtomData) {
188 <        atomData->setID("ATOMDATA");
189 <        datom->addProperty(atomData);
190 <    }
191 <
192 <    setVisited(datom);
193 < }
194 <
195 < const std::string SSDAtomVisitor::toString() {
196 <    char   buffer[65535];
197 <    std::string result;
198 <
199 <    sprintf(buffer,
200 <            "------------------------------------------------------------------\n");
201 <    result += buffer;
202 <
203 <    sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
204 <    result += buffer;
205 <
206 <    sprintf(buffer,
207 <            "Visitor Description: Convert SSD into 4 different atoms\n");
208 <    result += buffer;
209 <
210 <    sprintf(buffer,
211 <            "------------------------------------------------------------------\n");
212 <    result += buffer;
213 <
214 <    return result;
215 < }
216 <
217 < bool LinearAtomVisitor::isLinearAtom(const std::string& atomType){
218 <    std::set<std::string>::iterator strIter;
219 <    strIter = linearAtomType.find(atomType);
220 <
221 <    return strIter != linearAtomType.end() ? true : false;
222 < }
223 <
224 < void LinearAtomVisitor::visit(DirectionalAtom* datom){
225 <    std::vector<AtomInfo*> atoms;
226 <    //we need to convert linear into 4 different atoms
227 <    Vector3d c1(0.0, 0.0, -1.8);
228 <    Vector3d c2(0.0, 0.0, -0.6);
229 <    Vector3d c3(0.0, 0.0,  0.6);
230 <    Vector3d c4(0.0, 0.0,  1.8);
231 <    RotMat3x3d rotMatrix;
232 <    RotMat3x3d rotTrans;
233 <    AtomInfo* atomInfo;
234 <    Vector3d pos;
235 <    Vector3d newVec;
236 <    Quat4d q;
237 <    AtomData* atomData;
238 <    GenericData* data;
239 <    bool haveAtomData;
240 <
241 <    //if atom is not SSD atom, just skip it
242 <    if(!isLinearAtom(datom->getType()))
243 <        return;
244 <
245 <    data = datom->getPropertyByName("ATOMDATA");
246 <    if(data != NULL){
247 <        atomData = dynamic_cast<AtomData*>(data);  
248 <        if(atomData == NULL){
249 <            std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
250 <            atomData = new AtomData;
251 <            haveAtomData = false;      
252 <        } else {
253 <            haveAtomData = true;
254 <        }
255 <    } else {
256 <        atomData = new AtomData;
257 <        haveAtomData = false;
258 <    }
259 <  
260 <  
261 <    pos = datom->getPos();
262 <    q = datom->getQ();
263 <    rotMatrix = datom->getA();
264 <
265 <    // We need A^T to convert from body-fixed to space-fixed:  
266 <    rotTrans = rotMatrix.transpose();
267 <
268 <    newVec = rotTrans * c1;
269 <    atomInfo = new AtomInfo;
270 <    atomInfo->atomTypeName = "C";
271 <    atomInfo->pos[0] = pos[0] + newVec[0];
272 <    atomInfo->pos[1] = pos[1] + newVec[1];
273 <    atomInfo->pos[2] = pos[2] + newVec[2];
274 <    atomInfo->dipole[0] = 0.0;
275 <    atomInfo->dipole[1] = 0.0;
276 <    atomInfo->dipole[2] = 0.0;
277 <    atomData->addAtomInfo(atomInfo);
278 <
279 <    newVec = rotTrans * c2;
280 <    atomInfo = new AtomInfo;
281 <    atomInfo->atomTypeName = "C";
282 <    atomInfo->pos[0] = pos[0] + newVec[0];
283 <    atomInfo->pos[1] = pos[1] + newVec[1];
284 <    atomInfo->pos[2] = pos[2] + newVec[2];
285 <    atomInfo->dipole[0] = 0.0;
286 <    atomInfo->dipole[1] = 0.0;
287 <    atomInfo->dipole[2] = 0.0;
288 <    atomData->addAtomInfo(atomInfo);
289 <
290 <    newVec = rotTrans * c3;
291 <    atomInfo = new AtomInfo;
292 <    atomInfo->atomTypeName = "C";
293 <    atomInfo->pos[0] = pos[0] + newVec[0];
294 <    atomInfo->pos[1] = pos[1] + newVec[1];
295 <    atomInfo->pos[2] = pos[2] + newVec[2];
296 <    atomInfo->dipole[0] = 0.0;
297 <    atomInfo->dipole[1] = 0.0;
298 <    atomInfo->dipole[2] = 0.0;
299 <    atomData->addAtomInfo(atomInfo);
300 <
301 <    newVec = rotTrans * c4;
302 <    atomInfo = new AtomInfo;
303 <    atomInfo->atomTypeName = "C";
304 <    atomInfo->pos[0] = pos[0] + newVec[0];
305 <    atomInfo->pos[1] = pos[1] + newVec[1];
306 <    atomInfo->pos[2] = pos[2] + newVec[2];
307 <    atomInfo->dipole[0] = 0.0;
308 <    atomInfo->dipole[1] = 0.0;
309 <    atomInfo->dipole[2] = 0.0;
310 <    atomData->addAtomInfo(atomInfo);
311 <
312 <    //add atom data into atom's property
313 <
314 <    if(!haveAtomData){
315 <        atomData->setID("ATOMDATA");
316 <        datom->addProperty(atomData);
317 <    }
318 <
319 <    setVisited(datom);
320 <
321 < }
322 <
323 < const std::string LinearAtomVisitor::toString(){
324 <  char buffer[65535];
325 <  std::string result;
326 <  
327 <  sprintf(buffer ,"------------------------------------------------------------------\n");
328 <  result += buffer;
329 <
330 <  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
331 <  result += buffer;
332 <
333 <  sprintf(buffer , "Visitor Description: Convert linear into 4 different atoms\n");
334 <  result += buffer;
335 <
336 <  sprintf(buffer ,"------------------------------------------------------------------\n");
337 <  result += buffer;
338 <
339 <  return result;
340 < }
341 <
342 < //----------------------------------------------------------------------------//
343 <
344 < void DefaultAtomVisitor::visit(Atom *atom) {
79 >  //------------------------------------------------------------------------//
80 >        
81 >  void DefaultAtomVisitor::visit(Atom *atom) {
82      AtomData *atomData;
83      AtomInfo *atomInfo;
84      Vector3d  pos;
85 +    Vector3d  vel;
86 +    Vector3d  frc;
87 +    Vector3d  u;
88  
89      if (isVisited(atom))
90 <        return;
91 <
90 >      return;
91 >    
92      atomInfo = new AtomInfo;
93 <
93 >    
94      atomData = new AtomData;
95      atomData->setID("ATOMDATA");
96 <
96 >    
97      pos = atom->getPos();
98 +    vel = atom->getVel();
99 +    frc = atom->getFrc();
100      atomInfo->atomTypeName = atom->getType();
359 –    printf("setting a type to %s\n", atom->getType().c_str());
101      atomInfo->pos[0] = pos[0];
102      atomInfo->pos[1] = pos[1];
103      atomInfo->pos[2] = pos[2];
104 <    atomInfo->dipole[0] = 0.0;
105 <    atomInfo->dipole[1] = 0.0;
106 <    atomInfo->dipole[2] = 0.0;
107 <
104 >    atomInfo->vel[0] = vel[0];
105 >    atomInfo->vel[1] = vel[1];
106 >    atomInfo->vel[2] = vel[2];
107 >    atomInfo->hasVelocity = true;
108 >    atomInfo->frc[0] = frc[0];
109 >    atomInfo->frc[1] = frc[1];
110 >    atomInfo->frc[2] = frc[2];
111 >    atomInfo->hasForce = true;
112 >    atomInfo->vec[0] = 0.0;
113 >    atomInfo->vec[1] = 0.0;
114 >    atomInfo->vec[2] = 0.0;
115 >    
116      atomData->addAtomInfo(atomInfo);
117 <
117 >    
118      atom->addProperty(atomData);
119 <
119 >    
120      setVisited(atom);
121 < }
122 <
123 < void DefaultAtomVisitor::visit(DirectionalAtom *datom) {
121 >  }
122 >  
123 >  void DefaultAtomVisitor::visit(DirectionalAtom *datom) {
124      AtomData *atomData;
125      AtomInfo *atomInfo;
126      Vector3d  pos;
127 +    Vector3d  vel;
128 +    Vector3d  frc;
129      Vector3d  u;
130  
131      if (isVisited(datom))
132 <        return;
133 <
132 >      return;
133 >    
134      pos = datom->getPos();
135 <    u = datom->getElectroFrame().getColumn(2);
135 >    vel = datom->getVel();
136 >    frc = datom->getFrc();
137  
138 +    GayBerneAdapter gba = GayBerneAdapter(datom->getAtomType());
139 +    MultipoleAdapter ma = MultipoleAdapter(datom->getAtomType());
140 +    
141 +    if (gba.isGayBerne()) {
142 +      u = datom->getA().transpose()*V3Z;        
143 +    } else if (ma.isDipole()) {
144 +      u = datom->getDipole();
145 +    }
146      atomData = new AtomData;
147      atomData->setID("ATOMDATA");
148      atomInfo = new AtomInfo;
# Line 391 | Line 151 | void DefaultAtomVisitor::visit(DirectionalAtom *datom)
151      atomInfo->pos[0] = pos[0];
152      atomInfo->pos[1] = pos[1];
153      atomInfo->pos[2] = pos[2];
154 <    atomInfo->dipole[0] = u[0];
155 <    atomInfo->dipole[1] = u[1];
156 <    atomInfo->dipole[2] = u[2];
154 >    atomInfo->vel[0] = vel[0];
155 >    atomInfo->vel[1] = vel[1];
156 >    atomInfo->vel[2] = vel[2];
157 >    atomInfo->hasVelocity = true;
158 >    atomInfo->frc[0] = frc[0];
159 >    atomInfo->frc[1] = frc[1];
160 >    atomInfo->frc[2] = frc[2];
161 >    atomInfo->hasForce = true;
162 >    atomInfo->vec[0] = u[0];
163 >    atomInfo->vec[1] = u[1];
164 >    atomInfo->vec[2] = u[2];
165 >    atomInfo->hasVector = true;
166  
167      atomData->addAtomInfo(atomInfo);
168  
169      datom->addProperty(atomData);
170  
171      setVisited(datom);
172 < }
172 >  }
173  
174 < const std::string DefaultAtomVisitor::toString() {
174 >  const std::string DefaultAtomVisitor::toString() {
175      char   buffer[65535];
176      std::string result;
177  
# Line 422 | Line 191 | const std::string DefaultAtomVisitor::toString() {
191      result += buffer;
192  
193      return result;
194 < }
195 < } //namespace oopse
194 >  }
195 > } //namespace OpenMD

Comparing:
trunk/src/visitors/AtomVisitor.cpp (property svn:keywords), Revision 407 by gezelter, Tue Mar 8 21:07:49 2005 UTC vs.
branches/development/src/visitors/AtomVisitor.cpp (property svn:keywords), Revision 1787 by gezelter, Wed Aug 29 18:13:11 2012 UTC

# Line 0 | Line 1
1 + Author Id Revision Date

Diff Legend

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