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 247 by tim, Wed Jan 12 23:15:37 2005 UTC vs.
branches/development/src/visitors/AtomVisitor.cpp (file contents), Revision 1665 by gezelter, Tue Nov 22 20:38:56 2011 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"
45 – #include "math/MatVec3.h"
46   #include "primitives/RigidBody.hpp"
47  
48 < namespace oopse {
49 < void BaseAtomVisitor::visit(RigidBody *rb) {
50 < //vector<Atom*> myAtoms;
51 < //vector<Atom*>::iterator atomIter;
48 > namespace OpenMD {
49 >  void BaseAtomVisitor::visit(RigidBody *rb) {
50 >    //vector<Atom*> myAtoms;
51 >    //vector<Atom*>::iterator atomIter;
52  
53 < //myAtoms = rb->getAtoms();
53 >    //myAtoms = rb->getAtoms();
54  
55 < //for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
56 < //  (*atomIter)->accept(this);
57 <    }
55 >    //for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
56 >    //  (*atomIter)->accept(this);
57 >  }
58  
59 < void BaseAtomVisitor::setVisited(Atom *atom) {
59 >  void BaseAtomVisitor::setVisited(Atom *atom) {
60      GenericData *data;
61      data = atom->getPropertyByName("VISITED");
62  
63      //if visited property is not existed, add it as new property
64      if (data == NULL) {
65 <        data = new GenericData();
66 <        data->setID("VISITED");
67 <        atom->addProperty(data);
65 >      data = new GenericData();
66 >      data->setID("VISITED");
67 >      atom->addProperty(data);
68      }
69 < }
69 >  }
70  
71 < bool BaseAtomVisitor::isVisited(Atom *atom) {
71 >  bool BaseAtomVisitor::isVisited(Atom *atom) {
72      GenericData *data;
73      data = atom->getPropertyByName("VISITED");
74      return data == NULL ? false : true;
75 < }
75 >  }
76  
77 < bool SSDAtomVisitor::isSSDAtom(const std::string&atomType) {
78 <    std::set<std::string>::iterator strIter;
79 <    strIter = ssdAtomType.find(atomType);
80 <    return strIter != ssdAtomType.end() ? true : false;
81 < }
82 <
83 < void SSDAtomVisitor::visit(DirectionalAtom *datom) {
84 <    std::vector<AtomInfo*>atoms;
85 <
86 <    //we need to convert SSD into 4 differnet atoms
87 <    //one oxygen atom, two hydrogen atoms and one pseudo atom which is the center of the mass
88 <    //of the water with a dipole moment
89 <    Vector3d h1(0.0, -0.75695, 0.5206);
90 <    Vector3d h2(0.0, 0.75695, 0.5206);
91 <    Vector3d ox(0.0, 0.0, -0.0654);
92 <    Vector3d u(0, 0, 1);
93 <    RotMat3x3d   rotMatrix;
94 <    RotMat3x3d   rotTrans;
95 <    AtomInfo *   atomInfo;
96 <    Vector3d     pos;
97 <    Vector3d     newVec;
98 <    Quat4d       q;
99 <    AtomData *   atomData;
100 <    GenericData *data;
101 <    bool         haveAtomData;
102 <
103 <    //if atom is not SSD atom, just skip it
104 <    if (!isSSDAtom(datom->getType()))
105 <        return;
106 <
107 <    data = datom->getPropertyByName("ATOMDATA");
108 <
109 <    if (data != NULL) {
110 <        atomData = dynamic_cast<AtomData *>(data);
111 <
112 <        if (atomData == NULL) {
113 <            std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
114 <            atomData = new AtomData;
115 <            haveAtomData = false;
116 <        } else
117 <            haveAtomData = true;
118 <    } else {
119 <        atomData = new AtomData;
120 <        haveAtomData = false;
121 <    }
122 <
123 <    pos = datom->getPos();
124 <    q = datom->getQ();
125 <    rotMatrix = datom->getA();
126 <
127 <    // We need A^T to convert from body-fixed to space-fixed:
128 <    //transposeMat3(rotMatrix, rotTrans);
129 <    rotTrans = rotMatrix.transpose();
130 <
131 <    //center of mass of the water molecule
132 <    //matVecMul3(rotTrans, u, newVec);
133 <    newVec = rotTrans * u;
134 <
135 <    atomInfo = new AtomInfo;
136 <    atomInfo->AtomType = "X";
137 <    atomInfo->pos[0] = pos[0];
138 <    atomInfo->pos[1] = pos[1];
139 <    atomInfo->pos[2] = pos[2];
140 <    atomInfo->dipole[0] = newVec[0];
141 <    atomInfo->dipole[1] = newVec[1];
142 <    atomInfo->dipole[2] = newVec[2];
143 <
144 <    atomData->addAtomInfo(atomInfo);
145 <
146 <    //oxygen
147 <    //matVecMul3(rotTrans, ox, newVec);
148 <    newVec = rotTrans * ox;
149 <
150 <    atomInfo = new AtomInfo;
151 <    atomInfo->AtomType = "O";
152 <    atomInfo->pos[0] = pos[0] + newVec[0];
153 <    atomInfo->pos[1] = pos[1] + newVec[1];
154 <    atomInfo->pos[2] = pos[2] + newVec[2];
155 <    atomInfo->dipole[0] = 0.0;
156 <    atomInfo->dipole[1] = 0.0;
157 <    atomInfo->dipole[2] = 0.0;
158 <    atomData->addAtomInfo(atomInfo);
159 <
160 <    //hydrogen1
161 <    //matVecMul3(rotTrans, h1, newVec);
162 <    newVec = rotTrans * h1;
163 <    atomInfo = new AtomInfo;
164 <    atomInfo->AtomType = "H";
165 <    atomInfo->pos[0] = pos[0] + newVec[0];
166 <    atomInfo->pos[1] = pos[1] + newVec[1];
167 <    atomInfo->pos[2] = pos[2] + newVec[2];
168 <    atomInfo->dipole[0] = 0.0;
169 <    atomInfo->dipole[1] = 0.0;
170 <    atomInfo->dipole[2] = 0.0;
171 <    atomData->addAtomInfo(atomInfo);
172 <
173 <    //hydrogen2
174 <    //matVecMul3(rotTrans, h2, newVec);
175 <    newVec = rotTrans * h2;
176 <    atomInfo = new AtomInfo;
177 <    atomInfo->AtomType = "H";
178 <    atomInfo->pos[0] = pos[0] + newVec[0];
179 <    atomInfo->pos[1] = pos[1] + newVec[1];
180 <    atomInfo->pos[2] = pos[2] + newVec[2];
181 <    atomInfo->dipole[0] = 0.0;
182 <    atomInfo->dipole[1] = 0.0;
183 <    atomInfo->dipole[2] = 0.0;
184 <    atomData->addAtomInfo(atomInfo);
185 <
186 <    //add atom data into atom's property
187 <
188 <    if (!haveAtomData) {
189 <        atomData->setID("ATOMDATA");
190 <        datom->addProperty(atomData);
191 <    }
192 <
193 <    setVisited(datom);
194 < }
195 <
196 < const std::string SSDAtomVisitor::toString() {
197 <    char   buffer[65535];
198 <    std::string result;
199 <
200 <    sprintf(buffer,
201 <            "------------------------------------------------------------------\n");
202 <    result += buffer;
203 <
204 <    sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
205 <    result += buffer;
206 <
207 <    sprintf(buffer,
208 <            "Visitor Description: Convert SSD into 4 different atoms\n");
209 <    result += buffer;
210 <
211 <    sprintf(buffer,
212 <            "------------------------------------------------------------------\n");
213 <    result += buffer;
214 <
215 <    return result;
216 < }
217 <
218 < bool LinearAtomVisitor::isLinearAtom(const std::string& atomType){
219 <    std::set<std::string>::iterator strIter;
220 <    strIter = linearAtomType.find(atomType);
221 <
222 <    return strIter != linearAtomType.end() ? true : false;
223 < }
224 <
225 < void LinearAtomVisitor::visit(DirectionalAtom* datom){
226 <    std::vector<AtomInfo*> atoms;
227 <    //we need to convert linear into 4 different atoms
228 <    Vector3d c1(0.0, 0.0, -1.8);
229 <    Vector3d c2(0.0, 0.0, -0.6);
230 <    Vector3d c3(0.0, 0.0,  0.6);
231 <    Vector3d c4(0.0, 0.0,  1.8);
232 <    RotMat3x3d rotMatrix;
233 <    RotMat3x3d rotTrans;
234 <    AtomInfo* atomInfo;
235 <    Vector3d pos;
236 <    Vector3d newVec;
237 <    Quat4d q;
238 <    AtomData* atomData;
239 <    GenericData* data;
240 <    bool haveAtomData;
241 <
242 <    //if atom is not SSD atom, just skip it
243 <    if(!isLinearAtom(datom->getType()))
244 <        return;
245 <
246 <    data = datom->getPropertyByName("ATOMDATA");
247 <    if(data != NULL){
248 <        atomData = dynamic_cast<AtomData*>(data);  
249 <        if(atomData == NULL){
250 <            std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
251 <            atomData = new AtomData;
252 <            haveAtomData = false;      
253 <        } else {
254 <            haveAtomData = true;
255 <        }
256 <    } else {
257 <        atomData = new AtomData;
258 <        haveAtomData = false;
259 <    }
260 <  
261 <  
262 <    pos = datom->getPos();
263 <    q = datom->getQ();
264 <    rotMatrix = datom->getA();
265 <
266 <    // We need A^T to convert from body-fixed to space-fixed:  
267 <    rotTrans = rotMatrix.transpose();
268 <
269 <    newVec = rotTrans * c1;
270 <    atomInfo = new AtomInfo;
271 <    atomInfo->AtomType = "C";
272 <    atomInfo->pos[0] = pos[0] + newVec[0];
273 <    atomInfo->pos[1] = pos[1] + newVec[1];
274 <    atomInfo->pos[2] = pos[2] + newVec[2];
275 <    atomInfo->dipole[0] = 0.0;
276 <    atomInfo->dipole[1] = 0.0;
277 <    atomInfo->dipole[2] = 0.0;
278 <    atomData->addAtomInfo(atomInfo);
279 <
280 <    newVec = rotTrans * c2;
281 <    atomInfo = new AtomInfo;
282 <    atomInfo->AtomType = "C";
283 <    atomInfo->pos[0] = pos[0] + newVec[0];
284 <    atomInfo->pos[1] = pos[1] + newVec[1];
285 <    atomInfo->pos[2] = pos[2] + newVec[2];
286 <    atomInfo->dipole[0] = 0.0;
287 <    atomInfo->dipole[1] = 0.0;
288 <    atomInfo->dipole[2] = 0.0;
289 <    atomData->addAtomInfo(atomInfo);
290 <
291 <    newVec = rotTrans * c3;
292 <    atomInfo = new AtomInfo;
293 <    atomInfo->AtomType = "C";
294 <    atomInfo->pos[0] = pos[0] + newVec[0];
295 <    atomInfo->pos[1] = pos[1] + newVec[1];
296 <    atomInfo->pos[2] = pos[2] + newVec[2];
297 <    atomInfo->dipole[0] = 0.0;
298 <    atomInfo->dipole[1] = 0.0;
299 <    atomInfo->dipole[2] = 0.0;
300 <    atomData->addAtomInfo(atomInfo);
301 <
302 <    newVec = rotTrans * c4;
303 <    atomInfo = new AtomInfo;
304 <    atomInfo->AtomType = "C";
305 <    atomInfo->pos[0] = pos[0] + newVec[0];
306 <    atomInfo->pos[1] = pos[1] + newVec[1];
307 <    atomInfo->pos[2] = pos[2] + newVec[2];
308 <    atomInfo->dipole[0] = 0.0;
309 <    atomInfo->dipole[1] = 0.0;
310 <    atomInfo->dipole[2] = 0.0;
311 <    atomData->addAtomInfo(atomInfo);
312 <
313 <    //add atom data into atom's property
314 <
315 <    if(!haveAtomData){
316 <        atomData->setID("ATOMDATA");
317 <        datom->addProperty(atomData);
318 <    }
319 <
320 <    setVisited(datom);
321 <
322 < }
323 <
324 < const std::string LinearAtomVisitor::toString(){
325 <  char buffer[65535];
326 <  std::string result;
327 <  
328 <  sprintf(buffer ,"------------------------------------------------------------------\n");
329 <  result += buffer;
330 <
331 <  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
332 <  result += buffer;
333 <
334 <  sprintf(buffer , "Visitor Description: Convert linear into 4 different atoms\n");
335 <  result += buffer;
336 <
337 <  sprintf(buffer ,"------------------------------------------------------------------\n");
338 <  result += buffer;
339 <
340 <  return result;
341 < }
342 <
343 < //----------------------------------------------------------------------------//
344 <
345 < void DefaultAtomVisitor::visit(Atom *atom) {
77 >  //------------------------------------------------------------------------//
78 >        
79 >  void DefaultAtomVisitor::visit(Atom *atom) {
80      AtomData *atomData;
81      AtomInfo *atomInfo;
82      Vector3d  pos;
83 +    Vector3d  vel;
84 +    Vector3d  frc;
85 +    Vector3d  u;
86 +    RealType  c;
87  
88      if (isVisited(atom))
89 <        return;
90 <
89 >      return;
90 >    
91      atomInfo = new AtomInfo;
92 <
92 >    
93      atomData = new AtomData;
94      atomData->setID("ATOMDATA");
95 <
95 >    
96      pos = atom->getPos();
97 <    atomInfo->AtomType = atom->getType();
97 >    vel = atom->getVel();
98 >    frc = atom->getFrc();
99 >    atomInfo->atomTypeName = atom->getType();
100      atomInfo->pos[0] = pos[0];
101      atomInfo->pos[1] = pos[1];
102      atomInfo->pos[2] = pos[2];
103 <    atomInfo->dipole[0] = 0.0;
104 <    atomInfo->dipole[1] = 0.0;
105 <    atomInfo->dipole[2] = 0.0;
106 <
103 >    atomInfo->vel[0] = vel[0];
104 >    atomInfo->vel[1] = vel[1];
105 >    atomInfo->vel[2] = vel[2];
106 >    atomInfo->hasVelocity = true;
107 >    atomInfo->frc[0] = frc[0];
108 >    atomInfo->frc[1] = frc[1];
109 >    atomInfo->frc[2] = frc[2];
110 >    atomInfo->hasForce = true;
111 >    atomInfo->vec[0] = 0.0;
112 >    atomInfo->vec[1] = 0.0;
113 >    atomInfo->vec[2] = 0.0;
114 >    
115      atomData->addAtomInfo(atomInfo);
116 <
116 >    
117      atom->addProperty(atomData);
118 <
118 >    
119      setVisited(atom);
120 < }
121 <
122 < void DefaultAtomVisitor::visit(DirectionalAtom *datom) {
120 >  }
121 >  
122 >  void DefaultAtomVisitor::visit(DirectionalAtom *datom) {
123      AtomData *atomData;
124      AtomInfo *atomInfo;
125      Vector3d  pos;
126 +    Vector3d  vel;
127 +    Vector3d  frc;
128      Vector3d  u;
129 +    RealType  c;
130  
131      if (isVisited(datom))
132 <        return;
133 <
132 >      return;
133 >    
134      pos = datom->getPos();
135 <    u = datom->getElectroFrame().getColumn(3);
136 <
135 >    vel = datom->getVel();
136 >    frc = datom->getFrc();
137 >    if (datom->getAtomType()->isGayBerne()) {
138 >        u = datom->getA().transpose()*V3Z;        
139 >    } else if (datom->getAtomType()->isMultipole()) {
140 >        u = datom->getElectroFrame().getColumn(2);
141 >    }
142      atomData = new AtomData;
143      atomData->setID("ATOMDATA");
144      atomInfo = new AtomInfo;
145  
146 <    atomInfo->AtomType = datom->getType();
146 >    atomInfo->atomTypeName = datom->getType();
147      atomInfo->pos[0] = pos[0];
148      atomInfo->pos[1] = pos[1];
149      atomInfo->pos[2] = pos[2];
150 <    atomInfo->dipole[0] = u[0];
151 <    atomInfo->dipole[1] = u[1];
152 <    atomInfo->dipole[2] = u[2];
150 >    atomInfo->vel[0] = vel[0];
151 >    atomInfo->vel[1] = vel[1];
152 >    atomInfo->vel[2] = vel[2];
153 >    atomInfo->hasVelocity = true;
154 >    atomInfo->frc[0] = frc[0];
155 >    atomInfo->frc[1] = frc[1];
156 >    atomInfo->frc[2] = frc[2];
157 >    atomInfo->hasForce = true;
158 >    atomInfo->vec[0] = u[0];
159 >    atomInfo->vec[1] = u[1];
160 >    atomInfo->vec[2] = u[2];
161 >    atomInfo->hasVector = true;
162  
163      atomData->addAtomInfo(atomInfo);
164  
165      datom->addProperty(atomData);
166  
167      setVisited(datom);
168 < }
168 >  }
169  
170 < const std::string DefaultAtomVisitor::toString() {
170 >  const std::string DefaultAtomVisitor::toString() {
171      char   buffer[65535];
172      std::string result;
173  
# Line 422 | Line 187 | const std::string DefaultAtomVisitor::toString() {
187      result += buffer;
188  
189      return result;
190 < }
191 < } //namespace oopse
190 >  }
191 > } //namespace OpenMD

Comparing:
trunk/src/visitors/AtomVisitor.cpp (property svn:keywords), Revision 247 by tim, Wed Jan 12 23:15:37 2005 UTC vs.
branches/development/src/visitors/AtomVisitor.cpp (property svn:keywords), Revision 1665 by gezelter, Tue Nov 22 20:38:56 2011 UTC

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

Diff Legend

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