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

Comparing trunk/OOPSE-4/src/visitors/OtherVisitor.cpp (file contents):
Revision 1490 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
Revision 3328 by xsun, Wed Jan 23 21:23:32 2008 UTC

# Line 1 | Line 1
1 < #include "OtherVisitor.hpp"
2 < #include "DirectionalAtom.hpp"
3 < #include "RigidBody.hpp"
4 < #include "Molecule.hpp"
5 < #include "SimInfo.hpp"
6 < //----------------------------------------------------------------------------//
7 < void IgnoreVisitor::visit(Atom* atom){
8 <  if(isIgnoreType(atom->getType()))
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 > #include "selection/SelectionManager.hpp"
42 > #include "visitors/OtherVisitor.hpp"
43 > #include "primitives/DirectionalAtom.hpp"
44 > #include "primitives/RigidBody.hpp"
45 > #include "primitives/Molecule.hpp"
46 > #include "brains/SimInfo.hpp"
47 > namespace oopse {
48 >
49 >  void WrappingVisitor::visit(Atom *atom) {
50      internalVisit(atom);
51 < }
51 >  }
52  
53 < void IgnoreVisitor::visit(DirectionalAtom* datom){
13 <  if(isIgnoreType(datom->getType()))
53 >  void WrappingVisitor::visit(DirectionalAtom *datom) {
54      internalVisit(datom);
55 < }
55 >  }
56  
57 < void IgnoreVisitor::visit(RigidBody* rb){
18 <  vector<Atom*> myAtoms;
19 <  vector<Atom*>::iterator atomIter;
20 <  AtomInfo* atomInfo;
21 <  
22 <  if(isIgnoreType(rb->getType())){
23 <    
57 >  void WrappingVisitor::visit(RigidBody *rb) {
58      internalVisit(rb);
59 +  }
60  
61 <    myAtoms = rb->getAtoms();    
62 <    
63 <    for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
64 <      internalVisit(*atomIter);
61 >  void WrappingVisitor::internalVisit(StuntDouble *sd) {
62 >    GenericData *                     data;
63 >    AtomData *                        atomData;
64 >    AtomInfo *                        atomInfo;
65 >    std::vector<AtomInfo *>::iterator i;
66  
67 <  }
32 <  
33 < }
67 >    data = sd->getPropertyByName("ATOMDATA");
68  
69 < bool IgnoreVisitor::isIgnoreType(const string& name){
70 <  return itList.find(name) != itList.end() ? true : false;
37 < }
69 >    if (data != NULL) {
70 >      atomData = dynamic_cast<AtomData *>(data);
71  
72 < void IgnoreVisitor::internalVisit(StuntDouble* sd){
73 <  GenericData* data;
74 <  data = sd->getProperty("IGNORE");
72 >      if (atomData == NULL)
73 >        return;
74 >    } else
75 >      return;
76  
77 <  //if this stuntdoulbe is already marked as ignore just skip it
44 <  if (data == NULL){
45 <    data = new GenericData;
46 <    data->setID("IGNORE");
47 <    sd->addProperty(data);
48 <  }
77 >    Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
78      
79 < }
79 >    for( atomInfo = atomData->beginAtomInfo(i); atomInfo; atomInfo = atomData->nextAtomInfo(i) ) {
80 >      Vector3d newPos = atomInfo->pos - origin_;
81 >      currSnapshot->wrapVector(newPos);
82 >      atomInfo->pos = newPos;
83 >    }
84 >  }
85  
86 < const string IgnoreVisitor::toString(){
87 <  char buffer[65535];
88 <  string result;
89 <  set<string>::iterator i;
86 >  void WrappingVisitor::update() {
87 >    if (useCom_){
88 >      origin_ = info->getCom();
89 >    }
90 >  }
91    
92 <  sprintf(buffer ,"------------------------------------------------------------------\n");
93 <  result += buffer;
92 >  const std::string WrappingVisitor::toString() {
93 >    char        buffer[65535];
94 >    std::string result;
95  
96 <  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
97 <  result += buffer;
96 >    sprintf(buffer,
97 >            "------------------------------------------------------------------\n");
98 >    result += buffer;
99  
100 <  sprintf(buffer ,"Visitor Description: ignore  stuntdoubles\n");
101 <  result += buffer;
100 >    sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
101 >    result += buffer;
102  
103 <  //print the ignore type list
104 <  sprintf(buffer , "Ignore type list contains below types:\n");
105 <  result += buffer;
103 >    sprintf(buffer,
104 >            "Visitor Description: wrapping atoms back to periodic box\n");
105 >    result += buffer;
106  
107 <  for(i = itList.begin(); i != itList.end(); ++i){
108 <    sprintf(buffer ,"%s\t", i->c_str());
107 >    sprintf(buffer,
108 >            "------------------------------------------------------------------\n");
109      result += buffer;
110  
111 +    return result;
112    }
75 –  sprintf(buffer ,"\n");
76 –  result += buffer;
113  
114 <  sprintf(buffer ,"------------------------------------------------------------------\n");
79 <  result += buffer;
114 >  //----------------------------------------------------------------------------//
115  
116 <  return result;
117 < }
116 >  ReplicateVisitor::ReplicateVisitor(SimInfo *info, Vector3i opt) :
117 >    BaseVisitor() {
118 >      this->info = info;
119 >      visitorName = "ReplicateVisitor";
120 >      this->replicateOpt = opt;
121  
122 < //----------------------------------------------------------------------------//
122 >      //generate the replicate directions
123 >      for( int i = 0; i <= replicateOpt[0]; i++ ) {
124 >        for( int j = 0; j <= replicateOpt[1]; j++ ) {
125 >          for( int k = 0; k <= replicateOpt[2]; k++ ) {
126 >            //skip original frame
127 >            if (i == 0 && j == 0 && k == 0) {
128 >              continue;
129 >            } else {
130 >              dir.push_back(Vector3i(i, j, k));
131 >            }
132 >          }
133 >        }
134 >      }
135 >    
136 >    }
137  
138 < void WrappingVisitor::visit(Atom* atom){
139 <  internalVisit(atom);
140 < }
89 < void WrappingVisitor::visit(DirectionalAtom* datom){
90 <  internalVisit(datom);
91 < }
138 >  void ReplicateVisitor::visit(Atom *atom) {
139 >    internalVisit(atom);
140 >  }
141  
142 < void WrappingVisitor::visit(RigidBody* rb){
143 <  internalVisit(rb);
144 < }
142 >  void ReplicateVisitor::visit(DirectionalAtom *datom) {
143 >    internalVisit(datom);
144 >  }
145  
146 < void WrappingVisitor::internalVisit(StuntDouble* sd){
147 <  GenericData* data;
99 <  AtomData* atomData;
100 <  AtomInfo* atomInfo;
101 <  vector<AtomInfo*>::iterator i;
102 <
103 <  data = sd->getProperty("ATOMDATA");
104 <  if(data != NULL){
105 <    atomData = dynamic_cast<AtomData*>(data);  
106 <    if(atomData == NULL)
107 <      return;
146 >  void ReplicateVisitor::visit(RigidBody *rb) {
147 >    internalVisit(rb);
148    }
109 –  else
110 –    return;
149  
150 <  for(atomInfo = atomData->beginAtomInfo(i); atomInfo; atomInfo = atomData->nextAtomInfo(i))
151 <    info->wrapVector(atomInfo->pos);
150 >  void ReplicateVisitor::internalVisit(StuntDouble *sd) {
151 >    GenericData *          data;
152 >    AtomData *             atomData;
153  
154 <  
155 < }
154 >    //if there is not atom data, just skip it
155 >    data = sd->getPropertyByName("ATOMDATA");
156  
157 < const string WrappingVisitor::toString(){
158 <  char buffer[65535];
120 <  string result;
121 <  
122 <  sprintf(buffer ,"------------------------------------------------------------------\n");
123 <  result += buffer;
157 >    if (data != NULL) {
158 >      atomData = dynamic_cast<AtomData *>(data);
159  
160 <  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
161 <  result += buffer;
160 >      if (atomData == NULL) {
161 >        return;
162 >      }
163 >    } else {
164 >      return;
165 >    }
166  
167 <  sprintf(buffer ,"Visitor Description: wrapping atoms back to periodic box\n");
168 <  result += buffer;
130 <
131 <  sprintf(buffer,"------------------------------------------------------------------\n");
132 <  result += buffer;
167 >    Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
168 >    Mat3x3d box = currSnapshot->getHmat();
169  
170 <  return result;
135 < }
170 >    std::vector<AtomInfo *> atomInfoList = atomData->getData();
171  
172 < //----------------------------------------------------------------------------//
172 >    replicate(atomInfoList, atomData, box);
173 >  }
174  
175 < ReplicateVisitor::ReplicateVisitor(SimInfo* info, IntVec3 opt) : BaseVisitor(){
176 <  this->info = info;
177 <  visitorName = "ReplicateVisitor";
178 <  this->replicateOpt = opt;
143 <  //generate the replicate directions
144 <  for(int i = 0; i <= replicateOpt[0]; i ++)
145 <    for(int j = 0; j <= replicateOpt[1]; j ++)
146 <      for(int k = 0; k <= replicateOpt[2]; k ++)
147 <        //skip original frame
148 <        if(i == 0 && j ==0 && k ==0)
149 <          continue;
150 <        else
151 <          dir.push_back(IntVec3(i, j, k));
152 <  
153 < }
154 < void ReplicateVisitor::visit(Atom* atom){
155 <  internalVisit(atom);
156 < }
157 < void ReplicateVisitor::visit(DirectionalAtom* datom){
158 <  internalVisit(datom);
159 < }
175 >  void ReplicateVisitor::replicate(std::vector<AtomInfo *>&infoList, AtomData *data, const Mat3x3d& box) {
176 >    AtomInfo* newAtomInfo;
177 >    std::vector<Vector3i>::iterator dirIter;
178 >    std::vector<AtomInfo *>::iterator i;
179  
180 < void ReplicateVisitor::visit(RigidBody* rb){
181 <  internalVisit(rb);
182 < }
180 >    for( dirIter = dir.begin(); dirIter != dir.end(); ++dirIter ) {
181 >      for( i = infoList.begin(); i != infoList.end(); i++ ) {
182 >        newAtomInfo = new AtomInfo();
183 >        *newAtomInfo = *(*i);
184  
185 < void ReplicateVisitor::internalVisit(StuntDouble* sd){
186 <  GenericData* data;
187 <  AtomData* atomData;
188 <  AtomInfo* atomInfo;
189 <  double box[3][3];
190 <  vector<AtomInfo*> atomInfoList;
171 <  IntVec3 dir;
172 <  
173 <  //if there is not atom data, just skip it
174 <  data = sd->getProperty("ATOMDATA");
175 <  if(data != NULL){
176 <    atomData = dynamic_cast<AtomData*>(data);  
177 <    if(atomData == NULL)
178 <      return;
185 >        for( int j = 0; j < 3; j++ )
186 >          newAtomInfo->pos[j] += (*dirIter)[0]*box(j, 0) + (*dirIter)[1]*box(j, 1) + (*dirIter)[2]*box(j, 2);
187 >
188 >        data->addAtomInfo(newAtomInfo);
189 >      }
190 >    } // end for(dirIter)  
191    }
180 –  else
181 –    return;
192  
193 <  
194 <  info->getBoxM(box);
193 >  const std::string ReplicateVisitor::toString() {
194 >    char                            buffer[65535];
195 >    std::string                     result;
196 >    std::set<std::string>::iterator i;
197  
198 <  atomInfoList = atomData->getData();
199 <  
200 <  replicate(atomInfoList, atomData, box);
198 >    sprintf(buffer,
199 >            "------------------------------------------------------------------\n");
200 >    result += buffer;
201  
202 < }
202 >    sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
203 >    result += buffer;
204  
205 < void ReplicateVisitor::replicate(vector<AtomInfo*>& infoList, AtomData* data, double boxM[3][3]){
206 <  AtomInfo * newAtomInfo;
207 <  vector<IntVec3>::iterator dirIter;
195 <  vector<AtomInfo*>::iterator i;
196 <  
197 <  for(dirIter = dir.begin(); dirIter != dir.end(); ++dirIter){
198 <    for(i = infoList.begin(); i != infoList.end(); i++){
199 <      newAtomInfo = new AtomInfo;
200 <      *newAtomInfo = *(*i);    
205 >    sprintf(buffer,
206 >            "Visitor Description: replicate the atoms in different direction\n");
207 >    result += buffer;
208  
209 <      for(int j = 0; j < 3; j++)
210 <        newAtomInfo->pos[j] +=   (*dirIter)[0] * boxM[j][0] + (*dirIter)[1]* boxM[j][1] + (*dirIter)[2] * boxM[j][2];
209 >    //print the replicate direction
210 >    sprintf(buffer, "repeatX = %d:\n", replicateOpt[0]);
211 >    result += buffer;
212  
213 <      data->addAtomInfo(newAtomInfo);
214 <    }
207 <  }// end for(dirIter)  
208 < }
213 >    sprintf(buffer, "repeatY = %d:\n", replicateOpt[1]);
214 >    result += buffer;
215  
216 < const string ReplicateVisitor::toString(){
217 <  char buffer[65535];
212 <  string result;
213 <  set<string>::iterator i;
214 <  
215 <  sprintf(buffer ,"------------------------------------------------------------------\n");
216 <  result += buffer;
216 >    sprintf(buffer, "repeatZ = %d:\n", replicateOpt[2]);
217 >    result += buffer;
218  
219 <  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
220 <  result += buffer;
219 >    sprintf(buffer,
220 >            "------------------------------------------------------------------\n");
221 >    result += buffer;
222  
223 <  sprintf(buffer ,"Visitor Description: replicate the atoms in different direction\n");
224 <  result += buffer;
223 <  
224 <  //print the replicate direction
225 <  sprintf(buffer , "repeatX = %d:\n", replicateOpt[0]);
226 <  result += buffer;
223 >    return result;
224 >  }
225  
226 <  sprintf(buffer , "repeatY = %d:\n", replicateOpt[1]);
229 <  result += buffer;
226 >  //----------------------------------------------------------------------------//
227  
228 <  sprintf(buffer , "repeatZ = %d:\n", replicateOpt[2]);
229 <  result += buffer;
228 >  XYZVisitor::XYZVisitor(SimInfo *info) :
229 >    BaseVisitor(), seleMan(info), evaluator(info){
230 >      this->info = info;
231 >      visitorName = "XYZVisitor";
232  
233 +      evaluator.loadScriptString("select all");
234  
235 <  sprintf(buffer,"------------------------------------------------------------------\n");
236 <  result += buffer;
235 >      if (!evaluator.isDynamic()) {
236 >        seleMan.setSelectionSet(evaluator.evaluate());
237 >      }
238 >      posOnly_ = false;
239 >    }
240  
241 <  return result;
242 < }
241 >  XYZVisitor::XYZVisitor(SimInfo *info, const std::string& script) :
242 >    BaseVisitor(), seleMan(info), evaluator(info) {
243 >      this->info = info;
244 >      visitorName = "XYZVisitor";
245  
246 < //----------------------------------------------------------------------------//
246 >      evaluator.loadScriptString(script);
247  
248 < XYZVisitor::XYZVisitor(SimInfo* info,  bool printDipole) : BaseVisitor(){
249 <  this->info = info;
250 <  visitorName = "XYZVisitor";
251 <  this->printDipole = printDipole;
252 < }
248 >      if (!evaluator.isDynamic()) {
249 >        seleMan.setSelectionSet(evaluator.evaluate());
250 >      }
251 >      posOnly_ = false;
252 >    }
253 >    
254 >  void XYZVisitor::visit(Atom *atom) {
255 >    if (isSelected(atom))
256 >      internalVisit(atom);
257 >  }
258  
259 < void XYZVisitor::visit(Atom* atom){
260 <  if(!isIgnore(atom))
261 <    internalVisit(atom);
262 < }
259 >  void XYZVisitor::visit(DirectionalAtom *datom) {
260 >    if (isSelected(datom))
261 >      internalVisit(datom);
262 >  }
263  
264 < void XYZVisitor::visit(DirectionalAtom* datom){
265 <  if(!isIgnore(datom))
266 <    internalVisit(datom);
257 < }
258 <
259 < void XYZVisitor::visit(RigidBody* rb){
260 <  if(!isIgnore(rb))
261 <    internalVisit(rb);
262 <
263 < }
264 <
265 < void XYZVisitor::internalVisit(StuntDouble* sd){
266 <  GenericData* data;
267 <  AtomData* atomData;
268 <  AtomInfo* atomInfo;
269 <  vector<AtomInfo*>::iterator i;
270 <  char buffer[1024];
271 <  
272 <  //if there is not atom data, just skip it
273 <  data = sd->getProperty("ATOMDATA");
274 <  if(data != NULL){
275 <    atomData = dynamic_cast<AtomData*>(data);  
276 <    if(atomData == NULL)
277 <      return;
264 >  void XYZVisitor::visit(RigidBody *rb) {
265 >    if (isSelected(rb))
266 >      internalVisit(rb);
267    }
279 –  else
280 –    return;
268  
269 <  for(atomInfo = atomData->beginAtomInfo(i); atomInfo; atomInfo = atomData->nextAtomInfo(i)){
270 <
271 <    if(printDipole)
272 <      sprintf(buffer, "%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
273 <                  atomInfo->AtomType.c_str(),
274 <                  atomInfo->pos[0],
288 <                  atomInfo->pos[1],
289 <                  atomInfo->pos[2],
290 <                  atomInfo->dipole[0],
291 <                  atomInfo->dipole[1],
292 <                  atomInfo->dipole[2]);
293 <    else
294 <      sprintf(buffer, "%s%15.8f%15.8f%15.8f",
295 <                  atomInfo->AtomType.c_str(),
296 <                  atomInfo->pos[0],
297 <                  atomInfo->pos[1],
298 <                  atomInfo->pos[2]);  
269 >  void XYZVisitor::update() {
270 >    //if dynamic, we need to re-evaluate the selection
271 >    if (evaluator.isDynamic()) {
272 >      seleMan.setSelectionSet(evaluator.evaluate());
273 >    }
274 >  }
275  
276 <    frame.push_back(buffer);
277 <              
278 <  }
276 >  void XYZVisitor::internalVisit(StuntDouble *sd) {
277 >    GenericData *                     data;
278 >    AtomData *                        atomData;
279 >    AtomInfo *                        atomInfo;
280 >    std::vector<AtomInfo *>::iterator i;
281 >    char                              buffer[1024];
282  
283 < }
283 >    //if there is not atom data, just skip it
284 >    data = sd->getPropertyByName("ATOMDATA");
285  
286 < bool XYZVisitor::isIgnore(StuntDouble* sd){
287 <  GenericData* data;
308 <  
309 <  data = sd->getProperty("IGNORE");
310 <  return data ==NULL ? false : true;
311 < }
286 >    if (data != NULL) {
287 >      atomData = dynamic_cast<AtomData *>(data);
288  
289 < void XYZVisitor::writeFrame(ostream& outStream){
290 <  vector<string>::iterator i;
291 <  double box[3][3];
292 <  char buffer[1024];
289 >      if (atomData == NULL)
290 >        return;
291 >    } else
292 >      return;
293  
294 <  if(frame.size() == 0)
295 <    cerr << "Current Frame does not contain any atoms" << endl;
294 >    if (posOnly_){
295 >      for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
296 >           atomInfo = atomData->nextAtomInfo(i) ) {
297 >        if (atomInfo->hasCharge) {
298 >          sprintf(buffer,
299 >                "%s%15.8f%15.8f%15.8f%15.8f",
300 >                atomInfo->atomTypeName.c_str(),
301 >                atomInfo->pos[0],
302 >                atomInfo->pos[1],
303 >                atomInfo->pos[2],
304 >                atomInfo->charge);
305 >        } else {
306 >          sprintf(buffer,
307 >                "%s%15.8f%15.8f%15.8f",
308 >                atomInfo->atomTypeName.c_str(),
309 >                atomInfo->pos[0],
310 >                atomInfo->pos[1],
311 >                atomInfo->pos[2]);
312 >        }
313 >        frame.push_back(buffer);
314 >      }
315 >    }else{
316 >      for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
317 >           atomInfo = atomData->nextAtomInfo(i) ) {
318 >        if (atomInfo->hasCharge) {
319 >        sprintf(buffer,
320 >                "%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
321 >                atomInfo->atomTypeName.c_str(),
322 >                atomInfo->pos[0],
323 >                atomInfo->pos[1],
324 >                atomInfo->pos[2],
325 >                atomInfo->charge,
326 >                atomInfo->dipole[0],
327 >                atomInfo->dipole[1],
328 >                atomInfo->dipole[2]);
329 >        } else {
330 >        sprintf(buffer,
331 >                "%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
332 >                atomInfo->atomTypeName.c_str(),
333 >                atomInfo->pos[0],
334 >                atomInfo->pos[1],
335 >                atomInfo->pos[2],
336 >                atomInfo->dipole[0],
337 >                atomInfo->dipole[1],
338 >                atomInfo->dipole[2]);
339 >        }
340 >        frame.push_back(buffer);
341 >      }
342 >    }
343 >  }
344  
345 <  //total number of atoms  
346 <  outStream << frame.size() << endl;
345 >  bool XYZVisitor::isSelected(StuntDouble *sd) {
346 >    return seleMan.isSelected(sd);
347 >  }
348  
349 <  //write comment line
350 <  info->getBoxM(box);
351 <  sprintf(buffer,"%15.8f;%15.8f%15.8f%15.8f;%15.8f%15.8f%15.8f;%15.8f%15.8f%15.8f",
327 <              info->getTime(),
328 <              box[0][0], box[0][1], box[0][2],
329 <              box[1][0], box[1][1], box[1][2],
330 <              box[2][0], box[2][1], box[2][2]);
349 >  void XYZVisitor::writeFrame(std::ostream &outStream) {
350 >    std::vector<std::string>::iterator i;
351 >    char buffer[1024];
352  
353 <  outStream << buffer << endl;  
353 >    if (frame.size() == 0)
354 >      std::cerr << "Current Frame does not contain any atoms" << std::endl;
355  
356 <  for(i = frame.begin(); i != frame.end(); ++i)
357 <    outStream << *i << endl;
336 < }
356 >    //total number of atoms  
357 >    outStream << frame.size() << std::endl;
358  
359 < const string XYZVisitor::toString(){
360 <  char buffer[65535];
361 <  string result;
362 <  
363 <  sprintf(buffer ,"------------------------------------------------------------------\n");
364 <  result += buffer;
359 >    //write comment line
360 >    Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
361 >    Mat3x3d box = currSnapshot->getHmat();
362 >    
363 >    sprintf(buffer,
364 >            "%15.8f;%15.8f%15.8f%15.8f;%15.8f%15.8f%15.8f;%15.8f%15.8f%15.8f",
365 >            currSnapshot->getTime(),
366 >            box(0, 0), box(0, 1), box(0, 2),
367 >            box(1, 0), box(1, 1), box(1, 2),
368 >            box(2, 0), box(2, 1), box(2, 2));
369  
370 <  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
346 <  result += buffer;
370 >    outStream << buffer << std::endl;
371  
372 <  sprintf(buffer ,"Visitor Description: assemble the atom data and output xyz file\n");
373 <  result += buffer;
374 <
351 <  sprintf(buffer,"------------------------------------------------------------------\n");
352 <  result += buffer;
372 >    for( i = frame.begin(); i != frame.end(); ++i )
373 >      outStream << *i << std::endl;
374 >  }
375  
376 <  return result;
377 < }
376 >  const std::string XYZVisitor::toString() {
377 >    char        buffer[65535];
378 >    std::string result;
379  
380 < //----------------------------------------------------------------------------//
380 >    sprintf(buffer,
381 >            "------------------------------------------------------------------\n");
382 >    result += buffer;
383  
384 < void PrepareVisitor::internalVisit(Atom * atom){
385 <  GenericData* data;
361 <  AtomData* atomData;
384 >    sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
385 >    result += buffer;
386  
387 <  //if visited property is  existed, remove it
388 <  data = atom->getProperty("VISITED");
389 <  if(data != NULL){
366 <    atom->removeProperty("VISITED");  
367 <  }
387 >    sprintf(buffer,
388 >            "Visitor Description: assemble the atom data and output xyz file\n");
389 >    result += buffer;
390  
391 <  //remove atomdata
392 <  data = atom->getProperty("ATOMDATA");
393 <  if(data != NULL){
372 <    atomData = dynamic_cast<AtomData*>(data);  
373 <    if(atomData != NULL)
374 <      atom->removeProperty("ATOMDATA");
375 <  }
376 <  
377 < }
391 >    sprintf(buffer,
392 >            "------------------------------------------------------------------\n");
393 >    result += buffer;
394  
395 < void PrepareVisitor::internalVisit(RigidBody * rb){
380 <  GenericData* data;
381 <  AtomData* atomData;
382 <  vector<Atom*> myAtoms;
383 <  vector<Atom*>::iterator atomIter;
384 <  
385 <  //if visited property is  existed, remove it
386 <  data = rb->getProperty("VISITED");
387 <  if(data != NULL){
388 <    rb->removeProperty("VISITED");  
395 >    return result;
396    }
397  
398 <  //remove atomdata
399 <  data = rb->getProperty("ATOMDATA");
400 <  if(data != NULL){
401 <    atomData = dynamic_cast<AtomData*>(data);  
402 <    if(atomData != NULL)
403 <      rb->removeProperty("ATOMDATA");
398 >  //----------------------------------------------------------------------------//
399 >
400 >  void PrepareVisitor::internalVisit(Atom *atom) {
401 >    GenericData *data;
402 >    AtomData *   atomData;
403 >
404 >    //if visited property is  existed, remove it
405 >    data = atom->getPropertyByName("VISITED");
406 >
407 >    if (data != NULL) {
408 >      atom->removeProperty("VISITED");
409 >    }
410 >
411 >    //remove atomdata
412 >    data = atom->getPropertyByName("ATOMDATA");
413 >
414 >    if (data != NULL) {
415 >      atomData = dynamic_cast<AtomData *>(data);
416 >
417 >      if (atomData != NULL)
418 >        atom->removeProperty("ATOMDATA");
419 >    }
420    }
421  
422 <  myAtoms = rb->getAtoms();
423 <    
424 <  for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
425 <   internalVisit (*atomIter);  
426 < }
422 >  void PrepareVisitor::internalVisit(RigidBody *rb) {
423 >    GenericData* data;
424 >    AtomData* atomData;
425 >    std::vector<Atom *> myAtoms;
426 >    std::vector<Atom *>::iterator atomIter;
427  
428 < const string PrepareVisitor::toString(){
429 <  char buffer[65535];
407 <  string result;
408 <  
409 <  sprintf(buffer ,"------------------------------------------------------------------\n");
410 <  result += buffer;
428 >    //if visited property is  existed, remove it
429 >    data = rb->getPropertyByName("VISITED");
430  
431 <  sprintf(buffer ,"Visitor name: %s", visitorName.c_str());
432 <  result += buffer;
431 >    if (data != NULL) {
432 >      rb->removeProperty("VISITED");
433 >    }
434  
435 <  sprintf(buffer ,"Visitor Description: prepare for operation of other vistors\n");
436 <  result += buffer;
435 >    //remove atomdata
436 >    data = rb->getPropertyByName("ATOMDATA");
437  
438 <  sprintf(buffer ,"------------------------------------------------------------------\n");
439 <  result += buffer;
438 >    if (data != NULL) {
439 >      atomData = dynamic_cast<AtomData *>(data);
440  
441 <  return result;
442 < }
441 >      if (atomData != NULL)
442 >        rb->removeProperty("ATOMDATA");
443 >    }
444  
445 < //----------------------------------------------------------------------------//
445 >    myAtoms = rb->getAtoms();
446  
447 < WaterTypeVisitor:: WaterTypeVisitor(){
448 <  visitorName = "WaterTypeVisitor";
449 <  waterTypeList.insert("TIP3P_RB_0");
429 <  waterTypeList.insert("TIP4P_RB_0");
430 <  waterTypeList.insert("TIP5P_RB_0");
431 <  waterTypeList.insert("SPCE_RB_0");  
432 < }
447 >    for( atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter )
448 >      internalVisit(*atomIter);
449 >  }
450  
451 +  const std::string PrepareVisitor::toString() {
452 +    char buffer[65535];
453 +    std::string result;
454 +
455 +    sprintf(buffer,
456 +            "------------------------------------------------------------------\n");
457 +    result += buffer;
458 +
459 +    sprintf(buffer, "Visitor name: %s", visitorName.c_str());
460 +    result += buffer;
461 +
462 +    sprintf(buffer,
463 +            "Visitor Description: prepare for operation of other vistors\n");
464 +    result += buffer;
465 +
466 +    sprintf(buffer,
467 +            "------------------------------------------------------------------\n");
468 +    result += buffer;
469 +
470 +    return result;
471 +  }
472  
473 < void WaterTypeVisitor:: visit(RigidBody* rb){
436 <  string rbName;
437 <  vector<Atom*> myAtoms;
438 <  vector<Atom*>::iterator atomIter;
439 <  GenericData* data;
440 <  AtomData* atomData;
441 <  AtomInfo* atomInfo;
442 <  vector<AtomInfo*>::iterator i;
443 <  
444 <  rbName = rb->getType();
473 >  //----------------------------------------------------------------------------//
474  
475 <  if(waterTypeList.find(rbName) != waterTypeList.end()){
475 >  WaterTypeVisitor::WaterTypeVisitor() {
476 >    visitorName = "WaterTypeVisitor";
477 >    waterTypeList.insert("TIP3P_RB_0");
478 >    waterTypeList.insert("TIP4P_RB_0");
479 >    waterTypeList.insert("TIP5P_RB_0");
480 >    waterTypeList.insert("SPCE_RB_0");
481 >  }
482  
483 <    myAtoms = rb->getAtoms();    
484 <    for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter){
483 >  void WaterTypeVisitor::visit(RigidBody *rb) {
484 >    std::string rbName;
485 >    std::vector<Atom *> myAtoms;
486 >    std::vector<Atom *>::iterator atomIter;
487 >    GenericData* data;
488 >    AtomData* atomData;
489 >    AtomInfo* atomInfo;
490 >    std::vector<AtomInfo *>::iterator i;
491  
492 <      data = (*atomIter)->getProperty("ATOMDATA");
452 <      if(data != NULL){
453 <        atomData = dynamic_cast<AtomData*>(data);  
454 <        if(atomData == NULL)
455 <          continue;
456 <      }
457 <      else
458 <        continue;
459 <      
460 <      for(atomInfo = atomData->beginAtomInfo(i); atomInfo; atomInfo = atomData->nextAtomInfo(i)){
461 <        replaceType(atomInfo->AtomType);
462 <      }//end for(atomInfo)
492 >    rbName = rb->getType();
493  
494 <    }//end for(atomIter)
495 <      
466 <  }//end if (waterTypeList.find(rbName) != waterTypeList.end())
467 <  
468 < }
494 >    if (waterTypeList.find(rbName) != waterTypeList.end()) {
495 >      myAtoms = rb->getAtoms();
496  
497 < void WaterTypeVisitor:: replaceType(string& atomType){
498 <  atomType = atomType.substr(0, atomType.find('_'));
499 < }
497 >      for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
498 >           ++atomIter ) {
499 >        data = (*atomIter)->getPropertyByName("ATOMDATA");
500  
501 < const string WaterTypeVisitor:: toString(){
502 <  char buffer[65535];
476 <  string result;
477 <  
478 <  sprintf(buffer ,"------------------------------------------------------------------\n");
479 <  result += buffer;
501 >        if (data != NULL) {
502 >          atomData = dynamic_cast<AtomData *>(data);
503  
504 <  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
505 <  result += buffer;
504 >          if (atomData == NULL)
505 >            continue;
506 >        } else
507 >          continue;
508  
509 <  sprintf(buffer ,"Visitor Description: Replace the atom type in water model\n");
510 <  result += buffer;
509 >        for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
510 >             atomInfo = atomData->nextAtomInfo(i) ) {
511 >          atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
512 >        } //end for(atomInfo)
513 >      }     //end for(atomIter)
514 >    }         //end if (waterTypeList.find(rbName) != waterTypeList.end())
515 >  }
516  
517 <  sprintf(buffer ,"------------------------------------------------------------------\n");
518 <  result += buffer;
517 >  std::string WaterTypeVisitor::trimmedName(const std::string&atomTypeName) {
518 >    return atomTypeName.substr(0, atomTypeName.find('_'));
519 >  }
520  
521 <  return result;
522 < }
521 >  const std::string WaterTypeVisitor::toString() {
522 >    char buffer[65535];
523 >    std::string result;
524  
525 +    sprintf(buffer,
526 +            "------------------------------------------------------------------\n");
527 +    result += buffer;
528 +
529 +    sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
530 +    result += buffer;
531 +
532 +    sprintf(buffer,
533 +            "Visitor Description: Replace the atom type in water model\n");
534 +    result += buffer;
535 +
536 +    sprintf(buffer,
537 +            "------------------------------------------------------------------\n");
538 +    result += buffer;
539 +
540 +    return result;
541 +  }
542 +
543 + } //namespace oopse

Diff Legend

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