Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/externals/clhep/include/CLHEP/Vector/Rotation.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/Rotation.h (Version 11.3.0) and /externals/clhep/include/CLHEP/Vector/Rotation.h (Version 10.7.p3)


  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 HepRotation c      8 // This is the definition of the HepRotation class for performing rotations
  9 // on objects of the Hep3Vector (and HepLorent      9 // on objects of the Hep3Vector (and HepLorentzVector) class.
 10 //                                                 10 //
 11 // HepRotation is a concrete implementation of     11 // HepRotation 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 // Leif Lonnblad, Mark Fischler                    18 // Leif Lonnblad, Mark Fischler
 19                                                    19 
 20 #ifndef HEP_ROTATION_H                             20 #ifndef HEP_ROTATION_H
 21 #define HEP_ROTATION_H                             21 #define HEP_ROTATION_H
 22                                                    22 
 23 #include "CLHEP/Vector/RotationInterfaces.h"       23 #include "CLHEP/Vector/RotationInterfaces.h"
 24 #include "CLHEP/Vector/RotationX.h"                24 #include "CLHEP/Vector/RotationX.h"
 25 #include "CLHEP/Vector/RotationY.h"                25 #include "CLHEP/Vector/RotationY.h"
 26 #include "CLHEP/Vector/RotationZ.h"                26 #include "CLHEP/Vector/RotationZ.h"
 27 #include "CLHEP/Vector/LorentzVector.h"            27 #include "CLHEP/Vector/LorentzVector.h"
 28                                                    28 
 29 namespace CLHEP {                                  29 namespace CLHEP {
 30                                                    30 
 31 // Declarations of classes and global methods      31 // Declarations of classes and global methods
 32 class HepRotation;                                 32 class HepRotation;
 33 inline HepRotation inverseOf ( const HepRotati     33 inline HepRotation inverseOf ( const HepRotation & r );
 34 inline HepRotation operator * (const HepRotati     34 inline HepRotation operator * (const HepRotationX & rx, const HepRotation & r);
 35 inline HepRotation operator * (const HepRotati     35 inline HepRotation operator * (const HepRotationY & ry, const HepRotation & r);
 36 inline HepRotation operator * (const HepRotati     36 inline HepRotation operator * (const HepRotationZ & rz, const HepRotation & r);
 37                                                    37 
 38 /**                                                38 /**
 39  * @author                                         39  * @author
 40  * @ingroup vector                                 40  * @ingroup vector
 41  */                                                41  */
 42 class HepRotation {                                42 class HepRotation {
 43                                                    43 
 44 public:                                            44 public:
 45                                                    45 
 46   // ----------  Constructors and Assignment:      46   // ----------  Constructors and Assignment:
 47                                                    47 
 48   inline HepRotation();                            48   inline HepRotation();
 49   // Default constructor. Gives a unit matrix.     49   // Default constructor. Gives a unit matrix.
 50                                                    50 
 51   inline HepRotation(const HepRotation & m);       51   inline HepRotation(const HepRotation & m);
 52   inline HepRotation(HepRotation && m) = defau     52   inline HepRotation(HepRotation && m) = default;
 53   // Copy and move constructors.                   53   // Copy and move constructors.
 54                                                    54 
 55   inline HepRotation(const HepRotationX & m);      55   inline HepRotation(const HepRotationX & m);
 56   inline HepRotation(const HepRotationY & m);      56   inline HepRotation(const HepRotationY & m);
 57   inline HepRotation(const HepRotationZ & m);      57   inline HepRotation(const HepRotationZ & m);
 58   // Construct from specialized rotation.          58   // Construct from specialized rotation.
 59                                                    59 
 60   HepRotation & set( const Hep3Vector & axis,      60   HepRotation & set( const Hep3Vector & axis, double delta );
 61   HepRotation      ( const Hep3Vector & axis,      61   HepRotation      ( const Hep3Vector & axis, double delta );
 62   // Construct from axis and angle.                62   // Construct from axis and angle.
 63                                                    63 
 64   HepRotation & set( const HepAxisAngle & ax )     64   HepRotation & set( const HepAxisAngle & ax );
 65   HepRotation      ( const HepAxisAngle & ax )     65   HepRotation      ( const HepAxisAngle & ax );
 66   // Construct from AxisAngle structure.           66   // Construct from AxisAngle structure.
 67                                                    67 
 68   HepRotation & set( double phi, double theta,     68   HepRotation & set( double phi, double theta, double psi );
 69   HepRotation      ( double phi, double theta,     69   HepRotation      ( double phi, double theta, double psi );
 70   // Construct from three Euler angles (in rad     70   // Construct from three Euler angles (in radians).
 71                                                    71 
 72   HepRotation & set( const HepEulerAngles & e      72   HepRotation & set( const HepEulerAngles & e );
 73   HepRotation      ( const HepEulerAngles & e      73   HepRotation      ( const HepEulerAngles & e );
 74   // Construct from EulerAngles structure.         74   // Construct from EulerAngles structure.
 75                                                    75 
 76   HepRotation ( const Hep3Vector & colX,           76   HepRotation ( const Hep3Vector & colX,
 77                 const Hep3Vector & colY,           77                 const Hep3Vector & colY,
 78                 const Hep3Vector & colZ );         78                 const Hep3Vector & colZ );
 79   // Construct from three *orthogonal* unit ve     79   // Construct from three *orthogonal* unit vector columns.
 80     // NOTE:                                       80     // NOTE:  
 81     //       This constructor, and the two set     81     //       This constructor, and the two set methods below, 
 82   //   will check that the columns (or rows) f     82   //   will check that the columns (or rows) form an orthonormal 
 83   //   matrix, and will adjust values so that      83   //   matrix, and will adjust values so that this relation is 
 84   //   as exact as possible.                       84   //   as exact as possible.
 85                                                    85 
 86   HepRotation & set( const Hep3Vector & colX,      86   HepRotation & set( const Hep3Vector & colX,
 87                              const Hep3Vector      87                              const Hep3Vector & colY,
 88                              const Hep3Vector      88                              const Hep3Vector & colZ );
 89   //   supply three *orthogonal* unit vectors      89   //   supply three *orthogonal* unit vectors for the columns.
 90                                                    90 
 91   HepRotation & setRows( const Hep3Vector & ro     91   HepRotation & setRows( const Hep3Vector & rowX,
 92                                  const Hep3Vec     92                                  const Hep3Vector & rowY,
 93                                  const Hep3Vec     93                                  const Hep3Vector & rowZ );
 94   //   supply three *orthogonal* unit vectors      94   //   supply three *orthogonal* unit vectors for the rows.
 95                                                    95 
 96   inline HepRotation & set(const HepRotationX      96   inline HepRotation & set(const HepRotationX & r);
 97   inline HepRotation & set(const HepRotationY      97   inline HepRotation & set(const HepRotationY & r);
 98   inline HepRotation & set(const HepRotationZ      98   inline HepRotation & set(const HepRotationZ & r);
 99   // set from specialized rotation.                99   // set from specialized rotation.
100                                                   100 
101   inline  HepRotation & operator = (const HepR    101   inline  HepRotation & operator = (const HepRotation & r);
102   inline  HepRotation & operator = (HepRotatio    102   inline  HepRotation & operator = (HepRotation && r) = default;
103   // Copy and move assignment operators.          103   // Copy and move assignment operators.
104                                                   104 
105   inline  HepRotation & operator = (const HepR    105   inline  HepRotation & operator = (const HepRotationX & r);
106   inline  HepRotation & operator = (const HepR    106   inline  HepRotation & operator = (const HepRotationY & r);
107   inline  HepRotation & operator = (const HepR    107   inline  HepRotation & operator = (const HepRotationZ & r);
108   // Assignment from specialized rotation.        108   // Assignment from specialized rotation.
109                                                   109 
110   inline HepRotation &set( const HepRep3x3 & m    110   inline HepRotation &set( const HepRep3x3 & m );
111   inline HepRotation     ( const HepRep3x3 & m    111   inline HepRotation     ( const HepRep3x3 & m );
112   // WARNING - NO CHECKING IS DONE!               112   // WARNING - NO CHECKING IS DONE!
113   // Constructon directly from from a 3x3 repr    113   // Constructon directly from from a 3x3 representation,
114   // which is required to be an orthogonal mat    114   // which is required to be an orthogonal matrix.
115                                                   115 
116   inline ~HepRotation();                          116   inline ~HepRotation();
117   // Trivial destructor.                          117   // Trivial destructor.
118                                                   118 
119   // ----------  Accessors:                       119   // ----------  Accessors:
120                                                   120 
121   inline Hep3Vector colX() const;                 121   inline Hep3Vector colX() const;
122   inline Hep3Vector colY() const;                 122   inline Hep3Vector colY() const;
123   inline Hep3Vector colZ() const;                 123   inline Hep3Vector colZ() const;
124   // orthogonal unit-length column vectors        124   // orthogonal unit-length column vectors
125                                                   125 
126   inline Hep3Vector rowX() const;                 126   inline Hep3Vector rowX() const;
127   inline Hep3Vector rowY() const;                 127   inline Hep3Vector rowY() const;
128   inline Hep3Vector rowZ() const;                 128   inline Hep3Vector rowZ() const;
129   // orthogonal unit-length row vectors           129   // orthogonal unit-length row vectors
130                                                   130                                 
131   inline double xx() const;                       131   inline double xx() const;
132   inline double xy() const;                       132   inline double xy() const;
133   inline double xz() const;                       133   inline double xz() const;
134   inline double yx() const;                       134   inline double yx() const;
135   inline double yy() const;                       135   inline double yy() const;
136   inline double yz() const;                       136   inline double yz() const;
137   inline double zx() const;                       137   inline double zx() const;
138   inline double zy() const;                       138   inline double zy() const;
139   inline double zz() const;                       139   inline double zz() const;
140   // Elements of the rotation matrix (Geant4).    140   // Elements of the rotation matrix (Geant4).
141                                                   141 
142   inline HepRep3x3 rep3x3() const;                142   inline HepRep3x3 rep3x3() const;
143   //   3x3 representation:                        143   //   3x3 representation:
144                                                   144 
145   // ------------  Subscripting:                  145   // ------------  Subscripting:
146                                                   146 
147   class HepRotation_row {                         147   class HepRotation_row {
148   public:                                         148   public:
149     inline HepRotation_row(const HepRotation &    149     inline HepRotation_row(const HepRotation &, int);
150     inline double operator [] (int) const;        150     inline double operator [] (int) const;
151   private:                                        151   private:
152     const HepRotation & rr;                       152     const HepRotation & rr;
153     int ii;                                       153     int ii;
154   };                                              154   };
155   // Helper class for implemention of C-style     155   // Helper class for implemention of C-style subscripting r[i][j] 
156                                                   156 
157   inline const HepRotation_row operator [] (in    157   inline const HepRotation_row operator [] (int) const; 
158   // Returns object of the helper class for C-    158   // Returns object of the helper class for C-style subscripting r[i][j]
159   // i and j range from 0 to 2.                   159   // i and j range from 0 to 2.  
160                                                   160 
161   double operator () (int, int) const;            161   double operator () (int, int) const;
162   // Fortran-style subscripting: returns (i,j)    162   // Fortran-style subscripting: returns (i,j) element of the rotation matrix.
163   // Note:  i and j still range from 0 to 2.      163   // Note:  i and j still range from 0 to 2.      [Rotation.cc]
164                                                   164 
165   // ------------  Euler angles:                  165   // ------------  Euler angles:
166   inline  double getPhi  () const;                166   inline  double getPhi  () const;
167   inline  double getTheta() const;                167   inline  double getTheta() const;
168   inline  double getPsi  () const;                168   inline  double getPsi  () const;
169   double    phi  () const;                        169   double    phi  () const;
170   double    theta() const;                        170   double    theta() const;
171   double    psi  () const;                        171   double    psi  () const;
172   HepEulerAngles eulerAngles() const;             172   HepEulerAngles eulerAngles() const;
173                                                   173 
174   // ------------  axis & angle of rotation:      174   // ------------  axis & angle of rotation:
175   inline  double  getDelta() const;               175   inline  double  getDelta() const;
176   inline  Hep3Vector getAxis () const;            176   inline  Hep3Vector getAxis () const;
177   double     delta() const;                       177   double     delta() const;
178   Hep3Vector    axis () const;                    178   Hep3Vector    axis () const;
179   HepAxisAngle  axisAngle() const;                179   HepAxisAngle  axisAngle() const;
180   void getAngleAxis(double & delta, Hep3Vector    180   void getAngleAxis(double & delta, Hep3Vector & axis) const;
181   // Returns the rotation angle and rotation a    181   // Returns the rotation angle and rotation axis (Geant4).   [Rotation.cc]
182                                                   182 
183   // ------------- Angles of rotated axes         183   // ------------- Angles of rotated axes
184   double phiX() const;                            184   double phiX() const;
185   double phiY() const;                            185   double phiY() const;
186   double phiZ() const;                            186   double phiZ() const;
187   double thetaX() const;                          187   double thetaX() const;
188   double thetaY() const;                          188   double thetaY() const;
189   double thetaZ() const;                          189   double thetaZ() const;
190   // Return angles (RADS) made by rotated axes    190   // Return angles (RADS) made by rotated axes against original axes (Geant4).
191   //                [Rotation.cc]                 191   //                [Rotation.cc]
192                                                   192 
193   // ----------  Other accessors treating pure    193   // ----------  Other accessors treating pure rotation as a 4-rotation
194                                                   194 
195   inline HepLorentzVector col1() const;           195   inline HepLorentzVector col1() const;
196   inline HepLorentzVector col2() const;           196   inline HepLorentzVector col2() const;
197   inline HepLorentzVector col3() const;           197   inline HepLorentzVector col3() const;
198   //  orthosymplectic 4-vector columns - T com    198   //  orthosymplectic 4-vector columns - T component will be zero
199                                                   199 
200   inline HepLorentzVector col4() const;           200   inline HepLorentzVector col4() const;
201   // Will be (0,0,0,1) for this pure Rotation.    201   // Will be (0,0,0,1) for this pure Rotation.
202                                                   202 
203   inline HepLorentzVector row1() const;           203   inline HepLorentzVector row1() const;
204   inline HepLorentzVector row2() const;           204   inline HepLorentzVector row2() const;
205   inline HepLorentzVector row3() const;           205   inline HepLorentzVector row3() const;
206   //  orthosymplectic 4-vector rows - T compon    206   //  orthosymplectic 4-vector rows - T component will be zero
207                                                   207 
208   inline HepLorentzVector row4() const;           208   inline HepLorentzVector row4() const;
209   // Will be (0,0,0,1) for this pure Rotation.    209   // Will be (0,0,0,1) for this pure Rotation.
210                                                   210 
211   inline double xt() const;                       211   inline double xt() const;
212   inline double yt() const;                       212   inline double yt() const;
213   inline double zt() const;                       213   inline double zt() const;
214   inline double tx() const;                       214   inline double tx() const;
215   inline double ty() const;                       215   inline double ty() const;
216   inline double tz() const;                       216   inline double tz() const;
217   // Will be zero for this pure Rotation          217   // Will be zero for this pure Rotation
218                                                   218 
219   inline double tt() const;                       219   inline double tt() const;
220   // Will be one for this pure Rotation           220   // Will be one for this pure Rotation
221                                                   221 
222   inline HepRep4x4 rep4x4() const;                222   inline HepRep4x4 rep4x4() const;
223   //   4x4 representation.                        223   //   4x4 representation.
224                                                   224 
225   // ---------   Mutators                         225   // ---------   Mutators 
226                                                   226 
227   void setPhi (double phi);                       227   void setPhi (double phi);
228   // change Euler angle phi, leaving theta and    228   // change Euler angle phi, leaving theta and psi unchanged.
229                                                   229 
230   void setTheta (double theta);                   230   void setTheta (double theta);
231   // change Euler angle theta, leaving phi and    231   // change Euler angle theta, leaving phi and psi unchanged.
232                                                   232 
233   void setPsi (double psi);                       233   void setPsi (double psi);
234   // change Euler angle psi, leaving theta and    234   // change Euler angle psi, leaving theta and phi unchanged.
235                                                   235 
236   void setAxis (const Hep3Vector & axis);         236   void setAxis (const Hep3Vector & axis);
237   // change rotation axis, leaving delta uncha    237   // change rotation axis, leaving delta unchanged.
238                                                   238 
239   void setDelta (double delta);                   239   void setDelta (double delta);
240   // change angle of rotation, leaving rotatio    240   // change angle of rotation, leaving rotation axis unchanged.
241                                                   241 
242   // ----------  Decomposition:                   242   // ----------  Decomposition:
243                                                   243 
244   void decompose (HepAxisAngle & rotation, Hep    244   void decompose (HepAxisAngle & rotation, Hep3Vector & boost) const;
245   void decompose (Hep3Vector & boost, HepAxisA    245   void decompose (Hep3Vector & boost, HepAxisAngle & rotation) const;
246   // These are trivial, as the boost vector is    246   // These are trivial, as the boost vector is 0.   [RotationP.cc]
247                                                   247 
248   // ----------  Comparisons:                     248   // ----------  Comparisons: 
249                                                   249   
250   bool isIdentity() const;                        250   bool isIdentity() const;        
251   // Returns true if the identity matrix (Gean    251   // Returns true if the identity matrix (Geant4).    [Rotation.cc] 
252                                                   252 
253   int compare( const HepRotation & r  ) const;    253   int compare( const HepRotation & r  ) const;
254   // Dictionary-order comparison, in order zz,    254   // Dictionary-order comparison, in order zz, zy, zx, yz, ... xx
255   // Used in operator<, >, <=, >=                 255   // Used in operator<, >, <=, >= 
256                                                   256 
257   inline bool operator== ( const HepRotation &    257   inline bool operator== ( const HepRotation & r ) const;
258   inline bool operator!= ( const HepRotation &    258   inline bool operator!= ( const HepRotation & r ) const;
259   inline bool operator<  ( const HepRotation &    259   inline bool operator<  ( const HepRotation & r ) const;
260   inline bool operator>  ( const HepRotation &    260   inline bool operator>  ( const HepRotation & r ) const;
261   inline bool operator<= ( const HepRotation &    261   inline bool operator<= ( const HepRotation & r ) const;
262   inline bool operator>= ( const HepRotation &    262   inline bool operator>= ( const HepRotation & r ) const;
263                                                   263   
264   double distance2( const HepRotation &  r  )     264   double distance2( const HepRotation &  r  ) const; 
265   // 3 - Tr ( this/r ) -- This works with Rota    265   // 3 - Tr ( this/r ) -- This works with RotationX, Y or Z also
266                                                   266 
267   double howNear( const HepRotation & r ) cons    267   double howNear( const HepRotation & r ) const;
268   bool isNear( const HepRotation & r,             268   bool isNear( const HepRotation & r,
269              double epsilon=Hep4RotationInterf    269              double epsilon=Hep4RotationInterface::tolerance) const;
270                                                   270 
271   double distance2( const HepBoost           &    271   double distance2( const HepBoost           & lt  ) const; 
272   // 3 - Tr ( this ) + |b|^2 / (1-|b|^2)          272   // 3 - Tr ( this ) + |b|^2 / (1-|b|^2) 
273   double distance2( const HepLorentzRotation &    273   double distance2( const HepLorentzRotation & lt  ) const; 
274   // 3 - Tr ( this/r ) + |b|^2 / (1-|b|^2) whe    274   // 3 - Tr ( this/r ) + |b|^2 / (1-|b|^2) where b is the boost vector of lt
275                                                   275 
276   double howNear( const HepBoost           & l    276   double howNear( const HepBoost           & lt ) const;
277   double howNear( const HepLorentzRotation & l    277   double howNear( const HepLorentzRotation & lt ) const;
278   bool isNear( const HepBoost           & lt,     278   bool isNear( const HepBoost           & lt, 
279              double epsilon=Hep4RotationInterf    279              double epsilon=Hep4RotationInterface::tolerance) const;
280   bool isNear( const HepLorentzRotation & lt,     280   bool isNear( const HepLorentzRotation & lt,
281              double epsilon=Hep4RotationInterf    281              double epsilon=Hep4RotationInterface::tolerance) const;
282                                                   282 
283   // ----------  Properties:                      283   // ----------  Properties:
284                                                   284 
285   double norm2() const;                           285   double norm2() const; 
286   // distance2 (IDENTITY), which is 3 - Tr ( *    286   // distance2 (IDENTITY), which is 3 - Tr ( *this )
287                                                   287 
288   void rectify();                                 288   void rectify();
289   // non-const but logically moot correction f    289   // non-const but logically moot correction for accumulated roundoff errors
290   // rectify averages the matrix with the tran    290   // rectify averages the matrix with the transpose of its actual
291   // inverse (absent accumulated roundoff erro    291   // inverse (absent accumulated roundoff errors, the transpose IS
292   // the inverse)); this removes to first orde    292   // the inverse)); this removes to first order those errors.
293   // Then it formally extracts axis and delta,    293   // Then it formally extracts axis and delta, and forms a true
294   // HepRotation with those values of axis and    294   // HepRotation with those values of axis and delta.
295                                                   295 
296   // ---------- Application:                      296   // ---------- Application:
297                                                   297 
298   inline Hep3Vector operator() (const Hep3Vect    298   inline Hep3Vector operator() (const Hep3Vector & p) const;
299   // Rotate a Hep3Vector.                         299   // Rotate a Hep3Vector.         
300                                                   300 
301   inline  Hep3Vector operator * (const Hep3Vec    301   inline  Hep3Vector operator * (const Hep3Vector & p) const;
302   // Multiplication with a Hep3Vector.            302   // Multiplication with a Hep3Vector.
303                                                   303 
304   inline HepLorentzVector operator()( const He    304   inline HepLorentzVector operator()( const HepLorentzVector & w ) const;
305   // Rotate (the space part of) a HepLorentzVe    305   // Rotate (the space part of) a HepLorentzVector.   
306                                                   306 
307   inline  HepLorentzVector operator* ( const H    307   inline  HepLorentzVector operator* ( const HepLorentzVector & w ) const;
308   // Multiplication with a HepLorentzVector.      308   // Multiplication with a HepLorentzVector.
309                                                   309 
310   // ---------- Operations in the group of Rot    310   // ---------- Operations in the group of Rotations
311                                                   311 
312   inline HepRotation operator * (const HepRota    312   inline HepRotation operator * (const HepRotation & r) const;
313   // Product of two rotations (this) * r - mat    313   // Product of two rotations (this) * r - matrix multiplication  
314                                                   314 
315   inline HepRotation operator * (const HepRota    315   inline HepRotation operator * (const HepRotationX & rx) const; 
316   inline HepRotation operator * (const HepRota    316   inline HepRotation operator * (const HepRotationY & ry) const;
317   inline HepRotation operator * (const HepRota    317   inline HepRotation operator * (const HepRotationZ & rz) const;
318   // Product of two rotations (this) * r - fas    318   // Product of two rotations (this) * r - faster when specialized type 
319                                                   319 
320   inline  HepRotation & operator *= (const Hep    320   inline  HepRotation & operator *= (const HepRotation & r);
321   inline  HepRotation & transform   (const Hep    321   inline  HepRotation & transform   (const HepRotation & r);
322   // Matrix multiplication.                       322   // Matrix multiplication.
323   // Note a *= b; <=> a = a * b; while a.trans    323   // Note a *= b; <=> a = a * b; while a.transform(b); <=> a = b * a;
324                                                   324 
325   inline  HepRotation & operator *= (const Hep    325   inline  HepRotation & operator *= (const HepRotationX & r);
326   inline  HepRotation & operator *= (const Hep    326   inline  HepRotation & operator *= (const HepRotationY & r);
327   inline  HepRotation & operator *= (const Hep    327   inline  HepRotation & operator *= (const HepRotationZ & r);
328   inline  HepRotation & transform   (const Hep    328   inline  HepRotation & transform   (const HepRotationX & r);
329   inline  HepRotation & transform   (const Hep    329   inline  HepRotation & transform   (const HepRotationY & r);
330   inline  HepRotation & transform   (const Hep    330   inline  HepRotation & transform   (const HepRotationZ & r);
331   // Matrix multiplication by specialized matr    331   // Matrix multiplication by specialized matrices
332                                                   332 
333   HepRotation & rotateX(double delta);            333   HepRotation & rotateX(double delta);
334   // Rotation around the x-axis; equivalent to    334   // Rotation around the x-axis; equivalent to R = RotationX(delta) * R
335                                                   335 
336   HepRotation & rotateY(double delta);            336   HepRotation & rotateY(double delta);
337   // Rotation around the y-axis; equivalent to    337   // Rotation around the y-axis; equivalent to R = RotationY(delta) * R
338                                                   338 
339   HepRotation & rotateZ(double delta);            339   HepRotation & rotateZ(double delta);
340   // Rotation around the z-axis; equivalent to    340   // Rotation around the z-axis; equivalent to R = RotationZ(delta) * R
341                                                   341 
342          HepRotation & rotate(double delta, co    342          HepRotation & rotate(double delta, const Hep3Vector & axis);
343   inline HepRotation & rotate(double delta, co    343   inline HepRotation & rotate(double delta, const Hep3Vector * axis);
344   // Rotation around a specified vector.          344   // Rotation around a specified vector.  
345   // r.rotate(d,a) is equivalent to r = Rotati    345   // r.rotate(d,a) is equivalent to r = Rotation(d,a) * r
346                                                   346 
347   HepRotation & rotateAxes(const Hep3Vector &     347   HepRotation & rotateAxes(const Hep3Vector & newX,
348                            const Hep3Vector &     348                            const Hep3Vector & newY,
349                            const Hep3Vector &     349                            const Hep3Vector & newZ);
350   // Rotation of local axes defined by 3 ortho    350   // Rotation of local axes defined by 3 orthonormal vectors (Geant4).
351   // Equivalent to r = Rotation (newX, newY, n    351   // Equivalent to r = Rotation (newX, newY, newZ) * r
352                                                   352 
353   inline HepRotation inverse() const;             353   inline HepRotation inverse() const;
354   // Returns the inverse.                         354   // Returns the inverse.
355                                                   355 
356   inline HepRotation & invert();                  356   inline HepRotation & invert();
357   // Inverts the Rotation matrix.                 357   // Inverts the Rotation matrix.
358                                                   358 
359   // ---------- I/O:                              359   // ---------- I/O: 
360                                                   360 
361   std::ostream & print( std::ostream & os ) co    361   std::ostream & print( std::ostream & os ) const;
362   // Aligned six-digit-accurate output of the     362   // Aligned six-digit-accurate output of the  rotation matrix. [RotationIO.cc]
363                                                   363 
364   // ---------- Identity Rotation:                364   // ---------- Identity Rotation:
365                                                   365 
366   DLL_API static const HepRotation IDENTITY;      366   DLL_API static const HepRotation IDENTITY;
367                                                   367 
368   // ---------- Tolerance                         368   // ---------- Tolerance
369                                                   369 
370   static inline double getTolerance();            370   static inline double getTolerance();
371   static inline double setTolerance(double tol    371   static inline double setTolerance(double tol); 
372                                                   372 
373 protected:                                        373 protected:
374                                                   374 
375   inline HepRotation(double mxx, double mxy, d    375   inline HepRotation(double mxx, double mxy, double mxz, 
376          double myx, double myy, double myz,      376          double myx, double myy, double myz,
377          double mzx, double mzy, double mzz);     377          double mzx, double mzy, double mzz);
378   // Protected constructor.                       378   // Protected constructor.  
379   // DOES NOT CHECK FOR VALIDITY AS A ROTATION    379   // DOES NOT CHECK FOR VALIDITY AS A ROTATION.
380                                                   380 
381   friend HepRotation operator* (const HepRotat    381   friend HepRotation operator* (const HepRotationX & rx, const HepRotation & r);
382   friend HepRotation operator* (const HepRotat    382   friend HepRotation operator* (const HepRotationY & ry, const HepRotation & r);
383   friend HepRotation operator* (const HepRotat    383   friend HepRotation operator* (const HepRotationZ & rz, const HepRotation & r);
384                                                   384 
385   double rxx, rxy, rxz,                           385   double rxx, rxy, rxz, 
386       ryx, ryy, ryz,                              386       ryx, ryy, ryz, 
387       rzx, rzy, rzz;                              387       rzx, rzy, rzz;
388   // The matrix elements.                         388   // The matrix elements.
389                                                   389 
390 private:                                          390 private:
391   bool                                            391   bool 
392        setCols ( const Hep3Vector & u1, // Vec    392        setCols ( const Hep3Vector & u1, // Vectors assume to be of unit length 
393                  const Hep3Vector & u2,           393                  const Hep3Vector & u2,
394                  const Hep3Vector & u3,           394                  const Hep3Vector & u3,
395                  double u1u2,                     395                  double u1u2,
396                  Hep3Vector & v1,   // Returne    396                  Hep3Vector & v1,   // Returned vectors
397                  Hep3Vector & v2,                 397                  Hep3Vector & v2,
398                  Hep3Vector & v3 ) const;         398                  Hep3Vector & v3 ) const;
399   void setArbitrarily (const Hep3Vector & colX    399   void setArbitrarily (const Hep3Vector & colX, // assumed to be of unit length
400                       Hep3Vector & v1,            400                       Hep3Vector & v1,
401                       Hep3Vector & v2,            401                       Hep3Vector & v2,
402                       Hep3Vector & v3) const;     402                       Hep3Vector & v3) const;
403 };  // HepRotation                                403 };  // HepRotation
404                                                   404 
405 inline                                            405 inline   
406 std::ostream & operator <<                        406 std::ostream & operator << 
407   ( std::ostream & os, const HepRotation & r )    407   ( std::ostream & os, const HepRotation & r ) {return r.print(os);}
408                                                   408 
409 }  // namespace CLHEP                             409 }  // namespace CLHEP
410                                                   410 
411 #include "CLHEP/Vector/Rotation.icc"              411 #include "CLHEP/Vector/Rotation.icc"
412                                                   412 
413 #endif /* HEP_ROTATION_H */                       413 #endif /* HEP_ROTATION_H */
414                                                   414 
415                                                   415