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

Comparing branches/development/src/brains/Snapshot.cpp (file contents):
Revision 1715 by gezelter, Tue May 22 21:55:31 2012 UTC vs.
Revision 1868 by gezelter, Tue Apr 30 15:56:54 2013 UTC

# Line 35 | Line 35
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).          
38 > * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).          
39   * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40   * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41   */
# Line 44 | Line 44
44   * @file Snapshot.cpp
45   * @author tlin
46   * @date 11/11/2004
47 – * @time 10:56am
47   * @version 1.0
48   */
49  
# Line 56 | Line 55 | namespace OpenMD {
55  
56   namespace OpenMD {
57  
58 <  void  Snapshot::setHmat(const Mat3x3d& m) {
58 >  Snapshot::Snapshot(int nAtoms, int nRigidbodies, int nCutoffGroups) :
59 >    atomData(nAtoms), rigidbodyData(nRigidbodies),
60 >    cgData(nCutoffGroups, DataStorage::dslPosition),
61 >    orthoTolerance_(1e-6) {
62 >    
63 >    frameData.id = -1;                  
64 >    frameData.currentTime = 0;    
65 >    frameData.hmat = Mat3x3d(0.0);            
66 >    frameData.invHmat = Mat3x3d(0.0);          
67 >    frameData.orthoRhombic = false;        
68 >    frameData.bondPotential = 0.0;      
69 >    frameData.bendPotential = 0.0;      
70 >    frameData.torsionPotential = 0.0;  
71 >    frameData.inversionPotential = 0.0;
72 >    frameData.lrPotentials = potVec(0.0);
73 >    frameData.excludedPotentials = potVec(0.0);
74 >    frameData.restraintPotential = 0.0;
75 >    frameData.rawPotential = 0.0;  
76 >    frameData.xyArea = 0.0;
77 >    frameData.volume = 0.0;          
78 >    frameData.thermostat = make_pair(0.0, 0.0);
79 >    frameData.electronicThermostat = make_pair(0.0, 0.0);
80 >    frameData.barostat = Mat3x3d(0.0);              
81 >    frameData.stressTensor = Mat3x3d(0.0);              
82 >    frameData.conductiveHeatFlux = Vector3d(0.0, 0.0, 0.0);
83 >
84 >    clearDerivedProperties();
85 >  }
86 >  
87 >  Snapshot::Snapshot(int nAtoms, int nRigidbodies, int nCutoffGroups,
88 >                     int storageLayout) :
89 >    atomData(nAtoms, storageLayout),
90 >    rigidbodyData(nRigidbodies, storageLayout),
91 >    cgData(nCutoffGroups, DataStorage::dslPosition),
92 >    orthoTolerance_(1e-6) {
93 >    
94 >    frameData.id = -1;                  
95 >    frameData.currentTime = 0;    
96 >    frameData.hmat = Mat3x3d(0.0);            
97 >    frameData.invHmat = Mat3x3d(0.0);      
98 >    frameData.bBox = Mat3x3d(0.0);            
99 >    frameData.invBbox = Mat3x3d(0.0);
100 >    frameData.orthoRhombic = false;        
101 >    frameData.bondPotential = 0.0;      
102 >    frameData.bendPotential = 0.0;      
103 >    frameData.torsionPotential = 0.0;  
104 >    frameData.inversionPotential = 0.0;
105 >    frameData.lrPotentials = potVec(0.0);
106 >    frameData.excludedPotentials = potVec(0.0);
107 >    frameData.restraintPotential = 0.0;
108 >    frameData.rawPotential = 0.0;      
109 >    frameData.xyArea = 0.0;
110 >    frameData.volume = 0.0;          
111 >    frameData.thermostat = make_pair(0.0, 0.0);
112 >    frameData.electronicThermostat = make_pair(0.0, 0.0);
113 >    frameData.barostat = Mat3x3d(0.0);              
114 >    frameData.stressTensor = Mat3x3d(0.0);              
115 >    frameData.conductiveHeatFlux = Vector3d(0.0, 0.0, 0.0);
116 >
117 >    clearDerivedProperties();
118 >  }
119 >
120 >  void Snapshot::clearDerivedProperties() {
121 >    frameData.totalEnergy = 0.0;    
122 >    frameData.translationalKinetic = 0.0;  
123 >    frameData.rotationalKinetic = 0.0;  
124 >    frameData.kineticEnergy = 0.0;  
125 >    frameData.potentialEnergy = 0.0;
126 >    frameData.shortRangePotential = 0.0;
127 >    frameData.longRangePotential = 0.0;
128 >    frameData.pressure = 0.0;        
129 >    frameData.temperature = 0.0;
130 >    frameData.pressureTensor = Mat3x3d(0.0);  
131 >    frameData.systemDipole = Vector3d(0.0);            
132 >    frameData.convectiveHeatFlux = Vector3d(0.0, 0.0, 0.0);
133 >    frameData.electronicTemperature = 0.0;
134 >    frameData.COM = V3Zero;            
135 >    frameData.COMvel = V3Zero;          
136 >    frameData.COMw = V3Zero;  
137 >
138 >    hasTotalEnergy = false;        
139 >    hasTranslationalKineticEnergy = false;      
140 >    hasRotationalKineticEnergy = false;      
141 >    hasKineticEnergy = false;      
142 >    hasShortRangePotential = false;
143 >    hasLongRangePotential = false;
144 >    hasPotentialEnergy = false;  
145 >    hasXYarea = false;
146 >    hasVolume = false;        
147 >    hasPressure = false;      
148 >    hasTemperature = false;    
149 >    hasElectronicTemperature = false;
150 >    hasCOM = false;
151 >    hasCOMvel = false;
152 >    hasCOMw = false;
153 >    hasPressureTensor = false;    
154 >    hasSystemDipole = false;      
155 >    hasConvectiveHeatFlux = false;  
156 >    hasInertiaTensor = false;
157 >    hasGyrationalVolume = false;  
158 >    hasHullVolume = false;
159 >    hasConservedQuantity = false;
160 >    hasBoundingBox = false;
161 >  }
162 >
163 >  /** Returns the id of this Snapshot */
164 >  int Snapshot::getID() {
165 >    return frameData.id;
166 >  }
167 >  
168 >  /** Sets the id of this Snapshot */
169 >  void Snapshot::setID(int id) {
170 >    frameData.id = id;
171 >  }
172 >  
173 >  int Snapshot::getSize() {
174 >    return atomData.getSize() + rigidbodyData.getSize();
175 >  }
176 >  
177 >  /** Returns the number of atoms */
178 >  int Snapshot::getNumberOfAtoms() {
179 >    return atomData.getSize();
180 >  }
181 >  
182 >  /** Returns the number of rigid bodies */
183 >  int Snapshot::getNumberOfRigidBodies() {
184 >    return rigidbodyData.getSize();
185 >  }
186 >  
187 >  /** Returns the number of rigid bodies */
188 >  int Snapshot::getNumberOfCutoffGroups() {
189 >    return cgData.getSize();
190 >  }
191 >  
192 >  /** Returns the H-Matrix */
193 >  Mat3x3d Snapshot::getHmat() {
194 >    return frameData.hmat;
195 >  }
196 >
197 >  /** Sets the H-Matrix */  
198 >  void Snapshot::setHmat(const Mat3x3d& m) {
199 >    hasVolume = false;
200      frameData.hmat = m;
201      frameData.invHmat = frameData.hmat.inverse();
202      
# Line 80 | Line 220 | namespace OpenMD {
220          }
221        }
222      }
223 <
223 >    
224      if( oldOrthoRhombic != frameData.orthoRhombic){
225 +      
226 +      // It is finally time to suppress these warnings once and for
227 +      // all.  They were annoying and not very informative.
228  
229 <      if( frameData.orthoRhombic ) {
230 <        sprintf( painCave.errMsg,
231 <                 "OpenMD is switching from the default Non-Orthorhombic\n"
232 <                 "\tto the faster Orthorhombic periodic boundary computations.\n"
233 <                 "\tThis is usually a good thing, but if you want the\n"
234 <                 "\tNon-Orthorhombic computations, make the orthoBoxTolerance\n"
235 <                 "\tvariable ( currently set to %G ) smaller.\n",
236 <                 orthoTolerance_);
237 <        painCave.severity = OPENMD_INFO;
238 <        simError();
239 <      }
240 <      else {
241 <        sprintf( painCave.errMsg,
242 <                 "OpenMD is switching from the faster Orthorhombic to the more\n"
243 <                 "\tflexible Non-Orthorhombic periodic boundary computations.\n"
244 <                 "\tThis is usually because the box has deformed under\n"
245 <                 "\tNPTf integration. If you want to live on the edge with\n"
246 <                 "\tthe Orthorhombic computations, make the orthoBoxTolerance\n"
247 <                 "\tvariable ( currently set to %G ) larger.\n",
248 <                 orthoTolerance_);
249 <        painCave.severity = OPENMD_WARNING;
250 <        simError();
251 <      }
229 >      // if( frameData.orthoRhombic ) {
230 >      //   sprintf( painCave.errMsg,
231 >      //         "OpenMD is switching from the default Non-Orthorhombic\n"
232 >      //         "\tto the faster Orthorhombic periodic boundary computations.\n"
233 >      //         "\tThis is usually a good thing, but if you want the\n"
234 >      //         "\tNon-Orthorhombic computations, make the orthoBoxTolerance\n"
235 >      //         "\tvariable ( currently set to %G ) smaller.\n",
236 >      //         orthoTolerance_);
237 >      //   painCave.severity = OPENMD_INFO;
238 >      //   simError();
239 >      // }
240 >      // else {
241 >      //   sprintf( painCave.errMsg,
242 >      //         "OpenMD is switching from the faster Orthorhombic to the more\n"
243 >      //         "\tflexible Non-Orthorhombic periodic boundary computations.\n"
244 >      //         "\tThis is usually because the box has deformed under\n"
245 >      //         "\tNPTf integration. If you want to live on the edge with\n"
246 >      //         "\tthe Orthorhombic computations, make the orthoBoxTolerance\n"
247 >      //         "\tvariable ( currently set to %G ) larger.\n",
248 >      //         orthoTolerance_);
249 >      //   painCave.severity = OPENMD_WARNING;
250 >      //   simError();
251 >      // }
252      }    
253    }
254 +  
255 +  /** Returns the inverse H-Matrix */
256 +  Mat3x3d Snapshot::getInvHmat() {
257 +    return frameData.invHmat;
258 +  }
259  
260 +  /** Returns the Bounding Box */
261 +  Mat3x3d Snapshot::getBoundingBox() {
262 +    return frameData.bBox;
263 +  }
264  
265 +  /** Sets the Bounding Box */  
266 +  void Snapshot::setBoundingBox(const Mat3x3d& m) {
267 +    frameData.bBox = m;
268 +    frameData.invBbox = frameData.bBox.inverse();
269 +    hasBoundingBox = true;
270 +  }
271 +
272 +  /** Returns the inverse Bounding Box */
273 +  Mat3x3d Snapshot::getInvBoundingBox() {
274 +    return frameData.invBbox;
275 +  }
276 +
277 +  RealType Snapshot::getXYarea() {
278 +    if (!hasXYarea) {
279 +      Vector3d x = frameData.hmat.getColumn(0);
280 +      Vector3d y = frameData.hmat.getColumn(1);
281 +      frameData.xyArea = cross(x,y).length();
282 +      hasXYarea = true;
283 +    }
284 +    return frameData.xyArea;
285 +  }
286 +
287 +  RealType Snapshot::getVolume() {
288 +    if (!hasVolume) {
289 +      frameData.volume = frameData.hmat.determinant();
290 +      hasVolume = true;
291 +    }
292 +    return frameData.volume;
293 +  }
294 +
295 +  void Snapshot::setVolume(RealType vol) {
296 +    hasVolume = true;
297 +    frameData.volume = vol;
298 +  }
299 +
300 +  /** Wrap a vector according to periodic boundary conditions */
301    void Snapshot::wrapVector(Vector3d& pos) {
302      
303      Vector3d scaled = scaleVector(pos);
304      
305      for (int i = 0; i < 3; i++)
306        scaled[i] -= roundMe(scaled[i]);
307 <
307 >    
308      if( !frameData.orthoRhombic )
309        pos = frameData.hmat * scaled;    
310      else {
311 <
311 >      
312        // calc the wrapped real coordinates from the wrapped scaled coordinates
313        for (int i=0; i<3; i++) {
314          pos[i] = scaled[i] * frameData.hmat(i, i);
# Line 128 | Line 316 | namespace OpenMD {
316      }
317    }
318  
319 +  /** Scaling a vector to multiples of the periodic box */
320    inline Vector3d Snapshot::scaleVector(Vector3d& pos) {  
321      
322      Vector3d scaled;
# Line 142 | Line 331 | namespace OpenMD {
331  
332      return scaled;
333    }
334 +
335 +  void Snapshot::setCOM(const Vector3d& com) {
336 +    frameData.COM = com;
337 +    hasCOM = true;
338 +  }
339    
340 +  void Snapshot::setCOMvel(const Vector3d& comVel) {
341 +    frameData.COMvel = comVel;
342 +    hasCOMvel = true;
343 +  }
344 +  
345 +  void Snapshot::setCOMw(const Vector3d& comw) {
346 +    frameData.COMw = comw;
347 +    hasCOMw = true;
348 +  }
349 +  
350    Vector3d Snapshot::getCOM() {
147 –    if( !hasCOM_ ) {
148 –      sprintf( painCave.errMsg, "COM was requested before COM was computed!\n");
149 –      painCave.severity = OPENMD_ERROR;
150 –      simError();
151 –    }
351      return frameData.COM;
352    }
353    
354    Vector3d Snapshot::getCOMvel() {
156 –    if( !hasCOM_ ) {
157 –      sprintf( painCave.errMsg, "COMvel was requested before COM was computed!\n");
158 –      painCave.severity = OPENMD_ERROR;
159 –      simError();
160 –    }
355      return frameData.COMvel;
356    }
357    
358    Vector3d Snapshot::getCOMw() {
165 –    if( !hasCOM_ ) {
166 –      sprintf( painCave.errMsg, "COMw was requested before COM was computed!\n");
167 –      painCave.severity = OPENMD_ERROR;
168 –      simError();
169 –    }
359      return frameData.COMw;
360    }
361 < }
361 >  
362 >  RealType Snapshot::getTime() {
363 >    return frameData.currentTime;
364 >  }
365    
366 +  void Snapshot::increaseTime(RealType dt) {
367 +    setTime(getTime() + dt);
368 +  }
369 +  
370 +  void Snapshot::setTime(RealType time) {
371 +    frameData.currentTime = time;
372 +  }
373 +
374 +  void Snapshot::setBondPotential(RealType bp) {
375 +    frameData.bondPotential = bp;
376 +  }
377 +  
378 +  void Snapshot::setBendPotential(RealType bp) {
379 +    frameData.bendPotential = bp;
380 +  }
381 +  
382 +  void Snapshot::setTorsionPotential(RealType tp) {
383 +    frameData.torsionPotential = tp;
384 +  }
385 +  
386 +  void Snapshot::setInversionPotential(RealType ip) {
387 +    frameData.inversionPotential = ip;
388 +  }
389 +
390 +
391 +  RealType Snapshot::getBondPotential() {
392 +    return frameData.bondPotential;
393 +  }
394 +  RealType Snapshot::getBendPotential() {
395 +    return frameData.bendPotential;
396 +  }
397 +  RealType Snapshot::getTorsionPotential() {
398 +    return frameData.torsionPotential;
399 +  }
400 +  RealType Snapshot::getInversionPotential() {
401 +    return frameData.inversionPotential;
402 +  }
403 +
404 +  RealType Snapshot::getShortRangePotential() {
405 +    if (!hasShortRangePotential) {
406 +      frameData.shortRangePotential = frameData.bondPotential;
407 +      frameData.shortRangePotential += frameData.bendPotential;
408 +      frameData.shortRangePotential += frameData.torsionPotential;
409 +      frameData.shortRangePotential += frameData.inversionPotential;
410 +      hasShortRangePotential = true;
411 +    }
412 +    return frameData.shortRangePotential;
413 +  }
414 +
415 +  void Snapshot::setLongRangePotential(potVec lrPot) {
416 +    frameData.lrPotentials = lrPot;
417 +  }
418 +    
419 +  RealType Snapshot::getLongRangePotential() {
420 +    if (!hasLongRangePotential) {
421 +      for (int i = 0; i < N_INTERACTION_FAMILIES; i++) {
422 +        frameData.longRangePotential += frameData.lrPotentials[i];
423 +      }
424 +      hasLongRangePotential = true;
425 +    }  
426 +    return frameData.longRangePotential;
427 +  }
428 +
429 +  potVec Snapshot::getLongRangePotentials() {
430 +    return frameData.lrPotentials;
431 +  }
432 +
433 +  RealType Snapshot::getPotentialEnergy() {
434 +    if (!hasPotentialEnergy) {
435 +      frameData.potentialEnergy = this->getLongRangePotential();
436 +      frameData.potentialEnergy += this->getShortRangePotential();
437 +      hasPotentialEnergy = true;
438 +    }
439 +    return frameData.potentialEnergy;
440 +  }
441 +    
442 +  void Snapshot::setExcludedPotentials(potVec exPot) {
443 +    frameData.excludedPotentials = exPot;
444 +  }
445 +
446 +  potVec Snapshot::getExcludedPotentials() {
447 +    return frameData.excludedPotentials;
448 +  }
449 +      
450 +  void Snapshot::setRestraintPotential(RealType rp) {
451 +    frameData.restraintPotential = rp;
452 +  }
453 +  
454 +  RealType Snapshot::getRestraintPotential() {
455 +    return frameData.restraintPotential;
456 +  }
457 +  
458 +  void Snapshot::setRawPotential(RealType rp) {
459 +    frameData.rawPotential = rp;
460 +  }
461 +  
462 +  RealType Snapshot::getRawPotential() {
463 +    return frameData.rawPotential;
464 +  }
465 +
466 +  RealType Snapshot::getTranslationalKineticEnergy() {
467 +    return frameData.translationalKinetic;
468 +  }
469 +
470 +  RealType Snapshot::getRotationalKineticEnergy() {
471 +    return frameData.rotationalKinetic;
472 +  }
473 +
474 +  RealType Snapshot::getKineticEnergy() {
475 +    return frameData.kineticEnergy;
476 +  }
477 +
478 +  void Snapshot::setTranslationalKineticEnergy(RealType tke) {
479 +    hasTranslationalKineticEnergy = true;
480 +    frameData.translationalKinetic = tke;
481 +  }
482 +
483 +  void Snapshot::setRotationalKineticEnergy(RealType rke) {
484 +    hasRotationalKineticEnergy = true;
485 +    frameData.rotationalKinetic = rke;
486 +  }
487 +
488 +  void Snapshot::setKineticEnergy(RealType ke) {
489 +    hasKineticEnergy = true;
490 +    frameData.kineticEnergy = ke;
491 +  }
492 +
493 +  RealType Snapshot::getTotalEnergy() {
494 +    return frameData.totalEnergy;
495 +  }
496 +
497 +  void Snapshot::setTotalEnergy(RealType te) {
498 +    hasTotalEnergy = true;
499 +    frameData.totalEnergy = te;
500 +  }
501 +
502 +  RealType Snapshot::getConservedQuantity() {
503 +    return frameData.conservedQuantity;
504 +  }
505 +
506 +  void Snapshot::setConservedQuantity(RealType cq) {
507 +    hasConservedQuantity = true;
508 +    frameData.conservedQuantity = cq;
509 +  }
510 +
511 +  RealType Snapshot::getTemperature() {
512 +    return frameData.temperature;
513 +  }
514 +
515 +  void Snapshot::setTemperature(RealType temp) {
516 +    hasTemperature = true;
517 +    frameData.temperature = temp;
518 +  }
519 +
520 +  RealType Snapshot::getElectronicTemperature() {
521 +    return frameData.electronicTemperature;
522 +  }
523 +
524 +  void Snapshot::setElectronicTemperature(RealType eTemp) {
525 +    hasElectronicTemperature = true;
526 +    frameData.electronicTemperature = eTemp;
527 +  }
528 +
529 +  RealType Snapshot::getPressure() {
530 +    return frameData.pressure;
531 +  }
532 +
533 +  void Snapshot::setPressure(RealType pressure) {
534 +    hasPressure = true;
535 +    frameData.pressure = pressure;
536 +  }
537 +
538 +  Mat3x3d Snapshot::getPressureTensor() {
539 +    return frameData.pressureTensor;
540 +  }
541 +
542 +
543 +  void Snapshot::setPressureTensor(const Mat3x3d& pressureTensor) {
544 +    hasPressureTensor = true;
545 +    frameData.pressureTensor = pressureTensor;
546 +  }
547 +
548 +  void Snapshot::setStressTensor(const Mat3x3d& stressTensor) {
549 +    frameData.stressTensor = stressTensor;
550 +  }
551 +
552 +  Mat3x3d  Snapshot::getStressTensor() {
553 +    return frameData.stressTensor;
554 +  }
555 +
556 +  void Snapshot::setConductiveHeatFlux(const Vector3d& chf) {
557 +    frameData.conductiveHeatFlux = chf;
558 +  }
559 +
560 +  Vector3d Snapshot::getConductiveHeatFlux() {
561 +    return frameData.conductiveHeatFlux;
562 +  }
563 +  
564 +  Vector3d Snapshot::getConvectiveHeatFlux() {
565 +    return frameData.convectiveHeatFlux;
566 +  }
567 +
568 +  void Snapshot::setConvectiveHeatFlux(const Vector3d& chf) {    
569 +    hasConvectiveHeatFlux = true;
570 +    frameData.convectiveHeatFlux = chf;
571 +  }
572 +
573 +  Vector3d Snapshot::getHeatFlux() {
574 +    // BE CAREFUL WITH UNITS
575 +    return getConductiveHeatFlux() + getConvectiveHeatFlux();
576 +  }
577 +
578 +  Vector3d Snapshot::getSystemDipole() {
579 +    return frameData.systemDipole;
580 +  }
581 +
582 +  void Snapshot::setSystemDipole(const Vector3d& bd) {    
583 +    hasSystemDipole = true;
584 +    frameData.systemDipole = bd;
585 +  }
586 +
587 +  void Snapshot::setThermostat(const pair<RealType, RealType>& thermostat) {
588 +    frameData.thermostat = thermostat;
589 +  }
590 +
591 +  pair<RealType, RealType> Snapshot::getThermostat() {
592 +    return frameData.thermostat;
593 +  }
594 +
595 +  void Snapshot::setElectronicThermostat(const pair<RealType, RealType>& eTherm) {
596 +    frameData.electronicThermostat = eTherm;
597 +  }
598 +
599 +  pair<RealType, RealType> Snapshot::getElectronicThermostat() {
600 +    return frameData.electronicThermostat;
601 +  }
602 +
603 +  void Snapshot::setBarostat(const Mat3x3d& barostat) {
604 +    frameData.barostat = barostat;
605 +  }
606 +
607 +  Mat3x3d Snapshot::getBarostat() {
608 +    return frameData.barostat;
609 +  }
610 +
611 +  void Snapshot::setInertiaTensor(const Mat3x3d& inertiaTensor) {
612 +    frameData.inertiaTensor = inertiaTensor;
613 +    hasInertiaTensor = true;
614 +  }
615 +
616 +  Mat3x3d Snapshot::getInertiaTensor() {
617 +    return frameData.inertiaTensor;
618 +  }
619 +
620 +  void Snapshot::setGyrationalVolume(const RealType gyrationalVolume) {
621 +    frameData.gyrationalVolume = gyrationalVolume;
622 +    hasGyrationalVolume = true;
623 +  }
624 +
625 +  RealType Snapshot::getGyrationalVolume() {
626 +    return frameData.gyrationalVolume;
627 +  }
628 +
629 +  void Snapshot::setHullVolume(const RealType hullVolume) {
630 +    frameData.hullVolume = hullVolume;
631 +    hasHullVolume = true;
632 +  }
633 +
634 +  RealType Snapshot::getHullVolume() {
635 +    return frameData.hullVolume;
636 +  }
637 +
638 +  void Snapshot::setOrthoTolerance(RealType ot) {
639 +    orthoTolerance_ = ot;
640 +  }
641 + }

Diff Legend

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