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 385 by tim, Tue Mar 1 20:10:14 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>
# Line 44 | Line 45
45   #include "primitives/DirectionalAtom.hpp"
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);
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->AtomType = "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->AtomType = "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->AtomType = "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->AtomType = "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->AtomType = "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->AtomType = "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->AtomType = "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->AtomType = "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) {
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(2);
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 421 | 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 385 by tim, Tue Mar 1 20:10:14 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