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

Matrix/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 
30 namespace CLHEP {
31 
32 class HepRotationY;
33 class HepRotation;
34 class HepBoost;
35 
36 inline HepRotationY inverseOf(const HepRotationY & r);
37 // Returns the inverse of a RotationY.
38 
43 class HepRotationY {
44 
45 public:
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 
58  inline HepRotationY & operator = (const HepRotationY & r);
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 
222  inline HepLorentzVector operator()( const HepLorentzVector & w ) const;
223  // Rotate (the space part of) a HepLorentzVector.
224 
225  inline HepLorentzVector operator* ( const HepLorentzVector & w ) const;
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 
245  inline HepRotationY & invert();
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 
258 protected:
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 
277 inline
278 std::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
287 using namespace CLHEP;
288 #endif
289 
290 #endif /* HEP_ROTATIONY_H */
291 
double getPhi() const
std::ostream & print(std::ostream &os) const
void setDelta(double delta)
bool operator>(const HepRotationY &r) const
static double proper(double delta)
double phiZ() const
Hep3Vector rowY() const
HepRotationY & operator=(const HepRotationY &r)
HepRotationY(const HepRotationY &orig)
HepLorentzVector col4() const
double delta() const
HepLorentzVector row4() const
double zz() const
HepRotationY & transform(const HepRotationY &r)
bool operator==(const HepRotationY &r) const
double yz() const
double theta() const
double yx() const
double yt() const
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
HepRotationY & invert()
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
HepRotationY & set(double delta)
void decompose(HepAxisAngle &rotation, Hep3Vector &boost) const
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
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)
double phiX() const
double ty() const
Hep3Vector rowZ() const
double norm2() const
double tx() const
HepRotationY & operator*=(const HepRotationY &r)
HepEulerAngles eulerAngles() const
double getTheta() const
HepBoost inverseOf(const HepBoost &lt)