ViewVC Help

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

root/OpenMD/trunk/src/brains/DataStorage.cpp

Comparing trunk/src/brains/DataStorage.cpp (file contents):
Revision 507 by gezelter, Fri Apr 15 22:04:00 2005 UTC vs.
Revision 1793 by gezelter, Fri Aug 31 21:16:10 2012 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]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40	+	* [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41		*/
42
43		/**
#	Line 48 | Line 49
49		*/
50
51		#include "brains/DataStorage.hpp"
52	+	using namespace std;
53	+	namespace OpenMD {
54
52	–	namespace oopse {
53	–
55		DataStorage::DataStorage() : size_(0), storageLayout_(0){
56
57		}
#	Line 64 | Line 65 | namespace oopse {
65
66		if (storageLayout_ & dslPosition && position.size() != size_) {
67		//error
68	<	std::cerr << "size does not match"<< std::endl;
68	>	cerr << "size does not match"<< endl;
69		}
70
71		if (storageLayout_ & dslVelocity && velocity.size() != size_) {
72		//error
73	<	std::cerr << "size does not match"<< std::endl;
73	>	cerr << "size does not match"<< endl;
74		}
75
76		if (storageLayout_ & dslAmat && aMat.size() != size_) {
77		//error
78	<	std::cerr << "size does not match"<< std::endl;
78	>	cerr << "size does not match"<< endl;
79		}
80
81		if (storageLayout_ & dslAngularMomentum && angularMomentum.size() != size_) {
82		//error
83	<	std::cerr << "size does not match"<< std::endl;
83	>	cerr << "size does not match"<< endl;
84		}
85
86		if (storageLayout_ & dslElectroFrame && electroFrame.size() != size_) {
87		//error
88	<	std::cerr << "size does not match"<< std::endl;
88	>	cerr << "size does not match"<< endl;
89		}
90
91	<	if (storageLayout_ & dslZAngle && zAngle.size() != size_) {
91	>	if (storageLayout_ & dslForce && force.size() != size_) {
92		//error
93	<	std::cerr << "size does not match"<< std::endl;
93	>	cerr << "size does not match"<< endl;
94		}
95
96	<	if (storageLayout_ & dslForce && force.size() != size_) {
96	>	if (storageLayout_ & dslTorque && torque.size() != size_) {
97		//error
98	<	std::cerr << "size does not match"<< std::endl;
98	>	cerr << "size does not match"<< endl;
99		}
100
101	<	if (storageLayout_ & dslTorque && torque.size() != size_) {
101	>	if (storageLayout_ & dslParticlePot && particlePot.size() != size_) {
102		//error
103	<	std::cerr << "size does not match"<< std::endl;
103	>	cerr << "size does not match"<< endl;
104		}
105
106	+	if (storageLayout_ & dslDensity && density.size() != size_) {
107	+	//error
108	+	cerr << "size does not match"<< endl;
109	+	}
110	+
111	+	if (storageLayout_ & dslFunctional && functional.size() != size_) {
112	+	//error
113	+	cerr << "size does not match"<< endl;
114	+	}
115	+
116	+	if (storageLayout_ & dslFunctionalDerivative && functionalDerivative.size() != size_) {
117	+	//error
118	+	cerr << "size does not match"<< endl;
119	+	}
120	+
121	+	if (storageLayout_ & dslElectricField && electricField.size() != size_) {
122	+	//error
123	+	cerr << "size does not match"<< endl;
124	+	}
125	+
126	+	if (storageLayout_ & dslSkippedCharge && skippedCharge.size() != size_) {
127	+	//error
128	+	cerr << "size does not match"<< endl;
129	+	}
130	+
131	+	if (storageLayout_ & dslFlucQPosition && flucQPos.size() != size_) {
132	+	//error
133	+	cerr << "size does not match"<< endl;
134	+	}
135	+
136	+	if (storageLayout_ & dslFlucQVelocity && flucQVel.size() != size_) {
137	+	//error
138	+	cerr << "size does not match"<< endl;
139	+	}
140	+
141	+	if (storageLayout_ & dslFlucQForce && flucQFrc.size() != size_) {
142	+	//error
143	+	cerr << "size does not match"<< endl;
144	+	}
145	+
146		return size_;
147
148		}
#	Line 128 | Line 169 | namespace oopse {
169		internalResize(electroFrame, newSize);
170		}
171
131	–	if (storageLayout_ & dslZAngle) {
132	–	internalResize(zAngle, newSize);
133	–	}
134	–
172		if (storageLayout_ & dslForce) {
173		internalResize(force, newSize);
174		}
#	Line 140 | Line 177 | namespace oopse {
177		internalResize(torque, newSize);
178		}
179
180	+	if (storageLayout_ & dslParticlePot) {
181	+	internalResize(particlePot, newSize);
182	+	}
183	+
184	+	if (storageLayout_ & dslDensity) {
185	+	internalResize(density, newSize);
186	+	}
187	+
188	+	if (storageLayout_ & dslFunctional) {
189	+	internalResize(functional, newSize);
190	+	}
191	+
192	+	if (storageLayout_ & dslFunctionalDerivative) {
193	+	internalResize(functionalDerivative, newSize);
194	+	}
195	+
196	+	if (storageLayout_ & dslElectricField) {
197	+	internalResize(electricField, newSize);
198	+	}
199	+
200	+	if (storageLayout_ & dslSkippedCharge) {
201	+	internalResize(skippedCharge, newSize);
202	+	}
203	+
204	+	if (storageLayout_ & dslFlucQPosition) {
205	+	internalResize(flucQPos, newSize);
206	+	}
207	+
208	+	if (storageLayout_ & dslFlucQVelocity) {
209	+	internalResize(flucQVel, newSize);
210	+	}
211	+
212	+	if (storageLayout_ & dslFlucQForce) {
213	+	internalResize(flucQFrc, newSize);
214	+	}
215	+
216		size_ = newSize;
217		}
218
#	Line 164 | Line 237 | namespace oopse {
237		electroFrame.reserve(size);
238		}
239
167	–	if (storageLayout_ & dslZAngle) {
168	–	zAngle.reserve(size);
169	–	}
170	–
240		if (storageLayout_ & dslForce) {
241		force.reserve(size);
242		}
243
244		if (storageLayout_ & dslTorque) {
245		torque.reserve(size);
246	+	}
247	+
248	+	if (storageLayout_ & dslParticlePot) {
249	+	particlePot.reserve(size);
250	+	}
251	+
252	+	if (storageLayout_ & dslDensity) {
253	+	density.reserve(size);
254	+	}
255	+
256	+	if (storageLayout_ & dslFunctional) {
257	+	functional.reserve(size);
258	+	}
259	+
260	+	if (storageLayout_ & dslFunctionalDerivative) {
261	+	functionalDerivative.reserve(size);
262		}
263
264	+	if (storageLayout_ & dslElectricField) {
265	+	electricField.reserve(size);
266	+	}
267	+
268	+	if (storageLayout_ & dslSkippedCharge) {
269	+	skippedCharge.reserve(size);
270	+	}
271	+
272	+	if (storageLayout_ & dslFlucQPosition) {
273	+	flucQPos.reserve(size);
274	+	}
275	+
276	+	if (storageLayout_ & dslFlucQVelocity) {
277	+	flucQVel.reserve(size);
278	+	}
279	+
280	+	if (storageLayout_ & dslFlucQForce) {
281	+	flucQFrc.reserve(size);
282	+	}
283		}
284
285		void DataStorage::copy(int source, int num, int target) {
#	Line 203 | Line 307 | namespace oopse {
307		internalCopy(electroFrame, source, num, target);
308		}
309
206	–	if (storageLayout_ & dslZAngle) {
207	–	internalCopy(zAngle, source, num, target);
208	–	}
209	–
310		if (storageLayout_ & dslForce) {
311		internalCopy(force, source, num, target);
312		}
#	Line 214 | Line 314 | namespace oopse {
314		if (storageLayout_ & dslTorque) {
315		internalCopy(torque, source, num, target);
316		}
217	–
317
318	+	if (storageLayout_ & dslParticlePot) {
319	+	internalCopy(particlePot, source, num, target);
320	+	}
321	+
322	+	if (storageLayout_ & dslDensity) {
323	+	internalCopy(density, source, num, target);
324	+	}
325	+
326	+	if (storageLayout_ & dslFunctional) {
327	+	internalCopy(functional, source, num, target);
328	+	}
329	+
330	+	if (storageLayout_ & dslFunctionalDerivative) {
331	+	internalCopy(functionalDerivative, source, num, target);
332	+	}
333	+
334	+	if (storageLayout_ & dslElectricField) {
335	+	internalCopy(electricField, source, num, target);
336	+	}
337	+
338	+	if (storageLayout_ & dslSkippedCharge) {
339	+	internalCopy(skippedCharge, source, num, target);
340	+	}
341	+
342	+	if (storageLayout_ & dslFlucQPosition) {
343	+	internalCopy(flucQPos, source, num, target);
344	+	}
345	+
346	+	if (storageLayout_ & dslFlucQVelocity) {
347	+	internalCopy(flucQVel, source, num, target);
348	+	}
349	+	if (storageLayout_ & dslFlucQForce) {
350	+	internalCopy(flucQFrc, source, num, target);
351	+	}
352		}
353
354		int DataStorage::getStorageLayout() {
#	Line 227 | Line 360 | namespace oopse {
360		resize(size_);
361		}
362
363	<	double* DataStorage::getArrayPointer(int whichArray) {
363	>	RealType* DataStorage::getArrayPointer(int whichArray) {
364
365		switch (whichArray) {
366		case dslPosition:
367		return internalGetArrayPointer(position);
235	–	break;
368
369		case dslVelocity:
370		return internalGetArrayPointer(velocity);
239	–	break;
371
372		case dslAmat:
373		return internalGetArrayPointer(aMat);
243	–	break;
374
375		case dslAngularMomentum:
376		return internalGetArrayPointer(angularMomentum);
247	–	break;
377
378		case dslElectroFrame:
379		return internalGetArrayPointer(electroFrame);
251	–	break;
380
253	–	case dslZAngle:
254	–	return internalGetArrayPointer(zAngle);
255	–	break;
256	–
381		case dslForce:
382		return internalGetArrayPointer(force);
259	–	break;
383
384		case dslTorque:
385		return internalGetArrayPointer(torque);
386	<	break;
387	<
386	>
387	>	case dslParticlePot:
388	>	return internalGetArrayPointer(particlePot);
389	>
390	>	case dslDensity:
391	>	return internalGetArrayPointer(density);
392	>
393	>	case dslFunctional:
394	>	return internalGetArrayPointer(functional);
395	>
396	>	case dslFunctionalDerivative:
397	>	return internalGetArrayPointer(functionalDerivative);
398	>
399	>	case dslElectricField:
400	>	return internalGetArrayPointer(electricField);
401	>
402	>	case dslSkippedCharge:
403	>	return internalGetArrayPointer(skippedCharge);
404	>
405	>	case dslFlucQPosition:
406	>	return internalGetArrayPointer(flucQPos);
407	>
408	>	case dslFlucQVelocity:
409	>	return internalGetArrayPointer(flucQVel);
410	>
411	>	case dslFlucQForce:
412	>	return internalGetArrayPointer(flucQFrc);
413	>
414		default:
415		//error message
416		return NULL;
#	Line 269 | Line 418 | namespace oopse {
418		}
419		}
420
421	<	double* DataStorage::internalGetArrayPointer(std::vector<Vector3d>& v) {
421	>	RealType* DataStorage::internalGetArrayPointer(std::vector<Vector3d>& v) {
422		if (v.size() == 0) {
423		return NULL;
424		} else {
#	Line 277 | Line 426 | namespace oopse {
426		}
427		}
428
429	<	double* DataStorage::internalGetArrayPointer(std::vector<RotMat3x3d>& v) {
429	>	RealType* DataStorage::internalGetArrayPointer(std::vector<RotMat3x3d>& v) {
430		if (v.size() == 0) {
431		return NULL;
432		} else {
#	Line 286 | Line 435 | namespace oopse {
435
436		}
437
438	<	double* DataStorage::internalGetArrayPointer(std::vector<double>& v) {
438	>	RealType* DataStorage::internalGetArrayPointer(std::vector<RealType>& v) {
439		if (v.size() == 0) {
440		return NULL;
441		} else {
#	Line 338 | Line 487 | namespace oopse {
487		bytes += sizeof(Vector3d);
488		}
489		if (layout & dslAmat) {
490	<	bytes += sizeof(Mat3x3d);
490	>	bytes += sizeof(RotMat3x3d);
491		}
492		if (layout & dslAngularMomentum) {
493		bytes += sizeof(Vector3d);
#	Line 346 | Line 495 | namespace oopse {
495		if (layout & dslElectroFrame) {
496		bytes += sizeof(Mat3x3d);
497		}
349	–	if (layout & dslZAngle) {
350	–	bytes += sizeof(Vector3d);
351	–	}
498		if (layout & dslForce) {
499		bytes += sizeof(Vector3d);
500		}
501		if (layout & dslTorque) {
502		bytes += sizeof(Vector3d);
503		}
504	+	if (layout & dslParticlePot) {
505	+	bytes += sizeof(RealType);
506	+	}
507	+	if (layout & dslDensity) {
508	+	bytes += sizeof(RealType);
509	+	}
510	+	if (layout & dslFunctional) {
511	+	bytes += sizeof(RealType);
512	+	}
513	+	if (layout & dslFunctionalDerivative) {
514	+	bytes += sizeof(RealType);
515	+	}
516	+	if (layout & dslElectricField) {
517	+	bytes += sizeof(Vector3d);
518	+	}
519	+	if (layout & dslSkippedCharge) {
520	+	bytes += sizeof(RealType);
521	+	}
522	+	if (layout & dslFlucQPosition) {
523	+	bytes += sizeof(RealType);
524	+	}
525	+	if (layout & dslFlucQVelocity) {
526	+	bytes += sizeof(RealType);
527	+	}
528	+	if (layout & dslFlucQForce) {
529	+	bytes += sizeof(RealType);
530	+	}
531	+
532		return bytes;
533		}
534

Comparing trunk/src/brains/DataStorage.cpp (property svn:keywords):
Revision 507 by gezelter, Fri Apr 15 22:04:00 2005 UTC vs.
Revision 1793 by gezelter, Fri Aug 31 21:16:10 2012 UTC

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

Diff Legend

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