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 2097 by tim, Wed Mar 9 17:30:29 2005 UTC vs.
Revision 2240 by tim, Thu May 26 22:45:00 2005 UTC

# Line 46 | Line 46 | void WrappingVisitor::visit(Atom *atom) {
46   #include "brains/SimInfo.hpp"
47   namespace oopse {
48  
49 < void WrappingVisitor::visit(Atom *atom) {
50 < internalVisit(atom);
51 < }
49 >  void WrappingVisitor::visit(Atom *atom) {
50 >    internalVisit(atom);
51 >  }
52  
53 < void WrappingVisitor::visit(DirectionalAtom *datom) {
54 < internalVisit(datom);
55 < }
53 >  void WrappingVisitor::visit(DirectionalAtom *datom) {
54 >    internalVisit(datom);
55 >  }
56  
57 < void WrappingVisitor::visit(RigidBody *rb) {
58 < internalVisit(rb);
59 < }
57 >  void WrappingVisitor::visit(RigidBody *rb) {
58 >    internalVisit(rb);
59 >  }
60  
61 < void WrappingVisitor::internalVisit(StuntDouble *sd) {
61 >  void WrappingVisitor::internalVisit(StuntDouble *sd) {
62      GenericData *                     data;
63      AtomData *                        atomData;
64      AtomInfo *                        atomInfo;
# Line 67 | Line 67 | void WrappingVisitor::internalVisit(StuntDouble *sd) {
67      data = sd->getPropertyByName("ATOMDATA");
68  
69      if (data != NULL) {
70 <        atomData = dynamic_cast<AtomData *>(data);
70 >      atomData = dynamic_cast<AtomData *>(data);
71  
72 <        if (atomData == NULL)
73 <            return;
72 >      if (atomData == NULL)
73 >        return;
74      } else
75 <        return;
75 >      return;
76  
77      Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
78      
79      for( atomInfo = atomData->beginAtomInfo(i); atomInfo; atomInfo = atomData->nextAtomInfo(i) ) {
80 <        currSnapshot->wrapVector(atomInfo->pos);
80 >      Vector3d newPos = atomInfo->pos - origin_;
81 >      currSnapshot->wrapVector(newPos);
82 >      atomInfo->pos = newPos;
83      }
84 < }
84 >  }
85  
86 < const std::string WrappingVisitor::toString() {
86 >  void WrappingVisitor::update() {
87 >    if (useCom_){
88 >      origin_ = info->getCom();
89 >    }
90 >  }
91 >  
92 >  const std::string WrappingVisitor::toString() {
93      char        buffer[65535];
94      std::string result;
95  
# Line 101 | Line 109 | const std::string WrappingVisitor::toString() {
109      result += buffer;
110  
111      return result;
112 < }
112 >  }
113  
114 < //----------------------------------------------------------------------------//
114 >  //----------------------------------------------------------------------------//
115  
116 < ReplicateVisitor::ReplicateVisitor(SimInfo *info, Vector3i opt) :
116 >  ReplicateVisitor::ReplicateVisitor(SimInfo *info, Vector3i opt) :
117      BaseVisitor() {
118 <    this->info = info;
119 <    visitorName = "ReplicateVisitor";
120 <    this->replicateOpt = opt;
118 >      this->info = info;
119 >      visitorName = "ReplicateVisitor";
120 >      this->replicateOpt = opt;
121  
122 <    //generate the replicate directions
123 <    for( int i = 0; i <= replicateOpt[0]; i++ ) {
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 <            }
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 <    }
134 >      }
135      
136 < }
136 >    }
137  
138 < void ReplicateVisitor::visit(Atom *atom) {
139 < internalVisit(atom);
140 < }
138 >  void ReplicateVisitor::visit(Atom *atom) {
139 >    internalVisit(atom);
140 >  }
141  
142 < void ReplicateVisitor::visit(DirectionalAtom *datom) {
143 < internalVisit(datom);
144 < }
142 >  void ReplicateVisitor::visit(DirectionalAtom *datom) {
143 >    internalVisit(datom);
144 >  }
145  
146 < void ReplicateVisitor::visit(RigidBody *rb) {
147 < internalVisit(rb);
148 < }
146 >  void ReplicateVisitor::visit(RigidBody *rb) {
147 >    internalVisit(rb);
148 >  }
149  
150 < void ReplicateVisitor::internalVisit(StuntDouble *sd) {
150 >  void ReplicateVisitor::internalVisit(StuntDouble *sd) {
151      GenericData *          data;
152      AtomData *             atomData;
153  
# Line 147 | Line 155 | void ReplicateVisitor::internalVisit(StuntDouble *sd)
155      data = sd->getPropertyByName("ATOMDATA");
156  
157      if (data != NULL) {
158 <        atomData = dynamic_cast<AtomData *>(data);
158 >      atomData = dynamic_cast<AtomData *>(data);
159  
160 <        if (atomData == NULL) {
161 <            return;
162 <        }
160 >      if (atomData == NULL) {
161 >        return;
162 >      }
163      } else {
164 <        return;
164 >      return;
165      }
166  
167      Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
# Line 162 | Line 170 | void ReplicateVisitor::internalVisit(StuntDouble *sd)
170      std::vector<AtomInfo *> atomInfoList = atomData->getData();
171  
172      replicate(atomInfoList, atomData, box);
173 < }
173 >  }
174  
175 < void ReplicateVisitor::replicate(std::vector<AtomInfo *>&infoList, AtomData *data, const Mat3x3d& box) {
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      for( dirIter = dir.begin(); dirIter != dir.end(); ++dirIter ) {
181 <        for( i = infoList.begin(); i != infoList.end(); i++ ) {
182 <            newAtomInfo = new AtomInfo();
183 <            *newAtomInfo = *(*i);
181 >      for( i = infoList.begin(); i != infoList.end(); i++ ) {
182 >        newAtomInfo = new AtomInfo();
183 >        *newAtomInfo = *(*i);
184  
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);
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 <        }
188 >        data->addAtomInfo(newAtomInfo);
189 >      }
190      } // end for(dirIter)  
191 < }
191 >  }
192  
193 < const std::string ReplicateVisitor::toString() {
193 >  const std::string ReplicateVisitor::toString() {
194      char                            buffer[65535];
195      std::string                     result;
196      std::set<std::string>::iterator i;
# Line 213 | Line 221 | const std::string ReplicateVisitor::toString() {
221      result += buffer;
222  
223      return result;
224 < }
224 >  }
225  
226 < //----------------------------------------------------------------------------//
226 >  //----------------------------------------------------------------------------//
227  
228 < XYZVisitor::XYZVisitor(SimInfo *info) :
228 >  XYZVisitor::XYZVisitor(SimInfo *info) :
229      BaseVisitor(), seleMan(info), evaluator(info){
230 <    this->info = info;
231 <    visitorName = "XYZVisitor";
230 >      this->info = info;
231 >      visitorName = "XYZVisitor";
232  
233 <    evaluator.loadScriptString("select all");
233 >      evaluator.loadScriptString("select all");
234  
235 <    if (!evaluator.isDynamic()) {
235 >      if (!evaluator.isDynamic()) {
236          seleMan.setSelectionSet(evaluator.evaluate());
237 +      }
238 +
239      }
240  
241 < }
232 <
233 < XYZVisitor::XYZVisitor(SimInfo *info, const std::string& script) :
241 >  XYZVisitor::XYZVisitor(SimInfo *info, const std::string& script) :
242      BaseVisitor(), seleMan(info), evaluator(info) {
243 <    this->info = info;
244 <    visitorName = "XYZVisitor";
243 >      this->info = info;
244 >      visitorName = "XYZVisitor";
245  
246 <    evaluator.loadScriptString(script);
246 >      evaluator.loadScriptString(script);
247  
248 <    if (!evaluator.isDynamic()) {
248 >      if (!evaluator.isDynamic()) {
249          seleMan.setSelectionSet(evaluator.evaluate());
250 <    }
250 >      }
251            
252 < }
252 >    }
253      
254 < void XYZVisitor::visit(Atom *atom) {
254 >  void XYZVisitor::visit(Atom *atom) {
255      if (isSelected(atom))
256 <        internalVisit(atom);
257 < }
256 >      internalVisit(atom);
257 >  }
258  
259 < void XYZVisitor::visit(DirectionalAtom *datom) {
259 >  void XYZVisitor::visit(DirectionalAtom *datom) {
260      if (isSelected(datom))
261 <        internalVisit(datom);
262 < }
261 >      internalVisit(datom);
262 >  }
263  
264 < void XYZVisitor::visit(RigidBody *rb) {
264 >  void XYZVisitor::visit(RigidBody *rb) {
265      if (isSelected(rb))
266 <        internalVisit(rb);
267 < }
266 >      internalVisit(rb);
267 >  }
268  
269 < void XYZVisitor::update() {
269 >  void XYZVisitor::update() {
270      //if dynamic, we need to re-evaluate the selection
271      if (evaluator.isDynamic()) {
272 <       seleMan.setSelectionSet(evaluator.evaluate());
272 >      seleMan.setSelectionSet(evaluator.evaluate());
273      }
274 < }
274 >  }
275  
276 < void XYZVisitor::internalVisit(StuntDouble *sd) {
276 >  void XYZVisitor::internalVisit(StuntDouble *sd) {
277      GenericData *                     data;
278      AtomData *                        atomData;
279      AtomInfo *                        atomInfo;
# Line 276 | Line 284 | void XYZVisitor::internalVisit(StuntDouble *sd) {
284      data = sd->getPropertyByName("ATOMDATA");
285  
286      if (data != NULL) {
287 <        atomData = dynamic_cast<AtomData *>(data);
287 >      atomData = dynamic_cast<AtomData *>(data);
288  
289 <        if (atomData == NULL)
290 <            return;
289 >      if (atomData == NULL)
290 >        return;
291      } else
292 <        return;
292 >      return;
293  
294      for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
295 <        atomInfo = atomData->nextAtomInfo(i) ) {
296 <        sprintf(buffer,
297 <                "%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
298 <                atomInfo->atomTypeName.c_str(),
299 <                atomInfo->pos[0],
300 <                atomInfo->pos[1],
301 <                atomInfo->pos[2],
302 <                atomInfo->dipole[0],
303 <                atomInfo->dipole[1],
304 <                atomInfo->dipole[2]);
305 <        frame.push_back(buffer);
295 >         atomInfo = atomData->nextAtomInfo(i) ) {
296 >      sprintf(buffer,
297 >              "%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
298 >              atomInfo->atomTypeName.c_str(),
299 >              atomInfo->pos[0],
300 >              atomInfo->pos[1],
301 >              atomInfo->pos[2],
302 >              atomInfo->dipole[0],
303 >              atomInfo->dipole[1],
304 >              atomInfo->dipole[2]);
305 >      frame.push_back(buffer);
306      }
307 < }
307 >  }
308  
309 < bool XYZVisitor::isSelected(StuntDouble *sd) {
309 >  bool XYZVisitor::isSelected(StuntDouble *sd) {
310      return seleMan.isSelected(sd);
311 < }
311 >  }
312  
313 < void XYZVisitor::writeFrame(std::ostream &outStream) {
313 >  void XYZVisitor::writeFrame(std::ostream &outStream) {
314      std::vector<std::string>::iterator i;
315      char buffer[1024];
316  
317      if (frame.size() == 0)
318 <        std::cerr << "Current Frame does not contain any atoms" << std::endl;
318 >      std::cerr << "Current Frame does not contain any atoms" << std::endl;
319  
320      //total number of atoms  
321      outStream << frame.size() << std::endl;
# Line 326 | Line 334 | void XYZVisitor::writeFrame(std::ostream &outStream) {
334      outStream << buffer << std::endl;
335  
336      for( i = frame.begin(); i != frame.end(); ++i )
337 <        outStream << *i << std::endl;
338 < }
337 >      outStream << *i << std::endl;
338 >  }
339  
340 < const std::string XYZVisitor::toString() {
340 >  const std::string XYZVisitor::toString() {
341      char        buffer[65535];
342      std::string result;
343  
# Line 349 | Line 357 | const std::string XYZVisitor::toString() {
357      result += buffer;
358  
359      return result;
360 < }
360 >  }
361  
362 < //----------------------------------------------------------------------------//
362 >  //----------------------------------------------------------------------------//
363  
364 < void PrepareVisitor::internalVisit(Atom *atom) {
364 >  void PrepareVisitor::internalVisit(Atom *atom) {
365      GenericData *data;
366      AtomData *   atomData;
367  
# Line 361 | Line 369 | void PrepareVisitor::internalVisit(Atom *atom) {
369      data = atom->getPropertyByName("VISITED");
370  
371      if (data != NULL) {
372 <    atom->removeProperty("VISITED");
372 >      atom->removeProperty("VISITED");
373      }
374  
375      //remove atomdata
376      data = atom->getPropertyByName("ATOMDATA");
377  
378      if (data != NULL) {
379 <        atomData = dynamic_cast<AtomData *>(data);
379 >      atomData = dynamic_cast<AtomData *>(data);
380  
381 <        if (atomData != NULL)
382 <            atom->removeProperty("ATOMDATA");
381 >      if (atomData != NULL)
382 >        atom->removeProperty("ATOMDATA");
383      }
384 < }
384 >  }
385  
386 < void PrepareVisitor::internalVisit(RigidBody *rb) {
386 >  void PrepareVisitor::internalVisit(RigidBody *rb) {
387      GenericData* data;
388      AtomData* atomData;
389      std::vector<Atom *> myAtoms;
# Line 385 | Line 393 | void PrepareVisitor::internalVisit(RigidBody *rb) {
393      data = rb->getPropertyByName("VISITED");
394  
395      if (data != NULL) {
396 <    rb->removeProperty("VISITED");
396 >      rb->removeProperty("VISITED");
397      }
398  
399      //remove atomdata
400      data = rb->getPropertyByName("ATOMDATA");
401  
402      if (data != NULL) {
403 <        atomData = dynamic_cast<AtomData *>(data);
403 >      atomData = dynamic_cast<AtomData *>(data);
404  
405 <        if (atomData != NULL)
406 <            rb->removeProperty("ATOMDATA");
405 >      if (atomData != NULL)
406 >        rb->removeProperty("ATOMDATA");
407      }
408  
409      myAtoms = rb->getAtoms();
410  
411      for( atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter )
412 <        internalVisit(*atomIter);
413 < }
412 >      internalVisit(*atomIter);
413 >  }
414  
415 < const std::string PrepareVisitor::toString() {
416 <     char buffer[65535];
417 <     std::string result;
415 >  const std::string PrepareVisitor::toString() {
416 >    char buffer[65535];
417 >    std::string result;
418  
419 <     sprintf(buffer,
420 <             "------------------------------------------------------------------\n");
421 <     result += buffer;
419 >    sprintf(buffer,
420 >            "------------------------------------------------------------------\n");
421 >    result += buffer;
422  
423 <     sprintf(buffer, "Visitor name: %s", visitorName.c_str());
424 <     result += buffer;
423 >    sprintf(buffer, "Visitor name: %s", visitorName.c_str());
424 >    result += buffer;
425  
426 <     sprintf(buffer,
427 <             "Visitor Description: prepare for operation of other vistors\n");
428 <     result += buffer;
426 >    sprintf(buffer,
427 >            "Visitor Description: prepare for operation of other vistors\n");
428 >    result += buffer;
429  
430 <     sprintf(buffer,
431 <             "------------------------------------------------------------------\n");
432 <     result += buffer;
430 >    sprintf(buffer,
431 >            "------------------------------------------------------------------\n");
432 >    result += buffer;
433  
434 <     return result;
435 < }
434 >    return result;
435 >  }
436  
437 < //----------------------------------------------------------------------------//
437 >  //----------------------------------------------------------------------------//
438  
439 < WaterTypeVisitor::WaterTypeVisitor() {
439 >  WaterTypeVisitor::WaterTypeVisitor() {
440      visitorName = "WaterTypeVisitor";
441      waterTypeList.insert("TIP3P_RB_0");
442      waterTypeList.insert("TIP4P_RB_0");
443      waterTypeList.insert("TIP5P_RB_0");
444      waterTypeList.insert("SPCE_RB_0");
445 < }
445 >  }
446  
447 < void WaterTypeVisitor::visit(RigidBody *rb) {
447 >  void WaterTypeVisitor::visit(RigidBody *rb) {
448      std::string rbName;
449      std::vector<Atom *> myAtoms;
450      std::vector<Atom *>::iterator atomIter;
# Line 448 | Line 456 | void WaterTypeVisitor::visit(RigidBody *rb) {
456      rbName = rb->getType();
457  
458      if (waterTypeList.find(rbName) != waterTypeList.end()) {
459 <        myAtoms = rb->getAtoms();
459 >      myAtoms = rb->getAtoms();
460  
461 <        for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
462 <            ++atomIter ) {
463 <            data = (*atomIter)->getPropertyByName("ATOMDATA");
461 >      for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
462 >           ++atomIter ) {
463 >        data = (*atomIter)->getPropertyByName("ATOMDATA");
464  
465 <            if (data != NULL) {
466 <                atomData = dynamic_cast<AtomData *>(data);
465 >        if (data != NULL) {
466 >          atomData = dynamic_cast<AtomData *>(data);
467  
468 <                if (atomData == NULL)
469 <                    continue;
470 <            } else
471 <                continue;
468 >          if (atomData == NULL)
469 >            continue;
470 >        } else
471 >          continue;
472  
473 <            for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
474 <                 atomInfo = atomData->nextAtomInfo(i) ) {
475 <              atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
476 <            } //end for(atomInfo)
477 <        }     //end for(atomIter)
473 >        for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
474 >             atomInfo = atomData->nextAtomInfo(i) ) {
475 >          atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
476 >        } //end for(atomInfo)
477 >      }     //end for(atomIter)
478      }         //end if (waterTypeList.find(rbName) != waterTypeList.end())
479 < }
479 >  }
480  
481    std::string WaterTypeVisitor::trimmedName(const std::string&atomTypeName) {
482      return atomTypeName.substr(0, atomTypeName.find('_'));
483    }
484  
485 < const std::string WaterTypeVisitor::toString() {
485 >  const std::string WaterTypeVisitor::toString() {
486      char buffer[65535];
487      std::string result;
488  
# Line 494 | Line 502 | const std::string WaterTypeVisitor::toString() {
502      result += buffer;
503  
504      return result;
505 < }
505 >  }
506  
507   } //namespace oopse

Diff Legend

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