ROOT logo
// @(#)root/geom:$Id: TGeoMatrix.h 40116 2011-07-04 12:00:32Z agheata $
// Author: Andrei Gheata   25/10/01

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT_TGeoMatrix
#define ROOT_TGeoMatrix

/*************************************************************************
 * Geometrical transformations. TGeoMatrix - base class, TGeoTranslation *
 * TGeoRotation, TGeoScale, TGeoCombiTrans, TGeoGenTrans .               *
 *                                                                       *
 *************************************************************************/

#ifndef ROOT_TNamed
#include "TNamed.h"
#endif

//--- globals 
const Double_t kNullVector[3]       =       {0.0,  0.0,  0.0};

const Double_t kIdentityMatrix[3*3] =       {1.0,  0.0,  0.0,
                                             0.0,  1.0,  0.0,
                                             0.0,  0.0,  1.0};

const Double_t kUnitScale[3]        =       {1.0,  1.0,  1.0};

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoMatrix - base class for geometrical transformations.               //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoMatrix : public TNamed
{
public:
enum EGeoTransfTypes {
   kGeoIdentity  = 0,
   kGeoTranslation  = BIT(17),
   kGeoRotation     = BIT(18),
   kGeoScale        = BIT(19),
   kGeoReflection   = BIT(20),
   kGeoRegistered   = BIT(21),
   kGeoSavePrimitive = BIT(22),
   kGeoMatrixOwned   = BIT(23),
   kGeoCombiTrans   = kGeoTranslation | kGeoRotation,
   kGeoGenTrans     = kGeoTranslation | kGeoRotation | kGeoScale
};

protected:
   TGeoMatrix(const TGeoMatrix &other);

public :
   TGeoMatrix();
   TGeoMatrix(const char *name);
   virtual ~TGeoMatrix();

   TGeoMatrix& operator=(const TGeoMatrix &matrix);
// Preventing warnings with -Weffc++ in GCC since the behaviour of operator * was chosen so by design.
#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40600
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
   TGeoMatrix& operator*(const TGeoMatrix &right) const;
#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40600
#pragma GCC diagnostic pop
#endif
   Bool_t      operator ==(const TGeoMatrix &other) const;
   
   Bool_t               IsIdentity()    const {return !TestBit(kGeoGenTrans);}
   Bool_t               IsTranslation() const {return TestBit(kGeoTranslation);}
   Bool_t               IsRotation()    const {return TestBit(kGeoRotation);}
   Bool_t               IsReflection()  const {return TestBit(kGeoReflection);}
   Bool_t               IsScale()       const {return TestBit(kGeoScale);}
   Bool_t               IsCombi()       const {return (TestBit(kGeoTranslation) 
                                               && TestBit(kGeoRotation));}
   Bool_t               IsGeneral()     const {return (TestBit(kGeoTranslation) 
                            && TestBit(kGeoRotation) && TestBit(kGeoScale));}
   Bool_t               IsRegistered()  const {return TestBit(kGeoRegistered);}
   Bool_t               IsRotAboutZ()   const;
   void                 GetHomogenousMatrix(Double_t *hmat) const;
   char                *GetPointerName() const;

   virtual Int_t              GetByteCount() const;
   virtual const Double_t    *GetTranslation()    const = 0;
   virtual const Double_t    *GetRotationMatrix() const = 0;
   virtual const Double_t    *GetScale()          const = 0;
   virtual TGeoMatrix&  Inverse()                 const = 0;
   virtual void         LocalToMaster(const Double_t *local, Double_t *master) const;
   virtual void         LocalToMasterVect(const Double_t *local, Double_t *master) const;
   virtual void         LocalToMasterBomb(const Double_t *local, Double_t *master) const;
   virtual TGeoMatrix  *MakeClone() const = 0;
   virtual void         MasterToLocal(const Double_t *master, Double_t *local) const;
   virtual void         MasterToLocalVect(const Double_t *master, Double_t *local) const;
   virtual void         MasterToLocalBomb(const Double_t *master, Double_t *local) const;
   static void          Normalize(Double_t *vect);
   void                 Print(Option_t *option="") const; // *MENU*
   virtual void         RotateX(Double_t) {}
   virtual void         RotateY(Double_t) {}
   virtual void         RotateZ(Double_t) {}
   virtual void         ReflectX(Bool_t leftside,Bool_t rotonly=kFALSE);
   virtual void         ReflectY(Bool_t leftside,Bool_t rotonly=kFALSE);
   virtual void         ReflectZ(Bool_t leftside,Bool_t rotonly=kFALSE);
   virtual void         RegisterYourself();
   void                 SetDefaultName();
   virtual void         SetDx(Double_t) {}
   virtual void         SetDy(Double_t) {}
   virtual void         SetDz(Double_t) {}
   
   ClassDef(TGeoMatrix, 1)                 // base geometrical transformation class
};



