Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/externals/clhep/include/CLHEP/Vector/RotationY.h

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

  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 #include "CLHEP/Vector/RotationInterfaces.h"
 24 
 25 namespace CLHEP {
 26 
 27 class HepRotationY;
 28 class HepRotation;
 29 class HepBoost;
 30 
 31 inline HepRotationY inverseOf(const HepRotationY & r);
 32 // Returns the inverse of a RotationY.
 33 
 34 /**
 35  * @author
 36  * @ingroup vector
 37  */
 38 class HepRotationY {
 39 
 40 public:
 41 
 42   // ----------  Constructors and Assignment:
 43 
 44   inline HepRotationY();
 45   // Default constructor. Gives an identity rotation. 
 46 
 47   HepRotationY(double delta);
 48   // supply angle of rotation 
 49 
 50   inline HepRotationY(const HepRotationY & orig);
 51   inline HepRotationY(HepRotationY && orig) = default;
 52   // Copy and move constructors.
 53 
 54   inline HepRotationY & operator = (const HepRotationY & r);
 55   inline HepRotationY & operator = (HepRotationY && r) = default;
 56   // Copy and move assignments from a Rotation, which must be RotationY
 57 
 58   HepRotationY & set ( double delta );
 59   // set angle of rotation 
 60 
 61   inline ~HepRotationY();
 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, Hep3Vector & axis) const;
106   // Returns the rotation angle and rotation axis (Geant4).   
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 against original axes (Geant4).
116 
117   // ----------  Other accessors treating pure rotation as a 4-rotation
118 
119   inline HepLorentzVector col1() const;
120   inline HepLorentzVector col2() const;
121   inline HepLorentzVector col3() const;
122   //  orthosymplectic 4-vector columns - T component will be zero
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 component will be zero
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 rotation axis unchanged.
153 
154   // ----------  Decomposition:
155 
156   void decompose (HepAxisAngle & rotation, Hep3Vector & boost) const;
157   void decompose (Hep3Vector & boost, HepAxisAngle & rotation) const;
158   void decompose (HepRotation & rotation, HepBoost & boost) const;
159   void decompose (HepBoost & boost, HepRotation & rotation) const;
160    // These are trivial, as the boost vector is 0.    
161 
162   // ----------  Comparisons: 
163   
164   inline bool isIdentity() const;       
165   // Returns true if the identity matrix (Geant4).  
166 
167   inline int compare( const HepRotationY & r  ) const;
168   // Dictionary-order comparison, in order of delta
169   // Used in operator<, >, <=, >=
170 
171   inline bool operator== ( const HepRotationY & r ) const;
172   inline bool operator!= ( const HepRotationY & r ) const;
173   inline bool operator<  ( const HepRotationY & r ) const;
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 
178   double distance2( const HepRotationY & r  ) const; 
179   // 3 - Tr ( this/r )
180 
181   double distance2( const HepRotation &  r  ) const;
182   // 3 - Tr ( this/r ) -- This works with RotationY or Z also
183 
184   double howNear( const HepRotationY & r ) const;
185   double howNear( const HepRotation  & r ) const;
186   bool isNear( const HepRotationY & r,
187              double epsilon=Hep4RotationInterface::tolerance) const;
188   bool isNear( const HepRotation  & r,
189              double epsilon=Hep4RotationInterface::tolerance) const;
190                                      
191   double distance2( const HepBoost           & lt  ) const;
192   // 3 - Tr ( this ) + |b|^2 / (1-|b|^2)
193   double distance2( const HepLorentzRotation & lt  ) const;
194   // 3 - Tr ( this/r ) + |b|^2 / (1-|b|^2) where b is the boost vector of lt
195 
196   double howNear( const HepBoost           & lt ) const;
197   double howNear( const HepLorentzRotation & lt ) const;
198   bool isNear( const HepBoost           & lt,
199              double epsilon=Hep4RotationInterface::tolerance) const;
200   bool isNear( const HepLorentzRotation & lt,
201              double epsilon=Hep4RotationInterface::tolerance) const;
202 
203   // ----------  Properties:
204 
205   double norm2() const; 
206   // distance2 (IDENTITY), which is 3 - Tr ( *this )
207 
208   inline void rectify();
209   // non-const but logically moot correction for accumulated roundoff errors
210 
211   // ---------- Application:
212 
213   inline Hep3Vector operator() (const Hep3Vector & p) const;
214   // Rotate a Hep3Vector.         
215 
216   inline  Hep3Vector operator * (const Hep3Vector & p) const;
217   // Multiplication with a Hep3Vector.
218 
219   inline HepLorentzVector operator()( const HepLorentzVector & w ) const;
220   // Rotate (the space part of) a HepLorentzVector.   
221 
222   inline  HepLorentzVector operator* ( const HepLorentzVector & w ) const;
223   // Multiplication with a HepLorentzVector.
224 
225   // ---------- Operations in the group of Rotations
226 
227   inline HepRotationY operator * (const HepRotationY & ry) const;
228   // Product of two Y rotations (this) * ry is known to be RotationY.
229 
230   inline  HepRotationY & operator *= (const HepRotationY & r);
231   inline  HepRotationY & transform   (const HepRotationY & r);
232   // Matrix multiplication.
233   // Note a *= b; <=> a = a * b; while a.transform(b); <=> a = b * a;
234   // However, in this special case, they commute:  Both just add deltas.
235 
236   inline HepRotationY inverse() const;
237   // Returns the inverse.
238 
239   friend HepRotationY inverseOf(const HepRotationY & r);
240   // Returns the inverse of a RotationY.
241 
242   inline HepRotationY & invert();
243   // Inverts the Rotation matrix (be negating delta).
244 
245   // ---------- I/O: 
246 
247   std::ostream & print( std::ostream & os ) const;
248   // Output, identifying type of rotation and delta.
249 
250   // ---------- Tolerance
251 
252   static inline double getTolerance();
253   static inline double setTolerance(double tol);
254 
255 protected:
256 
257   double its_d;
258   // The angle of rotation.
259 
260   double its_s;
261   double its_c;
262   // Cache the trig functions, for rapid operations.
263 
264   inline HepRotationY ( double dd, double ss, double cc );
265   // Unchecked load-the-data-members
266 
267   static inline double proper (double delta);
268   // Put an angle into the range of (-PI, PI].  Useful helper method.
269 
270 };  // HepRotationY
271 
272 // ---------- Free-function operations in the group of Rotations
273 
274 inline   
275 std::ostream & operator << 
276   ( std::ostream & os, const HepRotationY & r ) {return r.print(os);}
277 
278 }  // namespace CLHEP
279 
280 #include "CLHEP/Vector/RotationY.icc"
281 
282 #endif /* HEP_ROTATIONY_H */
283 
284