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