src/brains/DataStorage.cpp

/*
 * Copyright (C) 2000-2004  Object Oriented Parallel Simulation Engine (OOPSE) project
 * 
 * Contact: oopse@oopse.org
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 * All we ask is that proper credit is given for our work, which includes
 * - but is not limited to - adding the above copyright notice to the beginning
 * of your source code files, and to any copyright notice that you may distribute
 * with programs based on this work.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */
 
 /**
  * @file DataStorage.cpp
  * @author tlin
  * @date 10/26/2004
  * @time 11:56am
  * @version 1.0
  */

#include "brains/DataStorage.hpp"


DataStorage::DataStorage() : size_(0), storageLayout_(0){

}

DataStorage::DataStorage(int size, int storageLayout) : size_(size){
    setStorageLayout(storageLayout);
    resize(size);
}

int DataStorage::getSize() {

    if (storageLayout_ & dslPosition && position.size() != size_) {
        //error
        std::cerr << "size does not match"<< std::endl;
    }

    if (storageLayout_ & dslVelocity && velocity.size() != size_) {
        //error
        std::cerr << "size does not match"<< std::endl;        
    }

    if (storageLayout_ & dslAmat && aMat.size() != size_) {
        //error
        std::cerr << "size does not match"<< std::endl;        
    }

    if (storageLayout_ & dslAngularMomentum && angularMomentum.size() != size_) {
        //error
        std::cerr << "size does not match"<< std::endl;        
    }

    if (storageLayout_ & dslUnitVector && unitVector.size() != size_) {
        //error
        std::cerr << "size does not match"<< std::endl;        
    }

    if (storageLayout_ & dslZAngle && zAngle.size() != size_) {
        //error
        std::cerr << "size does not match"<< std::endl;        
    }

    if (storageLayout_ & dslForce && force.size() != size_) {
        //error
        std::cerr << "size does not match"<< std::endl;        
    }

    if (storageLayout_ & dslTorque && torque.size() != size_) {
        //error
        std::cerr << "size does not match"<< std::endl;        
    }

    return size_;

}

void DataStorage::resize(int newSize) {

    if (storageLayout_ & dslPosition) {
        internalResize(position, newSize);
    }

    if (storageLayout_ & dslVelocity) {
        internalResize(velocity, newSize);
    }

    if (storageLayout_ & dslAmat) {
        internalResize(aMat, newSize);
    }

    if (storageLayout_ & dslAngularMomentum) {
        internalResize(angularMomentum, newSize);
    }

    if (storageLayout_ & dslUnitVector) {
        internalResize(unitVector, newSize);
    }
    
    if (storageLayout_ & dslZAngle) {
        internalResize(zAngle, newSize);
    }

    if (storageLayout_ & dslForce) {
        internalResize(force, newSize);
    }

    if (storageLayout_ & dslTorque) {
        internalResize(torque, newSize);
    }

    size_ = newSize;
}

void DataStorage::reserve(int size) {
    if (storageLayout_ & dslPosition) {
        position.reserve(size);
    } 

    if (storageLayout_ & dslVelocity) {
        velocity.reserve(size);
    } 

    if (storageLayout_ & dslAmat) {
        aMat.reserve(size);
    } 

    if (storageLayout_ & dslAngularMomentum) {
        angularMomentum.reserve(size);
    } 

    if (storageLayout_ & dslUnitVector) {
        unitVector.reserve(size);
    }
    
    if (storageLayout_ & dslZAngle) {
        zAngle.reserve(size);
    }

    if (storageLayout_ & dslForce) {
        force.reserve(size);
    } 

    if (storageLayout_ & dslTorque) {
        torque.reserve(size);
    }

}

void DataStorage::copy(int source, int num, int target) {
    if (num + target > size_ ) {
        //error
    }
    
    if (storageLayout_ & dslPosition) {
        interalCopy(position, source, num, target);
    } 

    if (storageLayout_ & dslVelocity) {
        interalCopy(velocity, source, num, target);
  } 

    if (storageLayout_ & dslAmat) {
        interalCopy(aMat, source, num, target);
   } 

    if (storageLayout_ & dslAngularMomentum) {
        interalCopy(angularMomentum, source, num, target);
    } 

    if (storageLayout_ & dslUnitVector) {
        interalCopy(unitVector, source, num, target);
    }
    
    if (storageLayout_ & dslZAngle) {
        interalCopy(zAngle, source, num, target);
    }

    if (storageLayout_ & dslForce) {
        interalCopy(force, source, num, target);
    } 

    if (storageLayout_ & dslTorque) {
        interalCopy(torque, source, num, target); 
    }
    

}

int DataStorage::getStorageLayout() {
    return storageLayout_;
}

void DataStorage::setStorageLayout(int layout) {
    storageLayout_ = layout;
    resize(size_);
}

