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