////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoTranslation - class describing translations. A translation is      //
//    basicaly an array of 3 doubles matching the positions 12, 13        //
//    and 14 in the homogenous matrix description.                        //
//                                                                        //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoTranslation : public TGeoMatrix
{
protected:
   Double_t             fTranslation[3];  // translation vector
public :
   TGeoTranslation();
   TGeoTranslation(const TGeoTranslation &other);
   TGeoTranslation(const TGeoMatrix &other);
   TGeoTranslation(Double_t dx, Double_t dy, Double_t dz);
   TGeoTranslation(const char *name, Double_t dx, Double_t dy, Double_t dz);
   virtual ~TGeoTranslation() {}
   
   TGeoTranslation& operator=(const TGeoMatrix &matrix);
   TGeoTranslation& operator=(const TGeoTranslation &other) {return operator=((const TGeoMatrix&)other);};

   void                 Add(const TGeoTranslation *other);
   virtual TGeoMatrix&  Inverse() const;
   virtual void         LocalToMaster(const Double_t *local, Double_t *master) const;
   virtual void         LocalToMasterVect(const Double_t *local, Double_t *master) const;
   virtual void         LocalToMasterBomb(const Double_t *local, Double_t *master) const;
   virtual TGeoMatrix  *MakeClone() const;
   virtual void         MasterToLocal(const Double_t *master, Double_t *local) const;
   virtual void         MasterToLocalVect(const Double_t *master, Double_t *local) const;
   virtual void         MasterToLocalBomb(const Double_t *master, Double_t *local) const;
   virtual void         RotateX(Double_t angle);
   virtual void         RotateY(Double_t angle);
   virtual void         RotateZ(Double_t angle);
   virtual void         SavePrimitive(ostream &out, Option_t *option = "");
   void                 Subtract(const TGeoTranslation *other);
   void                 SetTranslation(Double_t dx, Double_t dy, Double_t dz);
   void                 SetTranslation(const TGeoMatrix &other);
   virtual void         SetDx(Double_t dx) {SetTranslation(dx, fTranslation[1], fTranslation[2]);}
   virtual void         SetDy(Double_t dy) {SetTranslation(fTranslation[0], dy, fTranslation[2]);}
   virtual void         SetDz(Double_t dz) {SetTranslation(fTranslation[0], fTranslation[1], dz);}
   
   virtual const Double_t    *GetTranslation() const {return &fTranslation[0];}
   virtual const Double_t    *GetRotationMatrix() const {return &kIdentityMatrix[0];}
   virtual const Double_t    *GetScale()       const {return &kUnitScale[0];}

   ClassDef(TGeoTranslation, 1)                 // translation class
};

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoRotation - class describing rotations. A rotation is a 3*3 array   //
//    Column vectors has to be orthogonal unit vectors.                   //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoRotation : public TGeoMatrix
{
protected:
   Double_t             fRotationMatrix[3*3];   // rotation matrix

   void                 CheckMatrix();
public :
   TGeoRotation();
   TGeoRotation(const TGeoRotation &other);
   TGeoRotation(const TGeoMatrix &other);
   TGeoRotation(const char *name);
//   TGeoRotation(const char *name, Double_t *matrix) ;
   TGeoRotation(const char *name, Double_t phi, Double_t theta, Double_t psi);
   TGeoRotation(const char *name, Double_t theta1, Double_t phi1, Double_t theta2, Double_t phi2,
                Double_t theta3, Double_t phi3);
   virtual ~TGeoRotation() {}
   
   TGeoRotation& operator=(const TGeoMatrix &matrix);
   TGeoRotation& operator=(const TGeoRotation &other) {return operator=((const TGeoMatrix&)other);};
   
   Bool_t               IsValid() const;
   virtual TGeoMatrix&  Inverse() const;
   void                 Clear(Option_t *option ="");
   Double_t             Determinant() const;
   void                 FastRotZ(const Double_t *sincos);
   void                 GetAngles(Double_t &theta1, Double_t &phi1, Double_t &theta2, Double_t &phi2,
                                  Double_t &theta3, Double_t &phi3) const;
   void                 GetAngles(Double_t &phi, Double_t &theta, Double_t &psi) const;
   Double_t             GetPhiRotation(Bool_t fixX=kFALSE) const;
   virtual void         LocalToMaster(const Double_t *local, Double_t *master) const;
   virtual void         LocalToMasterVect(const Double_t *local, Double_t *master) const {TGeoRotation::LocalToMaster(local, master);}
   virtual void         LocalToMasterBomb(const Double_t *local, Double_t *master) const {TGeoRotation::LocalToMaster(local, master);}
   virtual TGeoMatrix  *MakeClone() const;
   virtual void         MasterToLocal(const Double_t *master, Double_t *local) const;
   virtual void         MasterToLocalVect(const Double_t *master, Double_t *local) const {TGeoRotation::MasterToLocal(master, local);}
   virtual void         MasterToLocalBomb(const Double_t *master, Double_t *local) const {TGeoRotation::MasterToLocal(master, local);}
   void                 MultiplyBy(TGeoRotation *rot, Bool_t after=kTRUE);
   virtual void         RotateX(Double_t angle);
   virtual void         RotateY(Double_t angle);
   virtual void         RotateZ(Double_t angle);
   virtual void         SavePrimitive(ostream &out, Option_t *option = "");
   virtual void         ReflectX(Bool_t leftside, Bool_t rotonly=kFALSE);
   virtual void         ReflectY(Bool_t leftside, Bool_t rotonly=kFALSE);
   virtual void         ReflectZ(Bool_t leftside, Bool_t rotonly=kFALSE);
   void                 SetAngles(Double_t phi, Double_t theta, Double_t psi);
   void                 SetAngles(Double_t theta1, Double_t phi1, Double_t theta2, Double_t phi2,
                                  Double_t theta3, Double_t phi3);
   void                 SetMatrix(const Double_t *rot) {memcpy(&fRotationMatrix[0], rot, 9*sizeof(Double_t));CheckMatrix();}
   void                 SetRotation(const TGeoMatrix &other);
   void                 GetInverse(Double_t *invmat) const;
   
   virtual const Double_t    *GetTranslation()    const {return &kNullVector[0];}
   virtual const Double_t    *GetRotationMatrix() const {return &fRotationMatrix[0];}
   virtual const Double_t    *GetScale()          const {return &kUnitScale[0];}

   ClassDef(TGeoRotation, 1)               // rotation class
};

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoScale - class describing scale transformations. A scale is an      //
//    array of 3 doubles (sx, sy, sz) multiplying elements 0, 5 and 10    //
//    of the homogenous matrix. A scale is normalized : sx*sy*sz = 1      //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoScale : public TGeoMatrix
{
protected:
   Double_t             fScale[3];        // scale (x, y, z)
public :
   TGeoScale();
   TGeoScale(const TGeoScale &other);
   TGeoScale(Double_t sx, Double_t sy, Double_t sz);
   TGeoScale(const char *name, Double_t sx, Double_t sy, Double_t sz);
   virtual ~TGeoScale();
   
   virtual TGeoMatrix&  Inverse() const;
   void                 SetScale(Double_t sx, Double_t sy, Double_t sz);
   virtual void         LocalToMaster(const Double_t *local, Double_t *master) const;
   Double_t             LocalToMaster(Double_t dist, const Double_t *dir=0) const;
   virtual void         LocalToMasterVect(const Double_t *local, Double_t *master) const {TGeoScale::LocalToMaster(local, master);}
   virtual TGeoMatrix  *MakeClone() const;
   virtual void         MasterToLocal(const Double_t *master, Double_t *local) const;
   Double_t             MasterToLocal(Double_t dist, const Double_t *dir=0) const;
   virtual void         MasterToLocalVect(const Double_t *master, Double_t *local) const {TGeoScale::MasterToLocal(master, local);}
   virtual void         ReflectX(Bool_t, Bool_t) {fScale[0]=-fScale[0]; SetBit(kGeoReflection, !IsReflection());}
   virtual void         ReflectY(Bool_t, Bool_t) {fScale[1]=-fScale[1]; SetBit(kGeoReflection, !IsReflection());}
   virtual void         ReflectZ(Bool_t, Bool_t) {fScale[2]=-fScale[2]; SetBit(kGeoReflection, !IsReflection());}
   
   virtual const Double_t    *GetTranslation()    const {return &kNullVector[0];}
   virtual const Double_t    *GetRotationMatrix() const {return &kIdentityMatrix[0];}
   virtual const Double_t    *GetScale()          const {return &fScale[0];}

   ClassDef(TGeoScale, 1)                 // scaling class
};

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoCombiTrans - class describing rotation + translation. Most         //
//    frequently used in the description of TGeoNode 's                   //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoCombiTrans : public TGeoMatrix
{
protected:
   Double_t             fTranslation[3]; // translation vector
   TGeoRotation        *fRotation;       // rotation matrix
public :
   TGeoCombiTrans();
   TGeoCombiTrans(const TGeoCombiTrans &other);
   TGeoCombiTrans(const TGeoMatrix &other);
   TGeoCombiTrans(const TGeoTranslation &tr, const TGeoRotation &rot);
   TGeoCombiTrans(const char *name);
   TGeoCombiTrans(Double_t dx, Double_t dy, Double_t dz, TGeoRotation *rot);
   TGeoCombiTrans(const char *name, Double_t dx, Double_t dy, Double_t dz, TGeoRotation *rot);

   TGeoCombiTrans& operator=(const TGeoMatrix &matrix);
   TGeoCombiTrans& operator=(const TGeoCombiTrans &other) {return operator=((const TGeoMatrix&)other);};

   virtual ~TGeoCombiTrans();
   
   void                 Clear(Option_t *option ="");
   virtual TGeoMatrix&  Inverse() const;
   virtual TGeoMatrix  *MakeClone() const;
   virtual void         RegisterYourself();
   virtual void         RotateX(Double_t angle);
   virtual void         RotateY(Double_t angle);
   virtual void         RotateZ(Double_t angle);
   virtual void         ReflectX(Bool_t leftside, Bool_t rotonly=kFALSE);
   virtual void         ReflectY(Bool_t leftside, Bool_t rotonly=kFALSE);
   virtual void         ReflectZ(Bool_t leftside, Bool_t rotonly=kFALSE);
   virtual void         SavePrimitive(ostream &out, Option_t *option = "");
   virtual void         SetDx(Double_t dx) {SetTranslation(dx, fTranslation[1], fTranslation[2]);}
   virtual void         SetDy(Double_t dy) {SetTranslation(fTranslation[0], dy, fTranslation[2]);}
   virtual void         SetDz(Double_t dz) {SetTranslation(fTranslation[0], fTranslation[1], dz);}
   void                 SetTranslation(const TGeoTranslation &tr);
   void                 SetTranslation(Double_t dx, Double_t dy, Double_t dz);
   void                 SetTranslation(Double_t *vect);
   void                 SetRotation(const TGeoRotation &other);
   void                 SetRotation(const TGeoRotation *rot);

   TGeoRotation              *GetRotation() const    {return fRotation;}

   virtual const Double_t    *GetTranslation()    const {return &fTranslation[0];}
   virtual const Double_t    *GetRotationMatrix() const;
   virtual const Double_t    *GetScale()          const {return &kUnitScale[0];}

   ClassDef(TGeoCombiTrans, 1)            // rotation + translation
};

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoGenTrans - most general transformation, holding a translation,     //
//    a rotation and a scale                                              //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoGenTrans : public TGeoCombiTrans
{
protected:
   Double_t             fScale[3];       // scale (x, y, z)
public :
   TGeoGenTrans();
   TGeoGenTrans(const char *name);
   TGeoGenTrans(Double_t dx, Double_t dy, Double_t dz,
                Double_t sx, Double_t sy, Double_t sz, TGeoRotation *rot);
   TGeoGenTrans(const char *name, Double_t dx, Double_t dy, Double_t dz,
                Double_t sx, Double_t sy, Double_t sz, TGeoRotation *rot);
   virtual ~TGeoGenTrans();
   
   void                 Clear(Option_t *option ="");
   virtual TGeoMatrix&  Inverse() const;
   void                 SetScale(Double_t sx, Double_t sy, Double_t sz);
   void                 SetScale(Double_t *scale) {memcpy(&fScale[0], scale, 3*sizeof(Double_t));}
   virtual TGeoMatrix  *MakeClone() const {return NULL;}
   Bool_t               Normalize();

   virtual const Double_t    *GetScale()     const {return &fScale[0];}

   ClassDef(TGeoGenTrans, 1)            // rotation + translation + scale
};

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoIdentity - an identity transformation. It holds no data member     //
//    and returns pointers to static null translation and identity        //
//    transformations for rotation and scale                              //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoIdentity : public TGeoMatrix
{
private:
   // no data members
public :
   TGeoIdentity();
   TGeoIdentity(const char *name);
   virtual ~TGeoIdentity() {}
   
   virtual TGeoMatrix&  Inverse() const;
   virtual void         LocalToMaster(const Double_t *local, Double_t *master) const {memcpy(master, local, 3*sizeof(Double_t));}
   virtual void         LocalToMasterVect(const Double_t *local, Double_t *master) const {memcpy(master, local, 3*sizeof(Double_t));}
   virtual void         LocalToMasterBomb(const Double_t *local, Double_t *master) const {TGeoIdentity::LocalToMaster(local, master);}
   virtual TGeoMatrix  *MakeClone() const {return NULL;}
   virtual void         MasterToLocal(const Double_t *master, Double_t *local) const {memcpy(local, master, 3*sizeof(Double_t));}
   virtual void         MasterToLocalVect(const Double_t *master, Double_t *local) const {memcpy(local, master, 3*sizeof(Double_t));}
   virtual void         MasterToLocalBomb(const Double_t *master, Double_t *local) const {TGeoIdentity::MasterToLocal(master, local);}

   virtual const Double_t    *GetTranslation() const {return &kNullVector[0];}
   virtual const Double_t    *GetRotationMatrix() const {return &kIdentityMatrix[0];}
   virtual const Double_t    *GetScale()       const {return &kUnitScale[0];}
   virtual void         SavePrimitive(ostream &, Option_t * = "") {;}

   ClassDef(TGeoIdentity, 1)                 // identity transformation class
};



