ViewVC Help

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

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

Comparing:
trunk/src/brains/DataStorage.cpp (file contents), Revision 331 by tim, Sun Feb 13 21:18:27 2005 UTC vs.
branches/development/src/brains/DataStorage.cpp (file contents), Revision 1584 by gezelter, Fri Jun 17 20:16:35 2011 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]  Vardeman & Gezelter, in progress (2009).
40		*/
41
42	<	/**
43	<	* @file DataStorage.cpp
44	<	* @author tlin
45	<	* @date 10/26/2004
46	<	* @time 11:56am
47	<	* @version 1.0
48	<	*/
42	>	/**
43	>	* @file DataStorage.cpp
44	>	* @author tlin
45	>	* @date 10/26/2004
46	>	* @time 11:56am
47	>	* @version 1.0
48	>	*/
49
50		#include "brains/DataStorage.hpp"
51
52	<	namespace oopse {
52	>	namespace OpenMD {
53
54	<	DataStorage::DataStorage() : size_(0), storageLayout_(0){
54	>	DataStorage::DataStorage() : size_(0), storageLayout_(0){
55
56	<	}
56	>	}
57
58	<	DataStorage::DataStorage(int size, int storageLayout) : size_(size){
58	>	DataStorage::DataStorage(int size, int storageLayout) : size_(size){
59		setStorageLayout(storageLayout);
60		resize(size);
61	<	}
61	>	}
62
63	<	int DataStorage::getSize() {
63	>	int DataStorage::getSize() {
64
65		if (storageLayout_ & dslPosition && position.size() != size_) {
66	<	//error
67	<	std::cerr << "size does not match"<< std::endl;
66	>	//error
67	>	std::cerr << "size does not match"<< std::endl;
68		}
69
70		if (storageLayout_ & dslVelocity && velocity.size() != size_) {
71	<	//error
72	<	std::cerr << "size does not match"<< std::endl;
71	>	//error
72	>	std::cerr << "size does not match"<< std::endl;
73		}
74
75		if (storageLayout_ & dslAmat && aMat.size() != size_) {
76	<	//error
77	<	std::cerr << "size does not match"<< std::endl;
76	>	//error
77	>	std::cerr << "size does not match"<< std::endl;
78		}
79
80		if (storageLayout_ & dslAngularMomentum && angularMomentum.size() != size_) {
81	<	//error
82	<	std::cerr << "size does not match"<< std::endl;
81	>	//error
82	>	std::cerr << "size does not match"<< std::endl;
83		}
84
85		if (storageLayout_ & dslElectroFrame && electroFrame.size() != size_) {
86	<	//error
87	<	std::cerr << "size does not match"<< std::endl;
86	>	//error
87	>	std::cerr << "size does not match"<< std::endl;
88		}
89
90		if (storageLayout_ & dslZAngle && zAngle.size() != size_) {
91	<	//error
92	<	std::cerr << "size does not match"<< std::endl;
91	>	//error
92	>	std::cerr << "size does not match"<< std::endl;
93		}
94
95		if (storageLayout_ & dslForce && force.size() != size_) {
96	<	//error
97	<	std::cerr << "size does not match"<< std::endl;
96	>	//error
97	>	std::cerr << "size does not match"<< std::endl;
98		}
99
100		if (storageLayout_ & dslTorque && torque.size() != size_) {
101	<	//error
102	<	std::cerr << "size does not match"<< std::endl;
101	>	//error
102	>	std::cerr << "size does not match"<< std::endl;
103		}
104
105	+	if (storageLayout_ & dslParticlePot && particlePot.size() != size_) {
106	+	//error
107	+	std::cerr << "size does not match"<< std::endl;
108	+	}
109	+
110	+	if (storageLayout_ & dslDensity && density.size() != size_) {
111	+	//error
112	+	std::cerr << "size does not match"<< std::endl;
113	+	}
114	+
115	+	if (storageLayout_ & dslFunctional && functional.size() != size_) {
116	+	//error
117	+	std::cerr << "size does not match"<< std::endl;
118	+	}
119	+
120	+	if (storageLayout_ & dslFunctionalDerivative && functionalDerivative.size() != size_) {
121	+	//error
122	+	std::cerr << "size does not match"<< std::endl;
123	+	}
124	+
125	+	if (storageLayout_ & dslElectricField && electricField.size() != size_) {
126	+	//error
127	+	std::cerr << "size does not match"<< std::endl;
128	+	}
129	+
130	+	if (storageLayout_ & dslSkippedCharge && skippedCharge.size() != size_) {
131	+	//error
132	+	std::cerr << "size does not match"<< std::endl;
133	+	}
134	+
135		return size_;
136
137	<	}
137	>	}
138
139	<	void DataStorage::resize(int newSize) {
139	>	void DataStorage::resize(int newSize) {
140
141		if (storageLayout_ & dslPosition) {
142	<	internalResize(position, newSize);
142	>	internalResize(position, newSize);
143		}
144
145		if (storageLayout_ & dslVelocity) {
146	<	internalResize(velocity, newSize);
146	>	internalResize(velocity, newSize);
147		}
148
149		if (storageLayout_ & dslAmat) {
150	<	internalResize(aMat, newSize);
150	>	internalResize(aMat, newSize);
151		}
152
153		if (storageLayout_ & dslAngularMomentum) {
154	<	internalResize(angularMomentum, newSize);
154	>	internalResize(angularMomentum, newSize);
155		}
156
157		if (storageLayout_ & dslElectroFrame) {
158	<	internalResize(electroFrame, newSize);
158	>	internalResize(electroFrame, newSize);
159		}
160
161		if (storageLayout_ & dslZAngle) {
162	<	internalResize(zAngle, newSize);
162	>	internalResize(zAngle, newSize);
163		}
164
165		if (storageLayout_ & dslForce) {
166	<	internalResize(force, newSize);
166	>	internalResize(force, newSize);
167		}
168
169		if (storageLayout_ & dslTorque) {
170	<	internalResize(torque, newSize);
170	>	internalResize(torque, newSize);
171		}
172
173	<	size_ = newSize;
174	<	}
175	<
176	<	void DataStorage::reserve(int size) {
173	>	if (storageLayout_ & dslParticlePot) {
174	>	internalResize(particlePot, newSize);
175	>	}
176	>
177	>	if (storageLayout_ & dslDensity) {
178	>	internalResize(density, newSize);
179	>	}
180	>
181	>	if (storageLayout_ & dslFunctional) {
182	>	internalResize(functional, newSize);
183	>	}
184	>
185	>	if (storageLayout_ & dslFunctionalDerivative) {
186	>	internalResize(functionalDerivative, newSize);
187	>	}
188	>
189	>	if (storageLayout_ & dslElectricField) {
190	>	internalResize(electricField, newSize);
191	>	}
192	>
193	>	if (storageLayout_ & dslSkippedCharge) {
194	>	internalResize(skippedCharge, newSize);
195	>	}
196	>
197	>	size_ = newSize;
198	>	}
199	>
200	>	void DataStorage::reserve(int size) {
201		if (storageLayout_ & dslPosition) {
202	<	position.reserve(size);
202	>	position.reserve(size);
203		}
204
205		if (storageLayout_ & dslVelocity) {
206	<	velocity.reserve(size);
206	>	velocity.reserve(size);
207		}
208
209		if (storageLayout_ & dslAmat) {
210	<	aMat.reserve(size);
210	>	aMat.reserve(size);
211		}
212
213		if (storageLayout_ & dslAngularMomentum) {
214	<	angularMomentum.reserve(size);
214	>	angularMomentum.reserve(size);
215		}
216
217		if (storageLayout_ & dslElectroFrame) {
218	<	electroFrame.reserve(size);
218	>	electroFrame.reserve(size);
219		}
220
221		if (storageLayout_ & dslZAngle) {
222	<	zAngle.reserve(size);
222	>	zAngle.reserve(size);
223		}
224
225		if (storageLayout_ & dslForce) {
226	<	force.reserve(size);
226	>	force.reserve(size);
227		}
228
229		if (storageLayout_ & dslTorque) {
230	<	torque.reserve(size);
230	>	torque.reserve(size);
231		}
232	+
233	+	if (storageLayout_ & dslParticlePot) {
234	+	particlePot.reserve(size);
235	+	}
236
237	<	}
237	>	if (storageLayout_ & dslDensity) {
238	>	density.reserve(size);
239	>	}
240
241	<	void DataStorage::copy(int source, int num, int target) {
241	>	if (storageLayout_ & dslFunctional) {
242	>	functional.reserve(size);
243	>	}
244	>
245	>	if (storageLayout_ & dslFunctionalDerivative) {
246	>	functionalDerivative.reserve(size);
247	>	}
248	>
249	>	if (storageLayout_ & dslElectricField) {
250	>	electricField.reserve(size);
251	>	}
252	>
253	>	if (storageLayout_ & dslSkippedCharge) {
254	>	skippedCharge.reserve(size);
255	>	}
256	>
257	>	}
258	>
259	>	void DataStorage::copy(int source, int num, int target) {
260		if (num + target > size_ ) {
261	<	//error
261	>	//error
262		}
263
264		if (storageLayout_ & dslPosition) {
265	<	internalCopy(position, source, num, target);
265	>	internalCopy(position, source, num, target);
266		}
267
268		if (storageLayout_ & dslVelocity) {
269	<	internalCopy(velocity, source, num, target);
270	<	}
269	>	internalCopy(velocity, source, num, target);
270	>	}
271
272		if (storageLayout_ & dslAmat) {
273	<	internalCopy(aMat, source, num, target);
274	<	}
273	>	internalCopy(aMat, source, num, target);
274	>	}
275
276		if (storageLayout_ & dslAngularMomentum) {
277	<	internalCopy(angularMomentum, source, num, target);
277	>	internalCopy(angularMomentum, source, num, target);
278		}
279
280		if (storageLayout_ & dslElectroFrame) {
281	<	internalCopy(electroFrame, source, num, target);
281	>	internalCopy(electroFrame, source, num, target);
282		}
283
284		if (storageLayout_ & dslZAngle) {
285	<	internalCopy(zAngle, source, num, target);
285	>	internalCopy(zAngle, source, num, target);
286		}
287
288		if (storageLayout_ & dslForce) {
289	<	internalCopy(force, source, num, target);
289	>	internalCopy(force, source, num, target);
290		}
291
292		if (storageLayout_ & dslTorque) {
293	<	internalCopy(torque, source, num, target);
293	>	internalCopy(torque, source, num, target);
294		}
217	–
295
296	<	}
296	>	if (storageLayout_ & dslParticlePot) {
297	>	internalCopy(particlePot, source, num, target);
298	>	}
299
300	<	int DataStorage::getStorageLayout() {
300	>	if (storageLayout_ & dslDensity) {
301	>	internalCopy(density, source, num, target);
302	>	}
303	>
304	>	if (storageLayout_ & dslFunctional) {
305	>	internalCopy(functional, source, num, target);
306	>	}
307	>
308	>	if (storageLayout_ & dslFunctionalDerivative) {
309	>	internalCopy(functionalDerivative, source, num, target);
310	>	}
311	>
312	>	if (storageLayout_ & dslElectricField) {
313	>	internalCopy(electricField, source, num, target);
314	>	}
315	>
316	>	if (storageLayout_ & dslSkippedCharge) {
317	>	internalCopy(skippedCharge, source, num, target);
318	>	}
319	>	}
320	>
321	>	int DataStorage::getStorageLayout() {
322		return storageLayout_;
323	<	}
323	>	}
324
325	<	void DataStorage::setStorageLayout(int layout) {
325	>	void DataStorage::setStorageLayout(int layout) {
326		storageLayout_ = layout;
327		resize(size_);
328	<	}
328	>	}
329
330	<	double* DataStorage::getArrayPointer(int whichArray) {
330	>	RealType* DataStorage::getArrayPointer(int whichArray) {
331
332		switch (whichArray) {
333	<	case dslPosition:
334	<	return internalGetArrayPointer(position);
335	<	break;
333	>	case dslPosition:
334	>	return internalGetArrayPointer(position);
335	>	break;
336
337	<	case dslVelocity:
338	<	return internalGetArrayPointer(velocity);
339	<	break;
337	>	case dslVelocity:
338	>	return internalGetArrayPointer(velocity);
339	>	break;
340
341	<	case dslAmat:
342	<	return internalGetArrayPointer(aMat);
343	<	break;
341	>	case dslAmat:
342	>	return internalGetArrayPointer(aMat);
343	>	break;
344
345	<	case dslAngularMomentum:
346	<	return internalGetArrayPointer(angularMomentum);
347	<	break;
345	>	case dslAngularMomentum:
346	>	return internalGetArrayPointer(angularMomentum);
347	>	break;
348
349	<	case dslElectroFrame:
350	<	return internalGetArrayPointer(electroFrame);
351	<	break;
349	>	case dslElectroFrame:
350	>	return internalGetArrayPointer(electroFrame);
351	>	break;
352
353	<	case dslZAngle:
354	<	return internalGetArrayPointer(zAngle);
355	<	break;
353	>	case dslZAngle:
354	>	return internalGetArrayPointer(zAngle);
355	>	break;
356
357	<	case dslForce:
358	<	return internalGetArrayPointer(force);
359	<	break;
357	>	case dslForce:
358	>	return internalGetArrayPointer(force);
359	>	break;
360
361	<	case dslTorque:
362	<	return internalGetArrayPointer(torque);
363	<	break;
264	<
265	<	default:
266	<	//error message
267	<	return NULL;
361	>	case dslTorque:
362	>	return internalGetArrayPointer(torque);
363	>	break;
364
365	+	case dslParticlePot:
366	+	return internalGetArrayPointer(particlePot);
367	+	break;
368	+
369	+	case dslDensity:
370	+	return internalGetArrayPointer(density);
371	+	break;
372	+
373	+	case dslFunctional:
374	+	return internalGetArrayPointer(functional);
375	+	break;
376	+
377	+	case dslFunctionalDerivative:
378	+	return internalGetArrayPointer(functionalDerivative);
379	+	break;
380	+
381	+	case dslElectricField:
382	+	return internalGetArrayPointer(electricField);
383	+	break;
384	+
385	+	case dslSkippedCharge:
386	+	return internalGetArrayPointer(skippedCharge);
387	+	break;
388	+
389	+	default:
390	+	//error message
391	+	return NULL;
392	+
393		}
394	<	}
394	>	}
395
396	<	double* DataStorage::internalGetArrayPointer(std::vector<Vector3d>& v) {
396	>	RealType* DataStorage::internalGetArrayPointer(std::vector<Vector3d>& v) {
397		if (v.size() == 0) {
398	<	return NULL;
398	>	return NULL;
399		} else {
400	<	return v[0].getArrayPointer();
400	>	return v[0].getArrayPointer();
401		}
402	<	}
402	>	}
403
404	<	double* DataStorage::internalGetArrayPointer(std::vector<RotMat3x3d>& v) {
404	>	RealType* DataStorage::internalGetArrayPointer(std::vector<RotMat3x3d>& v) {
405		if (v.size() == 0) {
406	<	return NULL;
406	>	return NULL;
407		} else {
408	<	return v[0].getArrayPointer();
408	>	return v[0].getArrayPointer();
409		}
410
411	<	}
411	>	}
412
413	<	double* DataStorage::internalGetArrayPointer(std::vector<double>& v) {
413	>	RealType* DataStorage::internalGetArrayPointer(std::vector<RealType>& v) {
414		if (v.size() == 0) {
415	<	return NULL;
415	>	return NULL;
416		} else {
417	<	return &(v[0]);
417	>	return &(v[0]);
418		}
419
420	<	}
420	>	}
421
422	<	template<typename T>
423	<	void DataStorage::internalResize(std::vector<T>& v, int newSize){
422	>	template<typename T>
423	>	void DataStorage::internalResize(std::vector<T>& v, int newSize){
424		int oldSize = v.size();
425
426		if (oldSize == newSize) {
427	<	return;
427	>	return;
428		} else if (oldSize < newSize) {
429	<	v.insert(v.end(), newSize-oldSize, T());
429	>	v.insert(v.end(), newSize-oldSize, T());
430		} else {
431	<	typename std::vector<T>::iterator i;
432	<	i = v.begin();
433	<	std::advance(i, newSize);
434	<	v.erase(i, v.end());
431	>	typename std::vector<T>::iterator i;
432	>	i = v.begin();
433	>	std::advance(i, newSize);
434	>	v.erase(i, v.end());
435		}
436	<	}
436	>	}
437
438	<	template<typename T>
439	<	void DataStorage::internalCopy(std::vector<T>& v, int source,  int num, int target) {
438	>	template<typename T>
439	>	void DataStorage::internalCopy(std::vector<T>& v, int source,  int num, int target) {
440		typename std::vector<T>::iterator first;
441		typename std::vector<T>::iterator last;
442		typename std::vector<T>::iterator result;
#	Line 327 | Line 451 | void DataStorage::internalCopy(std::vector<T>& v, int
451		std::advance(result, target );
452
453		std::copy(first, last, result);
454	<	}
454	>	}
455
456	<	int DataStorage::getBytesPerStuntDouble(int layout) {
456	>	int DataStorage::getBytesPerStuntDouble(int layout) {
457		int bytes = 0;
458		if (layout & dslPosition) {
459	<	bytes += sizeof(Vector3d);
459	>	bytes += sizeof(Vector3d);
460		}
461		if (layout & dslVelocity) {
462	<	bytes += sizeof(Vector3d);
462	>	bytes += sizeof(Vector3d);
463		}
464		if (layout & dslAmat) {
465	<	bytes += sizeof(Mat3x3d);
465	>	bytes += sizeof(RotMat3x3d);
466		}
467		if (layout & dslAngularMomentum) {
468	<	bytes += sizeof(Vector3d);
468	>	bytes += sizeof(Vector3d);
469		}
470		if (layout & dslElectroFrame) {
471	<	bytes += sizeof(Mat3x3d);
471	>	bytes += sizeof(Mat3x3d);
472		}
473		if (layout & dslZAngle) {
474	<	bytes += sizeof(Vector3d);
474	>	bytes += sizeof(RealType);
475		}
476		if (layout & dslForce) {
477	<	bytes += sizeof(Vector3d);
477	>	bytes += sizeof(Vector3d);
478		}
479		if (layout & dslTorque) {
480	<	bytes += sizeof(Vector3d);
480	>	bytes += sizeof(Vector3d);
481		}
482	+	if (layout & dslParticlePot) {
483	+	bytes += sizeof(RealType);
484	+	}
485	+	if (layout & dslDensity) {
486	+	bytes += sizeof(RealType);
487	+	}
488	+	if (layout & dslFunctional) {
489	+	bytes += sizeof(RealType);
490	+	}
491	+	if (layout & dslFunctionalDerivative) {
492	+	bytes += sizeof(RealType);
493	+	}
494	+	if (layout & dslElectricField) {
495	+	bytes += sizeof(Vector3d);
496	+	}
497	+	if (layout & dslSkippedCharge) {
498	+	bytes += sizeof(RealType);
499	+	}
500	+
501		return bytes;
502	<	}
502	>	}
503
504		}

Comparing:
trunk/src/brains/DataStorage.cpp (property svn:keywords), Revision 331 by tim, Sun Feb 13 21:18:27 2005 UTC vs.
branches/development/src/brains/DataStorage.cpp (property svn:keywords), Revision 1584 by gezelter, Fri Jun 17 20:16:35 2011 UTC

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

Diff Legend

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