Geant4 Cross Reference

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


  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 contains the definition of two abstrac      8 // This contains the definition of two abstract interface classes:
  9 // Hep4RotationInterface                            9 // Hep4RotationInterface 
 10 // Hep3RotationInterface.                          10 // Hep3RotationInterface.  
 11 // However, these are mostly for defining meth     11 // However, these are mostly for defining methods which should be present in
 12 // any 4- or 3-rotation class, however special     12 // any 4- or 3-rotation class, however specialized.  The actual classes do
 13 // not inherit from these.  The virtual functi     13 // not inherit from these.  The virtual function overhead turns out 
 14 // to be too steep for that to be practical.       14 // to be too steep for that to be practical.
 15 //                                                 15 //
 16 // It may be desirable in the future to turn t     16 // It may be desirable in the future to turn these classes into constraints
 17 // in the Stroustrup sense, so as to enforce t     17 // in the Stroustrup sense, so as to enforce this interface, still without 
 18 // inheritance.  However, they do contain an i     18 // inheritance.  However, they do contain an important static:
 19 // static double tolerance to set criteria for     19 // static double tolerance to set criteria for relative nearness.
 20 //                                                 20 //
 21 // This file also defines structs                  21 // This file also defines structs 
 22 // HepRep3x3;                                      22 // HepRep3x3;
 23 // HepRep4x4;                                      23 // HepRep4x4;
 24 // HepRep4x4Symmetric;                             24 // HepRep4x4Symmetric;
 25 // which are used by various Rotation classes.     25 // which are used by various Rotation classes.
 26 //                                                 26 // 
 27 // Hep4RotationInterface                           27 // Hep4RotationInterface 
 28 //  contains all the methods to get attributes     28 //  contains all the methods to get attributes of either a
 29 //  HepLorentzRotation or a HepRotation -- any     29 //  HepLorentzRotation or a HepRotation -- any information 
 30 //  that pertains to a LorentzRotation can als     30 //  that pertains to a LorentzRotation can also be defined
 31 //  for a HepRotation.(For example, the 4x4 re     31 //  for a HepRotation.(For example, the 4x4 representation
 32 //  would just have 0's in the space-time entr     32 //  would just have 0's in the space-time entries and 1 in
 33 //  the time-time entry.)                          33 //  the time-time entry.) 
 34 //                                                 34 //
 35 // Hep3RotationInterface                           35 // Hep3RotationInterface 
 36 //  inherits from Hep4RotationInterface,  and      36 //  inherits from Hep4RotationInterface,  and adds methods
 37 //  which are well-defined only in the case of     37 //  which are well-defined only in the case of a Rotation.
 38 //  For example, a 3x3 representation is an at     38 //  For example, a 3x3 representation is an attribute only
 39 //  if the generic LorentzRotation involves no     39 //  if the generic LorentzRotation involves no boost.
 40 //                                                 40 //
 41 // In terms of classes in the ZOOM PhysicsVect     41 // In terms of classes in the ZOOM PhysicsVectors package, 
 42 //  Hep4RotationInterface <--> LorentzTransfor     42 //  Hep4RotationInterface <--> LorentzTransformationInterface
 43 //  Hep3RotationInterface <--> RotationInterfa     43 //  Hep3RotationInterface <--> RotationInterface
 44 //                                                 44 //
 45 // Hep4RotationInterface defines the required      45 // Hep4RotationInterface defines the required methods for:
 46 //  HepLorentzRotation                             46 //  HepLorentzRotation
 47 //  HepBoost                                       47 //  HepBoost
 48 //  HepBoostX                                      48 //  HepBoostX
 49 //  HepBoostY                                      49 //  HepBoostY
 50 //  HepBoostZ                                      50 //  HepBoostZ
 51 //                                                 51 //
 52 // Hep3RotationInterface defines the required      52 // Hep3RotationInterface defines the required methods for:
 53 //  HepRotation                                    53 //  HepRotation
 54 //  HepRotationX                                   54 //  HepRotationX
 55 //  HepRotationY                                   55 //  HepRotationY
 56 //  HepRotationZ                                   56 //  HepRotationZ
 57 //                                                 57 //
 58 // .SS See Also                                    58 // .SS See Also
 59 // Rotation.h, LorentzRotation.h                   59 // Rotation.h, LorentzRotation.h
 60 //                                                 60 //
 61 // .SS Author                                      61 // .SS Author
 62 // Mark Fischler                                   62 // Mark Fischler
 63 //                                                 63 //
 64                                                    64 
 65 #ifndef HEP_ROTATION_INTERFACES_H                  65 #ifndef HEP_ROTATION_INTERFACES_H
 66 #define HEP_ROTATION_INTERFACES_H                  66 #define HEP_ROTATION_INTERFACES_H
 67                                                    67 
 68 #include "CLHEP/Vector/ThreeVector.h"              68 #include "CLHEP/Vector/ThreeVector.h"
 69 #include "CLHEP/Vector/LorentzVector.h"            69 #include "CLHEP/Vector/LorentzVector.h"
 70 #include "CLHEP/Vector/AxisAngle.h"                70 #include "CLHEP/Vector/AxisAngle.h"
 71                                                    71 
 72 namespace CLHEP {                                  72 namespace CLHEP {
 73                                                    73 
 74 struct HepRep3x3;                                  74 struct HepRep3x3;
 75 struct HepRep4x4;                                  75 struct HepRep4x4;
 76 struct HepRep4x4Symmetric;                         76 struct HepRep4x4Symmetric;
 77                                                    77 
 78 class HepRotation;                                 78 class HepRotation;
 79 class HepRotationX;                                79 class HepRotationX;
 80 class HepRotationY;                                80 class HepRotationY;
 81 class HepRotationZ;                                81 class HepRotationZ;
 82 class HepLorentzRotation;                          82 class HepLorentzRotation;
 83 class HepBoost;                                    83 class HepBoost;
 84 class HepBoostX;                                   84 class HepBoostX;
 85 class HepBoostY;                                   85 class HepBoostY;
 86 class HepBoostZ;                                   86 class HepBoostZ;
 87                                                    87 
 88 //-******************************                  88 //-******************************
 89 //                                                 89 //
 90 // Hep4RotationInterface                           90 // Hep4RotationInterface 
 91 //                                                 91 //
 92 //-******************************                  92 //-******************************
 93                                                    93 
 94 /**                                                94 /**
 95  * @author                                         95  * @author
 96  * @ingroup vector                                 96  * @ingroup vector
 97  */                                                97  */
 98 class Hep4RotationInterface  {                     98 class Hep4RotationInterface  {
 99                                                    99 
100   // All attributes of shared by HepLorentzRot    100   // All attributes of shared by HepLorentzRotation, HepBoost, 
101   // HepBoostX, HepBoostY, HepBoostZ.  HepRota    101   // HepBoostX, HepBoostY, HepBoostZ.  HepRotation, HepRotationX, 
102   // HepRotationY, HepRotationZ also share thi    102   // HepRotationY, HepRotationZ also share this attribute interface.
103                                                   103 
104   friend class  HepRotation;                      104   friend class  HepRotation;
105   friend class  HepRotationX;                     105   friend class  HepRotationX;
106   friend class  HepRotationY;                     106   friend class  HepRotationY;
107   friend class  HepRotationZ;                     107   friend class  HepRotationZ;
108   friend class  HepLorentzRotation;               108   friend class  HepLorentzRotation;
109   friend class  HepBoost;                         109   friend class  HepBoost;
110   friend class  HepBoostX;                        110   friend class  HepBoostX;
111   friend class  HepBoostY;                        111   friend class  HepBoostY;
112   friend class  HepBoostZ;                        112   friend class  HepBoostZ;
113                                                   113 
114 public:                                           114 public:
115                                                   115 
116   DLL_API static double tolerance;        // t    116   DLL_API static double tolerance;        // to determine relative nearness
117                                                   117 
118   // ----------  Accessors:                       118   // ----------  Accessors:
119                                                   119 
120 #ifdef ONLY_IN_CONCRETE_CLASSES                   120 #ifdef ONLY_IN_CONCRETE_CLASSES
121   //  orthosymplectic 4-vectors:                  121   //  orthosymplectic 4-vectors:
122   HepLorentzVector col1() const;                  122   HepLorentzVector col1() const;
123   HepLorentzVector col2() const;                  123   HepLorentzVector col2() const;
124   HepLorentzVector col3() const;                  124   HepLorentzVector col3() const;
125   HepLorentzVector col4() const;                  125   HepLorentzVector col4() const;
126   HepLorentzVector row1() const;                  126   HepLorentzVector row1() const;
127   HepLorentzVector row2() const;                  127   HepLorentzVector row2() const;
128   HepLorentzVector row3() const;                  128   HepLorentzVector row3() const;
129   HepLorentzVector row4() const;                  129   HepLorentzVector row4() const;
130                                                   130 
131   //  individual elements:                        131   //  individual elements:
132   double xx() const  ;                            132   double xx() const  ;
133   double xy() const  ;                            133   double xy() const  ;
134   double xz() const  ;                            134   double xz() const  ;
135   double xt() const  ;                            135   double xt() const  ;
136   double yx() const  ;                            136   double yx() const  ;
137   double yy() const  ;                            137   double yy() const  ;
138   double yz() const  ;                            138   double yz() const  ;
139   double yt() const  ;                            139   double yt() const  ;
140   double zx() const  ;                            140   double zx() const  ;
141   double zy() const  ;                            141   double zy() const  ;
142   double zz() const  ;                            142   double zz() const  ;
143   double zt() const  ;                            143   double zt() const  ;
144   double tx() const  ;                            144   double tx() const  ;
145   double ty() const  ;                            145   double ty() const  ;
146   double tz() const  ;                            146   double tz() const  ;
147   double tt() const  ;                            147   double tt() const  ;
148                                                   148 
149   //   4x4 representation:                        149   //   4x4 representation:
150 //HepRep4x4 rep4x4() const; JMM  Declared here    150 //HepRep4x4 rep4x4() const; JMM  Declared here but not defined anywhere!
151                                                   151 
152   // ----------  Operations:                      152   // ----------  Operations:
153   //   comparisons:                               153   //   comparisons:
154                                                   154 
155   inline int compare( const Hep4RotationInterf    155   inline int compare( const Hep4RotationInterface & lt ) const;
156   // Dictionary-order comparisons, utilizing t    156   // Dictionary-order comparisons, utilizing the decompose(b,r) method
157                                                   157 
158   //   decomposition:                             158   //   decomposition:
159                                                   159 
160   void decompose (HepAxisAngle & rotation, Hep    160   void decompose (HepAxisAngle & rotation, Hep3Vector & boost)const;
161   // Decompose as T= R * B, where R is pure ro    161   // Decompose as T= R * B, where R is pure rotation, B is pure boost.
162                                                   162 
163   void decompose (Hep3Vector & boost, HepAxisA    163   void decompose (Hep3Vector & boost, HepAxisAngle & rotation)const;
164   // Decompose as T= B * R, where R is pure ro    164   // Decompose as T= B * R, where R is pure rotation, B is pure boost.
165                                                   165 
166   bool operator == (const Hep4RotationInterfac    166   bool operator == (const Hep4RotationInterface & r) const;
167   bool operator != (const Hep4RotationInterfac    167   bool operator != (const Hep4RotationInterface & r) const;
168                                                   168 
169   //   relative comparison:                       169   //   relative comparison:
170                                                   170 
171   double norm2() const  ;                         171   double norm2() const  ;
172   double  distance2( const Hep4RotationInterfa    172   double  distance2( const Hep4RotationInterface & lt ) const  ;
173   double  howNear( const Hep4RotationInterface    173   double  howNear( const Hep4RotationInterface & lt ) const  ;
174   bool isNear (const Hep4RotationInterface & l    174   bool isNear (const Hep4RotationInterface & lt, 
175            double epsilon=tolerance) const  ;     175            double epsilon=tolerance) const  ;
176                                                   176 
177   void rectify()  ;                               177   void rectify()  ;
178   // non-const but logically const correction     178   // non-const but logically const correction for accumulated roundoff errors
179                                                   179 
180   // ----------  Apply LorentzTransformations:    180   // ----------  Apply LorentzTransformations:
181                                                   181 
182   HepLorentzVector operator* ( const HepLorent    182   HepLorentzVector operator* ( const HepLorentzVector & w ) const  ;
183   HepLorentzVector operator()( const HepLorent    183   HepLorentzVector operator()( const HepLorentzVector & w ) const  ;
184   // Apply to a 4-vector                          184   // Apply to a 4-vector
185                                                   185 
186   // ----------  I/O:                             186   // ----------  I/O:
187                                                   187 
188   std::ostream & print( std::ostream & os ) co    188   std::ostream & print( std::ostream & os ) const;
189                                                   189 
190 #endif /* ONLY_IN_CONCRETE_CLASSES */             190 #endif /* ONLY_IN_CONCRETE_CLASSES */
191                                                   191 
192   static double getTolerance();                   192   static double getTolerance();
193   static double setTolerance( double tol );       193   static double setTolerance( double tol );
194                                                   194 
195   static const int ToleranceTicks = 100;       << 195   enum { ToleranceTicks = 100 };
196                                                   196 
197 protected:                                        197 protected:
198                                                   198 
199   ~Hep4RotationInterface() {} // protect destr    199   ~Hep4RotationInterface() {} // protect destructor to forbid instatiation
200                                                   200 
201 };  // Hep4RotationInterface                      201 };  // Hep4RotationInterface
202                                                   202 
203                                                   203 
204 //-******************************                 204 //-******************************
205 //                                                205 //
206 // Hep3RotationInterface                          206 // Hep3RotationInterface 
207 //                                                207 //
208 //-******************************                 208 //-******************************
209                                                   209 
210 /**                                               210 /**
211  * @author                                        211  * @author
212  * @ingroup vector                                212  * @ingroup vector
213  */                                               213  */
214 class Hep3RotationInterface : public Hep4Rotat    214 class Hep3RotationInterface : public Hep4RotationInterface {
215                                                   215 
216   // All attributes of HepRotation, HepRotatio    216   // All attributes of HepRotation, HepRotationX, HepRotationY, HepRotationZ
217   // beyond those available by virtue of being    217   // beyond those available by virtue of being a Hep3RotationInterface.
218                                                   218 
219   friend class  HepRotation;                      219   friend class  HepRotation;
220   friend class  HepRotationX;                     220   friend class  HepRotationX;
221   friend class  HepRotationY;                     221   friend class  HepRotationY;
222   friend class  HepRotationZ;                     222   friend class  HepRotationZ;
223                                                   223 
224 public:                                           224 public:
225                                                   225 
226 #ifdef ONLY_IN_CONCRETE_CLASSES                   226 #ifdef ONLY_IN_CONCRETE_CLASSES
227                                                   227 
228   //   Euler angles:                              228   //   Euler angles:
229   double getPhi  () const  ;                      229   double getPhi  () const  ;
230   double getTheta() const  ;                      230   double getTheta() const  ;
231   double getPsi  () const  ;                      231   double getPsi  () const  ;
232   double    phi  () const  ;                      232   double    phi  () const  ;
233   double    theta() const  ;                      233   double    theta() const  ;
234   double    psi  () const  ;                      234   double    psi  () const  ;
235   HepEulerAngles eulerAngles() const  ;           235   HepEulerAngles eulerAngles() const  ;
236                                                   236 
237   //   axis & angle of rotation:                  237   //   axis & angle of rotation:
238   double  getDelta() const  ;                     238   double  getDelta() const  ;
239   Hep3Vector getAxis () const  ;                  239   Hep3Vector getAxis () const  ;
240   double     delta() const  ;                     240   double     delta() const  ;
241   Hep3Vector    axis () const  ;                  241   Hep3Vector    axis () const  ;
242   HepAxisAngle axisAngle() const  ;               242   HepAxisAngle axisAngle() const  ;
243                                                   243 
244   //   orthogonal unit-length vectors:            244   //   orthogonal unit-length vectors:
245   Hep3Vector rowX() const;                        245   Hep3Vector rowX() const;
246   Hep3Vector rowY() const;                        246   Hep3Vector rowY() const;
247   Hep3Vector rowZ() const;                        247   Hep3Vector rowZ() const;
248                                                   248 
249   Hep3Vector colX() const;                        249   Hep3Vector colX() const;
250   Hep3Vector colY() const;                        250   Hep3Vector colY() const;
251   Hep3Vector colZ() const;                        251   Hep3Vector colZ() const;
252                                                   252 
253 //HepRep3x3 rep3x3() const; JMM  Declared here    253 //HepRep3x3 rep3x3() const; JMM  Declared here but not defined anywhere!
254   //   3x3 representation                         254   //   3x3 representation
255                                                   255 
256   //  orthosymplectic 4-vectors treating this     256   //  orthosymplectic 4-vectors treating this as a 4-rotation:
257   HepLorentzVector col1() const;                  257   HepLorentzVector col1() const;
258   HepLorentzVector col2() const;                  258   HepLorentzVector col2() const;
259   HepLorentzVector col3() const;                  259   HepLorentzVector col3() const;
260   HepLorentzVector col4() const;                  260   HepLorentzVector col4() const;
261   HepLorentzVector row1() const;                  261   HepLorentzVector row1() const;
262   HepLorentzVector row2() const;                  262   HepLorentzVector row2() const;
263   HepLorentzVector row3() const;                  263   HepLorentzVector row3() const;
264   HepLorentzVector row4() const;                  264   HepLorentzVector row4() const;
265                                                   265 
266   //  individual elements treating this as a 4    266   //  individual elements treating this as a 4-rotation:
267   double xt() const;                              267   double xt() const; 
268   double yt() const;                              268   double yt() const; 
269   double zt() const;                              269   double zt() const; 
270   double tx() const;                              270   double tx() const; 
271   double ty() const;                              271   double ty() const;
272   double tz() const;                              272   double tz() const;
273   double tt() const;                              273   double tt() const;
274                                                   274 
275   // ---------- Operations in the Rotation gro    275   // ---------- Operations in the Rotation group
276                                                   276 
277   HepRotation operator * ( const Hep3RotationI    277   HepRotation operator * ( const Hep3RotationInterface & r ) const  ;
278                                                   278 
279   // ---------- Application                       279   // ---------- Application
280                                                   280 
281   HepLorentzVector operator* ( const HepLorent    281   HepLorentzVector operator* ( const HepLorentzVector & w ) const  ;
282   HepLorentzVector operator()( const HepLorent    282   HepLorentzVector operator()( const HepLorentzVector & w ) const  ;
283   //   apply to HepLorentzVector                  283   //   apply to HepLorentzVector
284                                                   284 
285   Hep3Vector operator* ( const Hep3Vector & v     285   Hep3Vector operator* ( const Hep3Vector & v ) const  ;
286   Hep3Vector operator()( const Hep3Vector & v     286   Hep3Vector operator()( const Hep3Vector & v ) const  ;
287   //   apply to Hep3Vector                        287   //   apply to Hep3Vector
288                                                   288 
289   // ---------- I/O and a helper method           289   // ---------- I/O and a helper method
290                                                   290 
291   std::ostream & print( std::ostream & os ) co    291   std::ostream & print( std::ostream & os ) const;
292                                                   292 
293 #endif /* ONLY_IN_CONCRETE_CLASSES */             293 #endif /* ONLY_IN_CONCRETE_CLASSES */
294                                                   294 
295 private:                                          295 private:
296                                                   296 
297   ~Hep3RotationInterface() {} // private destr    297   ~Hep3RotationInterface() {} // private destructor to forbid instatiation
298                                                   298 
299 };  // Hep3RotationInterface                      299 };  // Hep3RotationInterface
300                                                   300 
301 //-***************************                    301 //-***************************
302 // 3x3 and 4x4 representations                    302 // 3x3 and 4x4 representations
303 //-***************************                    303 //-***************************
304                                                   304 
305 struct HepRep3x3 {                                305 struct HepRep3x3 {
306                                                   306 
307   // -----  Constructors:                         307   // -----  Constructors:
308                                                   308 
309   inline HepRep3x3();                             309   inline HepRep3x3();
310                                                   310 
311   inline HepRep3x3(  double xx, double xy, dou    311   inline HepRep3x3(  double xx, double xy, double xz
312                    , double yx, double yy, dou    312                    , double yx, double yy, double yz
313                    , double zx, double zy, dou    313                    , double zx, double zy, double zz
314                    );                             314                    );
315                                                   315 
316   inline HepRep3x3( const double * array );       316   inline HepRep3x3( const double * array );
317   // construct from an array of doubles, holdi    317   // construct from an array of doubles, holding the rotation matrix
318   // in ROW order (xx, xy, ...)                   318   // in ROW order (xx, xy, ...)
319                                                   319 
320   inline void setToIdentity();                    320   inline void setToIdentity();
321                                                   321 
322   // -----  The data members are public:          322   // -----  The data members are public:
323   double xx_, xy_, xz_,                           323   double xx_, xy_, xz_,
324             yx_, yy_, yz_,                        324             yx_, yy_, yz_,
325             zx_, zy_, zz_;                        325             zx_, zy_, zz_;
326                                                   326 
327   inline void getArray ( double * array ) cons    327   inline void getArray ( double * array ) const;
328   // fill array with the NINE doubles xx, xy,     328   // fill array with the NINE doubles xx, xy, xz ... zz
329                                                   329 
330 };  // HepRep3x3                                  330 };  // HepRep3x3
331                                                   331 
332 struct HepRep4x4 {                                332 struct HepRep4x4 {
333                                                   333 
334   // -----  Constructors:                         334   // -----  Constructors:
335   inline HepRep4x4();                             335   inline HepRep4x4();
336                                                   336 
337   inline HepRep4x4(  double xx, double xy, dou    337   inline HepRep4x4(  double xx, double xy, double xz, double xt
338                    , double yx, double yy, dou    338                    , double yx, double yy, double yz, double yt
339                    , double zx, double zy, dou    339                    , double zx, double zy, double zz, double zt
340                    , double tx, double ty, dou    340                    , double tx, double ty, double tz, double tt
341                    );                             341                    );
342                                                   342 
343   inline HepRep4x4( const HepRep4x4Symmetric &    343   inline HepRep4x4( const HepRep4x4Symmetric & rep );
344                                                   344 
345   inline HepRep4x4( const double * array );       345   inline HepRep4x4( const double * array );
346   // construct from an array of doubles, holdi    346   // construct from an array of doubles, holding the transformation matrix
347   // in ROW order xx, xy, ...                     347   // in ROW order xx, xy, ...
348                                                   348 
349   inline void setToIdentity();                    349   inline void setToIdentity();
350                                                   350 
351   // -----  The data members are public:          351   // -----  The data members are public:
352   double xx_, xy_, xz_, xt_,                      352   double xx_, xy_, xz_, xt_,
353             yx_, yy_, yz_, yt_,                   353             yx_, yy_, yz_, yt_,
354             zx_, zy_, zz_, zt_,                   354             zx_, zy_, zz_, zt_,
355             tx_, ty_, tz_, tt_;                   355             tx_, ty_, tz_, tt_;
356                                                   356                          
357   inline void getArray ( double * array ) cons    357   inline void getArray ( double * array ) const;
358   // fill array with the SIXTEEN doubles xx, x    358   // fill array with the SIXTEEN doubles xx, xy, xz ... tz, tt
359                                                   359 
360   inline bool operator==(HepRep4x4 const & r)     360   inline bool operator==(HepRep4x4 const & r) const;
361   inline bool operator!=(HepRep4x4 const & r)     361   inline bool operator!=(HepRep4x4 const & r) const;
362                                                   362 
363                                                   363 
364 };  // HepRep4x4                                  364 };  // HepRep4x4
365                                                   365 
366 struct HepRep4x4Symmetric {                       366 struct HepRep4x4Symmetric {
367                                                   367 
368   // -----  Constructors:                         368   // -----  Constructors:
369                                                   369 
370   inline HepRep4x4Symmetric();                    370   inline HepRep4x4Symmetric();
371                                                   371 
372   inline HepRep4x4Symmetric                       372   inline HepRep4x4Symmetric
373   ( double xx, double xy, double xz, double xt    373   ( double xx, double xy, double xz, double xt
374                       , double yy, double yz,     374                       , double yy, double yz, double yt
375                                     , double z    375                                     , double zz, double zt
376                                                   376                                                   , double tt );
377                                                   377 
378   inline HepRep4x4Symmetric( const double * ar    378   inline HepRep4x4Symmetric( const double * array );
379   // construct from an array of doubles, holdi    379   // construct from an array of doubles, holding the transformation matrix
380   // elements in this order:  xx, xy, xz, xt,     380   // elements in this order:  xx, xy, xz, xt, yy, yz, yt, zz, zt, tt
381                                                   381 
382   inline void setToIdentity();                    382   inline void setToIdentity();
383                                                   383 
384   // -----  The data members are public:          384   // -----  The data members are public:
385   double xx_, xy_, xz_, xt_,                      385   double xx_, xy_, xz_, xt_,
386                  yy_, yz_, yt_,                   386                  yy_, yz_, yt_,
387                       zz_, zt_,                   387                       zz_, zt_,
388                            tt_;                   388                            tt_;
389                                                   389 
390   inline void getArray ( double * array ) cons    390   inline void getArray ( double * array ) const;
391   // fill array with the TEN doubles xx, xy, x    391   // fill array with the TEN doubles xx, xy, xz, xt, yy, yz, yt, zz, zt, tt
392                                                   392 
393 };                                                393 };
394                                                   394 
395 }  // namespace CLHEP                             395 }  // namespace CLHEP
396                                                   396 
397 #include "CLHEP/Vector/RotationInterfaces.icc"    397 #include "CLHEP/Vector/RotationInterfaces.icc"
398                                                   398 
399 #endif // ROTATION_INTERFACES_H                   399 #endif // ROTATION_INTERFACES_H
400                                                   400