| 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 HepRotationX
9 // around the X axis on objects of the Hep3Vec
10 //
11 // HepRotationX is a concrete implementation o
12 //
13 // .SS See Also
14 // RotationInterfaces.h
15 // ThreeVector.h, LorentzVector.h, LorentzRota
16 //
17 // .SS Author
18 // Mark Fischler
19
20 #ifndef HEP_ROTATIONX_H
21 #define HEP_ROTATIONX_H
22
23 #include "CLHEP/Vector/RotationInterfaces.h"
24
25 namespace CLHEP {
26
27 class HepRotationX;
28
29 class HepRotation;
30 class HepBoost;
31
32 inline HepRotationX inverseOf(const HepRotatio
33 // Returns the inverse of a RotationX.
34
35 /**
36 * @author
37 * @ingroup vector
38 */
39 class HepRotationX {
40
41 public:
42
43 // ---------- Constructors and Assignment:
44
45 inline HepRotationX();
46 // Default constructor. Gives an identity ro
47
48 HepRotationX(double delta);
49 // supply angle of rotation
50
51 inline HepRotationX(const HepRotationX & ori
52 inline HepRotationX(HepRotationX && orig) =
53 // Copy and move constructors.
54
55 inline HepRotationX & operator = (const HepR
56 inline HepRotationX & operator = (HepRotatio
57 // Copy and move assignments from a Rotation
58
59 HepRotationX & set ( double delta );
60 // set angle of rotation
61
62 inline ~HepRotationX();
63 // Trivial destructor.
64
65 // ---------- Accessors:
66
67 inline Hep3Vector colX() const;
68 inline Hep3Vector colY() const;
69 inline Hep3Vector colZ() const;
70 // orthogonal unit-length column vectors
71
72 inline Hep3Vector rowX() const;
73 inline Hep3Vector rowY() const;
74 inline Hep3Vector rowZ() const;
75 // orthogonal unit-length row vectors
76
77 inline double xx() const;
78 inline double xy() const;
79 inline double xz() const;
80 inline double yx() const;
81 inline double yy() const;
82 inline double yz() const;
83 inline double zx() const;
84 inline double zy() const;
85 inline double zz() const;
86 // Elements of the rotation matrix (Geant4).
87
88 inline HepRep3x3 rep3x3() const;
89 // 3x3 representation:
90
91 // ------------ Euler angles:
92 inline double getPhi () const;
93 inline double getTheta() const;
94 inline double getPsi () const;
95 double phi () const;
96 double theta() const;
97 double psi () const;
98 HepEulerAngles eulerAngles() const;
99
100 // ------------ axis & angle of rotation:
101 inline double getDelta() const;
102 inline Hep3Vector getAxis () const;
103 inline double delta() const;
104 inline Hep3Vector axis () const;
105 inline HepAxisAngle axisAngle() const;
106 inline void getAngleAxis(double & delta, He
107 // Returns the rotation angle and rotation a
108
109 // ------------- Angles of rotated axes
110 double phiX() const;
111 double phiY() const;
112 double phiZ() const;
113 double thetaX() const;
114 double thetaY() const;
115 double thetaZ() const;
116 // Return angles (RADS) made by rotated axes
117
118 // ---------- Other accessors treating pure
119
120 inline HepLorentzVector col1() const;
121 inline HepLorentzVector col2() const;
122 inline HepLorentzVector col3() const;
123 // orthosymplectic 4-vector columns - T com
124
125 inline HepLorentzVector col4() const;
126 // Will be (0,0,0,1) for this pure Rotation.
127
128 inline HepLorentzVector row1() const;
129 inline HepLorentzVector row2() const;
130 inline HepLorentzVector row3() const;
131 // orthosymplectic 4-vector rows - T compon
132
133 inline HepLorentzVector row4() const;
134 // Will be (0,0,0,1) for this pure Rotation.
135
136 inline double xt() const;
137 inline double yt() const;
138 inline double zt() const;
139 inline double tx() const;
140 inline double ty() const;
141 inline double tz() const;
142 // Will be zero for this pure Rotation
143
144 inline double tt() const;
145 // Will be one for this pure Rotation
146
147 inline HepRep4x4 rep4x4() const;
148 // 4x4 representation.
149
150 // --------- Mutators
151
152 void setDelta (double delta);
153 // change angle of rotation, leaving rotatio
154
155 // ---------- Decomposition:
156
157 void decompose (HepAxisAngle & rotation, Hep
158 void decompose (Hep3Vector & boost, HepAxisA
159 void decompose (HepRotation & rotation, HepB
160 void decompose (HepBoost & boost, HepRotatio
161 // These are trivial, as the boost vector is
162
163 // ---------- Comparisons:
164
165 inline bool isIdentity() const;
166 // Returns true if the identity matrix (Gean
167
168 inline int compare( const HepRotationX & r
169 // Dictionary-order comparison, in order of
170 // Used in operator<, >, <=, >=
171
172 inline bool operator== ( const HepRotationX
173 inline bool operator!= ( const HepRotationX
174 inline bool operator< ( const HepRotationX
175 inline bool operator> ( const HepRotationX
176 inline bool operator<= ( const HepRotationX
177 inline bool operator>= ( const HepRotationX
178
179 double distance2( const HepRotationX & r )
180 // 3 - Tr ( this/r )
181
182 double distance2( const HepRotation & r )
183 // 3 - Tr ( this/r ) -- This works with Rota
184
185 double howNear( const HepRotationX & r ) con
186 double howNear( const HepRotation & r ) con
187 bool isNear( const HepRotationX & r,
188 double epsilon=Hep4RotationInte
189 bool isNear( const HepRotation & r,
190 double epsilon=Hep4RotationInte
191
192 double distance2( const HepBoost &
193 // 3 - Tr ( this ) + |b|^2 / (1-|b|^2)
194 double distance2( const HepLorentzRotation &
195 // 3 - Tr ( this/r ) + |b|^2 / (1-|b|^2) whe
196
197 double howNear( const HepBoost & l
198 double howNear( const HepLorentzRotation & l
199 bool isNear( const HepBoost & lt,
200 double epsilon=Hep4RotationInte
201 bool isNear( const HepLorentzRotation & lt,
202 double epsilon=Hep4RotationInte
203
204 // ---------- Properties:
205
206 double norm2() const;
207 // distance2 (IDENTITY), which is 3 - Tr ( *
208
209 inline void rectify();
210 // non-const but logically moot correction f
211
212 // ---------- Application:
213
214 inline Hep3Vector operator() (const Hep3Vect
215 // Rotate a Hep3Vector.
216
217 inline Hep3Vector operator * (const Hep3Vec
218 // Multiplication with a Hep3Vector.
219
220 inline HepLorentzVector operator()( const He
221 // Rotate (the space part of) a HepLorentzVe
222
223 inline HepLorentzVector operator* ( const H
224 // Multiplication with a HepLorentzVector.
225
226 // ---------- Operations in the group of Rot
227
228 inline HepRotationX operator * (const HepRot
229 // Product of two X rotations: (this) * rx i
230
231 inline HepRotationX & operator *= (const He
232 inline HepRotationX & transform (const He
233 // Matrix multiplication.
234 // Note a *= b; <=> a = a * b; while a.trans
235 // However, in this special case, they commu
236
237 inline HepRotationX inverse() const;
238 // Returns the inverse.
239
240 friend HepRotationX inverseOf(const HepRotat
241 // Returns the inverse of a RotationX.
242
243 inline HepRotationX & invert();
244 // Inverts the Rotation matrix (be negating
245
246 // ---------- I/O:
247
248 std::ostream & print( std::ostream & os ) co
249 // Output, identifying type of rotation and
250
251 // ---------- Tolerance
252
253 static inline double getTolerance();
254 static inline double setTolerance(double tol
255
256 protected:
257
258 double its_d;
259 // The angle of rotation.
260
261 double its_s;
262 double its_c;
263 // Cache the trig functions, for rapid opera
264
265 inline HepRotationX ( double dd, double ss,
266 // Unchecked load-the-data-members
267
268 static inline double proper (double delta);
269 // Put an angle into the range of (-PI, PI].
270
271 }; // HepRotationX
272 // ---------- Free-function operations in the
273
274 inline
275 std::ostream & operator <<
276 ( std::ostream & os, const HepRotationX & r
277
278 } // namespace CLHEP
279
280 #include "CLHEP/Vector/RotationX.icc"
281
282 #endif /* HEP_ROTATIONX_H */
283