////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoHMatrix - Matrix class used for computing global transformations   //
//     Should NOT be used for node definition. An instance of this class  //
//     is generally used to pile-up local transformations starting from   //
//     the top level physical node, down to the current node.             //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoHMatrix : public TGeoMatrix
{
private:
   Double_t              fTranslation[3];    // translation component
   Double_t              fRotationMatrix[9]; // rotation matrix
   Double_t              fScale[3];          // scale component
   
public :
   TGeoHMatrix();
   TGeoHMatrix(const TGeoMatrix &matrix);
   TGeoHMatrix(const char *name);
   virtual ~TGeoHMatrix();
   
   TGeoHMatrix& operator=(const TGeoMatrix *matrix);
   TGeoHMatrix& operator=(const TGeoMatrix &matrix);
   TGeoHMatrix& operator=(const TGeoHMatrix &other) {return operator=((const TGeoMatrix&)other);};
   
   TGeoHMatrix& operator*=(const TGeoMatrix &matrix) {Multiply(&matrix);return(*this);}

   void                 Clear(Option_t *option ="");
   void                 CopyFrom(const TGeoMatrix *other);
   Double_t             Determinant() const;
   void                 FastRotZ(const Double_t *sincos);
   virtual TGeoMatrix&  Inverse() const;
   virtual TGeoMatrix  *MakeClone() const;
   void                 Multiply(const TGeoMatrix *right);
   void                 MultiplyLeft(const TGeoMatrix *left);

   virtual void         RotateX(Double_t angle);
   virtual void         RotateY(Double_t angle);
   virtual void         RotateZ(Double_t angle);
   virtual void         ReflectX(Bool_t leftside, Bool_t rotonly=kFALSE);
   virtual void         ReflectY(Bool_t leftside, Bool_t rotonly=kFALSE);
   virtual void         ReflectZ(Bool_t leftside, Bool_t rotonly=kFALSE);
   virtual void         SavePrimitive(ostream &out, Option_t *option = "");
   virtual void         SetDx(Double_t dx) {fTranslation[0] = dx; SetBit(kGeoTranslation);}
   virtual void         SetDy(Double_t dy) {fTranslation[1] = dy; SetBit(kGeoTranslation);}
   virtual void         SetDz(Double_t dz) {fTranslation[2] = dz; SetBit(kGeoTranslation);}
   void                 SetTranslation(const Double_t *vect) {SetBit(kGeoTranslation); memcpy(&fTranslation[0], vect, 3*sizeof(Double_t));}
   void                 SetRotation(const Double_t *matrix) {SetBit(kGeoRotation); memcpy(&fRotationMatrix[0], matrix, 9*sizeof(Double_t));}
   void                 SetScale(const Double_t *scale) {SetBit(kGeoScale); memcpy(&fScale[0], scale, 3*sizeof(Double_t));}


   virtual const Double_t    *GetTranslation() const {return &fTranslation[0];}
   virtual const Double_t    *GetRotationMatrix() const {return &fRotationMatrix[0];}
   virtual const Double_t    *GetScale() const {return &fScale[0];}

   virtual Double_t    *GetTranslation() {return &fTranslation[0];}
   virtual Double_t    *GetRotationMatrix() {return &fRotationMatrix[0];}
   virtual Double_t    *GetScale() {return &fScale[0];}
   ClassDef(TGeoHMatrix, 1)                 // global matrix class
};