double* DataStorage::getArrayPointer(int whichArray) {

    switch (whichArray) {
        case dslPosition:
            return internalGetArrayPointer(torque);
            break;
            
        case dslVelocity:
            return internalGetArrayPointer(velocity);
            break;
            
        case dslAmat:
            return internalGetArrayPointer(aMat);
            break;            
            
        case dslAngularMomentum:
            return internalGetArrayPointer(angularMomentum);
            break;
            
        case dslUnitVector:
            return internalGetArrayPointer(unitVector);
            break;
            
        case dslZAngle:
            return internalGetArrayPointer(zAngle);
            break;

        case dslForce:
            return internalGetArrayPointer(force);
            break;            

        case dslTorque:
            return internalGetArrayPointer(torque);
            break;  
            
        default:
            //error message
            return NULL;

    }
}    

double* DataStorage::internalGetArrayPointer(std::vector<Vector3d>& v) {
    if (v.size() == 0) {
        return NULL;
    } else {
        return v[0].getArrayPointer();
    }
}

double* DataStorage::internalGetArrayPointer(std::vector<RotMat3x3d>& v) {
    if (v.size() == 0) {
        return NULL;
    } else {
        return v[0].getArrayPointer();
    }

}

double* DataStorage::internalGetArrayPointer(std::vector<double>& v) {
    if (v.size() == 0) {
        return NULL;
    } else {
        return &(v[0]);
    }

}    

template<typename T>
void DataStorage::internalResize(std::vector<T>& v, int newSize){
    int oldSize = v.size();

    if (oldSize == newSize) {
        return;
    } else if (oldSize < newSize) {
        v.insert(v.end(), newSize-oldSize, T());
    } else {
        typename std::vector<T>::iterator i;
        i = v.begin();
        std::advance(i, newSize);        
        v.erase(i, v.end());
    }
}

