```// @(#)root/geom:\$Id\$
// 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,
kGeoShared       = BIT(14),
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               IsShared()      const {return TestBit(kGeoShared);}
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) {}
void                 SetShared(Bool_t flag=kTRUE) {SetBit(kGeoShared, flag);}

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(std::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(std::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();

TGeoScale& operator=(const TGeoScale &other);
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(std::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(std::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(std::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
TGeoMatrix.h:466
TGeoMatrix.h:467
TGeoMatrix.h:468
TGeoMatrix.h:469