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 3116 by chuckv, Tue Jan 16 22:18:04 2007 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 +      posOnly_ = false;
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 +      }
251 +      posOnly_ = false;
252      }
243 –          
244 – }
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);
294 >    if (posOnly_){
295 >      for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
296 >           atomInfo = atomData->nextAtomInfo(i) ) {
297 >        sprintf(buffer,
298 >                "%s%15.8f%15.8f%15.8f",
299 >                atomInfo->atomTypeName.c_str(),
300 >                atomInfo->pos[0],
301 >                atomInfo->pos[1],
302 >                atomInfo->pos[2]);
303 >        frame.push_back(buffer);
304 >      }
305 >    }else{
306 >      for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
307 >           atomInfo = atomData->nextAtomInfo(i) ) {
308 >        sprintf(buffer,
309 >                "%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
310 >                atomInfo->atomTypeName.c_str(),
311 >                atomInfo->pos[0],
312 >                atomInfo->pos[1],
313 >                atomInfo->pos[2],
314 >                atomInfo->dipole[0],
315 >                atomInfo->dipole[1],
316 >                atomInfo->dipole[2]);
317 >        frame.push_back(buffer);
318 >      }
319      }
320 < }
320 >  }
321  
322 < bool XYZVisitor::isSelected(StuntDouble *sd) {
322 >  bool XYZVisitor::isSelected(StuntDouble *sd) {
323      return seleMan.isSelected(sd);
324 < }
324 >  }
325  
326 < void XYZVisitor::writeFrame(std::ostream &outStream) {
326 >  void XYZVisitor::writeFrame(std::ostream &outStream) {
327      std::vector<std::string>::iterator i;
328      char buffer[1024];
329  
330      if (frame.size() == 0)
331 <        std::cerr << "Current Frame does not contain any atoms" << std::endl;
331 >      std::cerr << "Current Frame does not contain any atoms" << std::endl;
332  
333      //total number of atoms  
334      outStream << frame.size() << std::endl;
# Line 326 | Line 347 | void XYZVisitor::writeFrame(std::ostream &outStream) {
347      outStream << buffer << std::endl;
348  
349      for( i = frame.begin(); i != frame.end(); ++i )
350 <        outStream << *i << std::endl;
351 < }
350 >      outStream << *i << std::endl;
351 >  }
352  
353 < const std::string XYZVisitor::toString() {
353 >  const std::string XYZVisitor::toString() {
354      char        buffer[65535];
355      std::string result;
356  
# Line 349 | Line 370 | const std::string XYZVisitor::toString() {
370      result += buffer;
371  
372      return result;
373 < }
373 >  }
374  
375 < //----------------------------------------------------------------------------//
375 >  //----------------------------------------------------------------------------//
376  
377 < void PrepareVisitor::internalVisit(Atom *atom) {
377 >  void PrepareVisitor::internalVisit(Atom *atom) {
378      GenericData *data;
379      AtomData *   atomData;
380  
# Line 361 | Line 382 | void PrepareVisitor::internalVisit(Atom *atom) {
382      data = atom->getPropertyByName("VISITED");
383  
384      if (data != NULL) {
385 <    atom->removeProperty("VISITED");
385 >      atom->removeProperty("VISITED");
386      }
387  
388      //remove atomdata
389      data = atom->getPropertyByName("ATOMDATA");
390  
391      if (data != NULL) {
392 <        atomData = dynamic_cast<AtomData *>(data);
392 >      atomData = dynamic_cast<AtomData *>(data);
393  
394 <        if (atomData != NULL)
395 <            atom->removeProperty("ATOMDATA");
394 >      if (atomData != NULL)
395 >        atom->removeProperty("ATOMDATA");
396      }
397 < }
397 >  }
398  
399 < void PrepareVisitor::internalVisit(RigidBody *rb) {
399 >  void PrepareVisitor::internalVisit(RigidBody *rb) {
400      GenericData* data;
401      AtomData* atomData;
402      std::vector<Atom *> myAtoms;
# Line 385 | Line 406 | void PrepareVisitor::internalVisit(RigidBody *rb) {
406      data = rb->getPropertyByName("VISITED");
407  
408      if (data != NULL) {
409 <    rb->removeProperty("VISITED");
409 >      rb->removeProperty("VISITED");
410      }
411  
412      //remove atomdata
413      data = rb->getPropertyByName("ATOMDATA");
414  
415      if (data != NULL) {
416 <        atomData = dynamic_cast<AtomData *>(data);
416 >      atomData = dynamic_cast<AtomData *>(data);
417  
418 <        if (atomData != NULL)
419 <            rb->removeProperty("ATOMDATA");
418 >      if (atomData != NULL)
419 >        rb->removeProperty("ATOMDATA");
420      }
421  
422      myAtoms = rb->getAtoms();
423  
424      for( atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter )
425 <        internalVisit(*atomIter);
426 < }
425 >      internalVisit(*atomIter);
426 >  }
427  
428 < const std::string PrepareVisitor::toString() {
429 <     char buffer[65535];
430 <     std::string result;
428 >  const std::string PrepareVisitor::toString() {
429 >    char buffer[65535];
430 >    std::string result;
431  
432 <     sprintf(buffer,
433 <             "------------------------------------------------------------------\n");
434 <     result += buffer;
432 >    sprintf(buffer,
433 >            "------------------------------------------------------------------\n");
434 >    result += buffer;
435  
436 <     sprintf(buffer, "Visitor name: %s", visitorName.c_str());
437 <     result += buffer;
436 >    sprintf(buffer, "Visitor name: %s", visitorName.c_str());
437 >    result += buffer;
438  
439 <     sprintf(buffer,
440 <             "Visitor Description: prepare for operation of other vistors\n");
441 <     result += buffer;
439 >    sprintf(buffer,
440 >            "Visitor Description: prepare for operation of other vistors\n");
441 >    result += buffer;
442  
443 <     sprintf(buffer,
444 <             "------------------------------------------------------------------\n");
445 <     result += buffer;
443 >    sprintf(buffer,
444 >            "------------------------------------------------------------------\n");
445 >    result += buffer;
446  
447 <     return result;
448 < }
447 >    return result;
448 >  }
449  
450 < //----------------------------------------------------------------------------//
450 >  //----------------------------------------------------------------------------//
451  
452 < WaterTypeVisitor::WaterTypeVisitor() {
452 >  WaterTypeVisitor::WaterTypeVisitor() {
453      visitorName = "WaterTypeVisitor";
454      waterTypeList.insert("TIP3P_RB_0");
455      waterTypeList.insert("TIP4P_RB_0");
456      waterTypeList.insert("TIP5P_RB_0");
457      waterTypeList.insert("SPCE_RB_0");
458 < }
458 >  }
459  
460 < void WaterTypeVisitor::visit(RigidBody *rb) {
460 >  void WaterTypeVisitor::visit(RigidBody *rb) {
461      std::string rbName;
462      std::vector<Atom *> myAtoms;
463      std::vector<Atom *>::iterator atomIter;
# Line 448 | Line 469 | void WaterTypeVisitor::visit(RigidBody *rb) {
469      rbName = rb->getType();
470  
471      if (waterTypeList.find(rbName) != waterTypeList.end()) {
472 <        myAtoms = rb->getAtoms();
472 >      myAtoms = rb->getAtoms();
473  
474 <        for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
475 <            ++atomIter ) {
476 <            data = (*atomIter)->getPropertyByName("ATOMDATA");
474 >      for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
475 >           ++atomIter ) {
476 >        data = (*atomIter)->getPropertyByName("ATOMDATA");
477  
478 <            if (data != NULL) {
479 <                atomData = dynamic_cast<AtomData *>(data);
478 >        if (data != NULL) {
479 >          atomData = dynamic_cast<AtomData *>(data);
480  
481 <                if (atomData == NULL)
482 <                    continue;
483 <            } else
484 <                continue;
481 >          if (atomData == NULL)
482 >            continue;
483 >        } else
484 >          continue;
485  
486 <            for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
487 <                 atomInfo = atomData->nextAtomInfo(i) ) {
488 <              atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
489 <            } //end for(atomInfo)
490 <        }     //end for(atomIter)
486 >        for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
487 >             atomInfo = atomData->nextAtomInfo(i) ) {
488 >          atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
489 >        } //end for(atomInfo)
490 >      }     //end for(atomIter)
491      }         //end if (waterTypeList.find(rbName) != waterTypeList.end())
492 < }
492 >  }
493  
494    std::string WaterTypeVisitor::trimmedName(const std::string&atomTypeName) {
495      return atomTypeName.substr(0, atomTypeName.find('_'));
496    }
497  
498 < const std::string WaterTypeVisitor::toString() {
498 >  const std::string WaterTypeVisitor::toString() {
499      char buffer[65535];
500      std::string result;
501  
# Line 494 | Line 515 | const std::string WaterTypeVisitor::toString() {
515      result += buffer;
516  
517      return result;
518 < }
518 >  }
519  
520   } //namespace oopse

Diff Legend

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