ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/branches/development/src/brains/Snapshot.cpp

Comparing:
trunk/src/brains/Snapshot.cpp (file contents), Revision 246 by gezelter, Wed Jan 12 22:41:40 2005 UTC vs.
branches/development/src/brains/Snapshot.cpp (file contents), Revision 1774 by gezelter, Wed Aug 8 16:03:02 2012 UTC

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

Comparing:
trunk/src/brains/Snapshot.cpp (property svn:keywords), Revision 246 by gezelter, Wed Jan 12 22:41:40 2005 UTC vs.
branches/development/src/brains/Snapshot.cpp (property svn:keywords), Revision 1774 by gezelter, Wed Aug 8 16:03:02 2012 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

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