CLHEP VERSION Reference Documentation
   
CLHEP Home Page     CLHEP Documentation     CLHEP Bug Reports

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