R__EXTERN TGeoIdentity *gGeoIdentity;

#endif

 TGeoMatrix.h:1
 TGeoMatrix.h:2
 TGeoMatrix.h:3
 TGeoMatrix.h:4
 TGeoMatrix.h:5
 TGeoMatrix.h:6
 TGeoMatrix.h:7
 TGeoMatrix.h:8
 TGeoMatrix.h:9
 TGeoMatrix.h:10
 TGeoMatrix.h:11
 TGeoMatrix.h:12
 TGeoMatrix.h:13
 TGeoMatrix.h:14
 TGeoMatrix.h:15
 TGeoMatrix.h:16
 TGeoMatrix.h:17
 TGeoMatrix.h:18
 TGeoMatrix.h:19
 TGeoMatrix.h:20
 TGeoMatrix.h:21
 TGeoMatrix.h:22
 TGeoMatrix.h:23
 TGeoMatrix.h:24
 TGeoMatrix.h:25
 TGeoMatrix.h:26
 TGeoMatrix.h:27
 TGeoMatrix.h:28
 TGeoMatrix.h:29
 TGeoMatrix.h:30
 TGeoMatrix.h:31
 TGeoMatrix.h:32
 TGeoMatrix.h:33
 TGeoMatrix.h:34
 TGeoMatrix.h:35
 TGeoMatrix.h:36
 TGeoMatrix.h:37
 TGeoMatrix.h:38
 TGeoMatrix.h:39
 TGeoMatrix.h:40
 TGeoMatrix.h:41
 TGeoMatrix.h:42
 TGeoMatrix.h:43
 TGeoMatrix.h:44
 TGeoMatrix.h:45
 TGeoMatrix.h:46
 TGeoMatrix.h:47
 TGeoMatrix.h:48
 TGeoMatrix.h:49
 TGeoMatrix.h:50
 TGeoMatrix.h:51
 TGeoMatrix.h:52
 TGeoMatrix.h:53
 TGeoMatrix.h:54
 TGeoMatrix.h:55
 TGeoMatrix.h:56
 TGeoMatrix.h:57
 TGeoMatrix.h:58
 TGeoMatrix.h:59
 TGeoMatrix.h:60
 TGeoMatrix.h:61
 TGeoMatrix.h:62
 TGeoMatrix.h:63
 TGeoMatrix.h:64
 TGeoMatrix.h:65
 TGeoMatrix.h:66
 TGeoMatrix.h:67
 TGeoMatrix.h:68
 TGeoMatrix.h:69
 TGeoMatrix.h:70
 TGeoMatrix.h:71
 TGeoMatrix.h:72
 TGeoMatrix.h:73
 TGeoMatrix.h:74
 TGeoMatrix.h:75
 TGeoMatrix.h:76
 TGeoMatrix.h:77
 TGeoMatrix.h:78
 TGeoMatrix.h:79
 TGeoMatrix.h:80
 TGeoMatrix.h:81
 TGeoMatrix.h:82
 TGeoMatrix.h:83
 TGeoMatrix.h:84
 TGeoMatrix.h:85
 TGeoMatrix.h:86
 TGeoMatrix.h:87
 TGeoMatrix.h:88
 TGeoMatrix.h:89
 TGeoMatrix.h:90
 TGeoMatrix.h:91
 TGeoMatrix.h:92
 TGeoMatrix.h:93
 TGeoMatrix.h:94
 TGeoMatrix.h:95
 TGeoMatrix.h:96
 TGeoMatrix.h:97
 TGeoMatrix.h:98
 TGeoMatrix.h:99
 TGeoMatrix.h:100
 TGeoMatrix.h:101
 TGeoMatrix.h:102
 TGeoMatrix.h:103
 TGeoMatrix.h:104
 TGeoMatrix.h:105
 TGeoMatrix.h:106
 TGeoMatrix.h:107
 TGeoMatrix.h:108
 TGeoMatrix.h:109
 TGeoMatrix.h:110
 TGeoMatrix.h:111
 TGeoMatrix.h:112
 TGeoMatrix.h:113
 TGeoMatrix.h:114
 TGeoMatrix.h:115
 TGeoMatrix.h:116
 TGeoMatrix.h:117
 TGeoMatrix.h:118
 TGeoMatrix.h:119
 TGeoMatrix.h:120
 TGeoMatrix.h:121
 TGeoMatrix.h:122
 TGeoMatrix.h:123
 TGeoMatrix.h:124
 TGeoMatrix.h:125
 TGeoMatrix.h:126
 TGeoMatrix.h:127
 TGeoMatrix.h:128
 TGeoMatrix.h:129
 TGeoMatrix.h:130
 TGeoMatrix.h:131
 TGeoMatrix.h:132
 TGeoMatrix.h:133
 TGeoMatrix.h:134
 TGeoMatrix.h:135
 TGeoMatrix.h:136
 TGeoMatrix.h:137
 TGeoMatrix.h:138
 TGeoMatrix.h:139
 TGeoMatrix.h:140
 TGeoMatrix.h:141
 TGeoMatrix.h:142
 TGeoMatrix.h:143
 TGeoMatrix.h:144
 TGeoMatrix.h:145
 TGeoMatrix.h:146
 TGeoMatrix.h:147
 TGeoMatrix.h:148
 TGeoMatrix.h:149
 TGeoMatrix.h:150
 TGeoMatrix.h:151
 TGeoMatrix.h:152
 TGeoMatrix.h:153
 TGeoMatrix.h:154
 TGeoMatrix.h:155
 TGeoMatrix.h:156
 TGeoMatrix.h:157
 TGeoMatrix.h:158
 TGeoMatrix.h:159
 TGeoMatrix.h:160
 TGeoMatrix.h:161
 TGeoMatrix.h:162
 TGeoMatrix.h:163
 TGeoMatrix.h:164
 TGeoMatrix.h:165
 TGeoMatrix.h:166
 TGeoMatrix.h:167
 TGeoMatrix.h:168
 TGeoMatrix.h:169
 TGeoMatrix.h:170
 TGeoMatrix.h:171
 TGeoMatrix.h:172
 TGeoMatrix.h:173
 TGeoMatrix.h:174
 TGeoMatrix.h:175
 TGeoMatrix.h:176
 TGeoMatrix.h:177
 TGeoMatrix.h:178
 TGeoMatrix.h:179
 TGeoMatrix.h:180
 TGeoMatrix.h:181
 TGeoMatrix.h:182
 TGeoMatrix.h:183
 TGeoMatrix.h:184
 TGeoMatrix.h:185
 TGeoMatrix.h:186
 TGeoMatrix.h:187
 TGeoMatrix.h:188
 TGeoMatrix.h:189
 TGeoMatrix.h:190
 TGeoMatrix.h:191
 TGeoMatrix.h:192
 TGeoMatrix.h:193
 TGeoMatrix.h:194
 TGeoMatrix.h:195
 TGeoMatrix.h:196
 TGeoMatrix.h:197
 TGeoMatrix.h:198
 TGeoMatrix.h:199
 TGeoMatrix.h:200
 TGeoMatrix.h:201
 TGeoMatrix.h:202
 TGeoMatrix.h:203
 TGeoMatrix.h:204
 TGeoMatrix.h:205
 TGeoMatrix.h:206
 TGeoMatrix.h:207
 TGeoMatrix.h:208
 TGeoMatrix.h:209
 TGeoMatrix.h:210
 TGeoMatrix.h:211
 TGeoMatrix.h:212
 TGeoMatrix.h:213
 TGeoMatrix.h:214
 TGeoMatrix.h:215
 TGeoMatrix.h:216
 TGeoMatrix.h:217
 TGeoMatrix.h:218
 TGeoMatrix.h:219
 TGeoMatrix.h:220
 TGeoMatrix.h:221
 TGeoMatrix.h:222
 TGeoMatrix.h:223
 TGeoMatrix.h:224
 TGeoMatrix.h:225
 TGeoMatrix.h:226
 TGeoMatrix.h:227
 TGeoMatrix.h:228
 TGeoMatrix.h:229
 TGeoMatrix.h:230
 TGeoMatrix.h:231
 TGeoMatrix.h:232
 TGeoMatrix.h:233
 TGeoMatrix.h:234
 TGeoMatrix.h:235
 TGeoMatrix.h:236
 TGeoMatrix.h:237
 TGeoMatrix.h:238
 TGeoMatrix.h:239
 TGeoMatrix.h:240
 TGeoMatrix.h:241
 TGeoMatrix.h:242
 TGeoMatrix.h:243
 TGeoMatrix.h:244
 TGeoMatrix.h:245
 TGeoMatrix.h:246
 TGeoMatrix.h:247
 TGeoMatrix.h:248
 TGeoMatrix.h:249
 TGeoMatrix.h:250
 TGeoMatrix.h:251
 TGeoMatrix.h:252
 TGeoMatrix.h:253
 TGeoMatrix.h:254
 TGeoMatrix.h:255
 TGeoMatrix.h:256
 TGeoMatrix.h:257
 TGeoMatrix.h:258
 TGeoMatrix.h:259
 TGeoMatrix.h:260
 TGeoMatrix.h:261
 TGeoMatrix.h:262
 TGeoMatrix.h:263
 TGeoMatrix.h:264
 TGeoMatrix.h:265
 TGeoMatrix.h:266
 TGeoMatrix.h:267
 TGeoMatrix.h:268
 TGeoMatrix.h:269
 TGeoMatrix.h:270
 TGeoMatrix.h:271
 TGeoMatrix.h:272
 TGeoMatrix.h:273
 TGeoMatrix.h:274
 TGeoMatrix.h:275
 TGeoMatrix.h:276
 TGeoMatrix.h:277
 TGeoMatrix.h:278
 TGeoMatrix.h:279
 TGeoMatrix.h:280
 TGeoMatrix.h:281
 TGeoMatrix.h:282
 TGeoMatrix.h:283
 TGeoMatrix.h:284
 TGeoMatrix.h:285
 TGeoMatrix.h:286
 TGeoMatrix.h:287
 TGeoMatrix.h:288
 TGeoMatrix.h:289
 TGeoMatrix.h:290
 TGeoMatrix.h:291
 TGeoMatrix.h:292
 TGeoMatrix.h:293
 TGeoMatrix.h:294
 TGeoMatrix.h:295
 TGeoMatrix.h:296
 TGeoMatrix.h:297
 TGeoMatrix.h:298
 TGeoMatrix.h:299
 TGeoMatrix.h:300
 TGeoMatrix.h:301
 TGeoMatrix.h:302
 TGeoMatrix.h:303
 TGeoMatrix.h:304
 TGeoMatrix.h:305
 TGeoMatrix.h:306
 TGeoMatrix.h:307
 TGeoMatrix.h:308
 TGeoMatrix.h:309
 TGeoMatrix.h:310
 TGeoMatrix.h:311
 TGeoMatrix.h:312
 TGeoMatrix.h:313
 TGeoMatrix.h:314
 TGeoMatrix.h:315
 TGeoMatrix.h:316
 TGeoMatrix.h:317
 TGeoMatrix.h:318
 TGeoMatrix.h:319
 TGeoMatrix.h:320
 TGeoMatrix.h:321
 TGeoMatrix.h:322
 TGeoMatrix.h:323
 TGeoMatrix.h:324
 TGeoMatrix.h:325
 TGeoMatrix.h:326
 TGeoMatrix.h:327
 TGeoMatrix.h:328
 TGeoMatrix.h:329
 TGeoMatrix.h:330
 TGeoMatrix.h:331
 TGeoMatrix.h:332
 TGeoMatrix.h:333
 TGeoMatrix.h:334
 TGeoMatrix.h:335
 TGeoMatrix.h:336
 TGeoMatrix.h:337
 TGeoMatrix.h:338
 TGeoMatrix.h:339
 TGeoMatrix.h:340
 TGeoMatrix.h:341
 TGeoMatrix.h:342
 TGeoMatrix.h:343
 TGeoMatrix.h:344
 TGeoMatrix.h:345
 TGeoMatrix.h:346
 TGeoMatrix.h:347
 TGeoMatrix.h:348
 TGeoMatrix.h:349
 TGeoMatrix.h:350
 TGeoMatrix.h:351
 TGeoMatrix.h:352
 TGeoMatrix.h:353
 TGeoMatrix.h:354
 TGeoMatrix.h:355
 TGeoMatrix.h:356
 TGeoMatrix.h:357
 TGeoMatrix.h:358
 TGeoMatrix.h:359
 TGeoMatrix.h:360
 TGeoMatrix.h:361
 TGeoMatrix.h:362
 TGeoMatrix.h:363
 TGeoMatrix.h:364
 TGeoMatrix.h:365
 TGeoMatrix.h:366
 TGeoMatrix.h:367
 TGeoMatrix.h:368
 TGeoMatrix.h:369
 TGeoMatrix.h:370
 TGeoMatrix.h:371
 TGeoMatrix.h:372
 TGeoMatrix.h:373
 TGeoMatrix.h:374
 TGeoMatrix.h:375
 TGeoMatrix.h:376
 TGeoMatrix.h:377
 TGeoMatrix.h:378
 TGeoMatrix.h:379
 TGeoMatrix.h:380
 TGeoMatrix.h:381
 TGeoMatrix.h:382
 TGeoMatrix.h:383
 TGeoMatrix.h:384
 TGeoMatrix.h:385
 TGeoMatrix.h:386
 TGeoMatrix.h:387
 TGeoMatrix.h:388
 TGeoMatrix.h:389
 TGeoMatrix.h:390
 TGeoMatrix.h:391
 TGeoMatrix.h:392
 TGeoMatrix.h:393
 TGeoMatrix.h:394
 TGeoMatrix.h:395
 TGeoMatrix.h:396
 TGeoMatrix.h:397
 TGeoMatrix.h:398
 TGeoMatrix.h:399
 TGeoMatrix.h:400
 TGeoMatrix.h:401
 TGeoMatrix.h:402
 TGeoMatrix.h:403
 TGeoMatrix.h:404
 TGeoMatrix.h:405
 TGeoMatrix.h:406
 TGeoMatrix.h:407
 TGeoMatrix.h:408
 TGeoMatrix.h:409
 TGeoMatrix.h:410
 TGeoMatrix.h:411
 TGeoMatrix.h:412
 TGeoMatrix.h:413
 TGeoMatrix.h:414
 TGeoMatrix.h:415
 TGeoMatrix.h:416
 TGeoMatrix.h:417
 TGeoMatrix.h:418
 TGeoMatrix.h:419
 TGeoMatrix.h:420
 TGeoMatrix.h:421
 TGeoMatrix.h:422
 TGeoMatrix.h:423
 TGeoMatrix.h:424
 TGeoMatrix.h:425
 TGeoMatrix.h:426
 TGeoMatrix.h:427
 TGeoMatrix.h:428
 TGeoMatrix.h:429
 TGeoMatrix.h:430
 TGeoMatrix.h:431
 TGeoMatrix.h:432
 TGeoMatrix.h:433
 TGeoMatrix.h:434
 TGeoMatrix.h:435
 TGeoMatrix.h:436
 TGeoMatrix.h:437
 TGeoMatrix.h:438
 TGeoMatrix.h:439
 TGeoMatrix.h:440
 TGeoMatrix.h:441
 TGeoMatrix.h:442
 TGeoMatrix.h:443
 TGeoMatrix.h:444
 TGeoMatrix.h:445
 TGeoMatrix.h:446
 TGeoMatrix.h:447
 TGeoMatrix.h:448
 TGeoMatrix.h:449
 TGeoMatrix.h:450
 TGeoMatrix.h:451
 TGeoMatrix.h:452
 TGeoMatrix.h:453
 TGeoMatrix.h:454
 TGeoMatrix.h:455
 TGeoMatrix.h:456
 TGeoMatrix.h:457
 TGeoMatrix.h:458
 TGeoMatrix.h:459
 TGeoMatrix.h:460
 TGeoMatrix.h:461
 TGeoMatrix.h:462
 TGeoMatrix.h:463
 TGeoMatrix.h:464
 TGeoMatrix.h:465