template<typename T>
void DataStorage::interalCopy(std::vector<T>& v, int source,  int num, int target) {
    typename std::vector<T>::iterator first;
    typename std::vector<T>::iterator last;
    typename std::vector<T>::iterator result;

    first = v.begin();
    last = v.begin();
    result = v.begin();

    std::advance(first, source);
    //STL algorithm use half opened range
    std::advance(last, num + 1);
    std::advance(result, target );

    std::copy(first, last, result);
}
Revision:	1648
Committed:	Tue Oct 26 22:19:22 2004 UTC (19 years, 8 months ago) by tim
File size:	7806 byte(s)
Log Message:	DataStorage passes unit test
#	User	Rev	Content
1	tim	1648	/*
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.
23			*
24			*/
25
26			/**
27			* @file DataStorage.cpp
28			* @author tlin
29			* @date 10/26/2004
30			* @time 11:56am
31			* @version 1.0
32			*/
33
34			#include "brains/DataStorage.hpp"
35
36
37			DataStorage::DataStorage() : size_(0), storageLayout_(0){
38
39			}
40
41			DataStorage::DataStorage(int size, int storageLayout) : size_(size){
42			setStorageLayout(storageLayout);
43			resize(size);
44			}
45
46			int DataStorage::getSize() {
47
48			if (storageLayout_ & dslPosition && position.size() != size_) {
49			//error
50			std::cerr << "size does not match"<< std::endl;
51			}
52
53			if (storageLayout_ & dslVelocity && velocity.size() != size_) {
54			//error
55			std::cerr << "size does not match"<< std::endl;
56			}
57
58			if (storageLayout_ & dslAmat && aMat.size() != size_) {
59			//error
60			std::cerr << "size does not match"<< std::endl;
61			}
62
63			if (storageLayout_ & dslAngularMomentum && angularMomentum.size() != size_) {
64			//error
65			std::cerr << "size does not match"<< std::endl;
66			}
67
68			if (storageLayout_ & dslUnitVector && unitVector.size() != size_) {
69			//error
70			std::cerr << "size does not match"<< std::endl;
71			}
72
73			if (storageLayout_ & dslZAngle && zAngle.size() != size_) {
74			//error
75			std::cerr << "size does not match"<< std::endl;
76			}
77
78			if (storageLayout_ & dslForce && force.size() != size_) {
79			//error
80			std::cerr << "size does not match"<< std::endl;
81			}
82
83			if (storageLayout_ & dslTorque && torque.size() != size_) {
84			//error
85			std::cerr << "size does not match"<< std::endl;
86			}
87
88			return size_;
89
90			}
91
92			void DataStorage::resize(int newSize) {
93
94			if (storageLayout_ & dslPosition) {
95			internalResize(position, newSize);
96			}
97
98			if (storageLayout_ & dslVelocity) {
99			internalResize(velocity, newSize);
100			}
101
102			if (storageLayout_ & dslAmat) {
103			internalResize(aMat, newSize);
104			}
105
106			if (storageLayout_ & dslAngularMomentum) {
107			internalResize(angularMomentum, newSize);
108			}
109
110			if (storageLayout_ & dslUnitVector) {
111			internalResize(unitVector, newSize);
112			}
113
114			if (storageLayout_ & dslZAngle) {
115			internalResize(zAngle, newSize);
116			}
117
118			if (storageLayout_ & dslForce) {
119			internalResize(force, newSize);
120			}
121
122			if (storageLayout_ & dslTorque) {
123			internalResize(torque, newSize);
124			}
125
126			size_ = newSize;
127			}
128
129			void DataStorage::reserve(int size) {
130			if (storageLayout_ & dslPosition) {
131			position.reserve(size);
132			}
133
134			if (storageLayout_ & dslVelocity) {
135			velocity.reserve(size);
136			}
137
138			if (storageLayout_ & dslAmat) {
139			aMat.reserve(size);
140			}
141
142			if (storageLayout_ & dslAngularMomentum) {
143			angularMomentum.reserve(size);
144			}
145
146			if (storageLayout_ & dslUnitVector) {
147			unitVector.reserve(size);
148			}
149
150			if (storageLayout_ & dslZAngle) {
151			zAngle.reserve(size);
152			}
153
154			if (storageLayout_ & dslForce) {
155			force.reserve(size);
156			}
157
158			if (storageLayout_ & dslTorque) {
159			torque.reserve(size);
160			}
161
162			}
163
164			void DataStorage::copy(int source, int num, int target) {
165			if (num + target > size_ ) {
166			//error
167			}
168
169			if (storageLayout_ & dslPosition) {
170			interalCopy(position, source, num, target);
171			}
172
173			if (storageLayout_ & dslVelocity) {
174			interalCopy(velocity, source, num, target);
175			}
176
177			if (storageLayout_ & dslAmat) {
178			interalCopy(aMat, source, num, target);
179			}
180
181			if (storageLayout_ & dslAngularMomentum) {
182			interalCopy(angularMomentum, source, num, target);
183			}
184
185			if (storageLayout_ & dslUnitVector) {
186			interalCopy(unitVector, source, num, target);
187			}
188
189			if (storageLayout_ & dslZAngle) {
190			interalCopy(zAngle, source, num, target);
191			}
192
193			if (storageLayout_ & dslForce) {
194			interalCopy(force, source, num, target);
195			}
196
197			if (storageLayout_ & dslTorque) {
198			interalCopy(torque, source, num, target);
199			}
200
201
202			}
203
204			int DataStorage::getStorageLayout() {
205			return storageLayout_;
206			}
207
208			void DataStorage::setStorageLayout(int layout) {
209			storageLayout_ = layout;
210			resize(size_);
211			}
212
213			double* DataStorage::getArrayPointer(int whichArray) {
214
215			switch (whichArray) {
216			case dslPosition:
217			return internalGetArrayPointer(torque);
218			break;
219
220			case dslVelocity:
221			return internalGetArrayPointer(velocity);
222			break;
223
224			case dslAmat:
225			return internalGetArrayPointer(aMat);
226			break;
227
228			case dslAngularMomentum:
229			return internalGetArrayPointer(angularMomentum);
230			break;
231
232			case dslUnitVector:
233			return internalGetArrayPointer(unitVector);
234			break;
235
236			case dslZAngle:
237			return internalGetArrayPointer(zAngle);
238			break;
239
240			case dslForce:
241			return internalGetArrayPointer(force);
242			break;
243
244			case dslTorque:
245			return internalGetArrayPointer(torque);
246			break;
247
248			default:
249			//error message
250			return NULL;
251
252			}
253			}
254
255			double* DataStorage::internalGetArrayPointer(std::vector<Vector3d>& v) {
256			if (v.size() == 0) {
257			return NULL;
258			} else {
259			return v[0].getArrayPointer();
260			}
261			}
262
263			double* DataStorage::internalGetArrayPointer(std::vector<RotMat3x3d>& v) {
264			if (v.size() == 0) {
265			return NULL;
266			} else {
267			return v[0].getArrayPointer();
268			}
269
270			}
271
272			double* DataStorage::internalGetArrayPointer(std::vector<double>& v) {
273			if (v.size() == 0) {
274			return NULL;
275			} else {
276			return &(v[0]);
277			}
278
279			}
280
281			template<typename T>
282			void DataStorage::internalResize(std::vector<T>& v, int newSize){
283			int oldSize = v.size();
284
285			if (oldSize == newSize) {
286			return;
287			} else if (oldSize < newSize) {
288			v.insert(v.end(), newSize-oldSize, T());
289			} else {
290			typename std::vector<T>::iterator i;
291			i = v.begin();
292			std::advance(i, newSize);
293			v.erase(i, v.end());
294			}
295			}
296
297			template<typename T>
298			void DataStorage::interalCopy(std::vector<T>& v, int source, int num, int target) {
299			typename std::vector<T>::iterator first;
300			typename std::vector<T>::iterator last;
301			typename std::vector<T>::iterator result;
302
303			first = v.begin();
304			last = v.begin();
305			result = v.begin();
306
307			std::advance(first, source);
308			//STL algorithm use half opened range
309			std::advance(last, num + 1);
310			std::advance(result, target );
311
312			std::copy(first, last, result);
313			}