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

Comparing trunk/OOPSE-2.0/src/visitors/AtomVisitor.cpp (file contents):
Revision 1718 by chrisfen, Fri Nov 5 21:45:14 2004 UTC vs.
Revision 1930 by gezelter, Wed Jan 12 22:41:40 2005 UTC

# Line 1 | Line 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
5 + * non-exclusive, royalty free, license to use, modify and
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
19 + *    notice, this list of conditions and the following disclaimer.
20 + *
21 + * 3. Redistributions in binary form must reproduce the above copyright
22 + *    notice, this list of conditions and the following disclaimer in the
23 + *    documentation and/or other materials provided with the
24 + *    distribution.
25 + *
26 + * This software is provided "AS IS," without a warranty of any
27 + * kind. All express or implied conditions, representations and
28 + * warranties, including any implied warranty of merchantability,
29 + * fitness for a particular purpose or non-infringement, are hereby
30 + * excluded.  The University of Notre Dame and its licensors shall not
31 + * be liable for any damages suffered by licensee as a result of
32 + * using, modifying or distributing the software or its
33 + * derivatives. In no event will the University of Notre Dame or its
34 + * licensors be liable for any lost revenue, profit or data, or for
35 + * direct, indirect, special, consequential, incidental or punitive
36 + * damages, however caused and regardless of the theory of liability,
37 + * arising out of the use of or inability to use software, even if the
38 + * University of Notre Dame has been advised of the possibility of
39 + * such damages.
40 + */
41 +
42   #include <cstring>
43   #include "visitors/AtomVisitor.hpp"
44   #include "primitives/DirectionalAtom.hpp"
# Line 5 | Line 46 | namespace oopse {
46   #include "primitives/RigidBody.hpp"
47  
48   namespace oopse {
49 + void BaseAtomVisitor::visit(RigidBody *rb) {
50 + //vector<Atom*> myAtoms;
51 + //vector<Atom*>::iterator atomIter;
52  
53 < void BaseAtomVisitor::visit(RigidBody* rb){
10 <  //vector<Atom*> myAtoms;
11 <  //vector<Atom*>::iterator atomIter;
53 > //myAtoms = rb->getAtoms();
54  
55 <  //myAtoms = rb->getAtoms();
56 <  
57 <  //for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
16 <  //  (*atomIter)->accept(this);
17 < }
55 > //for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
56 > //  (*atomIter)->accept(this);
57 >    }
58  
59 < void BaseAtomVisitor::setVisited(Atom* atom){
60 <  GenericData* data;
61 <  data = atom->getProperty("VISITED");
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);  
68 <  }
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);
68 >    }
69   }
70  
71 < bool BaseAtomVisitor::isVisited(Atom* atom){
72 <  GenericData* data;
73 <  data = atom->getProperty("VISITED");
74 <  return data == NULL ?  false : true;
71 > bool BaseAtomVisitor::isVisited(Atom *atom) {
72 >    GenericData *data;
73 >    data = atom->getPropertyByName("VISITED");
74 >    return data == NULL ? false : true;
75   }
76  
77 < bool SSDAtomVisitor::isSSDAtom(const string& atomType){
78 <  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 < }
77 > bool SSDAtomVisitor::isSSDAtom(const std::string&atomType) {
78 >    std::vector<std::string>::iterator strIter;
79  
80 < void SSDAtomVisitor::visit(DirectionalAtom* datom){
80 >    for( strIter = ssdAtomType.begin(); strIter != ssdAtomType.end();
81 >        ++strIter )
82 >  if (*strIter == atomType)
83 >      return true;
84  
85 <  vector<AtomInfo*> atoms;
85 >    return false;
86 > }
87  
88 <  //we need to convert SSD into 4 differnet atoms
89 <  //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 <  double h1[3] = {0.0, -0.75695, 0.5206};
55 <  double h2[3] = {0.0, 0.75695, 0.5206};
56 <  double ox[3] = {0.0, 0.0, -0.0654};
57 <  double u[3] = {0, 0, 1};
58 <  double rotMatrix[3][3];
59 <  double rotTrans[3][3];
60 <  AtomInfo* atomInfo;
61 <  double pos[3];
62 <  double newVec[3];
63 <  double q[4];
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;
88 > void SSDAtomVisitor::visit(DirectionalAtom *datom) {
89 >    std::vector<AtomInfo *>atoms;
90  
91 <  data = datom->getProperty("ATOMDATA");
92 <  if(data != NULL){
91 >    //we need to convert SSD into 4 differnet atoms
92 >    //one oxygen atom, two hydrogen atoms and one pseudo atom which is the center of the mass
93 >    //of the water with a dipole moment
94 >    Vector3d h1(0.0, -0.75695, 0.5206);
95 >    Vector3d h2(0.0, 0.75695, 0.5206);
96 >    Vector3d ox(0.0, 0.0, -0.0654);
97 >    Vector3d u(0, 0, 1);
98 >    RotMat3x3d   rotMatrix;
99 >    RotMat3x3d   rotTrans;
100 >    AtomInfo *   atomInfo;
101 >    Vector3d     pos;
102 >    Vector3d     newVec;
103 >    Quat4d       q;
104 >    AtomData *   atomData;
105 >    GenericData *data;
106 >    bool         haveAtomData;
107  
108 <    atomData = dynamic_cast<AtomData*>(data);  
109 <    if(atomData == NULL){
110 <      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 <  datom->getPos(pos);
91 <  datom->getQ(q);
92 <  datom->getA(rotMatrix);
108 >    //if atom is not SSD atom, just skip it
109 >    if (!isSSDAtom(datom->getType()))
110 >        return;
111  
112 <  // 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];
112 >    data = datom->getPropertyByName("ATOMDATA");
113  
114 <  atomData->addAtomInfo(atomInfo);
114 >    if (data != NULL) {
115 >        atomData = dynamic_cast<AtomData *>(data);
116  
117 <  //oxygen
118 <  matVecMul3(rotTrans, ox, newVec);
119 <  atomInfo = new AtomInfo;
120 <  atomInfo->AtomType = "O";
121 <  atomInfo->pos[0] = pos[0] + newVec[0];
122 <  atomInfo->pos[1] = pos[1] + newVec[1];
123 <  atomInfo->pos[2] = pos[2] + newVec[2];
124 <  atomInfo->dipole[0] = 0.0;
125 <  atomInfo->dipole[1] = 0.0;
126 <  atomInfo->dipole[2] = 0.0;
120 <  atomData->addAtomInfo(atomInfo);
117 >        if (atomData == NULL) {
118 >            std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
119 >            atomData = new AtomData;
120 >            haveAtomData = false;
121 >        } else
122 >            haveAtomData = true;
123 >    } else {
124 >        atomData = new AtomData;
125 >        haveAtomData = false;
126 >    }
127  
128 +    pos = datom->getPos();
129 +    q = datom->getQ();
130 +    rotMatrix = datom->getA();
131  
132 <  //hydrogen1
133 <    matVecMul3(rotTrans, h1, newVec);
134 <  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);
132 >    // We need A^T to convert from body-fixed to space-fixed:
133 >    //transposeMat3(rotMatrix, rotTrans);
134 >    rotTrans = rotMatrix.transpose();
135  
136 <  //hydrogen2
137 <  matVecMul3(rotTrans, h2, newVec);
138 <  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);
136 >    //center of mass of the water molecule
137 >    //matVecMul3(rotTrans, u, newVec);
138 >    newVec = rotTrans * u;
139  
140 <  //add atom data into atom's property
140 >    atomInfo = new AtomInfo;
141 >    atomInfo->AtomType = "X";
142 >    atomInfo->pos[0] = pos[0];
143 >    atomInfo->pos[1] = pos[1];
144 >    atomInfo->pos[2] = pos[2];
145 >    atomInfo->dipole[0] = newVec[0];
146 >    atomInfo->dipole[1] = newVec[1];
147 >    atomInfo->dipole[2] = newVec[2];
148  
149 <  if(!haveAtomData){
150 <    atomData->setID("ATOMDATA");
151 <    datom->addProperty(atomData);
152 <  }
149 >    atomData->addAtomInfo(atomInfo);
150  
151 <  setVisited(datom);
151 >    //oxygen
152 >    //matVecMul3(rotTrans, ox, newVec);
153 >    newVec = rotTrans * ox;
154  
155 +    atomInfo = new AtomInfo;
156 +    atomInfo->AtomType = "O";
157 +    atomInfo->pos[0] = pos[0] + newVec[0];
158 +    atomInfo->pos[1] = pos[1] + newVec[1];
159 +    atomInfo->pos[2] = pos[2] + newVec[2];
160 +    atomInfo->dipole[0] = 0.0;
161 +    atomInfo->dipole[1] = 0.0;
162 +    atomInfo->dipole[2] = 0.0;
163 +    atomData->addAtomInfo(atomInfo);
164 +
165 +    //hydrogen1
166 +    //matVecMul3(rotTrans, h1, newVec);
167 +    newVec = rotTrans * h1;
168 +    atomInfo = new AtomInfo;
169 +    atomInfo->AtomType = "H";
170 +    atomInfo->pos[0] = pos[0] + newVec[0];
171 +    atomInfo->pos[1] = pos[1] + newVec[1];
172 +    atomInfo->pos[2] = pos[2] + newVec[2];
173 +    atomInfo->dipole[0] = 0.0;
174 +    atomInfo->dipole[1] = 0.0;
175 +    atomInfo->dipole[2] = 0.0;
176 +    atomData->addAtomInfo(atomInfo);
177 +
178 +    //hydrogen2
179 +    //matVecMul3(rotTrans, h2, newVec);
180 +    newVec = rotTrans * h2;
181 +    atomInfo = new AtomInfo;
182 +    atomInfo->AtomType = "H";
183 +    atomInfo->pos[0] = pos[0] + newVec[0];
184 +    atomInfo->pos[1] = pos[1] + newVec[1];
185 +    atomInfo->pos[2] = pos[2] + newVec[2];
186 +    atomInfo->dipole[0] = 0.0;
187 +    atomInfo->dipole[1] = 0.0;
188 +    atomInfo->dipole[2] = 0.0;
189 +    atomData->addAtomInfo(atomInfo);
190 +
191 +    //add atom data into atom's property
192 +
193 +    if (!haveAtomData) {
194 +        atomData->setID("ATOMDATA");
195 +        datom->addProperty(atomData);
196 +    }
197 +
198 +    setVisited(datom);
199   }
200  
201 < const string SSDAtomVisitor::toString(){
202 <  char buffer[65535];
203 <  string result;
161 <  
162 <  sprintf(buffer ,"------------------------------------------------------------------\n");
163 <  result += buffer;
201 > const std::string SSDAtomVisitor::toString() {
202 >    char   buffer[65535];
203 >    std::string result;
204  
205 <  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
206 <  result += buffer;
205 >    sprintf(buffer,
206 >            "------------------------------------------------------------------\n");
207 >    result += buffer;
208  
209 <  sprintf(buffer , "Visitor Description: Convert SSD into 4 different atoms\n");
210 <  result += buffer;
209 >    sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
210 >    result += buffer;
211  
212 <  sprintf(buffer ,"------------------------------------------------------------------\n");
213 <  result += buffer;
212 >    sprintf(buffer,
213 >            "Visitor Description: Convert SSD into 4 different atoms\n");
214 >    result += buffer;
215  
216 <  return result;
216 >    sprintf(buffer,
217 >            "------------------------------------------------------------------\n");
218 >    result += buffer;
219 >
220 >    return result;
221   }
222  
223   bool LinearAtomVisitor::isLinearAtom(const string& atomType){
# Line 309 | Line 355 | void DefaultAtomVisitor::visit(Atom* atom){
355  
356   //----------------------------------------------------------------------------//
357  
358 < void DefaultAtomVisitor::visit(Atom* atom){
359 <  AtomData* atomData;
360 <  AtomInfo* atomInfo;
361 <  double pos[3];
358 > void DefaultAtomVisitor::visit(Atom *atom) {
359 >    AtomData *atomData;
360 >    AtomInfo *atomInfo;
361 >    Vector3d  pos;
362  
363 <  if(isVisited(atom))
364 <    return;
363 >    if (isVisited(atom))
364 >        return;
365  
366 < atomInfo =new AtomInfo;
366 >    atomInfo = new AtomInfo;
367  
368 <  atomData = new AtomData;
369 <  atomData->setID("ATOMDATA");
324 <
325 <  atom->getPos(pos);
326 <  atomInfo->AtomType = atom->getType();
327 <  atomInfo->pos[0] = pos[0];
328 <  atomInfo->pos[1] = pos[1];
329 <  atomInfo->pos[2] = pos[2];
330 <  atomInfo->dipole[0] = 0.0;
331 <  atomInfo->dipole[1] = 0.0;
332 <  atomInfo->dipole[2] = 0.0;
368 >    atomData = new AtomData;
369 >    atomData->setID("ATOMDATA");
370  
371 <
372 <  atomData->addAtomInfo(atomInfo);
373 <  
374 <  atom->addProperty(atomData);
375 <
376 <  setVisited(atom);
371 >    pos = atom->getPos();
372 >    atomInfo->AtomType = atom->getType();
373 >    atomInfo->pos[0] = pos[0];
374 >    atomInfo->pos[1] = pos[1];
375 >    atomInfo->pos[2] = pos[2];
376 >    atomInfo->dipole[0] = 0.0;
377 >    atomInfo->dipole[1] = 0.0;
378 >    atomInfo->dipole[2] = 0.0;
379 >
380 >    atomData->addAtomInfo(atomInfo);
381 >
382 >    atom->addProperty(atomData);
383 >
384 >    setVisited(atom);
385   }
341 – void DefaultAtomVisitor::visit(DirectionalAtom* datom){
342 –  AtomData* atomData;
343 –  AtomInfo* atomInfo;
344 –  double pos[3];
345 –  double u[3];
386  
387 <  if(isVisited(datom))
388 <    return;
389 <  
390 <  datom->getPos(pos);
391 <  datom->getU(u);
387 > void DefaultAtomVisitor::visit(DirectionalAtom *datom) {
388 >    AtomData *atomData;
389 >    AtomInfo *atomInfo;
390 >    Vector3d  pos;
391 >    Vector3d  u;
392  
393 <  atomData = new AtomData;
394 <  atomData->setID("ATOMDATA");
355 <  atomInfo =new AtomInfo;
356 <  
357 <  atomInfo->AtomType = datom->getType();
358 <  atomInfo->pos[0] = pos[0];
359 <  atomInfo->pos[1] = pos[1];
360 <  atomInfo->pos[2] = pos[2];
361 <  atomInfo->dipole[0] = u[0];
362 <  atomInfo->dipole[1] = u[1];
363 <  atomInfo->dipole[2] = u[2];  
393 >    if (isVisited(datom))
394 >        return;
395  
396 <  atomData->addAtomInfo(atomInfo);
396 >    pos = datom->getPos();
397 >    u = datom->getElectroFrame().getColumn(3);
398  
399 <  datom->addProperty(atomData);
399 >    atomData = new AtomData;
400 >    atomData->setID("ATOMDATA");
401 >    atomInfo = new AtomInfo;
402  
403 <  setVisited(datom);
404 < }
403 >    atomInfo->AtomType = datom->getType();
404 >    atomInfo->pos[0] = pos[0];
405 >    atomInfo->pos[1] = pos[1];
406 >    atomInfo->pos[2] = pos[2];
407 >    atomInfo->dipole[0] = u[0];
408 >    atomInfo->dipole[1] = u[1];
409 >    atomInfo->dipole[2] = u[2];
410  
411 +    atomData->addAtomInfo(atomInfo);
412  
413 < const string DefaultAtomVisitor::toString(){
374 <  char buffer[65535];
375 <  string result;
376 <  
377 <  sprintf(buffer ,"------------------------------------------------------------------\n");
378 <  result += buffer;
413 >    datom->addProperty(atomData);
414  
415 <  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
416 <  result += buffer;
415 >    setVisited(datom);
416 > }
417  
418 <  sprintf(buffer , "Visitor Description: copy atom infomation into atom data\n");
419 <  result += buffer;
418 > const std::string DefaultAtomVisitor::toString() {
419 >    char   buffer[65535];
420 >    std::string result;
421  
422 <  sprintf(buffer ,"------------------------------------------------------------------\n");
423 <  result += buffer;
422 >    sprintf(buffer,
423 >            "------------------------------------------------------------------\n");
424 >    result += buffer;
425  
426 <  return result;
427 < }    
426 >    sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
427 >    result += buffer;
428  
429 < }//namespace oopse
429 >    sprintf(buffer,
430 >            "Visitor Description: copy atom infomation into atom data\n");
431 >    result += buffer;
432 >
433 >    sprintf(buffer,
434 >            "------------------------------------------------------------------\n");
435 >    result += buffer;
436 >
437 >    return result;
438 > }
439 > } //namespace oopse

Diff Legend

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