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

Vector/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 
52  HepRotationY(double delta);
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;
100  HepEulerAngles eulerAngles() 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 
233  inline HepRotationY & operator *= (const HepRotationY & r);
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 
242  friend HepRotationY inverseOf(const HepRotationY & r);
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 
CLHEP::HepRotationY::delta
double delta() const
CLHEP::HepRotationY::xz
double xz() const
CLHEP::HepRotationY::isNear
bool isNear(const HepRotationY &r, double epsilon=Hep4RotationInterface::tolerance) const
Definition: RotationY.cc:175
CLHEP::HepRotationY::proper
static double proper(double delta)
CLHEP::HepRotationY::tt
double tt() const
CLHEP::HepRotationY::getTolerance
static double getTolerance()
cc
Technical Maintenance Note for CLHEP Random Consequences of seeding JamesRandom with positive seed values greater than In the source code JamesRandom cc
Definition: JamesRandomSeeding.txt:8
CLHEP::HepRotationY::xt
double xt() const
CLHEP::HepRotationY::set
HepRotationY & set(double delta)
Definition: RotationY.cc:36
CLHEP::HepRotationY::operator>
bool operator>(const HepRotationY &r) const
CLHEP::HepRotationY::transform
HepRotationY & transform(const HepRotationY &r)
CLHEP::HepRotationY::getDelta
double getDelta() const
HepBoost
namespace and inside the zmpv namespace it typedef s UnitVector to be HepUnit3Vector The conversion which provide those methods available for GETTING INFORMATION if an object might be either a Rotation or a since RI has methods a routine can be passed a RI &and take because anything you wish to ask about a LT you could equally well ask about a Rotation From one derives Rotation and its special cases RotationX etc We can t derive RotationX from from one derives HepLorentzRotation along with HepBoost
Definition: keyMergeIssues.doc:304
CLHEP::HepRotationY::zx
double zx() const
CLHEP::HepRotationY::setDelta
void setDelta(double delta)
Definition: RotationY.cc:108
CLHEP::HepRotationY::getAxis
Hep3Vector getAxis() const
CLHEP::HepRotationY::rowY
Hep3Vector rowY() const
CLHEP::HepRotationY::rectify
void rectify()
CLHEP::HepRotationY::HepRotationY
HepRotationY()
CLHEP::HepRotationY::~HepRotationY
~HepRotationY()
CLHEP::HepRotationY::thetaX
double thetaX() const
Definition: RotationY.cc:94
CLHEP::HepRotationY::norm2
double norm2() const
Definition: RotationY.cc:189
CLHEP::HepRotationY::thetaZ
double thetaZ() const
Definition: RotationY.cc:103
CLHEP::HepRotationY::operator()
Hep3Vector operator()(const Hep3Vector &p) const
CLHEP::HepRotationY::getPsi
double getPsi() const
CLHEP::HepRotationY::xy
double xy() const
CLHEP::HepRotationY::zy
double zy() const
CLHEP::HepRotationY::inverse
HepRotationY inverse() const
CLHEP::HepRotationY::rowX
Hep3Vector rowX() const
CLHEP::HepRotationY::operator*=
HepRotationY & operator*=(const HepRotationY &r)
CLHEP::HepRotationY::howNear
double howNear(const HepRotationY &r) const
Definition: RotationY.cc:163
CLHEP::HepRotationY::zz
double zz() const
CLHEP::Hep4RotationInterface::tolerance
static double tolerance
Definition: Geometry/CLHEP/Vector/RotationInterfaces.h:118
CLHEP::HepRotationY::operator=
HepRotationY & operator=(const HepRotationY &r)
CLHEP::HepRotationY::axisAngle
HepAxisAngle axisAngle() const
CLHEP::HepRotationY::col4
HepLorentzVector col4() const
CLHEP::HepRotationY::phiX
double phiX() const
Definition: RotationY.cc:79
CLHEP::HepRotationY::its_d
double its_d
Definition: Geometry/CLHEP/Vector/RotationY.h:260
CLHEP::HepRotationY::tz
double tz() const
CLHEP::HepRotationY::operator==
bool operator==(const HepRotationY &r) const
CLHEP::HepRotationY::ty
double ty() const
CLHEP::HepRotationY::yt
double yt() const
CLHEP::HepRotationY::colZ
Hep3Vector colZ() const
CLHEP::HepRotationY::invert
HepRotationY & invert()
CLHEP::HepRotationY::its_s
double its_s
Definition: Geometry/CLHEP/Vector/RotationY.h:263
CLHEP::HepRotationY::axis
Hep3Vector axis() const
CLHEP::HepRotationY::yy
double yy() const
CLHEP::HepRotationY::operator>=
bool operator>=(const HepRotationY &r) const
CLHEP::HepRotationY::psi
double psi() const
Definition: RotationY.cc:57
CLHEP::HepRotationY::phiY
double phiY() const
Definition: RotationY.cc:84
CLHEP
Definition: ClhepVersion.h:13
CLHEP::HepRotationY::rep3x3
HepRep3x3 rep3x3() const
CLHEP::HepRotationY::zt
double zt() const
CLHEP::HepRotationY::getPhi
double getPhi() const
CLHEP::HepRotationY::yx
double yx() const
CLHEP::HepRotationY::eulerAngles
HepEulerAngles eulerAngles() const
Definition: RotationY.cc:67
CLHEP::HepRotationY::operator<
bool operator<(const HepRotationY &r) const
Hep3Vector
Issues Concerning the PhysicsVectors CLHEP Vector Merge The merge of ZOOM PhysicsVdectors and the CLHEP Vector package is completed The purpose of this document is to list the major issues that affected the merge of these and where relevant describe the resolutions More detailed documents describe more minor issues General Approach As agreed at the June CLHEP the approach is to combine the features of each ZOOM class with the corresponding CLHEP class expanding the interface to create a single lingua franca of what a Hep3Vector(for example) means. We are not forming SpaceVector as an class derived from Hep3Vector and enhancing it in that way. Another rule imposed by the agreement is to avoid using the Exceptions package(even though that will later go into CLHEP for other uses). A desirable goal is to avoid cluttering the interface and enlarging the code linked in when ordinary CLHEP Vector functionallity is used. To this end
CLHEP::HepRotationY::print
std::ostream & print(std::ostream &os) const
Definition: RotationY.cc:193
CLHEP::HepRotationY::getAngleAxis
void getAngleAxis(double &delta, Hep3Vector &axis) const
CLHEP::inverseOf
HepBoost inverseOf(const HepBoost &lt)
CLHEP::HepRotationY::theta
double theta() const
Definition: RotationY.cc:53
CLHEP::HepRotationY::row3
HepLorentzVector row3() const
CLHEP::HepRotationY::tx
double tx() const
CLHEP::HepRotationY::compare
int compare(const HepRotationY &r) const
CLHEP::HepRotationY::col3
HepLorentzVector col3() const
CLHEP::HepRotationY::row1
HepLorentzVector row1() const
CLHEP::HepRotationY::phiZ
double phiZ() const
Definition: RotationY.cc:89
CLHEP::HepRotationY::operator<=
bool operator<=(const HepRotationY &r) const
CLHEP::HepRotationY::phi
double phi() const
Definition: RotationY.cc:43
CLHEP::HepRotationY::col2
HepLorentzVector col2() const
CLHEP::HepRotationY::rep4x4
HepRep4x4 rep4x4() const
CLHEP::HepRotationY::decompose
void decompose(HepAxisAngle &rotation, Hep3Vector &boost) const
Definition: RotationY.cc:113
CLHEP::HepRotationY::row2
HepLorentzVector row2() const
CLHEP::HepRotationY::inverseOf
friend HepRotationY inverseOf(const HepRotationY &r)
CLHEP::HepRotationY::xx
double xx() const
CLHEP::HepRotationY::getTheta
double getTheta() const
CLHEP::HepRotationY::its_c
double its_c
Definition: Geometry/CLHEP/Vector/RotationY.h:264
CLHEP::HepRotationY::colX
Hep3Vector colX() const
CLHEP::HepRotationY::thetaY
double thetaY() const
Definition: RotationY.cc:98
CLHEP::HepRotationY::setTolerance
static double setTolerance(double tol)
CLHEP::HepRotationY::isIdentity
bool isIdentity() const
CLHEP::HepRotationY::distance2
double distance2(const HepRotationY &r) const
Definition: RotationY.cc:136
CLHEP::HepRotationY::row4
HepLorentzVector row4() const
CLHEP::HepRotationY::col1
HepLorentzVector col1() const
CLHEP::HepRotationY::operator!=
bool operator!=(const HepRotationY &r) const
CLHEP::HepRotationY::operator*
Hep3Vector operator*(const Hep3Vector &p) const
CLHEP::HepRotationY::yz
double yz() const
CLHEP::HepRotationY::rowZ
Hep3Vector rowZ() const
CLHEP::HepRotationY::colY
Hep3Vector colY() const