ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/visitors/OtherVisitor.cpp
(Generate patch)

Comparing trunk/src/visitors/OtherVisitor.cpp (file contents):
Revision 413 by tim, Wed Mar 9 17:30:29 2005 UTC vs.
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC

# 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]  Vardeman & Gezelter, in progress (2009).                        
40   */
41   #include "selection/SelectionManager.hpp"
42   #include "visitors/OtherVisitor.hpp"
# Line 44 | Line 44
44   #include "primitives/RigidBody.hpp"
45   #include "primitives/Molecule.hpp"
46   #include "brains/SimInfo.hpp"
47 < namespace oopse {
47 > namespace OpenMD {
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 >    AtomType* at = dynamic_cast<Atom *>(sd)->getAtomType();
295 >    std::string bn = baseTypeName(at);
296 >
297 >    if (posOnly_){
298 >      for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
299 >           atomInfo = atomData->nextAtomInfo(i) ) {
300 >        if (atomInfo->hasCharge) {
301 >          sprintf(buffer,
302 >                  "%s%15.8f%15.8f%15.8f%15.8f",
303 >                  bn.c_str(),
304 >                  atomInfo->pos[0],
305 >                  atomInfo->pos[1],
306 >                  atomInfo->pos[2],
307 >                  atomInfo->charge);
308 >        } else {
309 >          sprintf(buffer,
310 >                "%s%15.8f%15.8f%15.8f",
311 >                  bn.c_str(),
312 >                  atomInfo->pos[0],
313 >                  atomInfo->pos[1],
314 >                  atomInfo->pos[2]);
315 >        }
316 >        frame.push_back(buffer);
317 >      }
318 >    }else{
319 >      for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
320 >           atomInfo = atomData->nextAtomInfo(i) ) {
321 >        if (atomInfo->hasCharge) {
322 >        sprintf(buffer,
323 >                "%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
324 >                bn.c_str(),
325 >                atomInfo->pos[0],
326 >                atomInfo->pos[1],
327 >                atomInfo->pos[2],
328 >                atomInfo->charge,
329 >                atomInfo->dipole[0],
330 >                atomInfo->dipole[1],
331 >                atomInfo->dipole[2]);
332 >        } else {
333 >        sprintf(buffer,
334 >                "%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
335 >                bn.c_str(),
336 >                atomInfo->pos[0],
337 >                atomInfo->pos[1],
338 >                atomInfo->pos[2],
339 >                atomInfo->dipole[0],
340 >                atomInfo->dipole[1],
341 >                atomInfo->dipole[2]);
342 >        }
343 >        frame.push_back(buffer);
344 >      }
345      }
346 < }
346 >  }
347  
348 < bool XYZVisitor::isSelected(StuntDouble *sd) {
348 >  bool XYZVisitor::isSelected(StuntDouble *sd) {
349      return seleMan.isSelected(sd);
350 < }
350 >  }
351  
352 < void XYZVisitor::writeFrame(std::ostream &outStream) {
352 >  void XYZVisitor::writeFrame(std::ostream &outStream) {
353      std::vector<std::string>::iterator i;
354      char buffer[1024];
355  
356      if (frame.size() == 0)
357 <        std::cerr << "Current Frame does not contain any atoms" << std::endl;
357 >      std::cerr << "Current Frame does not contain any atoms" << std::endl;
358  
359      //total number of atoms  
360      outStream << frame.size() << std::endl;
# Line 326 | Line 373 | void XYZVisitor::writeFrame(std::ostream &outStream) {
373      outStream << buffer << std::endl;
374  
375      for( i = frame.begin(); i != frame.end(); ++i )
376 <        outStream << *i << std::endl;
377 < }
376 >      outStream << *i << std::endl;
377 >  }
378  
379 < const std::string XYZVisitor::toString() {
379 >  std::string XYZVisitor::trimmedName(const std::string&atomTypeName) {    
380 >    return atomTypeName.substr(0, atomTypeName.find('-'));
381 >  }
382 >
383 >  std::string XYZVisitor::baseTypeName(AtomType* at) {
384 >    std::vector<AtomType*> ayb = at->allYourBase();
385 >    return ayb[ayb.size()-1]->getName();
386 >  }
387 >
388 >  const std::string XYZVisitor::toString() {
389      char        buffer[65535];
390      std::string result;
391  
# Line 349 | Line 405 | const std::string XYZVisitor::toString() {
405      result += buffer;
406  
407      return result;
408 < }
408 >  }
409  
410 < //----------------------------------------------------------------------------//
410 >  //----------------------------------------------------------------------------//
411  
412 < void PrepareVisitor::internalVisit(Atom *atom) {
412 >  void PrepareVisitor::internalVisit(Atom *atom) {
413      GenericData *data;
414      AtomData *   atomData;
415  
# Line 361 | Line 417 | void PrepareVisitor::internalVisit(Atom *atom) {
417      data = atom->getPropertyByName("VISITED");
418  
419      if (data != NULL) {
420 <    atom->removeProperty("VISITED");
420 >      atom->removeProperty("VISITED");
421      }
422  
423      //remove atomdata
424      data = atom->getPropertyByName("ATOMDATA");
425  
426      if (data != NULL) {
427 <        atomData = dynamic_cast<AtomData *>(data);
427 >      atomData = dynamic_cast<AtomData *>(data);
428  
429 <        if (atomData != NULL)
430 <            atom->removeProperty("ATOMDATA");
429 >      if (atomData != NULL)
430 >        atom->removeProperty("ATOMDATA");
431      }
432 < }
432 >  }
433  
434 < void PrepareVisitor::internalVisit(RigidBody *rb) {
434 >  void PrepareVisitor::internalVisit(RigidBody *rb) {
435      GenericData* data;
436      AtomData* atomData;
437      std::vector<Atom *> myAtoms;
# Line 385 | Line 441 | void PrepareVisitor::internalVisit(RigidBody *rb) {
441      data = rb->getPropertyByName("VISITED");
442  
443      if (data != NULL) {
444 <    rb->removeProperty("VISITED");
444 >      rb->removeProperty("VISITED");
445      }
446  
447      //remove atomdata
448      data = rb->getPropertyByName("ATOMDATA");
449  
450      if (data != NULL) {
451 <        atomData = dynamic_cast<AtomData *>(data);
451 >      atomData = dynamic_cast<AtomData *>(data);
452  
453 <        if (atomData != NULL)
454 <            rb->removeProperty("ATOMDATA");
453 >      if (atomData != NULL)
454 >        rb->removeProperty("ATOMDATA");
455      }
456  
457      myAtoms = rb->getAtoms();
458  
459      for( atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter )
460 <        internalVisit(*atomIter);
461 < }
460 >      internalVisit(*atomIter);
461 >  }
462  
463 < const std::string PrepareVisitor::toString() {
464 <     char buffer[65535];
465 <     std::string result;
463 >  const std::string PrepareVisitor::toString() {
464 >    char buffer[65535];
465 >    std::string result;
466  
467 <     sprintf(buffer,
468 <             "------------------------------------------------------------------\n");
469 <     result += buffer;
467 >    sprintf(buffer,
468 >            "------------------------------------------------------------------\n");
469 >    result += buffer;
470  
471 <     sprintf(buffer, "Visitor name: %s", visitorName.c_str());
472 <     result += buffer;
471 >    sprintf(buffer, "Visitor name: %s", visitorName.c_str());
472 >    result += buffer;
473  
474 <     sprintf(buffer,
475 <             "Visitor Description: prepare for operation of other vistors\n");
476 <     result += buffer;
474 >    sprintf(buffer,
475 >            "Visitor Description: prepare for operation of other vistors\n");
476 >    result += buffer;
477  
478 <     sprintf(buffer,
479 <             "------------------------------------------------------------------\n");
480 <     result += buffer;
478 >    sprintf(buffer,
479 >            "------------------------------------------------------------------\n");
480 >    result += buffer;
481  
482 <     return result;
483 < }
482 >    return result;
483 >  }
484  
485 < //----------------------------------------------------------------------------//
485 >  //----------------------------------------------------------------------------//
486  
487 < WaterTypeVisitor::WaterTypeVisitor() {
487 >  WaterTypeVisitor::WaterTypeVisitor() {
488      visitorName = "WaterTypeVisitor";
489      waterTypeList.insert("TIP3P_RB_0");
490      waterTypeList.insert("TIP4P_RB_0");
491      waterTypeList.insert("TIP5P_RB_0");
492      waterTypeList.insert("SPCE_RB_0");
493 < }
493 >  }
494  
495 < void WaterTypeVisitor::visit(RigidBody *rb) {
495 >  void WaterTypeVisitor::visit(RigidBody *rb) {
496      std::string rbName;
497      std::vector<Atom *> myAtoms;
498      std::vector<Atom *>::iterator atomIter;
# Line 448 | Line 504 | void WaterTypeVisitor::visit(RigidBody *rb) {
504      rbName = rb->getType();
505  
506      if (waterTypeList.find(rbName) != waterTypeList.end()) {
507 <        myAtoms = rb->getAtoms();
507 >      myAtoms = rb->getAtoms();
508  
509 <        for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
510 <            ++atomIter ) {
511 <            data = (*atomIter)->getPropertyByName("ATOMDATA");
509 >      for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
510 >           ++atomIter ) {
511 >        data = (*atomIter)->getPropertyByName("ATOMDATA");
512  
513 <            if (data != NULL) {
514 <                atomData = dynamic_cast<AtomData *>(data);
513 >        if (data != NULL) {
514 >          atomData = dynamic_cast<AtomData *>(data);
515  
516 <                if (atomData == NULL)
517 <                    continue;
518 <            } else
519 <                continue;
516 >          if (atomData == NULL)
517 >            continue;
518 >        } else
519 >          continue;
520  
521 <            for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
522 <                 atomInfo = atomData->nextAtomInfo(i) ) {
523 <              atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
524 <            } //end for(atomInfo)
525 <        }     //end for(atomIter)
521 >        for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
522 >             atomInfo = atomData->nextAtomInfo(i) ) {
523 >          atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
524 >        } //end for(atomInfo)
525 >      }     //end for(atomIter)
526      }         //end if (waterTypeList.find(rbName) != waterTypeList.end())
527 < }
527 >  }
528  
529    std::string WaterTypeVisitor::trimmedName(const std::string&atomTypeName) {
530      return atomTypeName.substr(0, atomTypeName.find('_'));
531    }
532  
533 < const std::string WaterTypeVisitor::toString() {
533 >  const std::string WaterTypeVisitor::toString() {
534      char buffer[65535];
535      std::string result;
536  
# Line 494 | Line 550 | const std::string WaterTypeVisitor::toString() {
550      result += buffer;
551  
552      return result;
553 < }
553 >  }
554  
555 < } //namespace oopse
555 > } //namespace OpenMD

Diff Legend

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