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 1465 by chuckv, Fri Jul 9 23:08:25 2010 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).          
39 < * [4]  Vardeman & Gezelter, in progress (2009).                        
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   */
42    
43   /**
44   * @file Snapshot.cpp
45   * @author tlin
46   * @date 11/11/2004
46 – * @time 10:56am
47   * @version 1.0
48   */
49  
# Line 55 | Line 55 | namespace OpenMD {
55  
56   namespace OpenMD {
57  
58 <  void  Snapshot::setHmat(const Mat3x3d& m) {
59 <    hmat_ = m;
60 <    invHmat_ = hmat_.inverse();
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 <    //prepare fortran Hmat
85 <    RealType fortranHmat[9];
86 <    RealType fortranInvHmat[9];
87 <    hmat_.getArray(fortranHmat);
88 <    invHmat_.getArray(fortranInvHmat);
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 +    
203      //determine whether the box is orthoTolerance or not
204 <    int oldOrthoRhombic = orthoRhombic_;
204 >    bool oldOrthoRhombic = frameData.orthoRhombic;
205      
206 <    RealType smallDiag = fabs(hmat_(0, 0));
207 <    if(smallDiag > fabs(hmat_(1, 1))) smallDiag = fabs(hmat_(1, 1));
208 <    if(smallDiag > fabs(hmat_(2, 2))) smallDiag = fabs(hmat_(2, 2));    
206 >    RealType smallDiag = fabs(frameData.hmat(0, 0));
207 >    if(smallDiag > fabs(frameData.hmat(1, 1))) smallDiag = fabs(frameData.hmat(1, 1));
208 >    if(smallDiag > fabs(frameData.hmat(2, 2))) smallDiag = fabs(frameData.hmat(2, 2));    
209      RealType tol = smallDiag * orthoTolerance_;
210  
211 <    orthoRhombic_ = 1;
211 >    frameData.orthoRhombic = true;
212  
213      for (int i = 0; i < 3; i++ ) {
214        for (int j = 0 ; j < 3; j++) {
215          if (i != j) {
216 <          if (orthoRhombic_) {
217 <            if ( fabs(hmat_(i, j)) >= tol)
218 <              orthoRhombic_ = 0;
216 >          if (frameData.orthoRhombic) {
217 >            if ( fabs(frameData.hmat(i, j)) >= tol)
218 >              frameData.orthoRhombic = false;
219            }        
220          }
221        }
222      }
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( oldOrthoRhombic != orthoRhombic_ ){
230 <
231 <      if( orthoRhombic_ ) {
232 <        sprintf( painCave.errMsg,
233 <                 "OpenMD is switching from the default Non-Orthorhombic\n"
234 <                 "\tto the faster Orthorhombic periodic boundary computations.\n"
235 <                 "\tThis is usually a good thing, but if you want the\n"
236 <                 "\tNon-Orthorhombic computations, make the orthoBoxTolerance\n"
237 <                 "\tvariable ( currently set to %G ) smaller.\n",
238 <                 orthoTolerance_);
239 <        painCave.severity = OPENMD_INFO;
240 <        simError();
241 <      }
242 <      else {
243 <        sprintf( painCave.errMsg,
244 <                 "OpenMD is switching from the faster Orthorhombic to the more\n"
245 <                 "\tflexible Non-Orthorhombic periodic boundary computations.\n"
246 <                 "\tThis is usually because the box has deformed under\n"
247 <                 "\tNPTf integration. If you want to live on the edge with\n"
248 <                 "\tthe Orthorhombic computations, make the orthoBoxTolerance\n"
249 <                 "\tvariable ( currently set to %G ) larger.\n",
250 <                 orthoTolerance_);
251 <        painCave.severity = OPENMD_WARNING;
113 <        simError();
114 <      }
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 <    //notify fortran simulation box has changed
261 <    setFortranBox(fortranHmat, fortranInvHmat, &orthoRhombic_);
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 <  void Snapshot::wrapVector(Vector3d& pos) {
272 >  /** Returns the inverse Bounding Box */
273 >  Mat3x3d Snapshot::getInvBoundingBox() {
274 >    return frameData.invBbox;
275 >  }
276  
277 <    int i;
278 <    Vector3d scaled;
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 <    if( !orthoRhombic_ ){
287 >  RealType Snapshot::getVolume() {
288 >    if (!hasVolume) {
289 >      frameData.volume = frameData.hmat.determinant();
290 >      hasVolume = true;
291 >    }
292 >    return frameData.volume;
293 >  }
294  
295 <      // calc the scaled coordinates.
296 <      scaled = invHmat_* pos;
295 >  void Snapshot::setVolume(RealType vol) {
296 >    hasVolume = true;
297 >    frameData.volume = vol;
298 >  }
299  
300 <      // wrap the scaled coordinates
301 <      for (i = 0; i < 3; ++i) {
302 <        scaled[i] -= roundMe(scaled[i]);
303 <      }
304 <
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 >    
308 >    if( !frameData.orthoRhombic )
309 >      pos = frameData.hmat * scaled;    
310 >    else {
311 >      
312        // calc the wrapped real coordinates from the wrapped scaled coordinates
313 <      pos = hmat_ * scaled;    
313 >      for (int i=0; i<3; i++) {
314 >        pos[i] = scaled[i] * frameData.hmat(i, i);
315 >      }  
316 >    }
317 >  }
318  
319 <    } else {//if it is orthoRhombic, we could improve efficiency by only caculating the diagonal element
319 >  /** Scaling a vector to multiples of the periodic box */
320 >  inline Vector3d Snapshot::scaleVector(Vector3d& pos) {  
321      
322 +    Vector3d scaled;
323 +
324 +    if( !frameData.orthoRhombic )
325 +      scaled = frameData.invHmat * pos;
326 +    else {
327        // calc the scaled coordinates.
328 <      for (i=0; i<3; i++) {
329 <        scaled[i] = pos[i] * invHmat_(i, i);
330 <      }
146 <        
147 <      // wrap the scaled coordinates
148 <      for (i = 0; i < 3; ++i) {
149 <        scaled[i] -= roundMe(scaled[i]);
150 <      }
328 >      for (int i=0; i<3; i++)
329 >        scaled[i] = pos[i] * frameData.invHmat(i, i);
330 >    }
331  
332 <      // calc the wrapped real coordinates from the wrapped scaled coordinates
333 <      for (i=0; i<3; i++) {
334 <        pos[i] = scaled[i] * hmat_(i, i);
335 <      }
336 <        
337 <    }
338 <
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 <
344 >  
345 >  void Snapshot::setCOMw(const Vector3d& comw) {
346 >    frameData.COMw = comw;
347 >    hasCOMw = true;
348 >  }
349 >  
350    Vector3d Snapshot::getCOM() {
351 <    if( !hasCOM_ ) {
163 <      sprintf( painCave.errMsg, "COM was requested before COM was computed!\n");
164 <      painCave.severity = OPENMD_ERROR;
165 <      simError();
166 <    }
167 <    return COM_;
351 >    return frameData.COM;
352    }
353    
354    Vector3d Snapshot::getCOMvel() {
355 <    if( !hasCOM_ ) {
172 <      sprintf( painCave.errMsg, "COMvel was requested before COM was computed!\n");
173 <      painCave.severity = OPENMD_ERROR;
174 <      simError();
175 <    }
176 <    return COMvel_;
355 >    return frameData.COMvel;
356    }
357    
358    Vector3d Snapshot::getCOMw() {
359 <    if( !hasCOM_ ) {
360 <      sprintf( painCave.errMsg, "COMw was requested before COM was computed!\n");
361 <      painCave.severity = OPENMD_ERROR;
362 <      simError();
359 >    return frameData.COMw;
360 >  }
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 COMw_;
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   }
189 –  

Diff Legend

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