| Geant4 Cross Reference |
1 // -*- C++ -*- 1 // -*- C++ -*-
2 // CLASSDOC OFF 2 // CLASSDOC OFF
3 // ------------------------------------------- 3 // ---------------------------------------------------------------------------
4 // CLASSDOC ON 4 // CLASSDOC ON
5 // 5 //
6 // This file is a part of the CLHEP - a Class 6 // This file is a part of the CLHEP - a Class Library for High Energy Physics.
7 // 7 //
8 // This is the definition of the HepRotation c 8 // This is the definition of the HepRotation class for performing rotations
9 // on objects of the Hep3Vector (and HepLorent 9 // on objects of the Hep3Vector (and HepLorentzVector) class.
10 // 10 //
11 // HepRotation is a concrete implementation of 11 // HepRotation is a concrete implementation of Hep3RotationInterface.
12 // 12 //
13 // .SS See Also 13 // .SS See Also
14 // RotationInterfaces.h 14 // RotationInterfaces.h
15 // ThreeVector.h, LorentzVector.h, LorentzRota 15 // ThreeVector.h, LorentzVector.h, LorentzRotation.h
16 // 16 //
17 // .SS Author 17 // .SS Author
18 // Leif Lonnblad, Mark Fischler 18 // Leif Lonnblad, Mark Fischler
19 19
20 #ifndef HEP_ROTATION_H 20 #ifndef HEP_ROTATION_H
21 #define HEP_ROTATION_H 21 #define HEP_ROTATION_H
22 22
>> 23 #ifdef GNUPRAGMA
>> 24 #pragma interface
>> 25 #endif
>> 26
23 #include "CLHEP/Vector/RotationInterfaces.h" 27 #include "CLHEP/Vector/RotationInterfaces.h"
24 #include "CLHEP/Vector/RotationX.h" 28 #include "CLHEP/Vector/RotationX.h"
25 #include "CLHEP/Vector/RotationY.h" 29 #include "CLHEP/Vector/RotationY.h"
26 #include "CLHEP/Vector/RotationZ.h" 30 #include "CLHEP/Vector/RotationZ.h"
27 #include "CLHEP/Vector/LorentzVector.h" 31 #include "CLHEP/Vector/LorentzVector.h"
28 32
29 namespace CLHEP { 33 namespace CLHEP {
30 34
31 // Declarations of classes and global methods 35 // Declarations of classes and global methods
32 class HepRotation; 36 class HepRotation;
33 inline HepRotation inverseOf ( const HepRotati 37 inline HepRotation inverseOf ( const HepRotation & r );
34 inline HepRotation operator * (const HepRotati 38 inline HepRotation operator * (const HepRotationX & rx, const HepRotation & r);
35 inline HepRotation operator * (const HepRotati 39 inline HepRotation operator * (const HepRotationY & ry, const HepRotation & r);
36 inline HepRotation operator * (const HepRotati 40 inline HepRotation operator * (const HepRotationZ & rz, const HepRotation & r);
37 41
38 /** 42 /**
39 * @author 43 * @author
40 * @ingroup vector 44 * @ingroup vector
41 */ 45 */
42 class HepRotation { 46 class HepRotation {
43 47
44 public: 48 public:
45 49
46 // ---------- Constructors and Assignment: 50 // ---------- Constructors and Assignment:
47 51
48 inline HepRotation(); 52 inline HepRotation();
49 // Default constructor. Gives a unit matrix. 53 // Default constructor. Gives a unit matrix.
50 54
51 inline HepRotation(const HepRotation & m); 55 inline HepRotation(const HepRotation & m);
52 inline HepRotation(HepRotation && m) = defau 56 inline HepRotation(HepRotation && m) = default;
53 // Copy and move constructors. 57 // Copy and move constructors.
54 58
55 inline HepRotation(const HepRotationX & m); 59 inline HepRotation(const HepRotationX & m);
56 inline HepRotation(const HepRotationY & m); 60 inline HepRotation(const HepRotationY & m);
57 inline HepRotation(const HepRotationZ & m); 61 inline HepRotation(const HepRotationZ & m);
58 // Construct from specialized rotation. 62 // Construct from specialized rotation.
59 63
60 HepRotation & set( const Hep3Vector & axis, 64 HepRotation & set( const Hep3Vector & axis, double delta );
61 HepRotation ( const Hep3Vector & axis, 65 HepRotation ( const Hep3Vector & axis, double delta );
62 // Construct from axis and angle. 66 // Construct from axis and angle.
63 67
64 HepRotation & set( const HepAxisAngle & ax ) 68 HepRotation & set( const HepAxisAngle & ax );
65 HepRotation ( const HepAxisAngle & ax ) 69 HepRotation ( const HepAxisAngle & ax );
66 // Construct from AxisAngle structure. 70 // Construct from AxisAngle structure.
67 71
68 HepRotation & set( double phi, double theta, 72 HepRotation & set( double phi, double theta, double psi );
69 HepRotation ( double phi, double theta, 73 HepRotation ( double phi, double theta, double psi );
70 // Construct from three Euler angles (in rad 74 // Construct from three Euler angles (in radians).
71 75
72 HepRotation & set( const HepEulerAngles & e 76 HepRotation & set( const HepEulerAngles & e );
73 HepRotation ( const HepEulerAngles & e 77 HepRotation ( const HepEulerAngles & e );
74 // Construct from EulerAngles structure. 78 // Construct from EulerAngles structure.
75 79
76 HepRotation ( const Hep3Vector & colX, 80 HepRotation ( const Hep3Vector & colX,
77 const Hep3Vector & colY, 81 const Hep3Vector & colY,
78 const Hep3Vector & colZ ); 82 const Hep3Vector & colZ );
79 // Construct from three *orthogonal* unit ve 83 // Construct from three *orthogonal* unit vector columns.
80 // NOTE: 84 // NOTE:
81 // This constructor, and the two set 85 // This constructor, and the two set methods below,
82 // will check that the columns (or rows) f 86 // will check that the columns (or rows) form an orthonormal
83 // matrix, and will adjust values so that 87 // matrix, and will adjust values so that this relation is
84 // as exact as possible. 88 // as exact as possible.
85 89
86 HepRotation & set( const Hep3Vector & colX, 90 HepRotation & set( const Hep3Vector & colX,
87 const Hep3Vector 91 const Hep3Vector & colY,
88 const Hep3Vector 92 const Hep3Vector & colZ );
89 // supply three *orthogonal* unit vectors 93 // supply three *orthogonal* unit vectors for the columns.
90 94
91 HepRotation & setRows( const Hep3Vector & ro 95 HepRotation & setRows( const Hep3Vector & rowX,
92 const Hep3Vec 96 const Hep3Vector & rowY,
93 const Hep3Vec 97 const Hep3Vector & rowZ );
94 // supply three *orthogonal* unit vectors 98 // supply three *orthogonal* unit vectors for the rows.
95 99
96 inline HepRotation & set(const HepRotationX 100 inline HepRotation & set(const HepRotationX & r);
97 inline HepRotation & set(const HepRotationY 101 inline HepRotation & set(const HepRotationY & r);
98 inline HepRotation & set(const HepRotationZ 102 inline HepRotation & set(const HepRotationZ & r);
99 // set from specialized rotation. 103 // set from specialized rotation.
100 104
101 inline HepRotation & operator = (const HepR 105 inline HepRotation & operator = (const HepRotation & r);
102 inline HepRotation & operator = (HepRotatio 106 inline HepRotation & operator = (HepRotation && r) = default;
103 // Copy and move assignment operators. 107 // Copy and move assignment operators.
104 108
105 inline HepRotation & operator = (const HepR 109 inline HepRotation & operator = (const HepRotationX & r);
106 inline HepRotation & operator = (const HepR 110 inline HepRotation & operator = (const HepRotationY & r);
107 inline HepRotation & operator = (const HepR 111 inline HepRotation & operator = (const HepRotationZ & r);
108 // Assignment from specialized rotation. 112 // Assignment from specialized rotation.
109 113
110 inline HepRotation &set( const HepRep3x3 & m 114 inline HepRotation &set( const HepRep3x3 & m );
111 inline HepRotation ( const HepRep3x3 & m 115 inline HepRotation ( const HepRep3x3 & m );
112 // WARNING - NO CHECKING IS DONE! 116 // WARNING - NO CHECKING IS DONE!
113 // Constructon directly from from a 3x3 repr 117 // Constructon directly from from a 3x3 representation,
114 // which is required to be an orthogonal mat 118 // which is required to be an orthogonal matrix.
115 119
116 inline ~HepRotation(); 120 inline ~HepRotation();
117 // Trivial destructor. 121 // Trivial destructor.
118 122
119 // ---------- Accessors: 123 // ---------- Accessors:
120 124
121 inline Hep3Vector colX() const; 125 inline Hep3Vector colX() const;
122 inline Hep3Vector colY() const; 126 inline Hep3Vector colY() const;
123 inline Hep3Vector colZ() const; 127 inline Hep3Vector colZ() const;
124 // orthogonal unit-length column vectors 128 // orthogonal unit-length column vectors
125 129
126 inline Hep3Vector rowX() const; 130 inline Hep3Vector rowX() const;
127 inline Hep3Vector rowY() const; 131 inline Hep3Vector rowY() const;
128 inline Hep3Vector rowZ() const; 132 inline Hep3Vector rowZ() const;
129 // orthogonal unit-length row vectors 133 // orthogonal unit-length row vectors
130 134
131 inline double xx() const; 135 inline double xx() const;
132 inline double xy() const; 136 inline double xy() const;
133 inline double xz() const; 137 inline double xz() const;
134 inline double yx() const; 138 inline double yx() const;
135 inline double yy() const; 139 inline double yy() const;
136 inline double yz() const; 140 inline double yz() const;
137 inline double zx() const; 141 inline double zx() const;
138 inline double zy() const; 142 inline double zy() const;
139 inline double zz() const; 143 inline double zz() const;
140 // Elements of the rotation matrix (Geant4). 144 // Elements of the rotation matrix (Geant4).
141 145
142 inline HepRep3x3 rep3x3() const; 146 inline HepRep3x3 rep3x3() const;
143 // 3x3 representation: 147 // 3x3 representation:
144 148
145 // ------------ Subscripting: 149 // ------------ Subscripting:
146 150
147 class HepRotation_row { 151 class HepRotation_row {
148 public: 152 public:
149 inline HepRotation_row(const HepRotation & 153 inline HepRotation_row(const HepRotation &, int);
150 inline double operator [] (int) const; 154 inline double operator [] (int) const;
151 private: 155 private:
152 const HepRotation & rr; 156 const HepRotation & rr;
153 int ii; 157 int ii;
154 }; 158 };
155 // Helper class for implemention of C-style 159 // Helper class for implemention of C-style subscripting r[i][j]
156 160
157 inline const HepRotation_row operator [] (in 161 inline const HepRotation_row operator [] (int) const;
158 // Returns object of the helper class for C- 162 // Returns object of the helper class for C-style subscripting r[i][j]
159 // i and j range from 0 to 2. 163 // i and j range from 0 to 2.
160 164
161 double operator () (int, int) const; 165 double operator () (int, int) const;
162 // Fortran-style subscripting: returns (i,j) 166 // Fortran-style subscripting: returns (i,j) element of the rotation matrix.
163 // Note: i and j still range from 0 to 2. 167 // Note: i and j still range from 0 to 2. [Rotation.cc]
164 168
165 // ------------ Euler angles: 169 // ------------ Euler angles:
166 inline double getPhi () const; 170 inline double getPhi () const;
167 inline double getTheta() const; 171 inline double getTheta() const;
168 inline double getPsi () const; 172 inline double getPsi () const;
169 double phi () const; 173 double phi () const;
170 double theta() const; 174 double theta() const;
171 double psi () const; 175 double psi () const;
172 HepEulerAngles eulerAngles() const; 176 HepEulerAngles eulerAngles() const;
173 177
174 // ------------ axis & angle of rotation: 178 // ------------ axis & angle of rotation:
175 inline double getDelta() const; 179 inline double getDelta() const;
176 inline Hep3Vector getAxis () const; 180 inline Hep3Vector getAxis () const;
177 double delta() const; 181 double delta() const;
178 Hep3Vector axis () const; 182 Hep3Vector axis () const;
179 HepAxisAngle axisAngle() const; 183 HepAxisAngle axisAngle() const;
180 void getAngleAxis(double & delta, Hep3Vector 184 void getAngleAxis(double & delta, Hep3Vector & axis) const;
181 // Returns the rotation angle and rotation a 185 // Returns the rotation angle and rotation axis (Geant4). [Rotation.cc]
182 186
183 // ------------- Angles of rotated axes 187 // ------------- Angles of rotated axes
184 double phiX() const; 188 double phiX() const;
185 double phiY() const; 189 double phiY() const;
186 double phiZ() const; 190 double phiZ() const;
187 double thetaX() const; 191 double thetaX() const;
188 double thetaY() const; 192 double thetaY() const;
189 double thetaZ() const; 193 double thetaZ() const;
190 // Return angles (RADS) made by rotated axes 194 // Return angles (RADS) made by rotated axes against original axes (Geant4).
191 // [Rotation.cc] 195 // [Rotation.cc]
192 196
193 // ---------- Other accessors treating pure 197 // ---------- Other accessors treating pure rotation as a 4-rotation
194 198
195 inline HepLorentzVector col1() const; 199 inline HepLorentzVector col1() const;
196 inline HepLorentzVector col2() const; 200 inline HepLorentzVector col2() const;
197 inline HepLorentzVector col3() const; 201 inline HepLorentzVector col3() const;
198 // orthosymplectic 4-vector columns - T com 202 // orthosymplectic 4-vector columns - T component will be zero
199 203
200 inline HepLorentzVector col4() const; 204 inline HepLorentzVector col4() const;
201 // Will be (0,0,0,1) for this pure Rotation. 205 // Will be (0,0,0,1) for this pure Rotation.
202 206
203 inline HepLorentzVector row1() const; 207 inline HepLorentzVector row1() const;
204 inline HepLorentzVector row2() const; 208 inline HepLorentzVector row2() const;
205 inline HepLorentzVector row3() const; 209 inline HepLorentzVector row3() const;
206 // orthosymplectic 4-vector rows - T compon 210 // orthosymplectic 4-vector rows - T component will be zero
207 211
208 inline HepLorentzVector row4() const; 212 inline HepLorentzVector row4() const;
209 // Will be (0,0,0,1) for this pure Rotation. 213 // Will be (0,0,0,1) for this pure Rotation.
210 214
211 inline double xt() const; 215 inline double xt() const;
212 inline double yt() const; 216 inline double yt() const;
213 inline double zt() const; 217 inline double zt() const;
214 inline double tx() const; 218 inline double tx() const;
215 inline double ty() const; 219 inline double ty() const;
216 inline double tz() const; 220 inline double tz() const;
217 // Will be zero for this pure Rotation 221 // Will be zero for this pure Rotation
218 222
219 inline double tt() const; 223 inline double tt() const;
220 // Will be one for this pure Rotation 224 // Will be one for this pure Rotation
221 225
222 inline HepRep4x4 rep4x4() const; 226 inline HepRep4x4 rep4x4() const;
223 // 4x4 representation. 227 // 4x4 representation.
224 228
225 // --------- Mutators 229 // --------- Mutators
226 230
227 void setPhi (double phi); 231 void setPhi (double phi);
228 // change Euler angle phi, leaving theta and 232 // change Euler angle phi, leaving theta and psi unchanged.
229 233
230 void setTheta (double theta); 234 void setTheta (double theta);
231 // change Euler angle theta, leaving phi and 235 // change Euler angle theta, leaving phi and psi unchanged.
232 236
233 void setPsi (double psi); 237 void setPsi (double psi);
234 // change Euler angle psi, leaving theta and 238 // change Euler angle psi, leaving theta and phi unchanged.
235 239
236 void setAxis (const Hep3Vector & axis); 240 void setAxis (const Hep3Vector & axis);
237 // change rotation axis, leaving delta uncha 241 // change rotation axis, leaving delta unchanged.
238 242
239 void setDelta (double delta); 243 void setDelta (double delta);
240 // change angle of rotation, leaving rotatio 244 // change angle of rotation, leaving rotation axis unchanged.
241 245
242 // ---------- Decomposition: 246 // ---------- Decomposition:
243 247
244 void decompose (HepAxisAngle & rotation, Hep 248 void decompose (HepAxisAngle & rotation, Hep3Vector & boost) const;
245 void decompose (Hep3Vector & boost, HepAxisA 249 void decompose (Hep3Vector & boost, HepAxisAngle & rotation) const;
246 // These are trivial, as the boost vector is 250 // These are trivial, as the boost vector is 0. [RotationP.cc]
247 251
248 // ---------- Comparisons: 252 // ---------- Comparisons:
249 253
250 bool isIdentity() const; 254 bool isIdentity() const;
251 // Returns true if the identity matrix (Gean 255 // Returns true if the identity matrix (Geant4). [Rotation.cc]
252 256
253 int compare( const HepRotation & r ) const; 257 int compare( const HepRotation & r ) const;
254 // Dictionary-order comparison, in order zz, 258 // Dictionary-order comparison, in order zz, zy, zx, yz, ... xx
255 // Used in operator<, >, <=, >= 259 // Used in operator<, >, <=, >=
256 260
257 inline bool operator== ( const HepRotation & 261 inline bool operator== ( const HepRotation & r ) const;
258 inline bool operator!= ( const HepRotation & 262 inline bool operator!= ( const HepRotation & r ) const;
259 inline bool operator< ( const HepRotation & 263 inline bool operator< ( const HepRotation & r ) const;
260 inline bool operator> ( const HepRotation & 264 inline bool operator> ( const HepRotation & r ) const;
261 inline bool operator<= ( const HepRotation & 265 inline bool operator<= ( const HepRotation & r ) const;
262 inline bool operator>= ( const HepRotation & 266 inline bool operator>= ( const HepRotation & r ) const;
263 267
264 double distance2( const HepRotation & r ) 268 double distance2( const HepRotation & r ) const;
265 // 3 - Tr ( this/r ) -- This works with Rota 269 // 3 - Tr ( this/r ) -- This works with RotationX, Y or Z also
266 270
267 double howNear( const HepRotation & r ) cons 271 double howNear( const HepRotation & r ) const;
268 bool isNear( const HepRotation & r, 272 bool isNear( const HepRotation & r,
269 double epsilon=Hep4RotationInterf 273 double epsilon=Hep4RotationInterface::tolerance) const;
270 274
271 double distance2( const HepBoost & 275 double distance2( const HepBoost & lt ) const;
272 // 3 - Tr ( this ) + |b|^2 / (1-|b|^2) 276 // 3 - Tr ( this ) + |b|^2 / (1-|b|^2)
273 double distance2( const HepLorentzRotation & 277 double distance2( const HepLorentzRotation & lt ) const;
274 // 3 - Tr ( this/r ) + |b|^2 / (1-|b|^2) whe 278 // 3 - Tr ( this/r ) + |b|^2 / (1-|b|^2) where b is the boost vector of lt
275 279
276 double howNear( const HepBoost & l 280 double howNear( const HepBoost & lt ) const;
277 double howNear( const HepLorentzRotation & l 281 double howNear( const HepLorentzRotation & lt ) const;
278 bool isNear( const HepBoost & lt, 282 bool isNear( const HepBoost & lt,
279 double epsilon=Hep4RotationInterf 283 double epsilon=Hep4RotationInterface::tolerance) const;
280 bool isNear( const HepLorentzRotation & lt, 284 bool isNear( const HepLorentzRotation & lt,
281 double epsilon=Hep4RotationInterf 285 double epsilon=Hep4RotationInterface::tolerance) const;
282 286
283 // ---------- Properties: 287 // ---------- Properties:
284 288
285 double norm2() const; 289 double norm2() const;
286 // distance2 (IDENTITY), which is 3 - Tr ( * 290 // distance2 (IDENTITY), which is 3 - Tr ( *this )
287 291
288 void rectify(); 292 void rectify();
289 // non-const but logically moot correction f 293 // non-const but logically moot correction for accumulated roundoff errors
290 // rectify averages the matrix with the tran 294 // rectify averages the matrix with the transpose of its actual
291 // inverse (absent accumulated roundoff erro 295 // inverse (absent accumulated roundoff errors, the transpose IS
292 // the inverse)); this removes to first orde 296 // the inverse)); this removes to first order those errors.
293 // Then it formally extracts axis and delta, 297 // Then it formally extracts axis and delta, and forms a true
294 // HepRotation with those values of axis and 298 // HepRotation with those values of axis and delta.
295 299
296 // ---------- Application: 300 // ---------- Application:
297 301
298 inline Hep3Vector operator() (const Hep3Vect 302 inline Hep3Vector operator() (const Hep3Vector & p) const;
299 // Rotate a Hep3Vector. 303 // Rotate a Hep3Vector.
300 304
301 inline Hep3Vector operator * (const Hep3Vec 305 inline Hep3Vector operator * (const Hep3Vector & p) const;
302 // Multiplication with a Hep3Vector. 306 // Multiplication with a Hep3Vector.
303 307
304 inline HepLorentzVector operator()( const He 308 inline HepLorentzVector operator()( const HepLorentzVector & w ) const;
305 // Rotate (the space part of) a HepLorentzVe 309 // Rotate (the space part of) a HepLorentzVector.
306 310
307 inline HepLorentzVector operator* ( const H 311 inline HepLorentzVector operator* ( const HepLorentzVector & w ) const;
308 // Multiplication with a HepLorentzVector. 312 // Multiplication with a HepLorentzVector.
309 313
310 // ---------- Operations in the group of Rot 314 // ---------- Operations in the group of Rotations
311 315
312 inline HepRotation operator * (const HepRota 316 inline HepRotation operator * (const HepRotation & r) const;
313 // Product of two rotations (this) * r - mat 317 // Product of two rotations (this) * r - matrix multiplication
314 318
315 inline HepRotation operator * (const HepRota 319 inline HepRotation operator * (const HepRotationX & rx) const;
316 inline HepRotation operator * (const HepRota 320 inline HepRotation operator * (const HepRotationY & ry) const;
317 inline HepRotation operator * (const HepRota 321 inline HepRotation operator * (const HepRotationZ & rz) const;
318 // Product of two rotations (this) * r - fas 322 // Product of two rotations (this) * r - faster when specialized type
319 323
320 inline HepRotation & operator *= (const Hep 324 inline HepRotation & operator *= (const HepRotation & r);
321 inline HepRotation & transform (const Hep 325 inline HepRotation & transform (const HepRotation & r);
322 // Matrix multiplication. 326 // Matrix multiplication.
323 // Note a *= b; <=> a = a * b; while a.trans 327 // Note a *= b; <=> a = a * b; while a.transform(b); <=> a = b * a;
324 328
325 inline HepRotation & operator *= (const Hep 329 inline HepRotation & operator *= (const HepRotationX & r);
326 inline HepRotation & operator *= (const Hep 330 inline HepRotation & operator *= (const HepRotationY & r);
327 inline HepRotation & operator *= (const Hep 331 inline HepRotation & operator *= (const HepRotationZ & r);
328 inline HepRotation & transform (const Hep 332 inline HepRotation & transform (const HepRotationX & r);
329 inline HepRotation & transform (const Hep 333 inline HepRotation & transform (const HepRotationY & r);
330 inline HepRotation & transform (const Hep 334 inline HepRotation & transform (const HepRotationZ & r);
331 // Matrix multiplication by specialized matr 335 // Matrix multiplication by specialized matrices
332 336
333 HepRotation & rotateX(double delta); 337 HepRotation & rotateX(double delta);
334 // Rotation around the x-axis; equivalent to 338 // Rotation around the x-axis; equivalent to R = RotationX(delta) * R
335 339
336 HepRotation & rotateY(double delta); 340 HepRotation & rotateY(double delta);
337 // Rotation around the y-axis; equivalent to 341 // Rotation around the y-axis; equivalent to R = RotationY(delta) * R
338 342
339 HepRotation & rotateZ(double delta); 343 HepRotation & rotateZ(double delta);
340 // Rotation around the z-axis; equivalent to 344 // Rotation around the z-axis; equivalent to R = RotationZ(delta) * R
341 345
342 HepRotation & rotate(double delta, co 346 HepRotation & rotate(double delta, const Hep3Vector & axis);
343 inline HepRotation & rotate(double delta, co 347 inline HepRotation & rotate(double delta, const Hep3Vector * axis);
344 // Rotation around a specified vector. 348 // Rotation around a specified vector.
345 // r.rotate(d,a) is equivalent to r = Rotati 349 // r.rotate(d,a) is equivalent to r = Rotation(d,a) * r
346 350
347 HepRotation & rotateAxes(const Hep3Vector & 351 HepRotation & rotateAxes(const Hep3Vector & newX,
348 const Hep3Vector & 352 const Hep3Vector & newY,
349 const Hep3Vector & 353 const Hep3Vector & newZ);
350 // Rotation of local axes defined by 3 ortho 354 // Rotation of local axes defined by 3 orthonormal vectors (Geant4).
351 // Equivalent to r = Rotation (newX, newY, n 355 // Equivalent to r = Rotation (newX, newY, newZ) * r
352 356
353 inline HepRotation inverse() const; 357 inline HepRotation inverse() const;
354 // Returns the inverse. 358 // Returns the inverse.
355 359
356 inline HepRotation & invert(); 360 inline HepRotation & invert();
357 // Inverts the Rotation matrix. 361 // Inverts the Rotation matrix.
358 362
359 // ---------- I/O: 363 // ---------- I/O:
360 364
361 std::ostream & print( std::ostream & os ) co 365 std::ostream & print( std::ostream & os ) const;
362 // Aligned six-digit-accurate output of the 366 // Aligned six-digit-accurate output of the rotation matrix. [RotationIO.cc]
363 367
364 // ---------- Identity Rotation: 368 // ---------- Identity Rotation:
365 369
366 DLL_API static const HepRotation IDENTITY; 370 DLL_API static const HepRotation IDENTITY;
367 371
368 // ---------- Tolerance 372 // ---------- Tolerance
369 373
370 static inline double getTolerance(); 374 static inline double getTolerance();
371 static inline double setTolerance(double tol 375 static inline double setTolerance(double tol);
372 376
373 protected: 377 protected:
374 378
375 inline HepRotation(double mxx, double mxy, d 379 inline HepRotation(double mxx, double mxy, double mxz,
376 double myx, double myy, double myz, 380 double myx, double myy, double myz,
377 double mzx, double mzy, double mzz); 381 double mzx, double mzy, double mzz);
378 // Protected constructor. 382 // Protected constructor.
379 // DOES NOT CHECK FOR VALIDITY AS A ROTATION 383 // DOES NOT CHECK FOR VALIDITY AS A ROTATION.
380 384
381 friend HepRotation operator* (const HepRotat 385 friend HepRotation operator* (const HepRotationX & rx, const HepRotation & r);
382 friend HepRotation operator* (const HepRotat 386 friend HepRotation operator* (const HepRotationY & ry, const HepRotation & r);
383 friend HepRotation operator* (const HepRotat 387 friend HepRotation operator* (const HepRotationZ & rz, const HepRotation & r);
384 388
385 double rxx, rxy, rxz, 389 double rxx, rxy, rxz,
386 ryx, ryy, ryz, 390 ryx, ryy, ryz,
387 rzx, rzy, rzz; 391 rzx, rzy, rzz;
388 // The matrix elements. 392 // The matrix elements.
389 393
390 private: 394 private:
391 bool 395 bool
392 setCols ( const Hep3Vector & u1, // Vec 396 setCols ( const Hep3Vector & u1, // Vectors assume to be of unit length
393 const Hep3Vector & u2, 397 const Hep3Vector & u2,
394 const Hep3Vector & u3, 398 const Hep3Vector & u3,
395 double u1u2, 399 double u1u2,
396 Hep3Vector & v1, // Returne 400 Hep3Vector & v1, // Returned vectors
397 Hep3Vector & v2, 401 Hep3Vector & v2,
398 Hep3Vector & v3 ) const; 402 Hep3Vector & v3 ) const;
399 void setArbitrarily (const Hep3Vector & colX 403 void setArbitrarily (const Hep3Vector & colX, // assumed to be of unit length
400 Hep3Vector & v1, 404 Hep3Vector & v1,
401 Hep3Vector & v2, 405 Hep3Vector & v2,
402 Hep3Vector & v3) const; 406 Hep3Vector & v3) const;
403 }; // HepRotation 407 }; // HepRotation
404 408
405 inline 409 inline
406 std::ostream & operator << 410 std::ostream & operator <<
407 ( std::ostream & os, const HepRotation & r ) 411 ( std::ostream & os, const HepRotation & r ) {return r.print(os);}
408 412
409 } // namespace CLHEP 413 } // namespace CLHEP
410 414
411 #include "CLHEP/Vector/Rotation.icc" 415 #include "CLHEP/Vector/Rotation.icc"
412 416
413 #endif /* HEP_ROTATION_H */ 417 #endif /* HEP_ROTATION_H */
414 418
415 419