Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/externals/clhep/include/CLHEP/Vector/RotationX.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 ]

Diff markup

Differences between /externals/clhep/include/CLHEP/Vector/RotationX.h (Version 11.3.0) and /externals/clhep/include/CLHEP/Vector/RotationX.h (Version 11.1.1)


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