ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-2.0/src/brains/Snapshot.hpp
(Generate patch)

Comparing trunk/OOPSE-2.0/src/brains/Snapshot.hpp (file contents):
Revision 1642 by tim, Mon Oct 25 04:08:14 2004 UTC vs.
Revision 1645 by tim, Tue Oct 26 17:28:53 2004 UTC

# Line 43 | Line 43 | namespace oopse{
43  
44   namespace oopse{
45  
46 <    enum DataStorageLayout {
47 <        dslPosition = 1,
48 <        dslVelocity = 2,
49 <        dslAMat = 4,
50 <        dslAngularMomentum = 8,
51 <        dslUnitVector = 16,
52 <        dslZAngle = 32,
53 <        dslForce = 64,
54 <        dslTorque = 128
55 <    };
46 >
47      //forward declaration
48      class Snapshot;
49      class SnapshotManager;
# Line 60 | Line 51 | namespace oopse{
51      
52      /**
53       * @class DataStorage
63 –     * @brief
54       * @warning do not try to insert element into (or ease element from) private member data
55       * of DataStorage directly.
56       */
57      class DataStorage {
58          public:
69 –            DataStorage() {};
70 –            DataStorage(size_t size);
59  
60 <            int size();
61 <            void resize(size_t size);
62 <            void reserve(size_t size);
60 >            enum{
61 >                slPosition = 1,
62 >                slVelocity = 2,
63 >                slAmat = 4,
64 >                slAngularMomentum = 8,
65 >                slUnitVector = 16,
66 >                slZAngle = 32,
67 >                slForce = 64,
68 >                slTorque = 128
69 >            };
70              
71 <            friend class Snapshot;
71 >            DataStorage(int size);
72 >
73 >            /** return the size of this DataStorage */
74 >            int size();
75 >            void resize(int size);
76 >            void reserve(int size);
77 >
78 >            void move(int source, int num, int target);
79 >            int getStorageLayout();
80 >            void setStorageLayout(int layout);
81 >
82 >            double *getArrayPointer(int );
83 >
84              friend class StuntDouble;
85 +
86          private:
87 +            int size_;
88 +            int storageLayout_;
89              vector<Vector3d> position;               /** position array */
90              vector<Vector3d> velocity;               /** velocity array */
91              vector<RotMat3x3d> aMat;            /** rotation matrix array */
# Line 84 | Line 94 | namespace oopse{
94              vector<double> zAngle;              /** z -angle array */        
95              vector<Vector3d> force;               /** force array */
96              vector<Vector3d> torque;               /** torque array */
87 –
97      };
98  
99      /**
# Line 122 | Line 131 | namespace oopse{
131              //    return v[0]->getArrayPointer();
132              //}
133  
125 –            static double* getArrayPointer(vector<Vector3d>& v) {
126 –                assert(v.size() > 0);
127 –                return v[0].getArrayPointer();
128 –            }
129 –            
130 –            static double* getArrayPointer(vector<RotMat3x3d>& v) {
131 –                assert(v.size() > 0);
132 –                return v[0].getArrayPointer();
133 –            }
134 –            
135 –            static double* getArrayPointer(vector<double>& v) {
136 –                assert(v.size() > 0);
137 –                return &(v[0]);
138 –            }
139 –
134              int getSize() {
135                  return atomData.size() + rigidbodyData.size();
136              }
137 <            
138 <            int getSizeOfAtoms() {
137 >
138 >            /** Returns the number of atoms */
139 >            int getNumberOfAtoms() {
140                  return atomData.size();
141              }
142 <            
143 <            int getSizeOfRigidBodies() {
142 >
143 >            /** Returns the number of rigid bodies */
144 >            int getNumberOfRigidBodies() {
145                  return rigidbodyData.size();
146              }
147 <            
147 >
148 >            /** Returns the H-Matrix */
149 >            Mat3x3d getHmat() {
150 >                return hmat_;
151 >            }
152 >
153 >            /** Sets the H-Matrix */
154 >            void setHamt(const Mat3x3d& m) {
155 >                hmat_ = m;
156 >                invHmat_ = hmat_.inverse();
157 >            }
158 >
159 >            /** Returns the inverse H-Matrix */
160 >            Mat3x3d getInvHmat() {
161 >                return invHmat_
162 >            }
163 >
164 >            double getTimeStamp() {
165 >                return timeStamp_;
166 >            }
167 >
168 >            void setTimeStamp(double timeStamp) {
169 >                timeStamp_ =timeStamp;
170 >            }
171 >
172 >
173              DataStorage atomData;
174              DataStorage rigidbodyData;
175 <
175 >            
176              friend class StuntDouble;
177 +            
178          private:
179 <
179 >            double timeStamp_;
180 >            Mat3x3d hmat_;
181 >            Mat3x3d invHmat_;
182              int id_; /**< identification number of the snapshot */
183      };
184  

Diff Legend

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