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 |
53 |
|
#include <math/Vector3.hpp> |
54 |
|
#include <math/SquareMatrix3.hpp> |
55 |
|
|
56 |
< |
using namespace oopse; |
56 |
> |
namespace oopse { |
57 |
> |
/** |
58 |
> |
* @class DataStorage |
59 |
> |
* @warning do not try to insert element into (or ease element from) private member data |
60 |
> |
* of DataStorage directly. |
61 |
> |
* @todo DataStorage may need refactorying. Every std::vector can inherit from the same base class |
62 |
> |
* which will make it easy to maintain |
63 |
> |
*/ |
64 |
> |
class DataStorage { |
65 |
> |
public: |
66 |
|
|
67 |
+ |
enum{ |
68 |
+ |
dslPosition = 1, |
69 |
+ |
dslVelocity = 2, |
70 |
+ |
dslAmat = 4, |
71 |
+ |
dslAngularMomentum = 8, |
72 |
+ |
dslElectroFrame = 16, |
73 |
+ |
dslZAngle = 32, |
74 |
+ |
dslForce = 64, |
75 |
+ |
dslTorque = 128 |
76 |
+ |
}; |
77 |
+ |
|
78 |
+ |
|
79 |
+ |
DataStorage(); |
80 |
+ |
DataStorage(int size, int storageLayout = 255); |
81 |
+ |
/** return the size of this DataStorage. */ |
82 |
+ |
int getSize(); |
83 |
|
/** |
84 |
< |
* @class DataStorage |
85 |
< |
* @warning do not try to insert element into (or ease element from) private member data |
61 |
< |
* of DataStorage directly. |
62 |
< |
* @todo DataStorage may need refactorying. Every std::vector can inherit from the same base class |
63 |
< |
* which will make it easy to maintain |
84 |
> |
* Changes the size of this DataStorage. |
85 |
> |
* @param size new size of this DataStorage |
86 |
|
*/ |
87 |
< |
class DataStorage { |
88 |
< |
public: |
87 |
> |
void resize(int newSize); |
88 |
> |
/** |
89 |
> |
* Reallocates memory manually. The main reason for using reserve() is efficiency |
90 |
> |
* if you know the capacity to which your std::vector must eventually grow, then it is usually more |
91 |
> |
* efficient to allocate that memory all at once. |
92 |
> |
*/ |
93 |
> |
void reserve(int size); |
94 |
> |
/** |
95 |
> |
* Copies data inside DataStorage class. |
96 |
> |
* Copy function actually call std::copy for every std::vector in DataStorage class. |
97 |
> |
* One Precondition of std::copy is that target is not within the range [soruce, soruce + num] |
98 |
> |
* @param souce |
99 |
> |
* @param num number of element to be moved |
100 |
> |
* @param target |
101 |
> |
*/ |
102 |
> |
void copy(int source, int num, int target); |
103 |
> |
/** Returns the storage layout */ |
104 |
> |
int getStorageLayout(); |
105 |
> |
/** Sets the storage layout */ |
106 |
> |
void setStorageLayout(int layout); |
107 |
> |
/** Returns the pointer of internal array */ |
108 |
> |
RealType *getArrayPointer(int whichArray); |
109 |
|
|
110 |
< |
enum{ |
111 |
< |
dslPosition = 1, |
112 |
< |
dslVelocity = 2, |
113 |
< |
dslAmat = 4, |
114 |
< |
dslAngularMomentum = 8, |
115 |
< |
dslElectroFrame = 16, |
116 |
< |
dslZAngle = 32, |
117 |
< |
dslForce = 64, |
76 |
< |
dslTorque = 128 |
77 |
< |
}; |
110 |
> |
std::vector<Vector3d> position; /** position array */ |
111 |
> |
std::vector<Vector3d> velocity; /** velocity array */ |
112 |
> |
std::vector<RotMat3x3d> aMat; /** rotation matrix array */ |
113 |
> |
std::vector<Vector3d> angularMomentum;/** angular momentum array (body-fixed) */ |
114 |
> |
std::vector<Mat3x3d> electroFrame; /** the lab frame unit std::vector array*/ |
115 |
> |
std::vector<RealType> zAngle; /** z -angle array */ |
116 |
> |
std::vector<Vector3d> force; /** force array */ |
117 |
> |
std::vector<Vector3d> torque; /** torque array */ |
118 |
|
|
119 |
+ |
static int getBytesPerStuntDouble(int layout); |
120 |
|
|
121 |
< |
DataStorage(); |
81 |
< |
DataStorage(int size, int storageLayout = 255); |
82 |
< |
/** return the size of this DataStorage. */ |
83 |
< |
int getSize(); |
84 |
< |
/** |
85 |
< |
* Changes the size of this DataStorage. |
86 |
< |
* @param size new size of this DataStorage |
87 |
< |
*/ |
88 |
< |
void resize(int newSize); |
89 |
< |
/** |
90 |
< |
* Reallocates memory manually. The main reason for using reserve() is efficiency |
91 |
< |
* if you know the capacity to which your std::vector must eventually grow, then it is usually more |
92 |
< |
* efficient to allocate that memory all at once. |
93 |
< |
*/ |
94 |
< |
void reserve(int size); |
95 |
< |
/** |
96 |
< |
* Copies data inside DataStorage class. |
97 |
< |
* Copy function actually call std::copy for every std::vector in DataStorage class. |
98 |
< |
* One Precondition of std::copy is that target is not within the range [soruce, soruce + num] |
99 |
< |
* @param souce |
100 |
< |
* @param num number of element to be moved |
101 |
< |
* @param target |
102 |
< |
*/ |
103 |
< |
void copy(int source, int num, int target); |
104 |
< |
/** Returns the storage layout */ |
105 |
< |
int getStorageLayout(); |
106 |
< |
/** Sets the storage layout */ |
107 |
< |
void setStorageLayout(int layout); |
108 |
< |
/** Returns the pointer of internal array */ |
109 |
< |
double *getArrayPointer(int whichArray); |
121 |
> |
private: |
122 |
|
|
123 |
< |
std::vector<Vector3d> position; /** position array */ |
112 |
< |
std::vector<Vector3d> velocity; /** velocity array */ |
113 |
< |
std::vector<RotMat3x3d> aMat; /** rotation matrix array */ |
114 |
< |
std::vector<Vector3d> angularMomentum;/** angular momentum array (body-fixed) */ |
115 |
< |
std::vector<Mat3x3d> electroFrame; /** the lab frame unit std::vector array*/ |
116 |
< |
std::vector<double> zAngle; /** z -angle array */ |
117 |
< |
std::vector<Vector3d> force; /** force array */ |
118 |
< |
std::vector<Vector3d> torque; /** torque array */ |
119 |
< |
|
120 |
< |
private: |
121 |
< |
|
122 |
< |
double* internalGetArrayPointer(std::vector<Vector3d>& v); |
123 |
> |
RealType* internalGetArrayPointer(std::vector<Vector3d>& v); |
124 |
|
|
125 |
< |
double* internalGetArrayPointer(std::vector<RotMat3x3d>& v); |
126 |
< |
double* internalGetArrayPointer(std::vector<double>& v); |
125 |
> |
RealType* internalGetArrayPointer(std::vector<RotMat3x3d>& v); |
126 |
> |
RealType* internalGetArrayPointer(std::vector<RealType>& v); |
127 |
|
|
128 |
< |
template<typename T> |
129 |
< |
void internalResize(std::vector<T>& v, int newSize); |
128 |
> |
template<typename T> |
129 |
> |
void internalResize(std::vector<T>& v, int newSize); |
130 |
|
|
131 |
< |
template<typename T> |
132 |
< |
void internalCopy(std::vector<T>& v, int source, int num, int target); |
131 |
> |
template<typename T> |
132 |
> |
void internalCopy(std::vector<T>& v, int source, int num, int target); |
133 |
|
|
134 |
< |
int size_; |
135 |
< |
int storageLayout_; |
134 |
> |
int size_; |
135 |
> |
int storageLayout_; |
136 |
|
|
137 |
< |
}; |
137 |
> |
}; |
138 |
|
|
139 |
< |
|
139 |
> |
} |
140 |
|
#endif //BRAINS_DATASTORAGE_HPP |