CLHEP/Vector/RotationY.h

0001 // -*- C++ -*-
0002 // CLASSDOC OFF
0003 // ---------------------------------------------------------------------------
0004 // CLASSDOC ON
0005 //
0006 // This file is a part of the CLHEP - a Class Library for High Energy Physics.
0007 //
0008 // This is the definition of the HepRotationY class for performing rotations
0009 // around the X axis on objects of the Hep3Vector (and HepLorentzVector) class.
0010 //
0011 // HepRotationY is a concrete implementation of Hep3RotationInterface.
0012 //
0013 // .SS See Also
0014 // RotationInterfaces.h
0015 // ThreeVector.h, LorentzVector.h, LorentzRotation.h
0016 //
0017 // .SS Author
0018 // Mark Fischler
0019
0020 #ifndef HEP_ROTATIONY_H
0021 #define HEP_ROTATIONY_H
0022
0023 #include "CLHEP/Vector/defs.h"
0024 #include "CLHEP/Vector/RotationInterfaces.h"
0025
0026 namespace CLHEP {
0027
0028 class HepRotationY;
0029 class HepRotation;
0030 class HepBoost;
0031
0032 inline HepRotationY inverseOf(const HepRotationY & r);
0033 // Returns the inverse of a RotationY.
0034
0035 /**
0036  * @author
0037  * @ingroup vector
0038  */
0039 class HepRotationY {
0040
0041 public:
0042
0043   // ----------  Constructors and Assignment:
0044
0045   inline HepRotationY();
0046   // Default constructor. Gives an identity rotation.
0047
0048   HepRotationY(double delta);
0049   // supply angle of rotation
0050
0051   inline HepRotationY(const HepRotationY & orig);
0052   inline HepRotationY(HepRotationY && orig) = default;
0053   // Copy and move constructors.
0054
0055   inline HepRotationY & operator = (const HepRotationY & r);
0056   inline HepRotationY & operator = (HepRotationY && r) = default;
0057   // Copy and move assignments from a Rotation, which must be RotationY
0058
0059   HepRotationY & set ( double delta );
0060   // set angle of rotation
0061
0062   inline ~HepRotationY();
0063   // Trivial destructor.
0064
0065   // ----------  Accessors:
0066
0067   inline Hep3Vector colX() const;
0068   inline Hep3Vector colY() const;
0069   inline Hep3Vector colZ() const;
0070   // orthogonal unit-length column vectors
0071
0072   inline Hep3Vector rowX() const;
0073   inline Hep3Vector rowY() const;
0074   inline Hep3Vector rowZ() const;
0075   // orthogonal unit-length row vectors
0076
0077   inline double xx() const;
0078   inline double xy() const;
0079   inline double xz() const;
0080   inline double yx() const;
0081   inline double yy() const;
0082   inline double yz() const;
0083   inline double zx() const;
0084   inline double zy() const;
0085   inline double zz() const;
0086   // Elements of the rotation matrix (Geant4).
0087
0088   inline HepRep3x3 rep3x3() const;
0089   //   3x3 representation:
0090
0091   // ------------  Euler angles:
0092   inline  double getPhi  () const;
0093   inline  double getTheta() const;
0094   inline  double getPsi  () const;
0095   double    phi  () const;
0096   double    theta() const;
0097   double    psi  () const;
0098   HepEulerAngles eulerAngles() const;
0099
0100   // ------------  axis & angle of rotation:
0101   inline  double  getDelta() const;
0102   inline  Hep3Vector getAxis () const;
0103   inline  double     delta() const;
0104   inline  Hep3Vector    axis () const;
0105   inline  HepAxisAngle  axisAngle() const;
0106   inline  void getAngleAxis(double & delta, Hep3Vector & axis) const;
0107   // Returns the rotation angle and rotation axis (Geant4).
0108
0109   // ------------- Angles of rotated axes
0110   double phiX() const;
0111   double phiY() const;
0112   double phiZ() const;
0113   double thetaX() const;
0114   double thetaY() const;
0115   double thetaZ() const;
0116   // Return angles (RADS) made by rotated axes against original axes (Geant4).
0117
0118   // ----------  Other accessors treating pure rotation as a 4-rotation
0119
0120   inline HepLorentzVector col1() const;
0121   inline HepLorentzVector col2() const;
0122   inline HepLorentzVector col3() const;
0123   //  orthosymplectic 4-vector columns - T component will be zero
0124
0125   inline HepLorentzVector col4() const;
0126   // Will be (0,0,0,1) for this pure Rotation.
0127
0128   inline HepLorentzVector row1() const;
0129   inline HepLorentzVector row2() const;
0130   inline HepLorentzVector row3() const;
0131   //  orthosymplectic 4-vector rows - T component will be zero
0132
0133   inline HepLorentzVector row4() const;
0134   // Will be (0,0,0,1) for this pure Rotation.
0135
0136   inline double xt() const;
0137   inline double yt() const;
0138   inline double zt() const;
0139   inline double tx() const;
0140   inline double ty() const;
0141   inline double tz() const;
0142   // Will be zero for this pure Rotation
0143
0144   inline double tt() const;
0145   // Will be one for this pure Rotation
0146
0147   inline HepRep4x4 rep4x4() const;
0148   //   4x4 representation.
0149
0150   // ---------   Mutators
0151
0152   void setDelta (double delta);
0153   // change angle of rotation, leaving rotation axis unchanged.
0154
0155   // ----------  Decomposition:
0156
0157   void decompose (HepAxisAngle & rotation, Hep3Vector & boost) const;
0158   void decompose (Hep3Vector & boost, HepAxisAngle & rotation) const;
0159   void decompose (HepRotation & rotation, HepBoost & boost) const;
0160   void decompose (HepBoost & boost, HepRotation & rotation) const;
0161    // These are trivial, as the boost vector is 0.
0162
0163   // ----------  Comparisons:
0164
0165   inline bool isIdentity() const;
0166   // Returns true if the identity matrix (Geant4).
0167
0168   inline int compare( const HepRotationY & r  ) const;
0169   // Dictionary-order comparison, in order of delta
0170   // Used in operator<, >, <=, >=
0171
0172   inline bool operator== ( const HepRotationY & r ) const;
0173   inline bool operator!= ( const HepRotationY & r ) const;
0174   inline bool operator<  ( const HepRotationY & r ) const;
0175   inline bool operator>  ( const HepRotationY & r ) const;
0176   inline bool operator<= ( const HepRotationY & r ) const;
0177   inline bool operator>= ( const HepRotationY & r ) const;
0178
0179   double distance2( const HepRotationY & r  ) const;
0180   // 3 - Tr ( this/r )
0181
0182   double distance2( const HepRotation &  r  ) const;
0183   // 3 - Tr ( this/r ) -- This works with RotationY or Z also
0184
0185   double howNear( const HepRotationY & r ) const;
0186   double howNear( const HepRotation  & r ) const;
0187   bool isNear( const HepRotationY & r,
0188              double epsilon=Hep4RotationInterface::tolerance) const;
0189   bool isNear( const HepRotation  & r,
0190              double epsilon=Hep4RotationInterface::tolerance) const;
0191
0192   double distance2( const HepBoost           & lt  ) const;
0193   // 3 - Tr ( this ) + |b|^2 / (1-|b|^2)
0194   double distance2( const HepLorentzRotation & lt  ) const;
0195   // 3 - Tr ( this/r ) + |b|^2 / (1-|b|^2) where b is the boost vector of lt
0196
0197   double howNear( const HepBoost           & lt ) const;
0198   double howNear( const HepLorentzRotation & lt ) const;
0199   bool isNear( const HepBoost           & lt,
0200              double epsilon=Hep4RotationInterface::tolerance) const;
0201   bool isNear( const HepLorentzRotation & lt,
0202              double epsilon=Hep4RotationInterface::tolerance) const;
0203
0204   // ----------  Properties:
0205
0206   double norm2() const;
0207   // distance2 (IDENTITY), which is 3 - Tr ( *this )
0208
0209   inline void rectify();
0210   // non-const but logically moot correction for accumulated roundoff errors
0211
0212   // ---------- Application:
0213
0214   inline Hep3Vector operator() (const Hep3Vector & p) const;
0215   // Rotate a Hep3Vector.
0216
0217   inline  Hep3Vector operator * (const Hep3Vector & p) const;
0218   // Multiplication with a Hep3Vector.
0219
0220   inline HepLorentzVector operator()( const HepLorentzVector & w ) const;
0221   // Rotate (the space part of) a HepLorentzVector.
0222
0223   inline  HepLorentzVector operator* ( const HepLorentzVector & w ) const;
0224   // Multiplication with a HepLorentzVector.
0225
0226   // ---------- Operations in the group of Rotations
0227
0228   inline HepRotationY operator * (const HepRotationY & ry) const;
0229   // Product of two Y rotations (this) * ry is known to be RotationY.
0230
0231   inline  HepRotationY & operator *= (const HepRotationY & r);
0232   inline  HepRotationY & transform   (const HepRotationY & r);
0233   // Matrix multiplication.
0234   // Note a *= b; <=> a = a * b; while a.transform(b); <=> a = b * a;
0235   // However, in this special case, they commute:  Both just add deltas.
0236
0237   inline HepRotationY inverse() const;
0238   // Returns the inverse.
0239
0240   friend HepRotationY inverseOf(const HepRotationY & r);
0241   // Returns the inverse of a RotationY.
0242
0243   inline HepRotationY & invert();
0244   // Inverts the Rotation matrix (be negating delta).
0245
0246   // ---------- I/O:
0247
0248   std::ostream & print( std::ostream & os ) const;
0249   // Output, identifying type of rotation and delta.
0250
0251   // ---------- Tolerance
0252
0253   static inline double getTolerance();
0254   static inline double setTolerance(double tol);
0255
0256 protected:
0257
0258   double its_d;
0259   // The angle of rotation.
0260
0261   double its_s;
0262   double its_c;
0263   // Cache the trig functions, for rapid operations.
0264
0265   inline HepRotationY ( double dd, double ss, double cc );
0266   // Unchecked load-the-data-members
0267
0268   static inline double proper (double delta);
0269   // Put an angle into the range of (-PI, PI].  Useful helper method.
0270
0271 };  // HepRotationY
0272
0273 // ---------- Free-function operations in the group of Rotations
0274
0275 inline
0276 std::ostream & operator <<
0277     ( std::ostream & os, const HepRotationY & r ) {return r.print(os);}
0278
0279 }  // namespace CLHEP
0280
0281 #include "CLHEP/Vector/RotationY.icc"
0282
0283 #ifdef ENABLE_BACKWARDS_COMPATIBILITY
0284 //  backwards compatibility will be enabled ONLY in CLHEP 1.9
0285 using namespace CLHEP;
0286 #endif
0287
0288 #endif /* HEP_ROTATIONY_H */
0289