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 155 by tim, Tue Oct 26 22:19:22 2004 UTC vs.
branches/development/src/brains/DataStorage.cpp (file contents), Revision 1665 by gezelter, Tue Nov 22 20:38:56 2011 UTC

#	Line 1 | Line 1
1		/*
2	<	* Copyright (C) 2000-2004  Object Oriented Parallel Simulation Engine (OOPSE) project
3	<	*
4	<	* Contact: oopse@oopse.org
5	<	*
6	<	* This program is free software; you can redistribute it and/or
7	<	* modify it under the terms of the GNU Lesser General Public License
8	<	* as published by the Free Software Foundation; either version 2.1
9	<	* of the License, or (at your option) any later version.
10	<	* All we ask is that proper credit is given for our work, which includes
11	<	* - but is not limited to - adding the above copyright notice to the beginning
12	<	* of your source code files, and to any copyright notice that you may distribute
13	<	* with programs based on this work.
14	<	*
15	<	* This program is distributed in the hope that it will be useful,
16	<	* but WITHOUT ANY WARRANTY; without even the implied warranty of
17	<	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18	<	* GNU Lesser General Public License for more details.
19	<	*
20	<	* You should have received a copy of the GNU Lesser General Public License
21	<	* along with this program; if not, write to the Free Software
22	<	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
2	>	* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3		*
4	+	* The University of Notre Dame grants you ("Licensee") a
5	+	* non-exclusive, royalty free, license to use, modify and
6	+	* redistribute this software in source and binary code form, provided
7	+	* that the following conditions are met:
8	+	*
9	+	* 1. Redistributions of source code must retain the above copyright
10	+	*    notice, this list of conditions and the following disclaimer.
11	+	*
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.
16	+	*
17	+	* This software is provided "AS IS," without a warranty of any
18	+	* kind. All express or implied conditions, representations and
19	+	* warranties, including any implied warranty of merchantability,
20	+	* fitness for a particular purpose or non-infringement, are hereby
21	+	* excluded.  The University of Notre Dame and its licensors shall not
22	+	* be liable for any damages suffered by licensee as a result of
23	+	* using, modifying or distributing the software or its
24	+	* derivatives. In no event will the University of Notre Dame or its
25	+	* licensors be liable for any lost revenue, profit or data, or for
26	+	* direct, indirect, special, consequential, incidental or punitive
27	+	* damages, however caused and regardless of the theory of liability,
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 DataStorage.cpp
45	<	* @author tlin
46	<	* @date 10/26/2004
47	<	* @time 11:56am
48	<	* @version 1.0
49	<	*/
43	>	/**
44	>	* @file DataStorage.cpp
45	>	* @author tlin
46	>	* @date 10/26/2004
47	>	* @time 11:56am
48	>	* @version 1.0
49	>	*/
50
51		#include "brains/DataStorage.hpp"
52
53	+	namespace OpenMD {
54
55	<	DataStorage::DataStorage() : size_(0), storageLayout_(0){
55	>	DataStorage::DataStorage() : size_(0), storageLayout_(0){
56
57	<	}
57	>	}
58
59	<	DataStorage::DataStorage(int size, int storageLayout) : size_(size){
59	>	DataStorage::DataStorage(int size, int storageLayout) : size_(size){
60		setStorageLayout(storageLayout);
61		resize(size);
62	<	}
62	>	}
63
64	<	int DataStorage::getSize() {
64	>	int DataStorage::getSize() {
65
66		if (storageLayout_ & dslPosition && position.size() != size_) {
67	<	//error
68	<	std::cerr << "size does not match"<< std::endl;
67	>	//error
68	>	std::cerr << "size does not match"<< std::endl;
69		}
70
71		if (storageLayout_ & dslVelocity && velocity.size() != size_) {
72	<	//error
73	<	std::cerr << "size does not match"<< std::endl;
72	>	//error
73	>	std::cerr << "size does not match"<< std::endl;
74		}
75
76		if (storageLayout_ & dslAmat && aMat.size() != size_) {
77	<	//error
78	<	std::cerr << "size does not match"<< std::endl;
77	>	//error
78	>	std::cerr << "size does not match"<< std::endl;
79		}
80
81		if (storageLayout_ & dslAngularMomentum && angularMomentum.size() != size_) {
82	<	//error
83	<	std::cerr << "size does not match"<< std::endl;
82	>	//error
83	>	std::cerr << "size does not match"<< std::endl;
84		}
85
86	<	if (storageLayout_ & dslUnitVector && unitVector.size() != size_) {
87	<	//error
88	<	std::cerr << "size does not match"<< std::endl;
86	>	if (storageLayout_ & dslElectroFrame && electroFrame.size() != size_) {
87	>	//error
88	>	std::cerr << "size does not match"<< std::endl;
89		}
90
91		if (storageLayout_ & dslZAngle && zAngle.size() != size_) {
92	<	//error
93	<	std::cerr << "size does not match"<< std::endl;
92	>	//error
93	>	std::cerr << "size does not match"<< std::endl;
94		}
95
96		if (storageLayout_ & dslForce && force.size() != size_) {
97	<	//error
98	<	std::cerr << "size does not match"<< std::endl;
97	>	//error
98	>	std::cerr << "size does not match"<< std::endl;
99		}
100
101		if (storageLayout_ & dslTorque && torque.size() != size_) {
102	<	//error
103	<	std::cerr << "size does not match"<< std::endl;
102	>	//error
103	>	std::cerr << "size does not match"<< std::endl;
104		}
105
106	+	if (storageLayout_ & dslParticlePot && particlePot.size() != size_) {
107	+	//error
108	+	std::cerr << "size does not match"<< std::endl;
109	+	}
110	+
111	+	if (storageLayout_ & dslDensity && density.size() != size_) {
112	+	//error
113	+	std::cerr << "size does not match"<< std::endl;
114	+	}
115	+
116	+	if (storageLayout_ & dslFunctional && functional.size() != size_) {
117	+	//error
118	+	std::cerr << "size does not match"<< std::endl;
119	+	}
120	+
121	+	if (storageLayout_ & dslFunctionalDerivative && functionalDerivative.size() != size_) {
122	+	//error
123	+	std::cerr << "size does not match"<< std::endl;
124	+	}
125	+
126	+	if (storageLayout_ & dslElectricField && electricField.size() != size_) {
127	+	//error
128	+	std::cerr << "size does not match"<< std::endl;
129	+	}
130	+
131	+	if (storageLayout_ & dslSkippedCharge && skippedCharge.size() != size_) {
132	+	//error
133	+	std::cerr << "size does not match"<< std::endl;
134	+	}
135	+
136		return size_;
137
138	<	}
138	>	}
139
140	<	void DataStorage::resize(int newSize) {
140	>	void DataStorage::resize(int newSize) {
141
142		if (storageLayout_ & dslPosition) {
143	<	internalResize(position, newSize);
143	>	internalResize(position, newSize);
144		}
145
146		if (storageLayout_ & dslVelocity) {
147	<	internalResize(velocity, newSize);
147	>	internalResize(velocity, newSize);
148		}
149
150		if (storageLayout_ & dslAmat) {
151	<	internalResize(aMat, newSize);
151	>	internalResize(aMat, newSize);
152		}
153
154		if (storageLayout_ & dslAngularMomentum) {
155	<	internalResize(angularMomentum, newSize);
155	>	internalResize(angularMomentum, newSize);
156		}
157
158	<	if (storageLayout_ & dslUnitVector) {
159	<	internalResize(unitVector, newSize);
158	>	if (storageLayout_ & dslElectroFrame) {
159	>	internalResize(electroFrame, newSize);
160		}
161
162		if (storageLayout_ & dslZAngle) {
163	<	internalResize(zAngle, newSize);
163	>	internalResize(zAngle, newSize);
164		}
165
166		if (storageLayout_ & dslForce) {
167	<	internalResize(force, newSize);
167	>	internalResize(force, newSize);
168		}
169
170		if (storageLayout_ & dslTorque) {
171	<	internalResize(torque, newSize);
171	>	internalResize(torque, newSize);
172		}
173
174	+	if (storageLayout_ & dslParticlePot) {
175	+	internalResize(particlePot, newSize);
176	+	}
177	+
178	+	if (storageLayout_ & dslDensity) {
179	+	internalResize(density, newSize);
180	+	}
181	+
182	+	if (storageLayout_ & dslFunctional) {
183	+	internalResize(functional, newSize);
184	+	}
185	+
186	+	if (storageLayout_ & dslFunctionalDerivative) {
187	+	internalResize(functionalDerivative, newSize);
188	+	}
189	+
190	+	if (storageLayout_ & dslElectricField) {
191	+	internalResize(electricField, newSize);
192	+	}
193	+
194	+	if (storageLayout_ & dslSkippedCharge) {
195	+	internalResize(skippedCharge, newSize);
196	+	}
197	+
198		size_ = newSize;
199	<	}
199	>	}
200
201	<	void DataStorage::reserve(int size) {
201	>	void DataStorage::reserve(int size) {
202		if (storageLayout_ & dslPosition) {
203	<	position.reserve(size);
203	>	position.reserve(size);
204		}
205
206		if (storageLayout_ & dslVelocity) {
207	<	velocity.reserve(size);
207	>	velocity.reserve(size);
208		}
209
210		if (storageLayout_ & dslAmat) {
211	<	aMat.reserve(size);
211	>	aMat.reserve(size);
212		}
213
214		if (storageLayout_ & dslAngularMomentum) {
215	<	angularMomentum.reserve(size);
215	>	angularMomentum.reserve(size);
216		}
217
218	<	if (storageLayout_ & dslUnitVector) {
219	<	unitVector.reserve(size);
218	>	if (storageLayout_ & dslElectroFrame) {
219	>	electroFrame.reserve(size);
220		}
221
222		if (storageLayout_ & dslZAngle) {
223	<	zAngle.reserve(size);
223	>	zAngle.reserve(size);
224		}
225
226		if (storageLayout_ & dslForce) {
227	<	force.reserve(size);
227	>	force.reserve(size);
228		}
229
230		if (storageLayout_ & dslTorque) {
231	<	torque.reserve(size);
231	>	torque.reserve(size);
232		}
233	+
234	+	if (storageLayout_ & dslParticlePot) {
235	+	particlePot.reserve(size);
236	+	}
237
238	<	}
238	>	if (storageLayout_ & dslDensity) {
239	>	density.reserve(size);
240	>	}
241
242	<	void DataStorage::copy(int source, int num, int target) {
242	>	if (storageLayout_ & dslFunctional) {
243	>	functional.reserve(size);
244	>	}
245	>
246	>	if (storageLayout_ & dslFunctionalDerivative) {
247	>	functionalDerivative.reserve(size);
248	>	}
249	>
250	>	if (storageLayout_ & dslElectricField) {
251	>	electricField.reserve(size);
252	>	}
253	>
254	>	if (storageLayout_ & dslSkippedCharge) {
255	>	skippedCharge.reserve(size);
256	>	}
257	>
258	>	}
259	>
260	>	void DataStorage::copy(int source, int num, int target) {
261		if (num + target > size_ ) {
262	<	//error
262	>	//error
263		}
264
265		if (storageLayout_ & dslPosition) {
266	<	interalCopy(position, source, num, target);
266	>	internalCopy(position, source, num, target);
267		}
268
269		if (storageLayout_ & dslVelocity) {
270	<	interalCopy(velocity, source, num, target);
271	<	}
270	>	internalCopy(velocity, source, num, target);
271	>	}
272
273		if (storageLayout_ & dslAmat) {
274	<	interalCopy(aMat, source, num, target);
275	<	}
274	>	internalCopy(aMat, source, num, target);
275	>	}
276
277		if (storageLayout_ & dslAngularMomentum) {
278	<	interalCopy(angularMomentum, source, num, target);
278	>	internalCopy(angularMomentum, source, num, target);
279		}
280
281	<	if (storageLayout_ & dslUnitVector) {
282	<	interalCopy(unitVector, source, num, target);
281	>	if (storageLayout_ & dslElectroFrame) {
282	>	internalCopy(electroFrame, source, num, target);
283		}
284
285		if (storageLayout_ & dslZAngle) {
286	<	interalCopy(zAngle, source, num, target);
286	>	internalCopy(zAngle, source, num, target);
287		}
288
289		if (storageLayout_ & dslForce) {
290	<	interalCopy(force, source, num, target);
290	>	internalCopy(force, source, num, target);
291		}
292
293		if (storageLayout_ & dslTorque) {
294	<	interalCopy(torque, source, num, target);
294	>	internalCopy(torque, source, num, target);
295		}
200	–
296
297	<	}
298	<
299	<	int DataStorage::getStorageLayout() {
205	<	return storageLayout_;
206	<	}
297	>	if (storageLayout_ & dslParticlePot) {
298	>	internalCopy(particlePot, source, num, target);
299	>	}
300
301	<	void DataStorage::setStorageLayout(int layout) {
301	>	if (storageLayout_ & dslDensity) {
302	>	internalCopy(density, source, num, target);
303	>	}
304	>
305	>	if (storageLayout_ & dslFunctional) {
306	>	internalCopy(functional, source, num, target);
307	>	}
308	>
309	>	if (storageLayout_ & dslFunctionalDerivative) {
310	>	internalCopy(functionalDerivative, source, num, target);
311	>	}
312	>
313	>	if (storageLayout_ & dslElectricField) {
314	>	internalCopy(electricField, source, num, target);
315	>	}
316	>
317	>	if (storageLayout_ & dslSkippedCharge) {
318	>	internalCopy(skippedCharge, source, num, target);
319	>	}
320	>	}
321	>
322	>	int DataStorage::getStorageLayout() {
323	>	return storageLayout_;
324	>	}
325	>
326	>	void DataStorage::setStorageLayout(int layout) {
327		storageLayout_ = layout;
328		resize(size_);
329	<	}
329	>	}
330
331	<	double* DataStorage::getArrayPointer(int whichArray) {
331	>	RealType* DataStorage::getArrayPointer(int whichArray) {
332
333		switch (whichArray) {
334	<	case dslPosition:
335	<	return internalGetArrayPointer(torque);
336	<	break;
334	>	case dslPosition:
335	>	return internalGetArrayPointer(position);
336	>	break;
337
338	<	case dslVelocity:
339	<	return internalGetArrayPointer(velocity);
340	<	break;
338	>	case dslVelocity:
339	>	return internalGetArrayPointer(velocity);
340	>	break;
341
342	<	case dslAmat:
343	<	return internalGetArrayPointer(aMat);
344	<	break;
342	>	case dslAmat:
343	>	return internalGetArrayPointer(aMat);
344	>	break;
345
346	<	case dslAngularMomentum:
347	<	return internalGetArrayPointer(angularMomentum);
348	<	break;
346	>	case dslAngularMomentum:
347	>	return internalGetArrayPointer(angularMomentum);
348	>	break;
349
350	<	case dslUnitVector:
351	<	return internalGetArrayPointer(unitVector);
352	<	break;
350	>	case dslElectroFrame:
351	>	return internalGetArrayPointer(electroFrame);
352	>	break;
353
354	<	case dslZAngle:
355	<	return internalGetArrayPointer(zAngle);
356	<	break;
354	>	case dslZAngle:
355	>	return internalGetArrayPointer(zAngle);
356	>	break;
357
358	<	case dslForce:
359	<	return internalGetArrayPointer(force);
360	<	break;
358	>	case dslForce:
359	>	return internalGetArrayPointer(force);
360	>	break;
361
362	<	case dslTorque:
363	<	return internalGetArrayPointer(torque);
364	<	break;
247	<
248	<	default:
249	<	//error message
250	<	return NULL;
362	>	case dslTorque:
363	>	return internalGetArrayPointer(torque);
364	>	break;
365
366	+	case dslParticlePot:
367	+	return internalGetArrayPointer(particlePot);
368	+	break;
369	+
370	+	case dslDensity:
371	+	return internalGetArrayPointer(density);
372	+	break;
373	+
374	+	case dslFunctional:
375	+	return internalGetArrayPointer(functional);
376	+	break;
377	+
378	+	case dslFunctionalDerivative:
379	+	return internalGetArrayPointer(functionalDerivative);
380	+	break;
381	+
382	+	case dslElectricField:
383	+	return internalGetArrayPointer(electricField);
384	+	break;
385	+
386	+	case dslSkippedCharge:
387	+	return internalGetArrayPointer(skippedCharge);
388	+	break;
389	+
390	+	default:
391	+	//error message
392	+	return NULL;
393	+
394		}
395	<	}
395	>	}
396
397	<	double* DataStorage::internalGetArrayPointer(std::vector<Vector3d>& v) {
397	>	RealType* DataStorage::internalGetArrayPointer(std::vector<Vector3d>& v) {
398		if (v.size() == 0) {
399	<	return NULL;
399	>	return NULL;
400		} else {
401	<	return v[0].getArrayPointer();
401	>	return v[0].getArrayPointer();
402		}
403	<	}
403	>	}
404
405	<	double* DataStorage::internalGetArrayPointer(std::vector<RotMat3x3d>& v) {
405	>	RealType* DataStorage::internalGetArrayPointer(std::vector<RotMat3x3d>& v) {
406		if (v.size() == 0) {
407	<	return NULL;
407	>	return NULL;
408		} else {
409	<	return v[0].getArrayPointer();
409	>	return v[0].getArrayPointer();
410		}
411
412	<	}
412	>	}
413
414	<	double* DataStorage::internalGetArrayPointer(std::vector<double>& v) {
414	>	RealType* DataStorage::internalGetArrayPointer(std::vector<RealType>& v) {
415		if (v.size() == 0) {
416	<	return NULL;
416	>	return NULL;
417		} else {
418	<	return &(v[0]);
418	>	return &(v[0]);
419		}
420
421	<	}
421	>	}
422
423	<	template<typename T>
424	<	void DataStorage::internalResize(std::vector<T>& v, int newSize){
423	>	template<typename T>
424	>	void DataStorage::internalResize(std::vector<T>& v, int newSize){
425		int oldSize = v.size();
426
427		if (oldSize == newSize) {
428	<	return;
428	>	return;
429		} else if (oldSize < newSize) {
430	<	v.insert(v.end(), newSize-oldSize, T());
430	>	v.insert(v.end(), newSize-oldSize, T());
431		} else {
432	<	typename std::vector<T>::iterator i;
433	<	i = v.begin();
434	<	std::advance(i, newSize);
435	<	v.erase(i, v.end());
432	>	typename std::vector<T>::iterator i;
433	>	i = v.begin();
434	>	std::advance(i, newSize);
435	>	v.erase(i, v.end());
436		}
437	<	}
437	>	}
438
439	<	template<typename T>
440	<	void DataStorage::interalCopy(std::vector<T>& v, int source,  int num, int target) {
439	>	template<typename T>
440	>	void DataStorage::internalCopy(std::vector<T>& v, int source,  int num, int target) {
441		typename std::vector<T>::iterator first;
442		typename std::vector<T>::iterator last;
443		typename std::vector<T>::iterator result;
#	Line 310 | Line 452 | void DataStorage::interalCopy(std::vector<T>& v, int s
452		std::advance(result, target );
453
454		std::copy(first, last, result);
455	+	}
456	+
457	+	int DataStorage::getBytesPerStuntDouble(int layout) {
458	+	int bytes = 0;
459	+	if (layout & dslPosition) {
460	+	bytes += sizeof(Vector3d);
461	+	}
462	+	if (layout & dslVelocity) {
463	+	bytes += sizeof(Vector3d);
464	+	}
465	+	if (layout & dslAmat) {
466	+	bytes += sizeof(RotMat3x3d);
467	+	}
468	+	if (layout & dslAngularMomentum) {
469	+	bytes += sizeof(Vector3d);
470	+	}
471	+	if (layout & dslElectroFrame) {
472	+	bytes += sizeof(Mat3x3d);
473	+	}
474	+	if (layout & dslZAngle) {
475	+	bytes += sizeof(RealType);
476	+	}
477	+	if (layout & dslForce) {
478	+	bytes += sizeof(Vector3d);
479	+	}
480	+	if (layout & dslTorque) {
481	+	bytes += sizeof(Vector3d);
482	+	}
483	+	if (layout & dslParticlePot) {
484	+	bytes += sizeof(RealType);
485	+	}
486	+	if (layout & dslDensity) {
487	+	bytes += sizeof(RealType);
488	+	}
489	+	if (layout & dslFunctional) {
490	+	bytes += sizeof(RealType);
491	+	}
492	+	if (layout & dslFunctionalDerivative) {
493	+	bytes += sizeof(RealType);
494	+	}
495	+	if (layout & dslElectricField) {
496	+	bytes += sizeof(Vector3d);
497	+	}
498	+	if (layout & dslSkippedCharge) {
499	+	bytes += sizeof(RealType);
500	+	}
501	+
502	+	return bytes;
503	+	}
504	+
505		}

Comparing:
trunk/src/brains/DataStorage.cpp (property svn:keywords), Revision 155 by tim, Tue Oct 26 22:19:22 2004 UTC vs.
branches/development/src/brains/DataStorage.cpp (property svn:keywords), Revision 1665 by gezelter, Tue Nov 22 20:38:56 2011 UTC

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

Diff Legend

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