ROOT logo
// @(#)root/geom:$Id: TGeoMatrix.cxx 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.             *
 *************************************************************************/
// Author : Andrei Gheata - Wed 24 Oct 2001 09:46:13 AM CEST

////////////////////////////////////////////////////////////////////////////////
// Geometrical transformation package.
//
//   All geometrical transformations handled by the modeller are provided as a
// built-in package. This was designed to minimize memory requirements and
// optimize performance of point/vector master-to-local and local-to-master
// computation. We need to have in mind that a transformation in TGeo has 2 
// major use-cases. The first one is for defining the placement of a volume
// with respect to its container reference frame. This frame will be called
// 'master' and the frame of the positioned volume - 'local'. If T is a 
// transformation used for positioning volume daughters, then:
//
//          MASTER = T * LOCAL
//  
//   Therefore a local-to-master conversion will be performed by using T, while
// a master-to-local by using its inverse. The second use case is the computation
// of the global transformation of a given object in the geometry. Since the
// geometry is built as 'volumes-inside-volumes', this global transformation 
// represent the pile-up of all local transformations in the corresponding
// branch. The conversion from the global reference frame and the given object
// is also called master-to-local, but it is handled by the manager class.
//   A general homogenous transformation is defined as a 4x4 matrix embeeding
// a rotation, a translation and a scale. The advantage of this description
// is that each basic transformation can be represented as a homogenous matrix, 
// composition being performed as simple matrix multiplication.
//   Rotation:                      Inverse rotation:
//         r11  r12  r13   0              r11  r21  r31   0
//         r21  r22  r23   0              r12  r22  r32   0
//         r31  r32  r33   0              r13  r23  r33   0
//          0    0    0    1               0    0    0    1
//
//   Translation:                   Inverse translation:
//          1    0    0    tx               1    0    0   -tx
//          0    1    0    ty               0    1    0   -ty
//          0    0    1    tz               0    0    1   -tz
//          0    0    0    1                0    0    0   1
//
//   Scale:                         Inverse scale:
//          sx   0    0    0              1/sx  0    0    0
//          0    sy   0    0               0   1/sy  0    0
//          0    0    sz   0               0    0   1/sz  0
//          0    0    0    1               0    0    0    1
// 
//  where: rij are the 3x3 rotation matrix components, 
//         tx, ty, tz are the translation components
//         sx, sy, sz are arbitrary scale constants on the eacks axis,
//
//   The disadvantage in using this approach is that computation for 4x4 matrices
// is expensive. Even combining two translation would become a multiplication
// of their corresponding matrices, which is quite an undesired effect. On the 
// other hand, it is not a good idea to store a translation as a block of 16
// numbers. We have therefore chosen to implement each basic transformation type 
// as a class deriving from the same basic abstract class and handling its specific
// data and point/vector transformation algorithms.
//
//Begin_Html
/*
<img src="gif/t_transf.jpg">
*/
//End_Html
//
// The base class TGeoMatrix defines abstract metods for:
//
// - translation, rotation and scale getters. Every derived class stores only
//   its specific data, e.g. a translation stores an array of 3 doubles and a
//   rotation an array of 9. However, asking which is the rotation array of a
//   TGeoTranslation through the base TGeoMatrix interface is a legal operation.
//   The answer in this case is a pointer to a global constant array representing
//   an identity rotation.
//      Double_t *TGeoMatrix::GetTranslation()
//      Double_t *TGeoMatrix::GetRotation()
//      Double_t *TGeoMatrix::GetScale()
//
// - MasterToLocal() and LocalToMaster() point and vector transformations :
//      void      TGeoMatrix::MasterToLocal(const Double_t *master, Double_t *local)
//      void      TGeoMatrix::LocalToMaster(const Double_t *local, Double_t *master)
//      void      TGeoMatrix::MasterToLocalVect(const Double_t *master, Double_t *local)
//      void      TGeoMatrix::LocalToMasterVect(const Double_t *local, Double_t *master)
//   These allow correct conversion also for reflections.
// - Transformation type getters :
//      Bool_t    TGeoMatrix::IsIdentity()
//      Bool_t    TGeoMatrix::IsTranslation()
//      Bool_t    TGeoMatrix::IsRotation()
//      Bool_t    TGeoMatrix::IsScale()
//      Bool_t    TGeoMatrix::IsCombi() (translation + rotation)
//      Bool_t    TGeoMatrix::IsGeneral() (translation + rotation + scale)
//
//   Combinations of basic transformations are represented by specific classes
// deriving from TGeoMatrix. In order to define a matrix as a combination of several
// others, a special class TGeoHMatrix is provided. Here is an example of matrix
// creation :
//
// Matrix creation example:
//
//   root[0] TGeoRotation r1,r2;
//           r1.SetAngles(90,0,30);        // rotation defined by Euler angles
//           r2.SetAngles(90,90,90,180,0,0); // rotation defined by GEANT3 angles
//           TGeoTranslation t1(-10,10,0);
//           TGeoTranslation t2(10,-10,5);
//           TGeoCombiTrans c1(t1,r1);
//           TGeoCombiTrans c2(t2,r2);
//           TGeoHMatrix h = c1 * c2; // composition is done via TGeoHMatrix class
//   root[7] TGeoHMatrix *ph = new TGeoHMatrix(hm); // this is the one we want to
//                                                // use for positioning a volume
//   root[8] ph->Print();
//           ...
//           pVolume->AddNode(pVolDaughter,id,ph) // now ph is owned by the manager
//
// Rule for matrix creation:
//  - unless explicitly used for positioning nodes (TGeoVolume::AddNode()) all
// matrices deletion have to be managed by users. Matrices passed to geometry
// have to be created by using new() operator and their deletion is done by 
// TGeoManager class.
//
// Available geometrical transformations
//
//   1. TGeoTranslation - represent a (dx,dy,dz) translation. Data members: 
// Double_t fTranslation[3]. Translations can be added/subtracted.
//         TGeoTranslation t1;
//         t1->SetTranslation(-5,10,4);
//         TGeoTranslation *t2 = new TGeoTranslation(4,3,10);
//         t2->Subtract(&t1);
//
//   2. Rotations - represent a pure rotation. Data members: Double_t fRotationMatrix[3*3].
// Rotations can be defined either by Euler angles, either, by GEANT3 angles :
//         TGeoRotation *r1 = new TGeoRotation();
//         r1->SetAngles(phi, theta, psi); // all angles in degrees
//      This represent the composition of : first a rotation about Z axis with
//      angle phi, then a rotation with theta about the rotated X axis, and
//      finally a rotation with psi about the new Z axis.
//          
//         r1->SetAngles(th1,phi1, th2,phi2, th3,phi3)
//      This is a rotation defined in GEANT3 style. Theta and phi are the spherical
//      angles of each axis of the rotated coordinate system with respect to the
//      initial one. This construction allows definition of malformed rotations,
//      e.g. not orthogonal. A check is performed and an error message is issued
//      in this case.
//
//      Specific utilities : determinant, inverse.
//
//   3. Scale transformations - represent a scale shrinking/enlargement. Data
//      members :Double_t fScale[3]. Not fully implemented yet.
//
//   4. Combined transformations - represent a rotation folowed by a translation.
//      Data members: Double_t fTranslation[3], TGeoRotation *fRotation.
//         TGeoRotation *rot = new TGeoRotation("rot",10,20,30);
//         TGeoTranslation trans;
//         ...
//         TGeoCombiTrans *c1 = new TGeoCombiTrans(trans, rot);
//         TGeoCombiTrans *c2 = new TGeoCombiTrans("somename",10,20,30,rot)
//         
//   5. TGeoGenTrans - combined transformations including a scale. Not implemented.
//   6. TGeoIdentity - a generic singleton matrix representing a identity transformation
//       NOTE: identified by the global variable gGeoIdentity.
//  
//     

#include "Riostream.h"
#include "TObjArray.h"

#include "TGeoManager.h"
#include "TGeoMatrix.h"
#include "TMath.h"

TGeoIdentity *gGeoIdentity = 0;
const Int_t kN3 = 3*sizeof(Double_t);
const Int_t kN9 = 9*sizeof(Double_t);

// statics and globals

ClassImp(TGeoMatrix)

//_____________________________________________________________________________
TGeoMatrix::TGeoMatrix()
{
// dummy constructor
}

//_____________________________________________________________________________
TGeoMatrix::TGeoMatrix(const TGeoMatrix &other)
           :TNamed(other)
{
// copy constructor
   ResetBit(kGeoRegistered);
}

//_____________________________________________________________________________
TGeoMatrix::TGeoMatrix(const char *name)
           :TNamed(name, "")
{
// Constructor
}

//_____________________________________________________________________________
TGeoMatrix::~TGeoMatrix()
{
// Destructor
   if (IsRegistered() && gGeoManager) {
      if (gGeoManager->GetListOfVolumes()) {
         gGeoManager->GetListOfMatrices()->Remove(this);
         Warning("dtor", "Registered matrix %s was removed", GetName());
      }
   }
}

//_____________________________________________________________________________
TGeoMatrix& TGeoMatrix::operator = (const TGeoMatrix &matrix)
{
// Assignment operator
   if (&matrix == this) return *this;
   Bool_t registered = TestBit(kGeoRegistered);
   TNamed::operator=(matrix);
   SetBit(kGeoRegistered,registered);
   return *this;
}   

//_____________________________________________________________________________
TGeoMatrix &TGeoMatrix::operator*(const TGeoMatrix &right) const
{
// Multiplication
   static TGeoHMatrix h;
   h = *this;
   h.Multiply(&right);
   return h;
}

//_____________________________________________________________________________
Bool_t TGeoMatrix::operator ==(const TGeoMatrix &other) const
{
// Is-equal operator
   if (&other == this) return kTRUE;
   Int_t i;
   Bool_t tr1 = IsTranslation();
   Bool_t tr2 = other.IsTranslation();
   if ((tr1 & !tr2) || (tr2 & !tr1)) return kFALSE; 
   Bool_t rr1 = IsRotation();
   Bool_t rr2 = other.IsRotation();
   if ((rr1 & !rr2) || (rr2 & !rr1)) return kFALSE; 

   if (tr1) {
      const Double_t *tr = GetTranslation();
      const Double_t *otr = other.GetTranslation();
      for (i=0; i<3; i++) if (TMath::Abs(tr[i]-otr[i])>1.E-10) return kFALSE;
   } 
   
   if (rr1) {
      const Double_t *rot = GetRotationMatrix();
      const Double_t *orot = other.GetRotationMatrix();
      for (i=0; i<9; i++) if (TMath::Abs(rot[i]-orot[i])>1.E-10) return kFALSE;
   }
   return kTRUE;
}        

//_____________________________________________________________________________
Bool_t TGeoMatrix::IsRotAboutZ() const
{
// Returns true if no rotation or the rotation is about Z axis
   if (IsIdentity()) return kTRUE;
   const Double_t *rot = GetRotationMatrix();
   if (TMath::Abs(rot[6])>1E-9) return kFALSE;
   if (TMath::Abs(rot[7])>1E-9) return kFALSE;
   if ((1.-TMath::Abs(rot[8]))>1E-9) return kFALSE;
   return kTRUE;
}   

//_____________________________________________________________________________
Int_t TGeoMatrix::GetByteCount() const
{
// Get total size in bytes of this
   Int_t count = 4+28+strlen(GetName())+strlen(GetTitle()); // fId + TNamed
   if (IsTranslation()) count += 12;
   if (IsScale()) count += 12;
   if (IsCombi() || IsGeneral()) count += 4 + 36;
   return count;
}

//_____________________________________________________________________________
char *TGeoMatrix::GetPointerName() const
{
// Provide a pointer name containing uid.
   static TString name;
   name = TString::Format("pMatrix%d", GetUniqueID());
   return (char*)name.Data();
}    

//_____________________________________________________________________________
void TGeoMatrix::GetHomogenousMatrix(Double_t *hmat) const
{
// The homogenous matrix associated with the transformation is used for
// piling up's and visualization. A homogenous matrix is a 4*4 array
// containing the translation, the rotation and the scale components
//
//          | R00*sx  R01    R02    dx |
//          | R10    R11*sy  R12    dy |
//          | R20     R21   R22*sz  dz |
//          |  0       0      0      1 |
//
//   where Rij is the rotation matrix, (sx, sy, sz) is the scale 
// transformation and (dx, dy, dz) is the translation.
   Double_t *hmatrix = hmat;
   const Double_t *mat = GetRotationMatrix();
   for (Int_t i=0; i<3; i++) {
      memcpy(hmatrix, mat, kN3);
      mat     += 3;
      hmatrix += 3;
      *hmatrix = 0.0;
      hmatrix++; 
   }
   memcpy(hmatrix, GetTranslation(), kN3);
   hmatrix = hmat;
   if (IsScale()) {
      for (Int_t i=0; i<3; i++) {
         *hmatrix *= GetScale()[i];
         hmatrix  += 5;
      }
   }
}

//_____________________________________________________________________________
void TGeoMatrix::LocalToMaster(const Double_t *local, Double_t *master) const
{
// convert a point by multiplying its column vector (x, y, z, 1) to matrix inverse
   if (IsIdentity()) {
      memcpy(master, local, kN3);
      return;
   }
   Int_t i;   
   const Double_t *tr = GetTranslation();
   if (!IsRotation()) {
      for (i=0; i<3; i++) master[i] = tr[i] + local[i];
      return;
   }   
   const Double_t *rot = GetRotationMatrix();
   for (i=0; i<3; i++) {
      master[i] = tr[i] 
                + local[0]*rot[3*i]
                + local[1]*rot[3*i+1]
                + local[2]*rot[3*i+2];
   }
}

//_____________________________________________________________________________
void TGeoMatrix::LocalToMasterVect(const Double_t *local, Double_t *master) const
{
// convert a vector by multiplying its column vector (x, y, z, 1) to matrix inverse
   if (!IsRotation()) {
      memcpy(master, local, kN3);
      return;
   }
   const Double_t *rot = GetRotationMatrix();
   for (Int_t i=0; i<3; i++) {
      master[i] = local[0]*rot[3*i]
                + local[1]*rot[3*i+1]
                + local[2]*rot[3*i+2];
   }
}

//_____________________________________________________________________________
void TGeoMatrix::LocalToMasterBomb(const Double_t *local, Double_t *master) const
{
// convert a point by multiplying its column vector (x, y, z, 1) to matrix inverse
   if (IsIdentity()) {
      memcpy(master, local, kN3);
      return;
   }   
   Int_t i;
   const Double_t *tr = GetTranslation();
   Double_t bombtr[3];
   gGeoManager->BombTranslation(tr, &bombtr[0]);
   if (!IsRotation()) {
      for (i=0; i<3; i++) master[i] = bombtr[i] + local[i];
      return;
   }   
   const Double_t *rot = GetRotationMatrix();
   for (i=0; i<3; i++) {
      master[i] = bombtr[i] 
                + local[0]*rot[3*i]
                + local[1]*rot[3*i+1]
                + local[2]*rot[3*i+2];
   }
}

//_____________________________________________________________________________
void TGeoMatrix::MasterToLocal(const Double_t *master, Double_t *local) const
{
// convert a point by multiplying its column vector (x, y, z, 1) to matrix
   if (IsIdentity()) {
      memcpy(local, master, kN3);
      return;
   }   
   const Double_t *tr  = GetTranslation();
   Double_t mt0  = master[0]-tr[0];
   Double_t mt1  = master[1]-tr[1];
   Double_t mt2  = master[2]-tr[2];
   if (!IsRotation()) {
      local[0] = mt0;
      local[1] = mt1;
      local[2] = mt2;
      return;
   }   
   const Double_t *rot = GetRotationMatrix();
   local[0] = mt0*rot[0] + mt1*rot[3] + mt2*rot[6];
   local[1] = mt0*rot[1] + mt1*rot[4] + mt2*rot[7];
   local[2] = mt0*rot[2] + mt1*rot[5] + mt2*rot[8];
}

//_____________________________________________________________________________
void TGeoMatrix::MasterToLocalVect(const Double_t *master, Double_t *local) const
{
// convert a point by multiplying its column vector (x, y, z, 1) to matrix
   if (!IsRotation()) {
      memcpy(local, master, kN3);
      return;
   }   
   const Double_t *rot = GetRotationMatrix();
   for (Int_t i=0; i<3; i++) {
      local[i] = master[0]*rot[i]
               + master[1]*rot[i+3]
               + master[2]*rot[i+6];
   }
}

//_____________________________________________________________________________
void TGeoMatrix::MasterToLocalBomb(const Double_t *master, Double_t *local) const
{
// convert a point by multiplying its column vector (x, y, z, 1) to matrix
   if (IsIdentity()) {
      memcpy(local, master, kN3);
      return;
   }   
   const Double_t *tr = GetTranslation();
   Double_t bombtr[3];
   Int_t i;
   gGeoManager->UnbombTranslation(tr, &bombtr[0]);
   if (!IsRotation()) {
      for (i=0; i<3; i++) local[i] = master[i]-bombtr[i];
      return;
   }   
   const Double_t *rot = GetRotationMatrix();
   for (i=0; i<3; i++) {
      local[i] = (master[0]-bombtr[0])*rot[i]
               + (master[1]-bombtr[1])*rot[i+3]
               + (master[2]-bombtr[2])*rot[i+6];
   }
}

//_____________________________________________________________________________
void TGeoMatrix::Normalize(Double_t *vect)
{
// Normalize a vector.
   Double_t normfactor = vect[0]*vect[0] + vect[1]*vect[1] + vect[2]*vect[2];
   if (normfactor <= 1E-10) return;
   normfactor = 1./TMath::Sqrt(normfactor);
   vect[0] *= normfactor;
   vect[1] *= normfactor;
   vect[2] *= normfactor;
}

//_____________________________________________________________________________
void TGeoMatrix::Print(Option_t *) const
{
// print the matrix in 4x4 format
   const Double_t *rot = GetRotationMatrix();
   const Double_t *tr  = GetTranslation();
   printf("matrix %s - tr=%d  rot=%d  refl=%d  scl=%d\n", GetName(),(Int_t)IsTranslation(),
          (Int_t)IsRotation(), (Int_t)IsReflection(), (Int_t)IsScale());
   printf("%10.6f%12.6f%12.6f    Tx = %10.6f\n", rot[0], rot[1], rot[2], tr[0]); 
   printf("%10.6f%12.6f%12.6f    Ty = %10.6f\n", rot[3], rot[4], rot[5], tr[1]); 
   printf("%10.6f%12.6f%12.6f    Tz = %10.6f\n", rot[6], rot[7], rot[8], tr[2]); 
   if (IsScale()) {
      const Double_t *scl  = GetScale();
      printf("Sx=%10.6fSy=%12.6fSz=%12.6f\n", scl[0], scl[1], scl[2]);
   }         
}

//_____________________________________________________________________________
void TGeoMatrix::ReflectX(Bool_t, Bool_t)
{
// Multiply by a reflection respect to YZ.
}

//_____________________________________________________________________________
void TGeoMatrix::ReflectY(Bool_t, Bool_t)
{
// Multiply by a reflection respect to ZX.
}

//_____________________________________________________________________________
void TGeoMatrix::ReflectZ(Bool_t, Bool_t)
{
// Multiply by a reflection respect to XY.
}

//_____________________________________________________________________________
void TGeoMatrix::RegisterYourself()
{
// Register the matrix in the current manager, which will become the owner.
   if (!gGeoManager) {
      Warning("RegisterYourself", "cannot register without geometry");
      return;
   }   
   if (!IsRegistered()) {
      gGeoManager->RegisterMatrix(this); 
      SetBit(kGeoRegistered);
   }   
}

//_____________________________________________________________________________
void TGeoMatrix::SetDefaultName()
{
// If no name was supplied in the ctor, the type of transformation is checked.
// A letter will be prepended to the name :
//   t - translation
//   r - rotation
//   s - scale
//   c - combi (translation + rotation)
//   g - general (tr+rot+scale)
// The index of the transformation in gGeoManager list of transformations will
// be appended.
   if (!gGeoManager) return;
   if (strlen(GetName())) return;
   char type = 'n';
   if (IsTranslation()) type = 't'; 
   if (IsRotation()) type = 'r';
   if (IsScale()) type = 's';
   if (IsCombi()) type = 'c';
   if (IsGeneral()) type = 'g';
   TObjArray *matrices = gGeoManager->GetListOfMatrices();
   Int_t index = 0;
   if (matrices) index =matrices->GetEntriesFast() - 1;
   TString name = TString::Format("%c%d", type, index);
   SetName(name);
}
//=============================================================================

ClassImp(TGeoTranslation)

//_____________________________________________________________________________
TGeoTranslation::TGeoTranslation()
{
// Default constructor
   for (Int_t i=0; i<3; i++) fTranslation[i] = 0;
}

//_____________________________________________________________________________
TGeoTranslation::TGeoTranslation(const TGeoTranslation &other)
                :TGeoMatrix(other)
{
// Copy ctor.
   SetTranslation(other);
}

//_____________________________________________________________________________
TGeoTranslation::TGeoTranslation(const TGeoMatrix &other)
                :TGeoMatrix(other)
{
// Ctor. based on a general matrix
   SetTranslation(other);
}

//_____________________________________________________________________________
TGeoTranslation::TGeoTranslation(Double_t dx, Double_t dy, Double_t dz)
                :TGeoMatrix("")
{
// Default constructor defining the translation
   if (dx || dy || dz) SetBit(kGeoTranslation);
   SetTranslation(dx, dy, dz);
}

//_____________________________________________________________________________
TGeoTranslation::TGeoTranslation(const char *name, Double_t dx, Double_t dy, Double_t dz)
                :TGeoMatrix(name)
{
// Default constructor defining the translation
   if (dx || dy || dz) SetBit(kGeoTranslation);
   SetTranslation(dx, dy, dz);
}

//_____________________________________________________________________________
TGeoTranslation& TGeoTranslation::operator = (const TGeoMatrix &matrix)
{
// Assignment from a general matrix
   if (&matrix == this) return *this;
   TGeoMatrix::operator=(matrix);
   SetTranslation(matrix);
   return *this;
}   

//_____________________________________________________________________________
TGeoMatrix& TGeoTranslation::Inverse() const
{
// Return a temporary inverse of this.
   static TGeoHMatrix h;
   h = *this;
   Double_t tr[3];
   tr[0] = -fTranslation[0];
   tr[1] = -fTranslation[1];
   tr[2] = -fTranslation[2];
   h.SetTranslation(tr);
   return h;
}   

//_____________________________________________________________________________
void TGeoTranslation::Add(const TGeoTranslation *other)
{
// Adding a translation to this one
   const Double_t *trans = other->GetTranslation();
   for (Int_t i=0; i<3; i++) 
      fTranslation[i] += trans[i];
}

//_____________________________________________________________________________
TGeoMatrix *TGeoTranslation::MakeClone() const
{
// Make a clone of this matrix.
   TGeoMatrix *matrix = new TGeoTranslation(*this);
   return matrix;
}

//_____________________________________________________________________________
void TGeoTranslation::RotateX(Double_t /*angle*/)
{
// Rotate about X axis of the master frame with angle expressed in degrees.
   Warning("RotateX", "Not implemented. Use TGeoCombiTrans instead");
}

//_____________________________________________________________________________
void TGeoTranslation::RotateY(Double_t /*angle*/)
{
// Rotate about Y axis of the master frame with angle expressed in degrees.
   Warning("RotateY", "Not implemented. Use TGeoCombiTrans instead");
}

//_____________________________________________________________________________
void TGeoTranslation::RotateZ(Double_t /*angle*/)
{
// Rotate about Z axis of the master frame with angle expressed in degrees.
   Warning("RotateZ", "Not implemented. Use TGeoCombiTrans instead");
}

//_____________________________________________________________________________
void TGeoTranslation::Subtract(const TGeoTranslation *other)
{
// Subtracting a translation from this one
   const Double_t *trans = other->GetTranslation();
   for (Int_t i=0; i<3; i++) 
      fTranslation[i] -= trans[i];
}

//_____________________________________________________________________________
void TGeoTranslation::SetTranslation(Double_t dx, Double_t dy, Double_t dz)
{
// Set translation components
   fTranslation[0] = dx;
   fTranslation[1] = dy;
   fTranslation[2] = dz;
   if (dx || dy || dz) SetBit(kGeoTranslation);
   else                ResetBit(kGeoTranslation);
}

//_____________________________________________________________________________
void TGeoTranslation::SetTranslation(const TGeoMatrix &other)
{
// Set translation components
   SetBit(kGeoTranslation, other.IsTranslation());
   const Double_t *transl = other.GetTranslation();
   memcpy(fTranslation, transl, kN3);
}

//_____________________________________________________________________________
void TGeoTranslation::LocalToMaster(const Double_t *local, Double_t *master) const
{
// convert a point by multiplying its column vector (x, y, z, 1) to matrix inverse
   const Double_t *tr = GetTranslation();
   for (Int_t i=0; i<3; i++) 
      master[i] = tr[i] + local[i]; 
}

//_____________________________________________________________________________
void TGeoTranslation::LocalToMasterVect(const Double_t *local, Double_t *master) const
{
// convert a vector to MARS
   memcpy(master, local, kN3);
}

//_____________________________________________________________________________
void TGeoTranslation::LocalToMasterBomb(const Double_t *local, Double_t *master) const
{
// convert a point by multiplying its column vector (x, y, z, 1) to matrix inverse
   const Double_t *tr = GetTranslation();
   Double_t bombtr[3];
   gGeoManager->BombTranslation(tr, &bombtr[0]);
   for (Int_t i=0; i<3; i++) 
      master[i] = bombtr[i] + local[i]; 
}

//_____________________________________________________________________________
void TGeoTranslation::MasterToLocal(const Double_t *master, Double_t *local) const
{
// convert a point by multiplying its column vector (x, y, z, 1) to matrix
   const Double_t *tr = GetTranslation();
   for (Int_t i=0; i<3; i++) 
      local[i] =  master[i]-tr[i];
}

//_____________________________________________________________________________
void TGeoTranslation::MasterToLocalVect(const Double_t *master, Double_t *local) const
{
// convert a vector from MARS to local
   memcpy(local, master, kN3);
}

//_____________________________________________________________________________
void TGeoTranslation::MasterToLocalBomb(const Double_t *master, Double_t *local) const
{
// convert a point by multiplying its column vector (x, y, z, 1) to matrix
   const Double_t *tr = GetTranslation();
   Double_t bombtr[3];
   gGeoManager->UnbombTranslation(tr, &bombtr[0]);
   for (Int_t i=0; i<3; i++) 
      local[i] =  master[i]-bombtr[i];
}

//_____________________________________________________________________________
void TGeoTranslation::SavePrimitive(ostream &out, Option_t * /*option*/ /*= ""*/)
{
// Save a primitive as a C++ statement(s) on output stream "out".
   if (TestBit(kGeoSavePrimitive)) return;
   out << "   // Translation: " << GetName() << endl;
   out << "   dx = " << fTranslation[0] << ";" << endl;
   out << "   dy = " << fTranslation[1] << ";" << endl;
   out << "   dz = " << fTranslation[2] << ";" << endl;
   out << "   TGeoTranslation *" << GetPointerName() << " = new TGeoTranslation(\"" << GetName() << "\",dx,dy,dz);" << endl;
   TObject::SetBit(kGeoSavePrimitive);
}

//=============================================================================

ClassImp(TGeoRotation)

//_____________________________________________________________________________
TGeoRotation::TGeoRotation()
{
// Default constructor.
   for (Int_t i=0; i<9; i++) {
      if (i%4) fRotationMatrix[i] = 0;
      else fRotationMatrix[i] = 1.0;
   }
}

//_____________________________________________________________________________
TGeoRotation::TGeoRotation(const TGeoRotation &other)
             :TGeoMatrix(other)
{
// Copy ctor.
   SetRotation(other);
}   

//_____________________________________________________________________________
TGeoRotation::TGeoRotation(const TGeoMatrix &other)
             :TGeoMatrix(other)
{
// Copy ctor.
   SetRotation(other);
}   

//_____________________________________________________________________________
TGeoRotation::TGeoRotation(const char *name)
             :TGeoMatrix(name)
{
// Named rotation constructor
   for (Int_t i=0; i<9; i++) {
      if (i%4) fRotationMatrix[i] = 0;
      else fRotationMatrix[i] = 1.0;
   }
}

//_____________________________________________________________________________
TGeoRotation::TGeoRotation(const char *name, Double_t phi, Double_t theta, Double_t psi)
             :TGeoMatrix(name)
{
// Default rotation constructor with Euler angles. Phi is the rotation angle about
// Z axis  and is done first, theta is the rotation about new Y and is done
// second, psi is the rotation angle about new Z and is done third. All angles are in
// degrees.
   SetAngles(phi, theta, psi);
}

//_____________________________________________________________________________
TGeoRotation::TGeoRotation(const char *name, Double_t theta1, Double_t phi1, Double_t theta2, Double_t phi2,
                           Double_t theta3, Double_t phi3)
             :TGeoMatrix(name)
{
// Rotation constructor a la GEANT3. Angles theta(i), phi(i) are the polar and azimuthal
// angles of the (i) axis of the rotated system with respect to the initial non-rotated
// system.
//   Example : the identity matrix (no rotation) is composed by
//      theta1=90, phi1=0, theta2=90, phi2=90, theta3=0, phi3=0
//   SetBit(kGeoRotation);
   SetAngles(theta1, phi1, theta2, phi2, theta3, phi3);
}

//_____________________________________________________________________________
TGeoRotation& TGeoRotation::operator = (const TGeoMatrix &other)
{
// Assignment from a general matrix
   if (&other == this) return *this;
   TGeoMatrix::operator=(other);
   SetRotation(other);
   return *this;
}
 
//_____________________________________________________________________________
TGeoMatrix& TGeoRotation::Inverse() const
{
// Return a temporary inverse of this.
   static TGeoHMatrix h;
   h = *this;
   Double_t newrot[9];
   newrot[0] = fRotationMatrix[0];
   newrot[1] = fRotationMatrix[3];
   newrot[2] = fRotationMatrix[6];
   newrot[3] = fRotationMatrix[1];
   newrot[4] = fRotationMatrix[4];
   newrot[5] = fRotationMatrix[7];
   newrot[6] = fRotationMatrix[2];
   newrot[7] = fRotationMatrix[5];
   newrot[8] = fRotationMatrix[8];
   h.SetRotation(newrot);
   return h;
}   

//_____________________________________________________________________________
Bool_t TGeoRotation::IsValid() const
{
// Perform orthogonality test for rotation.
   const Double_t *r = fRotationMatrix;
   Double_t cij;
   for (Int_t i=0; i<2; i++) {
      for (Int_t j=i+1; j<3; j++) {
         // check columns
         cij = TMath::Abs(r[i]*r[j]+r[i+3]*r[j+3]+r[i+6]*r[j+6]);
         if (cij>1E-4) return kFALSE;
         // check rows
         cij = TMath::Abs(r[3*i]*r[3*j]+r[3*i+1]*r[3*j+1]+r[3*i+2]*r[3*j+2]);
         if (cij>1E-4) return kFALSE;
      }
   }
   return kTRUE;   
}

//_____________________________________________________________________________
void TGeoRotation::Clear(Option_t *)
{
// reset data members
   memcpy(fRotationMatrix,kIdentityMatrix,kN9);
   ResetBit(kGeoRotation);
}

//_____________________________________________________________________________
void TGeoRotation::FastRotZ(const Double_t *sincos)
{
// Perform a rotation about Z having the sine/cosine of the rotation angle.
   fRotationMatrix[0] = sincos[1];
   fRotationMatrix[1] = -sincos[0];
   fRotationMatrix[3] = sincos[0];
   fRotationMatrix[4] = sincos[1];
   SetBit(kGeoRotation);
}

//_____________________________________________________________________________
Double_t TGeoRotation::GetPhiRotation(Bool_t fixX) const
{
//--- Returns rotation angle about Z axis in degrees. If the rotation is a pure
//    rotation about Z, fixX parameter does not matter, otherwise its meaning is:
//    - fixX = true  : result is the phi angle of the projection of the rotated X axis in the un-rotated XY
//    - fixX = false : result is the phi angle of the projection of the rotated Y axis - 90 degrees
   Double_t phi;
   if (fixX) phi = 180.*TMath::ATan2(-fRotationMatrix[1],fRotationMatrix[4])/TMath::Pi();
   else      phi = 180.*TMath::ATan2(fRotationMatrix[3], fRotationMatrix[0])/TMath::Pi();
   return phi;
}   

//_____________________________________________________________________________
void TGeoRotation::LocalToMaster(const Double_t *local, Double_t *master) const
{
// convert a point by multiplying its column vector (x, y, z, 1) to matrix inverse
   const Double_t *rot = GetRotationMatrix();
   for (Int_t i=0; i<3; i++) {
      master[i] = local[0]*rot[3*i]
                + local[1]*rot[3*i+1]
                + local[2]*rot[3*i+2];
   }
}

//_____________________________________________________________________________
void TGeoRotation::MasterToLocal(const Double_t *master, Double_t *local) const
{
// convert a point by multiplying its column vector (x, y, z, 1) to matrix
   const Double_t *rot = GetRotationMatrix();
   for (Int_t i=0; i<3; i++) {
      local[i] = master[0]*rot[i]
               + master[1]*rot[i+3]
               + master[2]*rot[i+6];
   }
}

//_____________________________________________________________________________
TGeoMatrix *TGeoRotation::MakeClone() const
{
// Make a clone of this matrix.
   TGeoMatrix *matrix = new TGeoRotation(*this);
   return matrix;
}

//_____________________________________________________________________________
void TGeoRotation::RotateX(Double_t angle)
{
// Rotate about X axis of the master frame with angle expressed in degrees.
   SetBit(kGeoRotation);
   Double_t phi = angle*TMath::DegToRad();
   Double_t c = TMath::Cos(phi);
   Double_t s = TMath::Sin(phi);
   Double_t v[9];
   v[0] = fRotationMatrix[0];
   v[1] = fRotationMatrix[1];
   v[2] = fRotationMatrix[2];
   v[3] = c*fRotationMatrix[3]-s*fRotationMatrix[6];
   v[4] = c*fRotationMatrix[4]-s*fRotationMatrix[7];
   v[5] = c*fRotationMatrix[5]-s*fRotationMatrix[8];
   v[6] = s*fRotationMatrix[3]+c*fRotationMatrix[6];
   v[7] = s*fRotationMatrix[4]+c*fRotationMatrix[7];
   v[8] = s*fRotationMatrix[5]+c*fRotationMatrix[8];
   
   memcpy(fRotationMatrix, v, kN9);
}

//_____________________________________________________________________________
void TGeoRotation::RotateY(Double_t angle)
{
// Rotate about Y axis of the master frame with angle expressed in degrees.
   SetBit(kGeoRotation);
   Double_t phi = angle*TMath::DegToRad();
   Double_t c = TMath::Cos(phi);
   Double_t s = TMath::Sin(phi);
   Double_t v[9];
   v[0] = c*fRotationMatrix[0]+s*fRotationMatrix[6];
   v[1] = c*fRotationMatrix[1]+s*fRotationMatrix[7];
   v[2] = c*fRotationMatrix[2]+s*fRotationMatrix[8];
   v[3] = fRotationMatrix[3];
   v[4] = fRotationMatrix[4];
   v[5] = fRotationMatrix[5];
   v[6] = -s*fRotationMatrix[0]+c*fRotationMatrix[6];
   v[7] = -s*fRotationMatrix[1]+c*fRotationMatrix[7];
   v[8] = -s*fRotationMatrix[2]+c*fRotationMatrix[8];
   
   memcpy(fRotationMatrix, v, kN9);
}

//_____________________________________________________________________________
void TGeoRotation::RotateZ(Double_t angle)
{
// Rotate about Z axis of the master frame with angle expressed in degrees.
   SetBit(kGeoRotation);
   Double_t phi = angle*TMath::DegToRad();
   Double_t c = TMath::Cos(phi);
   Double_t s = TMath::Sin(phi);
   Double_t v[9];
   v[0] = c*fRotationMatrix[0]-s*fRotationMatrix[3];
   v[1] = c*fRotationMatrix[1]-s*fRotationMatrix[4];
   v[2] = c*fRotationMatrix[2]-s*fRotationMatrix[5];
   v[3] = s*fRotationMatrix[0]+c*fRotationMatrix[3];
   v[4] = s*fRotationMatrix[1]+c*fRotationMatrix[4];
   v[5] = s*fRotationMatrix[2]+c*fRotationMatrix[5];
   v[6] = fRotationMatrix[6];
   v[7] = fRotationMatrix[7];
   v[8] = fRotationMatrix[8];
   
   memcpy(&fRotationMatrix[0],v,kN9);
}

//_____________________________________________________________________________
void TGeoRotation::ReflectX(Bool_t leftside, Bool_t)
{
// Multiply by a reflection respect to YZ.
   if (leftside) {
      fRotationMatrix[0]=-fRotationMatrix[0];
      fRotationMatrix[1]=-fRotationMatrix[1];
      fRotationMatrix[2]=-fRotationMatrix[2];
   } else {
      fRotationMatrix[0]=-fRotationMatrix[0];
      fRotationMatrix[3]=-fRotationMatrix[3];
      fRotationMatrix[6]=-fRotationMatrix[6];
   }   
   SetBit(kGeoRotation);
   SetBit(kGeoReflection, !IsReflection());
}      

//_____________________________________________________________________________
void TGeoRotation::ReflectY(Bool_t leftside, Bool_t)
{
// Multiply by a reflection respect to ZX.
   if (leftside) {
      fRotationMatrix[3]=-fRotationMatrix[3];
      fRotationMatrix[4]=-fRotationMatrix[4];
      fRotationMatrix[5]=-fRotationMatrix[5];
   } else {
      fRotationMatrix[1]=-fRotationMatrix[1];
      fRotationMatrix[4]=-fRotationMatrix[4];
      fRotationMatrix[7]=-fRotationMatrix[7];
   }   
   SetBit(kGeoRotation);
   SetBit(kGeoReflection, !IsReflection());
}      

//_____________________________________________________________________________
void TGeoRotation::ReflectZ(Bool_t leftside, Bool_t)
{
// Multiply by a reflection respect to XY.
   if (leftside) {
      fRotationMatrix[6]=-fRotationMatrix[6];
      fRotationMatrix[7]=-fRotationMatrix[7];
      fRotationMatrix[8]=-fRotationMatrix[8];
   } else {
      fRotationMatrix[2]=-fRotationMatrix[2];
      fRotationMatrix[5]=-fRotationMatrix[5];
      fRotationMatrix[8]=-fRotationMatrix[8];
   }   
   SetBit(kGeoRotation);
   SetBit(kGeoReflection, !IsReflection());
}      

//_____________________________________________________________________________
void TGeoRotation::SavePrimitive(ostream &out, Option_t * /*option*/ /*= ""*/)
{
// Save a primitive as a C++ statement(s) on output stream "out".
   if (TestBit(kGeoSavePrimitive)) return;
   out << "   // Rotation: " << GetName() << endl;
   Double_t th1,ph1,th2,ph2,th3,ph3;
   GetAngles(th1,ph1,th2,ph2,th3,ph3);
   out << "   thx = " << th1 << ";    phx = " << ph1 << ";" << endl;
   out << "   thy = " << th2 << ";    phy = " << ph2 << ";" << endl;
   out << "   thz = " << th3 << ";    phz = " << ph3 << ";" << endl;
   out << "   TGeoRotation *" << GetPointerName() << " = new TGeoRotation(\"" << GetName() << "\",thx,phx,thy,phy,thz,phz);" << endl;
   TObject::SetBit(kGeoSavePrimitive);
}

//_____________________________________________________________________________
void TGeoRotation::SetRotation(const TGeoMatrix &other)
{
// Copy rotation elements from other rotation matrix.
   SetBit(kGeoRotation, other.IsRotation());
   const Double_t *rot = other.GetRotationMatrix();
   SetMatrix(rot);
}

//_____________________________________________________________________________
void TGeoRotation::SetAngles(Double_t phi, Double_t theta, Double_t psi)
{
// Set matrix elements according to Euler angles
   Double_t degrad = TMath::Pi()/180.;
   Double_t sinphi = TMath::Sin(degrad*phi);
   Double_t cosphi = TMath::Cos(degrad*phi);
   Double_t sinthe = TMath::Sin(degrad*theta);
   Double_t costhe = TMath::Cos(degrad*theta);
   Double_t sinpsi = TMath::Sin(degrad*psi);
   Double_t cospsi = TMath::Cos(degrad*psi);

   fRotationMatrix[0] =  cospsi*cosphi - costhe*sinphi*sinpsi;
   fRotationMatrix[1] = -sinpsi*cosphi - costhe*sinphi*cospsi;
   fRotationMatrix[2] =  sinthe*sinphi;
   fRotationMatrix[3] =  cospsi*sinphi + costhe*cosphi*sinpsi;
   fRotationMatrix[4] = -sinpsi*sinphi + costhe*cosphi*cospsi;
   fRotationMatrix[5] = -sinthe*cosphi;
   fRotationMatrix[6] =  sinpsi*sinthe;
   fRotationMatrix[7] =  cospsi*sinthe;
   fRotationMatrix[8] =  costhe;

   if (!IsValid()) Error("SetAngles", "invalid rotation (Euler angles : phi=%f theta=%f psi=%f)",phi,theta,psi);
   CheckMatrix();
}

//_____________________________________________________________________________
void TGeoRotation::SetAngles(Double_t theta1, Double_t phi1, Double_t theta2, Double_t phi2,
                             Double_t theta3, Double_t phi3)
{
// Set matrix elements in the GEANT3 way
   Double_t degrad = TMath::Pi()/180.;
   fRotationMatrix[0] = TMath::Cos(degrad*phi1)*TMath::Sin(degrad*theta1);
   fRotationMatrix[3] = TMath::Sin(degrad*phi1)*TMath::Sin(degrad*theta1);
   fRotationMatrix[6] = TMath::Cos(degrad*theta1);
   fRotationMatrix[1] = TMath::Cos(degrad*phi2)*TMath::Sin(degrad*theta2);
   fRotationMatrix[4] = TMath::Sin(degrad*phi2)*TMath::Sin(degrad*theta2);
   fRotationMatrix[7] = TMath::Cos(degrad*theta2);
   fRotationMatrix[2] = TMath::Cos(degrad*phi3)*TMath::Sin(degrad*theta3);
   fRotationMatrix[5] = TMath::Sin(degrad*phi3)*TMath::Sin(degrad*theta3);
   fRotationMatrix[8] = TMath::Cos(degrad*theta3);
   // do the trick to eliminate most of the floating point errors
   for (Int_t i=0; i<9; i++) {
      if (TMath::Abs(fRotationMatrix[i])<1E-15) fRotationMatrix[i] = 0;
      if (TMath::Abs(fRotationMatrix[i]-1)<1E-15) fRotationMatrix[i] = 1;
      if (TMath::Abs(fRotationMatrix[i]+1)<1E-15) fRotationMatrix[i] = -1;
   }   
   if (!IsValid()) Error("SetAngles", "invalid rotation (G3 angles, th1=%f phi1=%f, th2=%f ph2=%f, th3=%f phi3=%f)",
                          theta1,phi1,theta2,phi2,theta3,phi3);
   CheckMatrix();
}

//_____________________________________________________________________________
void TGeoRotation::GetAngles(Double_t &theta1, Double_t &phi1, Double_t &theta2, Double_t &phi2,
                             Double_t &theta3, Double_t &phi3) const
{
// Retreive rotation angles
   Double_t raddeg = 180./TMath::Pi();
   theta1 = raddeg*TMath::ACos(fRotationMatrix[6]);
   theta2 = raddeg*TMath::ACos(fRotationMatrix[7]);
   theta3 = raddeg*TMath::ACos(fRotationMatrix[8]);
   if (TMath::Abs(fRotationMatrix[0])<1E-6 && TMath::Abs(fRotationMatrix[3])<1E-6) phi1=0.;
   else phi1 = raddeg*TMath::ATan2(fRotationMatrix[3],fRotationMatrix[0]);
   if (phi1<0) phi1+=360.;
   if (TMath::Abs(fRotationMatrix[1])<1E-6 && TMath::Abs(fRotationMatrix[4])<1E-6) phi2=0.;
   else phi2 = raddeg*TMath::ATan2(fRotationMatrix[4],fRotationMatrix[1]);
   if (phi2<0) phi2+=360.;
   if (TMath::Abs(fRotationMatrix[2])<1E-6 && TMath::Abs(fRotationMatrix[5])<1E-6) phi3=0.;
   else phi3 = raddeg*TMath::ATan2(fRotationMatrix[5],fRotationMatrix[2]);
   if (phi3<0) phi3+=360.;
}

//_____________________________________________________________________________
void TGeoRotation::GetAngles(Double_t &phi, Double_t &theta, Double_t &psi) const
{
// Retreive Euler angles.
   const Double_t *m = fRotationMatrix;
   // Check if theta is 0 or 180.
   if (TMath::Abs(1.-TMath::Abs(m[8]))<1.e-9) {      
      theta = TMath::ACos(m[8])*TMath::RadToDeg();
      phi = TMath::ATan2(-m[8]*m[1],m[0])*TMath::RadToDeg();
      psi = 0.; // convention, phi+psi matters
      return;
   }
   // sin(theta) != 0
   phi = TMath::ATan2(m[2],-m[5]);
   Double_t sphi = TMath::Sin(phi);
   if (TMath::Abs(sphi)<1.e-9) theta = -TMath::ASin(m[5]/TMath::Cos(phi))*TMath::RadToDeg();
   else theta = TMath::ASin(m[2]/sphi)*TMath::RadToDeg();
   phi *= TMath::RadToDeg();      
   psi = TMath::ATan2(m[6],m[7])*TMath::RadToDeg();
}   

//_____________________________________________________________________________
Double_t TGeoRotation::Determinant() const
{
// computes determinant of the rotation matrix
   Double_t 
   det = fRotationMatrix[0]*fRotationMatrix[4]*fRotationMatrix[8] + 
         fRotationMatrix[3]*fRotationMatrix[7]*fRotationMatrix[2] +
         fRotationMatrix[6]*fRotationMatrix[1]*fRotationMatrix[5] - 
         fRotationMatrix[2]*fRotationMatrix[4]*fRotationMatrix[6] -
         fRotationMatrix[5]*fRotationMatrix[7]*fRotationMatrix[0] - 
         fRotationMatrix[8]*fRotationMatrix[1]*fRotationMatrix[3];
   return det;
}

//_____________________________________________________________________________
void TGeoRotation::CheckMatrix()
{
   // performes an orthogonality check and finds if the matrix is a reflection
//   Warning("CheckMatrix", "orthogonality check not performed yet");
   if (Determinant() < 0) SetBit(kGeoReflection);
   Double_t dd = fRotationMatrix[0] + fRotationMatrix[4] + fRotationMatrix[8] - 3.;
   if (TMath::Abs(dd) < 1.E-12) ResetBit(kGeoRotation);
   else                         SetBit(kGeoRotation);
}

//_____________________________________________________________________________
void TGeoRotation::GetInverse(Double_t *invmat) const
{
// Get the inverse rotation matrix (which is simply the transpose)
   if (!invmat) {
      Error("GetInverse", "no place to store the inverse matrix");
      return;
   }
   for (Int_t i=0; i<3; i++) {
      for (Int_t j=0; j<3; j++) {   
         invmat[3*i+j] = fRotationMatrix[3*j+i];
      }
   }
}

//_____________________________________________________________________________
void TGeoRotation::MultiplyBy(TGeoRotation *rot, Bool_t after)
{
// Multiply this rotation with the one specified by ROT.
// -   after=TRUE (default): THIS*ROT
// -   after=FALSE         : ROT*THIS
   const Double_t *matleft, *matright;
   SetBit(kGeoRotation);
   Double_t  newmat[9] = {0};
   if (after) {
      matleft  = &fRotationMatrix[0];
      matright = rot->GetRotationMatrix();
   } else {
      matleft  = rot->GetRotationMatrix();
      matright = &fRotationMatrix[0];
   }
   for (Int_t i=0; i<3; i++) {
      for (Int_t j=0; j<3; j++) { 
         for (Int_t k=0; k<3; k++) {
            newmat[3*i+j] += matleft[3*i+k] * matright[3*k+j];
         }
      }
   }
   memcpy(&fRotationMatrix[0], &newmat[0], kN9);
}
//=============================================================================

ClassImp(TGeoScale)

//_____________________________________________________________________________
TGeoScale::TGeoScale()
{
// default constructor
   SetBit(kGeoScale);
   for (Int_t i=0; i<3; i++) fScale[i] = 1.;
}

//_____________________________________________________________________________
TGeoScale::TGeoScale(const TGeoScale &other)
          :TGeoMatrix(other)
{
// Copy constructor
   SetBit(kGeoScale);
   const Double_t *scl =  other.GetScale();
   memcpy(fScale, scl, kN3);
   if (fScale[0]*fScale[1]*fScale[2]<0) SetBit(kGeoReflection);
   else SetBit(kGeoReflection, kFALSE);
}   

//_____________________________________________________________________________
TGeoScale::TGeoScale(Double_t sx, Double_t sy, Double_t sz)
          :TGeoMatrix("")
{
// default constructor
   SetBit(kGeoScale);
   SetScale(sx, sy, sz);
}

//_____________________________________________________________________________
TGeoScale::TGeoScale(const char *name, Double_t sx, Double_t sy, Double_t sz)
          :TGeoMatrix(name)
{
// default constructor
   SetBit(kGeoScale);
   SetScale(sx, sy, sz);
}

//_____________________________________________________________________________
TGeoScale::~TGeoScale()
{
// destructor
}

//_____________________________________________________________________________
TGeoMatrix& TGeoScale::Inverse() const
{
// Return a temporary inverse of this.
   static TGeoHMatrix h;
   h = *this;
   Double_t scale[3];
   scale[0] = 1./fScale[0];
   scale[1] = 1./fScale[1];
   scale[2] = 1./fScale[2];
   h.SetScale(scale);
   return h;
}   

//_____________________________________________________________________________
void TGeoScale::SetScale(Double_t sx, Double_t sy, Double_t sz)
{
// scale setter
   if (TMath::Abs(sx*sy*sz) < 1.E-10) {
      Error("SetScale", "Invalid scale %f, %f, %f for transformation %s",sx,sy,sx,GetName());
      return;
   }   
   fScale[0] = sx;
   fScale[1] = sy;
   fScale[2] = sz;
   if (sx*sy*sz<0) SetBit(kGeoReflection);
   else            SetBit(kGeoReflection, kFALSE);
}

//_____________________________________________________________________________
void TGeoScale::LocalToMaster(const Double_t *local, Double_t *master) const
{
// Convert a local point to the master frame.
   master[0] = local[0]*fScale[0];
   master[1] = local[1]*fScale[1];
   master[2] = local[2]*fScale[2];
}

//_____________________________________________________________________________
Double_t TGeoScale::LocalToMaster(Double_t dist, const Double_t *dir) const
{
// Convert the local distance along unit vector DIR to master frame. If DIR
// is not specified perform a conversion such as the returned distance is the
// the minimum for all possible directions.
   Double_t scale;
   if (!dir) {
      scale = TMath::Abs(fScale[0]);
      if (TMath::Abs(fScale[1])<scale) scale = TMath::Abs(fScale[1]);
      if (TMath::Abs(fScale[2])<scale) scale = TMath::Abs(fScale[2]);
   } else {
      scale = fScale[0]*fScale[0]*dir[0]*dir[0] +
              fScale[1]*fScale[1]*dir[1]*dir[1] +
              fScale[2]*fScale[2]*dir[2]*dir[2];
      scale = TMath::Sqrt(scale);        
   }   
   return scale*dist;   
}   

//_____________________________________________________________________________
TGeoMatrix *TGeoScale::MakeClone() const
{
// Make a clone of this matrix.
   TGeoMatrix *matrix = new TGeoScale(*this);
   return matrix;
}
      
//_____________________________________________________________________________
void TGeoScale::MasterToLocal(const Double_t *master, Double_t *local) const
{
// Convert a global point to local frame.
   local[0] = master[0]/fScale[0];
   local[1] = master[1]/fScale[1];
   local[2] = master[2]/fScale[2];
}

//_____________________________________________________________________________
Double_t TGeoScale::MasterToLocal(Double_t dist, const Double_t *dir) const
{
// Convert the distance along unit vector DIR to local frame. If DIR
// is not specified perform a conversion such as the returned distance is the
// the minimum for all possible directions.
   Double_t scale;
   if (!dir) {
      scale = TMath::Abs(fScale[0]);
      if (TMath::Abs(fScale[1])>scale) scale = TMath::Abs(fScale[1]);
      if (TMath::Abs(fScale[2])>scale) scale = TMath::Abs(fScale[2]);
      scale = 1./scale;
   } else {
      scale = (dir[0]*dir[0])/(fScale[0]*fScale[0]) +
              (dir[1]*dir[1])/(fScale[1]*fScale[1]) +
              (dir[2]*dir[2])/(fScale[2]*fScale[2]);
      scale = TMath::Sqrt(scale);        
   }   
   return scale*dist;   
}   

//=============================================================================

ClassImp(TGeoCombiTrans)

//_____________________________________________________________________________
TGeoCombiTrans::TGeoCombiTrans()
{
// dummy ctor
   for (Int_t i=0; i<3; i++) fTranslation[i] = 0.0;
   fRotation = 0;
}

//_____________________________________________________________________________
TGeoCombiTrans::TGeoCombiTrans(const TGeoCombiTrans &other)
               :TGeoMatrix(other)
{
// Copy ctor
   Int_t i;
   if (other.IsTranslation()) {
      const Double_t *trans = other.GetTranslation();
      memcpy(fTranslation, trans, kN3);
   } else {
      for (i=0; i<3; i++) fTranslation[i] = 0.0;   
   }
   if (other.IsRotation()) {   
      const TGeoRotation rot = *other.GetRotation();
      fRotation = new TGeoRotation(rot); 
      SetBit(kGeoMatrixOwned);
   } 
   else fRotation = 0;  
}   

//_____________________________________________________________________________
TGeoCombiTrans::TGeoCombiTrans(const TGeoMatrix &other)
               :TGeoMatrix(other)
{
// Copy ctor.
   Int_t i;
   if (other.IsTranslation()) {
      SetBit(kGeoTranslation);
      memcpy(fTranslation,other.GetTranslation(),kN3);
   } else {
      for (i=0; i<3; i++) fTranslation[i] = 0.0;   
   }
   if (other.IsRotation()) {
      SetBit(kGeoRotation);
      SetBit(kGeoMatrixOwned);
      fRotation = new TGeoRotation(other);
   }
   else fRotation = 0;
}

//_____________________________________________________________________________
TGeoCombiTrans::TGeoCombiTrans(const TGeoTranslation &tr, const TGeoRotation &rot)
{
// Constructor from a translation and a rotation.
   if (tr.IsTranslation()) {
      SetBit(kGeoTranslation);
      const Double_t *trans = tr.GetTranslation();
      memcpy(fTranslation, trans, kN3);
   } else {
      for (Int_t i=0; i<3; i++) fTranslation[i] = 0.0;
   }   
   if (rot.IsRotation()) {
      SetBit(kGeoRotation);   
      SetBit(kGeoMatrixOwned);
      fRotation = new TGeoRotation(rot);
      SetBit(kGeoReflection, rot.TestBit(kGeoReflection));
   }
   else fRotation = 0;   
}   

//_____________________________________________________________________________
TGeoCombiTrans::TGeoCombiTrans(const char *name)
               :TGeoMatrix(name)
{
// Named ctor.
   for (Int_t i=0; i<3; i++) fTranslation[i] = 0.0;
   fRotation = 0;
}

//_____________________________________________________________________________
TGeoCombiTrans::TGeoCombiTrans(Double_t dx, Double_t dy, Double_t dz, TGeoRotation *rot)
               :TGeoMatrix("")
{
// Constructor from a translation specified by X,Y,Z and a pointer to a rotation. The rotation will not be owned by this.
   SetTranslation(dx, dy, dz);
   fRotation = 0;
   SetRotation(rot);
}

//_____________________________________________________________________________
TGeoCombiTrans::TGeoCombiTrans(const char *name, Double_t dx, Double_t dy, Double_t dz, TGeoRotation *rot)
               :TGeoMatrix(name)
{
// Named ctor
   SetTranslation(dx, dy, dz);
   fRotation = 0;
   SetRotation(rot);
}

//_____________________________________________________________________________
TGeoCombiTrans &TGeoCombiTrans::operator=(const TGeoMatrix &matrix)
{
// Assignment operator.
   if (&matrix == this) return *this;
   Clear();
   TGeoMatrix::operator=(matrix);
   
   if (matrix.IsTranslation()) {
      SetBit(kGeoTranslation);
      memcpy(fTranslation,matrix.GetTranslation(),kN3);
   }
   if (matrix.IsRotation()) {
      SetBit(kGeoRotation);
      if (!fRotation) {
         fRotation = new TGeoRotation();
         SetBit(kGeoMatrixOwned);
      } else {
         if (!TestBit(kGeoMatrixOwned)) {
            fRotation = new TGeoRotation(); 
            SetBit(kGeoMatrixOwned);
         }
      }        
      fRotation->SetMatrix(matrix.GetRotationMatrix());
      fRotation->SetBit(kGeoReflection, matrix.TestBit(kGeoReflection));
      fRotation->SetBit(kGeoRotation);
   } else {
      if (fRotation && TestBit(kGeoMatrixOwned)) delete fRotation;
      ResetBit(kGeoMatrixOwned);
      fRotation = 0;
   }   
   return *this;
}

//_____________________________________________________________________________
TGeoCombiTrans::~TGeoCombiTrans()
{
// destructor
   if (fRotation) {
      if(TestBit(TGeoMatrix::kGeoMatrixOwned) && !fRotation->IsRegistered()) delete fRotation;
   }   
}

//_____________________________________________________________________________
void TGeoCombiTrans::Clear(Option_t *)
{
// Reset translation/rotation to identity
   if (IsTranslation()) {
      ResetBit(kGeoTranslation);
      memset(fTranslation, 0, kN3);
   }
   if (fRotation) {
      if (TestBit(kGeoMatrixOwned)) delete fRotation;
      fRotation = 0;
   }
   ResetBit(kGeoRotation);
   ResetBit(kGeoReflection);
   ResetBit(kGeoMatrixOwned);
}         

//_____________________________________________________________________________
TGeoMatrix& TGeoCombiTrans::Inverse() const
{
// Return a temporary inverse of this.
   static TGeoHMatrix h;
   h = *this;
   Bool_t is_tr = IsTranslation();
   Bool_t is_rot = IsRotation();
   Double_t tr[3];
   Double_t newrot[9];
   const Double_t *rot = GetRotationMatrix();
   tr[0] = -fTranslation[0]*rot[0] - fTranslation[1]*rot[3] - fTranslation[2]*rot[6];
   tr[1] = -fTranslation[0]*rot[1] - fTranslation[1]*rot[4] - fTranslation[2]*rot[7];
   tr[2] = -fTranslation[0]*rot[2] - fTranslation[1]*rot[5] - fTranslation[2]*rot[8];
   h.SetTranslation(tr);
   newrot[0] = rot[0];
   newrot[1] = rot[3];
   newrot[2] = rot[6];
   newrot[3] = rot[1];
   newrot[4] = rot[4];
   newrot[5] = rot[7];
   newrot[6] = rot[2];
   newrot[7] = rot[5];
   newrot[8] = rot[8];
   h.SetRotation(newrot);
   h.SetBit(kGeoTranslation,is_tr);
   h.SetBit(kGeoRotation,is_rot);
   return h;
}   

//_____________________________________________________________________________
TGeoMatrix *TGeoCombiTrans::MakeClone() const
{
// Make a clone of this matrix.
   TGeoMatrix *matrix = new TGeoCombiTrans(*this);
   return matrix;
}

//_____________________________________________________________________________
void TGeoCombiTrans::RegisterYourself()
{
// Register the matrix in the current manager, which will become the owner. 
   TGeoMatrix::RegisterYourself();
   if (fRotation && fRotation->IsRotation()) fRotation->RegisterYourself();
}

//_____________________________________________________________________________
void TGeoCombiTrans::RotateX(Double_t angle)
{
// Rotate about X axis with angle expressed in degrees.
   if (!fRotation || !TestBit(kGeoMatrixOwned)) {
      if (fRotation) fRotation = new TGeoRotation(*fRotation);
      else fRotation = new TGeoRotation();
      SetBit(kGeoMatrixOwned);
   }   
   SetBit(kGeoRotation);
   const Double_t *rot = fRotation->GetRotationMatrix();
   Double_t phi = angle*TMath::DegToRad();
   Double_t c = TMath::Cos(phi);
   Double_t s = TMath::Sin(phi);
   Double_t v[9];
   v[0] = rot[0];
   v[1] = rot[1];
   v[2] = rot[2];
   v[3] = c*rot[3]-s*rot[6];
   v[4] = c*rot[4]-s*rot[7];
   v[5] = c*rot[5]-s*rot[8];
   v[6] = s*rot[3]+c*rot[6];
   v[7] = s*rot[4]+c*rot[7];
   v[8] = s*rot[5]+c*rot[8];
   fRotation->SetMatrix(v);
   fRotation->SetBit(kGeoRotation);
   if (!IsTranslation()) return;
   v[0] = fTranslation[0];
   v[1] = c*fTranslation[1]-s*fTranslation[2];
   v[2] = s*fTranslation[1]+c*fTranslation[2];   
   memcpy(fTranslation,v,kN3);
}   

//_____________________________________________________________________________
void TGeoCombiTrans::RotateY(Double_t angle)
{
// Rotate about Y axis with angle expressed in degrees.
   if (!fRotation || !TestBit(kGeoMatrixOwned)) {
      if (fRotation) fRotation = new TGeoRotation(*fRotation);
      else fRotation = new TGeoRotation();
      SetBit(kGeoMatrixOwned);
   }   
   SetBit(kGeoRotation);
   const Double_t *rot = fRotation->GetRotationMatrix();
   Double_t phi = angle*TMath::DegToRad();
   Double_t c = TMath::Cos(phi);
   Double_t s = TMath::Sin(phi);
   Double_t v[9];
   v[0] = c*rot[0]+s*rot[6];
   v[1] = c*rot[1]+s*rot[7];
   v[2] = c*rot[2]+s*rot[8];
   v[3] = rot[3];
   v[4] = rot[4];
   v[5] = rot[5];
   v[6] = -s*rot[0]+c*rot[6];
   v[7] = -s*rot[1]+c*rot[7];
   v[8] = -s*rot[2]+c*rot[8];
   fRotation->SetMatrix(v);
   fRotation->SetBit(kGeoRotation);
   if (!IsTranslation()) return;
   v[0] = c*fTranslation[0]+s*fTranslation[2];
   v[1] = fTranslation[1];
   v[2] = -s*fTranslation[0]+c*fTranslation[2];
   memcpy(fTranslation,v,kN3);
}   

//_____________________________________________________________________________
void TGeoCombiTrans::RotateZ(Double_t angle)
{
// Rotate about Z axis with angle expressed in degrees.
   if (!fRotation || !TestBit(kGeoMatrixOwned)) {
      if (fRotation) fRotation = new TGeoRotation(*fRotation);
      else fRotation = new TGeoRotation();
      SetBit(kGeoMatrixOwned);
   }   
   SetBit(kGeoRotation);
   const Double_t *rot = fRotation->GetRotationMatrix();
   Double_t phi = angle*TMath::DegToRad();
   Double_t c = TMath::Cos(phi);
   Double_t s = TMath::Sin(phi);
   Double_t v[9];
   v[0] = c*rot[0]-s*rot[3];
   v[1] = c*rot[1]-s*rot[4];
   v[2] = c*rot[2]-s*rot[5];
   v[3] = s*rot[0]+c*rot[3];
   v[4] = s*rot[1]+c*rot[4];
   v[5] = s*rot[2]+c*rot[5];
   v[6] = rot[6];
   v[7] = rot[7];
   v[8] = rot[8];
   fRotation->SetMatrix(v);
   fRotation->SetBit(kGeoRotation);
   if (!IsTranslation()) return;
   v[0] = c*fTranslation[0]-s*fTranslation[1];
   v[1] = s*fTranslation[0]+c*fTranslation[1];
   v[2] = fTranslation[2];
   memcpy(fTranslation,v,kN3);
}   

//_____________________________________________________________________________
void TGeoCombiTrans::ReflectX(Bool_t leftside, Bool_t rotonly)
{
// Multiply by a reflection respect to YZ.
   if (leftside && !rotonly) fTranslation[0] = -fTranslation[0];
   if (!fRotation || !TestBit(kGeoMatrixOwned)) {
      if (fRotation) fRotation = new TGeoRotation(*fRotation);
      else fRotation = new TGeoRotation();
      SetBit(kGeoMatrixOwned);
   }
   SetBit(kGeoRotation);
   fRotation->ReflectX(leftside);
   SetBit(kGeoReflection, !IsReflection());
}      
   
//_____________________________________________________________________________
void TGeoCombiTrans::ReflectY(Bool_t leftside, Bool_t rotonly)
{
// Multiply by a reflection respect to ZX.
   if (leftside && !rotonly) fTranslation[1] = -fTranslation[1];
   if (!fRotation || !TestBit(kGeoMatrixOwned)) {
      if (fRotation) fRotation = new TGeoRotation(*fRotation);
      else fRotation = new TGeoRotation();
      SetBit(kGeoMatrixOwned);
   }
   SetBit(kGeoRotation);
   fRotation->ReflectY(leftside);
   SetBit(kGeoReflection, !IsReflection());
}      

//_____________________________________________________________________________
void TGeoCombiTrans::ReflectZ(Bool_t leftside, Bool_t rotonly)
{
// Multiply by a reflection respect to XY.
   if (leftside && !rotonly) fTranslation[2] = -fTranslation[2];
   if (!fRotation || !TestBit(kGeoMatrixOwned)) {
      if (fRotation) fRotation = new TGeoRotation(*fRotation);
      else fRotation = new TGeoRotation();
      SetBit(kGeoMatrixOwned);
   }
   SetBit(kGeoRotation);
   fRotation->ReflectZ(leftside);
   SetBit(kGeoReflection, !IsReflection());
}      

//_____________________________________________________________________________
void TGeoCombiTrans::SavePrimitive(ostream &out, Option_t *option /*= ""*/)
{
// Save a primitive as a C++ statement(s) on output stream "out".
   if (TestBit(kGeoSavePrimitive)) return;
   out << "   // Combi transformation: " << GetName() << endl;
   out << "   dx = " << fTranslation[0] << ";" << endl;
   out << "   dy = " << fTranslation[1] << ";" << endl;
   out << "   dz = " << fTranslation[2] << ";" << endl;
   if (fRotation && fRotation->IsRotation()) {
      fRotation->SavePrimitive(out,option);
      out << "   " << GetPointerName() << " = new TGeoCombiTrans(\"" << GetName() << "\", dx,dy,dz,";
      out << fRotation->GetPointerName() << ");" << endl;
   } else {   
      out << "   " << GetPointerName() << " = new TGeoCombiTrans(\"" << GetName() << "\");" << endl;
      out << "   " << GetPointerName() << "->SetTranslation(dx,dy,dz);" << endl;
   }   
   TObject::SetBit(kGeoSavePrimitive);
}

//_____________________________________________________________________________
void TGeoCombiTrans::SetRotation(const TGeoRotation *rot)
{
// Assign a foreign rotation to the combi. The rotation is NOT owned by this.
   if (fRotation && TestBit(kGeoMatrixOwned)) delete fRotation;
   fRotation = 0;
   ResetBit(TGeoMatrix::kGeoMatrixOwned);      
   ResetBit(kGeoRotation);
   ResetBit(kGeoReflection);   
   if (!rot) return;
   if (!rot->IsRotation()) return;
         
   SetBit(kGeoRotation);
   SetBit(kGeoReflection, rot->TestBit(kGeoReflection));
   TGeoRotation *rr = (TGeoRotation*)rot;
   fRotation = rr;
}

//_____________________________________________________________________________
void TGeoCombiTrans::SetRotation(const TGeoRotation &rot)
{
// Copy the rotation from another one.
   if (fRotation && TestBit(kGeoMatrixOwned)) delete fRotation;
   fRotation = 0;
   if (!rot.IsRotation()) {
      ResetBit(kGeoRotation);
      ResetBit(kGeoReflection);
      ResetBit(TGeoMatrix::kGeoMatrixOwned);
      return;
   }         
      
   SetBit(kGeoRotation);
   SetBit(kGeoReflection, rot.TestBit(kGeoReflection));
   fRotation = new TGeoRotation(rot);
   SetBit(kGeoMatrixOwned);
}

//_____________________________________________________________________________
void TGeoCombiTrans::SetTranslation(const TGeoTranslation &tr)
{
// copy the translation component
   if (tr.IsTranslation()) {
      SetBit(kGeoTranslation);
      const Double_t *trans = tr.GetTranslation();
      memcpy(fTranslation, trans, kN3);
   } else {
      if (!IsTranslation()) return;
      memset(fTranslation, 0, kN3);
      ResetBit(kGeoTranslation);
   }      
}   

//_____________________________________________________________________________
void TGeoCombiTrans::SetTranslation(Double_t dx, Double_t dy, Double_t dz)
{
// set the translation component
   fTranslation[0] = dx;
   fTranslation[1] = dy;
   fTranslation[2] = dz;
   if (fTranslation[0] || fTranslation[1] || fTranslation[2]) SetBit(kGeoTranslation);
   else ResetBit(kGeoTranslation);
}

//_____________________________________________________________________________
void TGeoCombiTrans::SetTranslation(Double_t *vect)
{
// set the translation component
   fTranslation[0] = vect[0];
   fTranslation[1] = vect[1];
   fTranslation[2] = vect[2];
   if (fTranslation[0] || fTranslation[1] || fTranslation[2]) SetBit(kGeoTranslation);
   else ResetBit(kGeoTranslation);
}

//_____________________________________________________________________________
const Double_t *TGeoCombiTrans::GetRotationMatrix() const
{
// get the rotation array
   if (!fRotation) return kIdentityMatrix;
   return fRotation->GetRotationMatrix();
}
//=============================================================================

ClassImp(TGeoGenTrans)

//_____________________________________________________________________________
TGeoGenTrans::TGeoGenTrans()
{
// dummy ctor
   SetBit(kGeoGenTrans);
   for (Int_t i=0; i<3; i++) fTranslation[i] = 0.0;
   for (Int_t j=0; j<3; j++) fScale[j] = 1.0;
   fRotation = 0;
}

//_____________________________________________________________________________
TGeoGenTrans::TGeoGenTrans(const char *name)
             :TGeoCombiTrans(name)
{
// constructor
   SetBit(kGeoGenTrans);
   for (Int_t i=0; i<3; i++) fTranslation[i] = 0.0;
   for (Int_t j=0; j<3; j++) fScale[j] = 1.0;
   fRotation = 0;
}

//_____________________________________________________________________________
TGeoGenTrans::TGeoGenTrans(Double_t dx, Double_t dy, Double_t dz,
                           Double_t sx, Double_t sy, Double_t sz, TGeoRotation *rot)
             :TGeoCombiTrans("")
{
// constructor
   SetBit(kGeoGenTrans);
   SetTranslation(dx, dy, dz);
   SetScale(sx, sy, sz);
   SetRotation(rot);
}

//_____________________________________________________________________________
TGeoGenTrans::TGeoGenTrans(const char *name, Double_t dx, Double_t dy, Double_t dz,
                           Double_t sx, Double_t sy, Double_t sz, TGeoRotation *rot)
             :TGeoCombiTrans(name)
{
// constructor
   SetBit(kGeoGenTrans);
   SetTranslation(dx, dy, dz);
   SetScale(sx, sy, sz);
   SetRotation(rot);
}

//_____________________________________________________________________________
TGeoGenTrans::~TGeoGenTrans()
{
// destructor
}

//_____________________________________________________________________________
void TGeoGenTrans::Clear(Option_t *)
{
// clear the fields of this transformation
   memset(&fTranslation[0], 0, kN3);
   memset(&fScale[0], 0, kN3);
   if (fRotation) fRotation->Clear();
}

//_____________________________________________________________________________
void TGeoGenTrans::SetScale(Double_t sx, Double_t sy, Double_t sz)
{
// set the scale
   fScale[0] = sx;
   fScale[1] = sy;
   fScale[2] = sz;
   if (!(Normalize())) {
      Error("ctor", "Invalid scale");
      return;
   }
}

//_____________________________________________________________________________
TGeoMatrix& TGeoGenTrans::Inverse() const
{
// Return a temporary inverse of this.
   Error("Inverse", "not implemented");
   static TGeoHMatrix h;
   h = *this;
   return h;
}   

//_____________________________________________________________________________
Bool_t TGeoGenTrans::Normalize()
{
// A scale transformation should be normalized by sx*sy*sz factor
   Double_t normfactor = fScale[0]*fScale[1]*fScale[2];
   if (normfactor <= 1E-5) return kFALSE;
   for (Int_t i=0; i<3; i++)
      fScale[i] /= normfactor;
   return kTRUE;
}
//=============================================================================

ClassImp(TGeoIdentity)

//_____________________________________________________________________________
TGeoIdentity::TGeoIdentity()
{
// dummy ctor
   if (!gGeoIdentity) gGeoIdentity = this;
   RegisterYourself();
}

//_____________________________________________________________________________
TGeoIdentity::TGeoIdentity(const char *name)
             :TGeoMatrix(name)
{
// constructor
   if (!gGeoIdentity) gGeoIdentity = this;
   RegisterYourself();
}

//_____________________________________________________________________________
TGeoMatrix &TGeoIdentity::Inverse() const
{
// Return a temporary inverse of this.
   return *gGeoIdentity;
}
   
/*************************************************************************
 * 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.            *
 *************************************************************************/

//=============================================================================

ClassImp(TGeoHMatrix)
   
//_____________________________________________________________________________
TGeoHMatrix::TGeoHMatrix()
{
// dummy ctor
   memset(&fTranslation[0], 0, kN3);
   memcpy(fRotationMatrix,kIdentityMatrix,kN9);
   memcpy(fScale,kUnitScale,kN3);
}

//_____________________________________________________________________________
TGeoHMatrix::TGeoHMatrix(const char* name)
            :TGeoMatrix(name)
{
// constructor
   memset(&fTranslation[0], 0, kN3);
   memcpy(fRotationMatrix,kIdentityMatrix,kN9);
   memcpy(fScale,kUnitScale,kN3);
}

//_____________________________________________________________________________
TGeoHMatrix::TGeoHMatrix(const TGeoMatrix &matrix)
            :TGeoMatrix(matrix)
{
   // assignment
   if (matrix.IsTranslation()) {
      SetBit(kGeoTranslation);
      SetTranslation(matrix.GetTranslation());
   } else {
      memset(&fTranslation[0], 0, kN3);   
   }
   if (matrix.IsRotation()) {
      SetBit(kGeoRotation);
      memcpy(fRotationMatrix,matrix.GetRotationMatrix(),kN9);
   } else {
      memcpy(fRotationMatrix,kIdentityMatrix,kN9);   
   }
   if (matrix.IsScale()) {
      SetBit(kGeoScale);
      memcpy(fScale,matrix.GetScale(),kN3);
   } else {
      memcpy(fScale,kUnitScale,kN3);   
   }
}

//_____________________________________________________________________________
TGeoHMatrix::~TGeoHMatrix()
{
// destructor
}

//_____________________________________________________________________________
TGeoHMatrix &TGeoHMatrix::operator=(const TGeoMatrix *matrix)
{
   // assignment
   if (matrix == this) return *this;
   Clear();
   if (matrix == 0) return *this;
   TGeoMatrix::operator=(*matrix);
   if (matrix->IsIdentity()) return *this;
   if (matrix->IsTranslation()) {
      SetBit(kGeoTranslation);
      memcpy(fTranslation,matrix->GetTranslation(),kN3);
   }
   if (matrix->IsRotation()) {
      SetBit(kGeoRotation);
      memcpy(fRotationMatrix,matrix->GetRotationMatrix(),kN9);
   }
   if (matrix->IsScale()) {
      SetBit(kGeoScale);
      memcpy(fScale,matrix->GetScale(),kN3);
   }
   return *this;
}

//_____________________________________________________________________________
TGeoHMatrix &TGeoHMatrix::operator=(const TGeoMatrix &matrix)
{
   // assignment
   if (&matrix == this) return *this;
   Clear();
   TGeoMatrix::operator=(matrix);
   if (matrix.IsIdentity()) return *this;
   if (matrix.IsTranslation()) {
      SetBit(kGeoTranslation);
      memcpy(fTranslation,matrix.GetTranslation(),kN3);
   } else {
      memcpy(fTranslation,kNullVector,kN3);
   }   
   if (matrix.IsRotation()) {
      SetBit(kGeoRotation);
      memcpy(fRotationMatrix,matrix.GetRotationMatrix(),kN9);
   } else {
      memcpy(fRotationMatrix,kIdentityMatrix,kN9);
   }   
   if (matrix.IsScale()) {
      SetBit(kGeoScale);
      memcpy(fScale,matrix.GetScale(),kN3);
   } else {
      memcpy(fScale,kUnitScale,kN3);
   }   
   return *this;
}

//_____________________________________________________________________________
void TGeoHMatrix::CopyFrom(const TGeoMatrix *other)
{
// Fast copy method.
   SetBit(kGeoTranslation, other->IsTranslation());
   SetBit(kGeoRotation, other->IsRotation());
   SetBit(kGeoReflection, other->IsReflection());
   memcpy(fTranslation,other->GetTranslation(),kN3);
   memcpy(fRotationMatrix,other->GetRotationMatrix(),kN9);
}   

//_____________________________________________________________________________
void TGeoHMatrix::Clear(Option_t *)
{
// clear the data for this matrix
   SetBit(kGeoReflection, kFALSE);
   if (IsIdentity()) return;
   if (IsTranslation()) {
      ResetBit(kGeoTranslation);
      memcpy(fTranslation,kNullVector,kN3);
   }
   if (IsRotation()) {
      ResetBit(kGeoRotation);
      memcpy(fRotationMatrix,kIdentityMatrix,kN9);
   }
   if (IsScale()) {      
      ResetBit(kGeoScale);
      memcpy(fScale,kUnitScale,kN3);
   }
}

//_____________________________________________________________________________
TGeoMatrix *TGeoHMatrix::MakeClone() const
{
// Make a clone of this matrix.
   TGeoMatrix *matrix = new TGeoHMatrix(*this);
   return matrix;
}

//_____________________________________________________________________________
void TGeoHMatrix::FastRotZ(const Double_t *sincos)
{
// Perform a rotation about Z having the sine/cosine of the rotation angle.
   fRotationMatrix[0] = sincos[1];
   fRotationMatrix[1] = -sincos[0];
   fRotationMatrix[3] = sincos[0];
   fRotationMatrix[4] = sincos[1];
   SetBit(kGeoRotation);
}

//_____________________________________________________________________________
TGeoMatrix& TGeoHMatrix::Inverse() const
{
// Return a temporary inverse of this.
   static TGeoHMatrix h;
   h = *this;
   if (IsTranslation()) {
      Double_t tr[3];
      tr[0] = -fTranslation[0]*fRotationMatrix[0] - fTranslation[1]*fRotationMatrix[3] - fTranslation[2]*fRotationMatrix[6];
      tr[1] = -fTranslation[0]*fRotationMatrix[1] - fTranslation[1]*fRotationMatrix[4] - fTranslation[2]*fRotationMatrix[7];
      tr[2] = -fTranslation[0]*fRotationMatrix[2] - fTranslation[1]*fRotationMatrix[5] - fTranslation[2]*fRotationMatrix[8];
      h.SetTranslation(tr);
   }
   if (IsRotation()) {
      Double_t newrot[9];
      newrot[0] = fRotationMatrix[0];
      newrot[1] = fRotationMatrix[3];
      newrot[2] = fRotationMatrix[6];
      newrot[3] = fRotationMatrix[1];
      newrot[4] = fRotationMatrix[4];
      newrot[5] = fRotationMatrix[7];
      newrot[6] = fRotationMatrix[2];
      newrot[7] = fRotationMatrix[5];
      newrot[8] = fRotationMatrix[8];
      h.SetRotation(newrot);
   }
   if (IsScale()) {
      Double_t sc[3];
      sc[0] = 1./fScale[0];
      sc[1] = 1./fScale[1];
      sc[2] = 1./fScale[2]; 
      h.SetScale(sc);  
   }
   return h;
}   

//_____________________________________________________________________________
Double_t TGeoHMatrix::Determinant() const
{
// computes determinant of the rotation matrix
   Double_t 
   det = fRotationMatrix[0]*fRotationMatrix[4]*fRotationMatrix[8] + 
         fRotationMatrix[3]*fRotationMatrix[7]*fRotationMatrix[2] +
         fRotationMatrix[6]*fRotationMatrix[1]*fRotationMatrix[5] - 
         fRotationMatrix[2]*fRotationMatrix[4]*fRotationMatrix[6] -
         fRotationMatrix[5]*fRotationMatrix[7]*fRotationMatrix[0] - 
         fRotationMatrix[8]*fRotationMatrix[1]*fRotationMatrix[3];
   return det;
}

//_____________________________________________________________________________
void TGeoHMatrix::Multiply(const TGeoMatrix *right)
{
// multiply to the right with an other transformation
   // if right is identity matrix, just return
   if (right->IsIdentity()) return;
   const Double_t *r_tra = right->GetTranslation();
   const Double_t *r_rot = right->GetRotationMatrix();
   const Double_t *r_scl = right->GetScale();
   if (IsIdentity()) {
      if (right->IsRotation()) {
         SetBit(kGeoRotation);
         memcpy(fRotationMatrix,r_rot,kN9);
         if (right->IsReflection()) SetBit(kGeoReflection, !TestBit(kGeoReflection));
      }
      if (right->IsScale()) {
         SetBit(kGeoScale);
         memcpy(fScale,r_scl,kN3);
      }
      if (right->IsTranslation()) {
         SetBit(kGeoTranslation);
         memcpy(fTranslation,r_tra,kN3);
      }
      return;
   }
   Int_t i, j;
   Double_t new_rot[9]; 

   if (right->IsRotation())    {
      SetBit(kGeoRotation);
      if (right->IsReflection()) SetBit(kGeoReflection, !TestBit(kGeoReflection));
   }   
   if (right->IsScale())       SetBit(kGeoScale);
   if (right->IsTranslation()) SetBit(kGeoTranslation);

   // new translation
   if (IsTranslation()) { 
      for (i=0; i<3; i++) {
         fTranslation[i] += fRotationMatrix[3*i]*r_tra[0]
                         + fRotationMatrix[3*i+1]*r_tra[1]
                         + fRotationMatrix[3*i+2]*r_tra[2];
      }
   }
   if (IsRotation()) {
      // new rotation
      for (i=0; i<3; i++) {
         for (j=0; j<3; j++) {
               new_rot[3*i+j] = fRotationMatrix[3*i]*r_rot[j] +
                                fRotationMatrix[3*i+1]*r_rot[3+j] +
                                fRotationMatrix[3*i+2]*r_rot[6+j];
         }
      }
      memcpy(fRotationMatrix,new_rot,kN9);
   }
   // new scale
   if (IsScale()) {
      for (i=0; i<3; i++) fScale[i] *= r_scl[i];
   }
}
 
//_____________________________________________________________________________
void TGeoHMatrix::MultiplyLeft(const TGeoMatrix *left)
{
// multiply to the left with an other transformation
   // if right is identity matrix, just return
   if (left == gGeoIdentity) return;
   const Double_t *l_tra = left->GetTranslation();
   const Double_t *l_rot = left->GetRotationMatrix();
   const Double_t *l_scl = left->GetScale();
   if (IsIdentity()) {
      if (left->IsRotation()) {
         if (left->IsReflection()) SetBit(kGeoReflection, !TestBit(kGeoReflection));
         SetBit(kGeoRotation);
         memcpy(fRotationMatrix,l_rot,kN9);
      }
      if (left->IsScale()) {
         SetBit(kGeoScale);
         memcpy(fScale,l_scl,kN3);
      }
      if (left->IsTranslation()) {
         SetBit(kGeoTranslation);
         memcpy(fTranslation,l_tra,kN3);
      }
      return;
   }
   Int_t i, j;
   Double_t new_tra[3]; 
   Double_t new_rot[9]; 

   if (left->IsRotation()) {
      SetBit(kGeoRotation);
      if (left->IsReflection()) SetBit(kGeoReflection, !TestBit(kGeoReflection));
   }
   if (left->IsScale())       SetBit(kGeoScale);
   if (left->IsTranslation()) SetBit(kGeoTranslation);

   // new translation
   if (IsTranslation()) {  
      for (i=0; i<3; i++) {
         new_tra[i] = l_tra[i]
                      + l_rot[3*i]*  fTranslation[0]
                      + l_rot[3*i+1]*fTranslation[1]
                      + l_rot[3*i+2]*fTranslation[2];
      }
      memcpy(fTranslation,new_tra,kN3);
   }
   if (IsRotation()) {
      // new rotation
      for (i=0; i<3; i++) {
         for (j=0; j<3; j++) {
               new_rot[3*i+j] = l_rot[3*i]*fRotationMatrix[j] +
                                l_rot[3*i+1]*fRotationMatrix[3+j] +
                                l_rot[3*i+2]*fRotationMatrix[6+j];
         }
      }
      memcpy(fRotationMatrix,new_rot,kN9);
   }
   // new scale
   if (IsScale()) {
      for (i=0; i<3; i++) fScale[i] *= l_scl[i];
   }
}

//_____________________________________________________________________________
void TGeoHMatrix::RotateX(Double_t angle)
{
// Rotate about X axis with angle expressed in degrees.
   SetBit(kGeoRotation);
   Double_t phi = angle*TMath::DegToRad();
   Double_t c = TMath::Cos(phi);
   Double_t s = TMath::Sin(phi);
   Double_t v[9];
   v[0] = fRotationMatrix[0];
   v[1] = fRotationMatrix[1];
   v[2] = fRotationMatrix[2];
   v[3] = c*fRotationMatrix[3]-s*fRotationMatrix[6];
   v[4] = c*fRotationMatrix[4]-s*fRotationMatrix[7];
   v[5] = c*fRotationMatrix[5]-s*fRotationMatrix[8];
   v[6] = s*fRotationMatrix[3]+c*fRotationMatrix[6];
   v[7] = s*fRotationMatrix[4]+c*fRotationMatrix[7];
   v[8] = s*fRotationMatrix[5]+c*fRotationMatrix[8];
   memcpy(fRotationMatrix, v, kN9);

   v[0] = fTranslation[0];
   v[1] = c*fTranslation[1]-s*fTranslation[2];
   v[2] = s*fTranslation[1]+c*fTranslation[2];
   memcpy(fTranslation,v,kN3);
}

//_____________________________________________________________________________
void TGeoHMatrix::RotateY(Double_t angle)
{
// Rotate about Y axis with angle expressed in degrees.
   SetBit(kGeoRotation);
   Double_t phi = angle*TMath::DegToRad();
   Double_t c = TMath::Cos(phi);
   Double_t s = TMath::Sin(phi);
   Double_t v[9];
   v[0] = c*fRotationMatrix[0]+s*fRotationMatrix[6];
   v[1] = c*fRotationMatrix[1]+s*fRotationMatrix[7];
   v[2] = c*fRotationMatrix[2]+s*fRotationMatrix[8];
   v[3] = fRotationMatrix[3];
   v[4] = fRotationMatrix[4];
   v[5] = fRotationMatrix[5];
   v[6] = -s*fRotationMatrix[0]+c*fRotationMatrix[6];
   v[7] = -s*fRotationMatrix[1]+c*fRotationMatrix[7];
   v[8] = -s*fRotationMatrix[2]+c*fRotationMatrix[8];
   memcpy(fRotationMatrix, v, kN9);

   v[0] = c*fTranslation[0]+s*fTranslation[2];
   v[1] = fTranslation[1];
   v[2] = -s*fTranslation[0]+c*fTranslation[2];
   memcpy(fTranslation,v,kN3);
}

//_____________________________________________________________________________
void TGeoHMatrix::RotateZ(Double_t angle)
{
// Rotate about Z axis with angle expressed in degrees.
   SetBit(kGeoRotation);
   Double_t phi = angle*TMath::DegToRad();
   Double_t c = TMath::Cos(phi);
   Double_t s = TMath::Sin(phi);
   Double_t v[9];
   v[0] = c*fRotationMatrix[0]-s*fRotationMatrix[3];
   v[1] = c*fRotationMatrix[1]-s*fRotationMatrix[4];
   v[2] = c*fRotationMatrix[2]-s*fRotationMatrix[5];
   v[3] = s*fRotationMatrix[0]+c*fRotationMatrix[3];
   v[4] = s*fRotationMatrix[1]+c*fRotationMatrix[4];
   v[5] = s*fRotationMatrix[2]+c*fRotationMatrix[5];
   v[6] = fRotationMatrix[6];
   v[7] = fRotationMatrix[7];
   v[8] = fRotationMatrix[8];
   memcpy(&fRotationMatrix[0],v,kN9);

   v[0] = c*fTranslation[0]-s*fTranslation[1];
   v[1] = s*fTranslation[0]+c*fTranslation[1];
   v[2] = fTranslation[2];
   memcpy(fTranslation,v,kN3);
}

//_____________________________________________________________________________
void TGeoHMatrix::ReflectX(Bool_t leftside, Bool_t rotonly)
{
// Multiply by a reflection respect to YZ.
   if (leftside && !rotonly) fTranslation[0] = -fTranslation[0];
   if (leftside) {
      fRotationMatrix[0]=-fRotationMatrix[0];
      fRotationMatrix[1]=-fRotationMatrix[1];
      fRotationMatrix[2]=-fRotationMatrix[2];
   } else {
      fRotationMatrix[0]=-fRotationMatrix[0];
      fRotationMatrix[3]=-fRotationMatrix[3];
      fRotationMatrix[6]=-fRotationMatrix[6];
   }   
   SetBit(kGeoRotation);
   SetBit(kGeoReflection, !IsReflection());
}      

//_____________________________________________________________________________
void TGeoHMatrix::ReflectY(Bool_t leftside, Bool_t rotonly)
{
// Multiply by a reflection respect to ZX.
   if (leftside && !rotonly) fTranslation[1] = -fTranslation[1];
   if (leftside) {
      fRotationMatrix[3]=-fRotationMatrix[3];
      fRotationMatrix[4]=-fRotationMatrix[4];
      fRotationMatrix[5]=-fRotationMatrix[5];
   } else {
      fRotationMatrix[1]=-fRotationMatrix[1];
      fRotationMatrix[4]=-fRotationMatrix[4];
      fRotationMatrix[7]=-fRotationMatrix[7];
   }   
   SetBit(kGeoRotation);
   SetBit(kGeoReflection, !IsReflection());
}      

//_____________________________________________________________________________
void TGeoHMatrix::ReflectZ(Bool_t leftside, Bool_t rotonly)
{
// Multiply by a reflection respect to XY.
   if (leftside && !rotonly) fTranslation[2] = -fTranslation[2];
   if (leftside) {
      fRotationMatrix[6]=-fRotationMatrix[6];
      fRotationMatrix[7]=-fRotationMatrix[7];
      fRotationMatrix[8]=-fRotationMatrix[8];
   } else {
      fRotationMatrix[2]=-fRotationMatrix[2];
      fRotationMatrix[5]=-fRotationMatrix[5];
      fRotationMatrix[8]=-fRotationMatrix[8];
   }   
   SetBit(kGeoRotation);
   SetBit(kGeoReflection, !IsReflection());
}      

//_____________________________________________________________________________
void TGeoHMatrix::SavePrimitive(ostream &out, Option_t * /*option*/ /*= ""*/)
{
// Save a primitive as a C++ statement(s) on output stream "out".
   if (TestBit(kGeoSavePrimitive)) return;
   const Double_t *tr = fTranslation;
   const Double_t *rot = fRotationMatrix;
   out << "   // HMatrix: " << GetName() << endl;
   out << "   tr[0]  = " << tr[0] << ";    " << "tr[1] = " << tr[1] << ";    " << "tr[2] = " << tr[2] << ";" << endl;
   out << "   rot[0] =" << rot[0] << ";    " << "rot[1] = " << rot[1] << ";    " << "rot[2] = " << rot[2] << ";" << endl; 
   out << "   rot[3] =" << rot[3] << ";    " << "rot[4] = " << rot[4] << ";    " << "rot[5] = " << rot[5] << ";" << endl; 
   out << "   rot[6] =" << rot[6] << ";    " << "rot[7] = " << rot[7] << ";    " << "rot[8] = " << rot[8] << ";" << endl; 
   char *name = GetPointerName();
   out << "   TGeoHMatrix *" << name << " = new TGeoHMatrix(\"" << GetName() << "\");" << endl;
   out << "   " << name << "->SetTranslation(tr);" << endl;
   out << "   " << name << "->SetRotation(rot);" << endl;
   if (IsTranslation()) out << "   " << name << "->SetBit(TGeoMatrix::kGeoTranslation);" << endl;
   if (IsRotation()) out << "   " << name << "->SetBit(TGeoMatrix::kGeoRotation);" << endl;
   if (IsReflection()) out << "   " << name << "->SetBit(TGeoMatrix::kGeoReflection);" << endl;
   TObject::SetBit(kGeoSavePrimitive);
}
 TGeoMatrix.cxx:1
 TGeoMatrix.cxx:2
 TGeoMatrix.cxx:3
 TGeoMatrix.cxx:4
 TGeoMatrix.cxx:5
 TGeoMatrix.cxx:6
 TGeoMatrix.cxx:7
 TGeoMatrix.cxx:8
 TGeoMatrix.cxx:9
 TGeoMatrix.cxx:10
 TGeoMatrix.cxx:11
 TGeoMatrix.cxx:12
 TGeoMatrix.cxx:13
 TGeoMatrix.cxx:14
 TGeoMatrix.cxx:15
 TGeoMatrix.cxx:16
 TGeoMatrix.cxx:17
 TGeoMatrix.cxx:18
 TGeoMatrix.cxx:19
 TGeoMatrix.cxx:20
 TGeoMatrix.cxx:21
 TGeoMatrix.cxx:22
 TGeoMatrix.cxx:23
 TGeoMatrix.cxx:24
 TGeoMatrix.cxx:25
 TGeoMatrix.cxx:26
 TGeoMatrix.cxx:27
 TGeoMatrix.cxx:28
 TGeoMatrix.cxx:29
 TGeoMatrix.cxx:30
 TGeoMatrix.cxx:31
 TGeoMatrix.cxx:32
 TGeoMatrix.cxx:33
 TGeoMatrix.cxx:34
 TGeoMatrix.cxx:35
 TGeoMatrix.cxx:36
 TGeoMatrix.cxx:37
 TGeoMatrix.cxx:38
 TGeoMatrix.cxx:39
 TGeoMatrix.cxx:40
 TGeoMatrix.cxx:41
 TGeoMatrix.cxx:42
 TGeoMatrix.cxx:43
 TGeoMatrix.cxx:44
 TGeoMatrix.cxx:45
 TGeoMatrix.cxx:46
 TGeoMatrix.cxx:47
 TGeoMatrix.cxx:48
 TGeoMatrix.cxx:49
 TGeoMatrix.cxx:50
 TGeoMatrix.cxx:51
 TGeoMatrix.cxx:52
 TGeoMatrix.cxx:53
 TGeoMatrix.cxx:54
 TGeoMatrix.cxx:55
 TGeoMatrix.cxx:56
 TGeoMatrix.cxx:57
 TGeoMatrix.cxx:58
 TGeoMatrix.cxx:59
 TGeoMatrix.cxx:60
 TGeoMatrix.cxx:61
 TGeoMatrix.cxx:62
 TGeoMatrix.cxx:63
 TGeoMatrix.cxx:64
 TGeoMatrix.cxx:65
 TGeoMatrix.cxx:66
 TGeoMatrix.cxx:67
 TGeoMatrix.cxx:68
 TGeoMatrix.cxx:69
 TGeoMatrix.cxx:70
 TGeoMatrix.cxx:71
 TGeoMatrix.cxx:72
 TGeoMatrix.cxx:73
 TGeoMatrix.cxx:74
 TGeoMatrix.cxx:75
 TGeoMatrix.cxx:76
 TGeoMatrix.cxx:77
 TGeoMatrix.cxx:78
 TGeoMatrix.cxx:79
 TGeoMatrix.cxx:80
 TGeoMatrix.cxx:81
 TGeoMatrix.cxx:82
 TGeoMatrix.cxx:83
 TGeoMatrix.cxx:84
 TGeoMatrix.cxx:85
 TGeoMatrix.cxx:86
 TGeoMatrix.cxx:87
 TGeoMatrix.cxx:88
 TGeoMatrix.cxx:89
 TGeoMatrix.cxx:90
 TGeoMatrix.cxx:91
 TGeoMatrix.cxx:92
 TGeoMatrix.cxx:93
 TGeoMatrix.cxx:94
 TGeoMatrix.cxx:95
 TGeoMatrix.cxx:96
 TGeoMatrix.cxx:97
 TGeoMatrix.cxx:98
 TGeoMatrix.cxx:99
 TGeoMatrix.cxx:100
 TGeoMatrix.cxx:101
 TGeoMatrix.cxx:102
 TGeoMatrix.cxx:103
 TGeoMatrix.cxx:104
 TGeoMatrix.cxx:105
 TGeoMatrix.cxx:106
 TGeoMatrix.cxx:107
 TGeoMatrix.cxx:108
 TGeoMatrix.cxx:109
 TGeoMatrix.cxx:110
 TGeoMatrix.cxx:111
 TGeoMatrix.cxx:112
 TGeoMatrix.cxx:113
 TGeoMatrix.cxx:114
 TGeoMatrix.cxx:115
 TGeoMatrix.cxx:116
 TGeoMatrix.cxx:117
 TGeoMatrix.cxx:118
 TGeoMatrix.cxx:119
 TGeoMatrix.cxx:120
 TGeoMatrix.cxx:121
 TGeoMatrix.cxx:122
 TGeoMatrix.cxx:123
 TGeoMatrix.cxx:124
 TGeoMatrix.cxx:125
 TGeoMatrix.cxx:126
 TGeoMatrix.cxx:127
 TGeoMatrix.cxx:128
 TGeoMatrix.cxx:129
 TGeoMatrix.cxx:130
 TGeoMatrix.cxx:131
 TGeoMatrix.cxx:132
 TGeoMatrix.cxx:133
 TGeoMatrix.cxx:134
 TGeoMatrix.cxx:135
 TGeoMatrix.cxx:136
 TGeoMatrix.cxx:137
 TGeoMatrix.cxx:138
 TGeoMatrix.cxx:139
 TGeoMatrix.cxx:140
 TGeoMatrix.cxx:141
 TGeoMatrix.cxx:142
 TGeoMatrix.cxx:143
 TGeoMatrix.cxx:144
 TGeoMatrix.cxx:145
 TGeoMatrix.cxx:146
 TGeoMatrix.cxx:147
 TGeoMatrix.cxx:148
 TGeoMatrix.cxx:149
 TGeoMatrix.cxx:150
 TGeoMatrix.cxx:151
 TGeoMatrix.cxx:152
 TGeoMatrix.cxx:153
 TGeoMatrix.cxx:154
 TGeoMatrix.cxx:155
 TGeoMatrix.cxx:156
 TGeoMatrix.cxx:157
 TGeoMatrix.cxx:158
 TGeoMatrix.cxx:159
 TGeoMatrix.cxx:160
 TGeoMatrix.cxx:161
 TGeoMatrix.cxx:162
 TGeoMatrix.cxx:163
 TGeoMatrix.cxx:164
 TGeoMatrix.cxx:165
 TGeoMatrix.cxx:166
 TGeoMatrix.cxx:167
 TGeoMatrix.cxx:168
 TGeoMatrix.cxx:169
 TGeoMatrix.cxx:170
 TGeoMatrix.cxx:171
 TGeoMatrix.cxx:172
 TGeoMatrix.cxx:173
 TGeoMatrix.cxx:174
 TGeoMatrix.cxx:175
 TGeoMatrix.cxx:176
 TGeoMatrix.cxx:177
 TGeoMatrix.cxx:178
 TGeoMatrix.cxx:179
 TGeoMatrix.cxx:180
 TGeoMatrix.cxx:181
 TGeoMatrix.cxx:182
 TGeoMatrix.cxx:183
 TGeoMatrix.cxx:184
 TGeoMatrix.cxx:185
 TGeoMatrix.cxx:186
 TGeoMatrix.cxx:187
 TGeoMatrix.cxx:188
 TGeoMatrix.cxx:189
 TGeoMatrix.cxx:190
 TGeoMatrix.cxx:191
 TGeoMatrix.cxx:192
 TGeoMatrix.cxx:193
 TGeoMatrix.cxx:194
 TGeoMatrix.cxx:195
 TGeoMatrix.cxx:196
 TGeoMatrix.cxx:197
 TGeoMatrix.cxx:198
 TGeoMatrix.cxx:199
 TGeoMatrix.cxx:200
 TGeoMatrix.cxx:201
 TGeoMatrix.cxx:202
 TGeoMatrix.cxx:203
 TGeoMatrix.cxx:204
 TGeoMatrix.cxx:205
 TGeoMatrix.cxx:206
 TGeoMatrix.cxx:207
 TGeoMatrix.cxx:208
 TGeoMatrix.cxx:209
 TGeoMatrix.cxx:210
 TGeoMatrix.cxx:211
 TGeoMatrix.cxx:212
 TGeoMatrix.cxx:213
 TGeoMatrix.cxx:214
 TGeoMatrix.cxx:215
 TGeoMatrix.cxx:216
 TGeoMatrix.cxx:217
 TGeoMatrix.cxx:218
 TGeoMatrix.cxx:219
 TGeoMatrix.cxx:220
 TGeoMatrix.cxx:221
 TGeoMatrix.cxx:222
 TGeoMatrix.cxx:223
 TGeoMatrix.cxx:224
 TGeoMatrix.cxx:225
 TGeoMatrix.cxx:226
 TGeoMatrix.cxx:227
 TGeoMatrix.cxx:228
 TGeoMatrix.cxx:229
 TGeoMatrix.cxx:230
 TGeoMatrix.cxx:231
 TGeoMatrix.cxx:232
 TGeoMatrix.cxx:233
 TGeoMatrix.cxx:234
 TGeoMatrix.cxx:235
 TGeoMatrix.cxx:236
 TGeoMatrix.cxx:237
 TGeoMatrix.cxx:238
 TGeoMatrix.cxx:239
 TGeoMatrix.cxx:240
 TGeoMatrix.cxx:241
 TGeoMatrix.cxx:242
 TGeoMatrix.cxx:243
 TGeoMatrix.cxx:244
 TGeoMatrix.cxx:245
 TGeoMatrix.cxx:246
 TGeoMatrix.cxx:247
 TGeoMatrix.cxx:248
 TGeoMatrix.cxx:249
 TGeoMatrix.cxx:250
 TGeoMatrix.cxx:251
 TGeoMatrix.cxx:252
 TGeoMatrix.cxx:253
 TGeoMatrix.cxx:254
 TGeoMatrix.cxx:255
 TGeoMatrix.cxx:256
 TGeoMatrix.cxx:257
 TGeoMatrix.cxx:258
 TGeoMatrix.cxx:259
 TGeoMatrix.cxx:260
 TGeoMatrix.cxx:261
 TGeoMatrix.cxx:262
 TGeoMatrix.cxx:263
 TGeoMatrix.cxx:264
 TGeoMatrix.cxx:265
 TGeoMatrix.cxx:266
 TGeoMatrix.cxx:267
 TGeoMatrix.cxx:268
 TGeoMatrix.cxx:269
 TGeoMatrix.cxx:270
 TGeoMatrix.cxx:271
 TGeoMatrix.cxx:272
 TGeoMatrix.cxx:273
 TGeoMatrix.cxx:274
 TGeoMatrix.cxx:275
 TGeoMatrix.cxx:276
 TGeoMatrix.cxx:277
 TGeoMatrix.cxx:278
 TGeoMatrix.cxx:279
 TGeoMatrix.cxx:280
 TGeoMatrix.cxx:281
 TGeoMatrix.cxx:282
 TGeoMatrix.cxx:283
 TGeoMatrix.cxx:284
 TGeoMatrix.cxx:285
 TGeoMatrix.cxx:286
 TGeoMatrix.cxx:287
 TGeoMatrix.cxx:288
 TGeoMatrix.cxx:289
 TGeoMatrix.cxx:290
 TGeoMatrix.cxx:291
 TGeoMatrix.cxx:292
 TGeoMatrix.cxx:293
 TGeoMatrix.cxx:294
 TGeoMatrix.cxx:295
 TGeoMatrix.cxx:296
 TGeoMatrix.cxx:297
 TGeoMatrix.cxx:298
 TGeoMatrix.cxx:299
 TGeoMatrix.cxx:300
 TGeoMatrix.cxx:301
 TGeoMatrix.cxx:302
 TGeoMatrix.cxx:303
 TGeoMatrix.cxx:304
 TGeoMatrix.cxx:305
 TGeoMatrix.cxx:306
 TGeoMatrix.cxx:307
 TGeoMatrix.cxx:308
 TGeoMatrix.cxx:309
 TGeoMatrix.cxx:310
 TGeoMatrix.cxx:311
 TGeoMatrix.cxx:312
 TGeoMatrix.cxx:313
 TGeoMatrix.cxx:314
 TGeoMatrix.cxx:315
 TGeoMatrix.cxx:316
 TGeoMatrix.cxx:317
 TGeoMatrix.cxx:318
 TGeoMatrix.cxx:319
 TGeoMatrix.cxx:320
 TGeoMatrix.cxx:321
 TGeoMatrix.cxx:322
 TGeoMatrix.cxx:323
 TGeoMatrix.cxx:324
 TGeoMatrix.cxx:325
 TGeoMatrix.cxx:326
 TGeoMatrix.cxx:327
 TGeoMatrix.cxx:328
 TGeoMatrix.cxx:329
 TGeoMatrix.cxx:330
 TGeoMatrix.cxx:331
 TGeoMatrix.cxx:332
 TGeoMatrix.cxx:333
 TGeoMatrix.cxx:334
 TGeoMatrix.cxx:335
 TGeoMatrix.cxx:336
 TGeoMatrix.cxx:337
 TGeoMatrix.cxx:338
 TGeoMatrix.cxx:339
 TGeoMatrix.cxx:340
 TGeoMatrix.cxx:341
 TGeoMatrix.cxx:342
 TGeoMatrix.cxx:343
 TGeoMatrix.cxx:344
 TGeoMatrix.cxx:345
 TGeoMatrix.cxx:346
 TGeoMatrix.cxx:347
 TGeoMatrix.cxx:348
 TGeoMatrix.cxx:349
 TGeoMatrix.cxx:350
 TGeoMatrix.cxx:351
 TGeoMatrix.cxx:352
 TGeoMatrix.cxx:353
 TGeoMatrix.cxx:354
 TGeoMatrix.cxx:355
 TGeoMatrix.cxx:356
 TGeoMatrix.cxx:357
 TGeoMatrix.cxx:358
 TGeoMatrix.cxx:359
 TGeoMatrix.cxx:360
 TGeoMatrix.cxx:361
 TGeoMatrix.cxx:362
 TGeoMatrix.cxx:363
 TGeoMatrix.cxx:364
 TGeoMatrix.cxx:365
 TGeoMatrix.cxx:366
 TGeoMatrix.cxx:367
 TGeoMatrix.cxx:368
 TGeoMatrix.cxx:369
 TGeoMatrix.cxx:370
 TGeoMatrix.cxx:371
 TGeoMatrix.cxx:372
 TGeoMatrix.cxx:373
 TGeoMatrix.cxx:374
 TGeoMatrix.cxx:375
 TGeoMatrix.cxx:376
 TGeoMatrix.cxx:377
 TGeoMatrix.cxx:378
 TGeoMatrix.cxx:379
 TGeoMatrix.cxx:380
 TGeoMatrix.cxx:381
 TGeoMatrix.cxx:382
 TGeoMatrix.cxx:383
 TGeoMatrix.cxx:384
 TGeoMatrix.cxx:385
 TGeoMatrix.cxx:386
 TGeoMatrix.cxx:387
 TGeoMatrix.cxx:388
 TGeoMatrix.cxx:389
 TGeoMatrix.cxx:390
 TGeoMatrix.cxx:391
 TGeoMatrix.cxx:392
 TGeoMatrix.cxx:393
 TGeoMatrix.cxx:394
 TGeoMatrix.cxx:395
 TGeoMatrix.cxx:396
 TGeoMatrix.cxx:397
 TGeoMatrix.cxx:398
 TGeoMatrix.cxx:399
 TGeoMatrix.cxx:400
 TGeoMatrix.cxx:401
 TGeoMatrix.cxx:402
 TGeoMatrix.cxx:403
 TGeoMatrix.cxx:404
 TGeoMatrix.cxx:405
 TGeoMatrix.cxx:406
 TGeoMatrix.cxx:407
 TGeoMatrix.cxx:408
 TGeoMatrix.cxx:409
 TGeoMatrix.cxx:410
 TGeoMatrix.cxx:411
 TGeoMatrix.cxx:412
 TGeoMatrix.cxx:413
 TGeoMatrix.cxx:414
 TGeoMatrix.cxx:415
 TGeoMatrix.cxx:416
 TGeoMatrix.cxx:417
 TGeoMatrix.cxx:418
 TGeoMatrix.cxx:419
 TGeoMatrix.cxx:420
 TGeoMatrix.cxx:421
 TGeoMatrix.cxx:422
 TGeoMatrix.cxx:423
 TGeoMatrix.cxx:424
 TGeoMatrix.cxx:425
 TGeoMatrix.cxx:426
 TGeoMatrix.cxx:427
 TGeoMatrix.cxx:428
 TGeoMatrix.cxx:429
 TGeoMatrix.cxx:430
 TGeoMatrix.cxx:431
 TGeoMatrix.cxx:432
 TGeoMatrix.cxx:433
 TGeoMatrix.cxx:434
 TGeoMatrix.cxx:435
 TGeoMatrix.cxx:436
 TGeoMatrix.cxx:437
 TGeoMatrix.cxx:438
 TGeoMatrix.cxx:439
 TGeoMatrix.cxx:440
 TGeoMatrix.cxx:441
 TGeoMatrix.cxx:442
 TGeoMatrix.cxx:443
 TGeoMatrix.cxx:444
 TGeoMatrix.cxx:445
 TGeoMatrix.cxx:446
 TGeoMatrix.cxx:447
 TGeoMatrix.cxx:448
 TGeoMatrix.cxx:449
 TGeoMatrix.cxx:450
 TGeoMatrix.cxx:451
 TGeoMatrix.cxx:452
 TGeoMatrix.cxx:453
 TGeoMatrix.cxx:454
 TGeoMatrix.cxx:455
 TGeoMatrix.cxx:456
 TGeoMatrix.cxx:457
 TGeoMatrix.cxx:458
 TGeoMatrix.cxx:459
 TGeoMatrix.cxx:460
 TGeoMatrix.cxx:461
 TGeoMatrix.cxx:462
 TGeoMatrix.cxx:463
 TGeoMatrix.cxx:464
 TGeoMatrix.cxx:465
 TGeoMatrix.cxx:466
 TGeoMatrix.cxx:467
 TGeoMatrix.cxx:468
 TGeoMatrix.cxx:469
 TGeoMatrix.cxx:470
 TGeoMatrix.cxx:471
 TGeoMatrix.cxx:472
 TGeoMatrix.cxx:473
 TGeoMatrix.cxx:474
 TGeoMatrix.cxx:475
 TGeoMatrix.cxx:476
 TGeoMatrix.cxx:477
 TGeoMatrix.cxx:478
 TGeoMatrix.cxx:479
 TGeoMatrix.cxx:480
 TGeoMatrix.cxx:481
 TGeoMatrix.cxx:482
 TGeoMatrix.cxx:483
 TGeoMatrix.cxx:484
 TGeoMatrix.cxx:485
 TGeoMatrix.cxx:486
 TGeoMatrix.cxx:487
 TGeoMatrix.cxx:488
 TGeoMatrix.cxx:489
 TGeoMatrix.cxx:490
 TGeoMatrix.cxx:491
 TGeoMatrix.cxx:492
 TGeoMatrix.cxx:493
 TGeoMatrix.cxx:494
 TGeoMatrix.cxx:495
 TGeoMatrix.cxx:496
 TGeoMatrix.cxx:497
 TGeoMatrix.cxx:498
 TGeoMatrix.cxx:499
 TGeoMatrix.cxx:500
 TGeoMatrix.cxx:501
 TGeoMatrix.cxx:502
 TGeoMatrix.cxx:503
 TGeoMatrix.cxx:504
 TGeoMatrix.cxx:505
 TGeoMatrix.cxx:506
 TGeoMatrix.cxx:507
 TGeoMatrix.cxx:508
 TGeoMatrix.cxx:509
 TGeoMatrix.cxx:510
 TGeoMatrix.cxx:511
 TGeoMatrix.cxx:512
 TGeoMatrix.cxx:513
 TGeoMatrix.cxx:514
 TGeoMatrix.cxx:515
 TGeoMatrix.cxx:516
 TGeoMatrix.cxx:517
 TGeoMatrix.cxx:518
 TGeoMatrix.cxx:519
 TGeoMatrix.cxx:520
 TGeoMatrix.cxx:521
 TGeoMatrix.cxx:522
 TGeoMatrix.cxx:523
 TGeoMatrix.cxx:524
 TGeoMatrix.cxx:525
 TGeoMatrix.cxx:526
 TGeoMatrix.cxx:527
 TGeoMatrix.cxx:528
 TGeoMatrix.cxx:529
 TGeoMatrix.cxx:530
 TGeoMatrix.cxx:531
 TGeoMatrix.cxx:532
 TGeoMatrix.cxx:533
 TGeoMatrix.cxx:534
 TGeoMatrix.cxx:535
 TGeoMatrix.cxx:536
 TGeoMatrix.cxx:537
 TGeoMatrix.cxx:538
 TGeoMatrix.cxx:539
 TGeoMatrix.cxx:540
 TGeoMatrix.cxx:541
 TGeoMatrix.cxx:542
 TGeoMatrix.cxx:543
 TGeoMatrix.cxx:544
 TGeoMatrix.cxx:545
 TGeoMatrix.cxx:546
 TGeoMatrix.cxx:547
 TGeoMatrix.cxx:548
 TGeoMatrix.cxx:549
 TGeoMatrix.cxx:550
 TGeoMatrix.cxx:551
 TGeoMatrix.cxx:552
 TGeoMatrix.cxx:553
 TGeoMatrix.cxx:554
 TGeoMatrix.cxx:555
 TGeoMatrix.cxx:556
 TGeoMatrix.cxx:557
 TGeoMatrix.cxx:558
 TGeoMatrix.cxx:559
 TGeoMatrix.cxx:560
 TGeoMatrix.cxx:561
 TGeoMatrix.cxx:562
 TGeoMatrix.cxx:563
 TGeoMatrix.cxx:564
 TGeoMatrix.cxx:565
 TGeoMatrix.cxx:566
 TGeoMatrix.cxx:567
 TGeoMatrix.cxx:568
 TGeoMatrix.cxx:569
 TGeoMatrix.cxx:570
 TGeoMatrix.cxx:571
 TGeoMatrix.cxx:572
 TGeoMatrix.cxx:573
 TGeoMatrix.cxx:574
 TGeoMatrix.cxx:575
 TGeoMatrix.cxx:576
 TGeoMatrix.cxx:577
 TGeoMatrix.cxx:578
 TGeoMatrix.cxx:579
 TGeoMatrix.cxx:580
 TGeoMatrix.cxx:581
 TGeoMatrix.cxx:582
 TGeoMatrix.cxx:583
 TGeoMatrix.cxx:584
 TGeoMatrix.cxx:585
 TGeoMatrix.cxx:586
 TGeoMatrix.cxx:587
 TGeoMatrix.cxx:588
 TGeoMatrix.cxx:589
 TGeoMatrix.cxx:590
 TGeoMatrix.cxx:591
 TGeoMatrix.cxx:592
 TGeoMatrix.cxx:593
 TGeoMatrix.cxx:594
 TGeoMatrix.cxx:595
 TGeoMatrix.cxx:596
 TGeoMatrix.cxx:597
 TGeoMatrix.cxx:598
 TGeoMatrix.cxx:599
 TGeoMatrix.cxx:600
 TGeoMatrix.cxx:601
 TGeoMatrix.cxx:602
 TGeoMatrix.cxx:603
 TGeoMatrix.cxx:604
 TGeoMatrix.cxx:605
 TGeoMatrix.cxx:606
 TGeoMatrix.cxx:607
 TGeoMatrix.cxx:608
 TGeoMatrix.cxx:609
 TGeoMatrix.cxx:610
 TGeoMatrix.cxx:611
 TGeoMatrix.cxx:612
 TGeoMatrix.cxx:613
 TGeoMatrix.cxx:614
 TGeoMatrix.cxx:615
 TGeoMatrix.cxx:616
 TGeoMatrix.cxx:617
 TGeoMatrix.cxx:618
 TGeoMatrix.cxx:619
 TGeoMatrix.cxx:620
 TGeoMatrix.cxx:621
 TGeoMatrix.cxx:622
 TGeoMatrix.cxx:623
 TGeoMatrix.cxx:624
 TGeoMatrix.cxx:625
 TGeoMatrix.cxx:626
 TGeoMatrix.cxx:627
 TGeoMatrix.cxx:628
 TGeoMatrix.cxx:629
 TGeoMatrix.cxx:630
 TGeoMatrix.cxx:631
 TGeoMatrix.cxx:632
 TGeoMatrix.cxx:633
 TGeoMatrix.cxx:634
 TGeoMatrix.cxx:635
 TGeoMatrix.cxx:636
 TGeoMatrix.cxx:637
 TGeoMatrix.cxx:638
 TGeoMatrix.cxx:639
 TGeoMatrix.cxx:640
 TGeoMatrix.cxx:641
 TGeoMatrix.cxx:642
 TGeoMatrix.cxx:643
 TGeoMatrix.cxx:644
 TGeoMatrix.cxx:645
 TGeoMatrix.cxx:646
 TGeoMatrix.cxx:647
 TGeoMatrix.cxx:648
 TGeoMatrix.cxx:649
 TGeoMatrix.cxx:650
 TGeoMatrix.cxx:651
 TGeoMatrix.cxx:652
 TGeoMatrix.cxx:653
 TGeoMatrix.cxx:654
 TGeoMatrix.cxx:655
 TGeoMatrix.cxx:656
 TGeoMatrix.cxx:657
 TGeoMatrix.cxx:658
 TGeoMatrix.cxx:659
 TGeoMatrix.cxx:660
 TGeoMatrix.cxx:661
 TGeoMatrix.cxx:662
 TGeoMatrix.cxx:663
 TGeoMatrix.cxx:664
 TGeoMatrix.cxx:665
 TGeoMatrix.cxx:666
 TGeoMatrix.cxx:667
 TGeoMatrix.cxx:668
 TGeoMatrix.cxx:669
 TGeoMatrix.cxx:670
 TGeoMatrix.cxx:671
 TGeoMatrix.cxx:672
 TGeoMatrix.cxx:673
 TGeoMatrix.cxx:674
 TGeoMatrix.cxx:675
 TGeoMatrix.cxx:676
 TGeoMatrix.cxx:677
 TGeoMatrix.cxx:678
 TGeoMatrix.cxx:679
 TGeoMatrix.cxx:680
 TGeoMatrix.cxx:681
 TGeoMatrix.cxx:682
 TGeoMatrix.cxx:683
 TGeoMatrix.cxx:684
 TGeoMatrix.cxx:685
 TGeoMatrix.cxx:686
 TGeoMatrix.cxx:687
 TGeoMatrix.cxx:688
 TGeoMatrix.cxx:689
 TGeoMatrix.cxx:690
 TGeoMatrix.cxx:691
 TGeoMatrix.cxx:692
 TGeoMatrix.cxx:693
 TGeoMatrix.cxx:694
 TGeoMatrix.cxx:695
 TGeoMatrix.cxx:696
 TGeoMatrix.cxx:697
 TGeoMatrix.cxx:698
 TGeoMatrix.cxx:699
 TGeoMatrix.cxx:700
 TGeoMatrix.cxx:701
 TGeoMatrix.cxx:702
 TGeoMatrix.cxx:703
 TGeoMatrix.cxx:704
 TGeoMatrix.cxx:705
 TGeoMatrix.cxx:706
 TGeoMatrix.cxx:707
 TGeoMatrix.cxx:708
 TGeoMatrix.cxx:709
 TGeoMatrix.cxx:710
 TGeoMatrix.cxx:711
 TGeoMatrix.cxx:712
 TGeoMatrix.cxx:713
 TGeoMatrix.cxx:714
 TGeoMatrix.cxx:715
 TGeoMatrix.cxx:716
 TGeoMatrix.cxx:717
 TGeoMatrix.cxx:718
 TGeoMatrix.cxx:719
 TGeoMatrix.cxx:720
 TGeoMatrix.cxx:721
 TGeoMatrix.cxx:722
 TGeoMatrix.cxx:723
 TGeoMatrix.cxx:724
 TGeoMatrix.cxx:725
 TGeoMatrix.cxx:726
 TGeoMatrix.cxx:727
 TGeoMatrix.cxx:728
 TGeoMatrix.cxx:729
 TGeoMatrix.cxx:730
 TGeoMatrix.cxx:731
 TGeoMatrix.cxx:732
 TGeoMatrix.cxx:733
 TGeoMatrix.cxx:734
 TGeoMatrix.cxx:735
 TGeoMatrix.cxx:736
 TGeoMatrix.cxx:737
 TGeoMatrix.cxx:738
 TGeoMatrix.cxx:739
 TGeoMatrix.cxx:740
 TGeoMatrix.cxx:741
 TGeoMatrix.cxx:742
 TGeoMatrix.cxx:743
 TGeoMatrix.cxx:744
 TGeoMatrix.cxx:745
 TGeoMatrix.cxx:746
 TGeoMatrix.cxx:747
 TGeoMatrix.cxx:748
 TGeoMatrix.cxx:749
 TGeoMatrix.cxx:750
 TGeoMatrix.cxx:751
 TGeoMatrix.cxx:752
 TGeoMatrix.cxx:753
 TGeoMatrix.cxx:754
 TGeoMatrix.cxx:755
 TGeoMatrix.cxx:756
 TGeoMatrix.cxx:757
 TGeoMatrix.cxx:758
 TGeoMatrix.cxx:759
 TGeoMatrix.cxx:760
 TGeoMatrix.cxx:761
 TGeoMatrix.cxx:762
 TGeoMatrix.cxx:763
 TGeoMatrix.cxx:764
 TGeoMatrix.cxx:765
 TGeoMatrix.cxx:766
 TGeoMatrix.cxx:767
 TGeoMatrix.cxx:768
 TGeoMatrix.cxx:769
 TGeoMatrix.cxx:770
 TGeoMatrix.cxx:771
 TGeoMatrix.cxx:772
 TGeoMatrix.cxx:773
 TGeoMatrix.cxx:774
 TGeoMatrix.cxx:775
 TGeoMatrix.cxx:776
 TGeoMatrix.cxx:777
 TGeoMatrix.cxx:778
 TGeoMatrix.cxx:779
 TGeoMatrix.cxx:780
 TGeoMatrix.cxx:781
 TGeoMatrix.cxx:782
 TGeoMatrix.cxx:783
 TGeoMatrix.cxx:784
 TGeoMatrix.cxx:785
 TGeoMatrix.cxx:786
 TGeoMatrix.cxx:787
 TGeoMatrix.cxx:788
 TGeoMatrix.cxx:789
 TGeoMatrix.cxx:790
 TGeoMatrix.cxx:791
 TGeoMatrix.cxx:792
 TGeoMatrix.cxx:793
 TGeoMatrix.cxx:794
 TGeoMatrix.cxx:795
 TGeoMatrix.cxx:796
 TGeoMatrix.cxx:797
 TGeoMatrix.cxx:798
 TGeoMatrix.cxx:799
 TGeoMatrix.cxx:800
 TGeoMatrix.cxx:801
 TGeoMatrix.cxx:802
 TGeoMatrix.cxx:803
 TGeoMatrix.cxx:804
 TGeoMatrix.cxx:805
 TGeoMatrix.cxx:806
 TGeoMatrix.cxx:807
 TGeoMatrix.cxx:808
 TGeoMatrix.cxx:809
 TGeoMatrix.cxx:810
 TGeoMatrix.cxx:811
 TGeoMatrix.cxx:812
 TGeoMatrix.cxx:813
 TGeoMatrix.cxx:814
 TGeoMatrix.cxx:815
 TGeoMatrix.cxx:816
 TGeoMatrix.cxx:817
 TGeoMatrix.cxx:818
 TGeoMatrix.cxx:819
 TGeoMatrix.cxx:820
 TGeoMatrix.cxx:821
 TGeoMatrix.cxx:822
 TGeoMatrix.cxx:823
 TGeoMatrix.cxx:824
 TGeoMatrix.cxx:825
 TGeoMatrix.cxx:826
 TGeoMatrix.cxx:827
 TGeoMatrix.cxx:828
 TGeoMatrix.cxx:829
 TGeoMatrix.cxx:830
 TGeoMatrix.cxx:831
 TGeoMatrix.cxx:832
 TGeoMatrix.cxx:833
 TGeoMatrix.cxx:834
 TGeoMatrix.cxx:835
 TGeoMatrix.cxx:836
 TGeoMatrix.cxx:837
 TGeoMatrix.cxx:838
 TGeoMatrix.cxx:839
 TGeoMatrix.cxx:840
 TGeoMatrix.cxx:841
 TGeoMatrix.cxx:842
 TGeoMatrix.cxx:843
 TGeoMatrix.cxx:844
 TGeoMatrix.cxx:845
 TGeoMatrix.cxx:846
 TGeoMatrix.cxx:847
 TGeoMatrix.cxx:848
 TGeoMatrix.cxx:849
 TGeoMatrix.cxx:850
 TGeoMatrix.cxx:851
 TGeoMatrix.cxx:852
 TGeoMatrix.cxx:853
 TGeoMatrix.cxx:854
 TGeoMatrix.cxx:855
 TGeoMatrix.cxx:856
 TGeoMatrix.cxx:857
 TGeoMatrix.cxx:858
 TGeoMatrix.cxx:859
 TGeoMatrix.cxx:860
 TGeoMatrix.cxx:861
 TGeoMatrix.cxx:862
 TGeoMatrix.cxx:863
 TGeoMatrix.cxx:864
 TGeoMatrix.cxx:865
 TGeoMatrix.cxx:866
 TGeoMatrix.cxx:867
 TGeoMatrix.cxx:868
 TGeoMatrix.cxx:869
 TGeoMatrix.cxx:870
 TGeoMatrix.cxx:871
 TGeoMatrix.cxx:872
 TGeoMatrix.cxx:873
 TGeoMatrix.cxx:874
 TGeoMatrix.cxx:875
 TGeoMatrix.cxx:876
 TGeoMatrix.cxx:877
 TGeoMatrix.cxx:878
 TGeoMatrix.cxx:879
 TGeoMatrix.cxx:880
 TGeoMatrix.cxx:881
 TGeoMatrix.cxx:882
 TGeoMatrix.cxx:883
 TGeoMatrix.cxx:884
 TGeoMatrix.cxx:885
 TGeoMatrix.cxx:886
 TGeoMatrix.cxx:887
 TGeoMatrix.cxx:888
 TGeoMatrix.cxx:889
 TGeoMatrix.cxx:890
 TGeoMatrix.cxx:891
 TGeoMatrix.cxx:892
 TGeoMatrix.cxx:893
 TGeoMatrix.cxx:894
 TGeoMatrix.cxx:895
 TGeoMatrix.cxx:896
 TGeoMatrix.cxx:897
 TGeoMatrix.cxx:898
 TGeoMatrix.cxx:899
 TGeoMatrix.cxx:900
 TGeoMatrix.cxx:901
 TGeoMatrix.cxx:902
 TGeoMatrix.cxx:903
 TGeoMatrix.cxx:904
 TGeoMatrix.cxx:905
 TGeoMatrix.cxx:906
 TGeoMatrix.cxx:907
 TGeoMatrix.cxx:908
 TGeoMatrix.cxx:909
 TGeoMatrix.cxx:910
 TGeoMatrix.cxx:911
 TGeoMatrix.cxx:912
 TGeoMatrix.cxx:913
 TGeoMatrix.cxx:914
 TGeoMatrix.cxx:915
 TGeoMatrix.cxx:916
 TGeoMatrix.cxx:917
 TGeoMatrix.cxx:918
 TGeoMatrix.cxx:919
 TGeoMatrix.cxx:920
 TGeoMatrix.cxx:921
 TGeoMatrix.cxx:922
 TGeoMatrix.cxx:923
 TGeoMatrix.cxx:924
 TGeoMatrix.cxx:925
 TGeoMatrix.cxx:926
 TGeoMatrix.cxx:927
 TGeoMatrix.cxx:928
 TGeoMatrix.cxx:929
 TGeoMatrix.cxx:930
 TGeoMatrix.cxx:931
 TGeoMatrix.cxx:932
 TGeoMatrix.cxx:933
 TGeoMatrix.cxx:934
 TGeoMatrix.cxx:935
 TGeoMatrix.cxx:936
 TGeoMatrix.cxx:937
 TGeoMatrix.cxx:938
 TGeoMatrix.cxx:939
 TGeoMatrix.cxx:940
 TGeoMatrix.cxx:941
 TGeoMatrix.cxx:942
 TGeoMatrix.cxx:943
 TGeoMatrix.cxx:944
 TGeoMatrix.cxx:945
 TGeoMatrix.cxx:946
 TGeoMatrix.cxx:947
 TGeoMatrix.cxx:948
 TGeoMatrix.cxx:949
 TGeoMatrix.cxx:950
 TGeoMatrix.cxx:951
 TGeoMatrix.cxx:952
 TGeoMatrix.cxx:953
 TGeoMatrix.cxx:954
 TGeoMatrix.cxx:955
 TGeoMatrix.cxx:956
 TGeoMatrix.cxx:957
 TGeoMatrix.cxx:958
 TGeoMatrix.cxx:959
 TGeoMatrix.cxx:960
 TGeoMatrix.cxx:961
 TGeoMatrix.cxx:962
 TGeoMatrix.cxx:963
 TGeoMatrix.cxx:964
 TGeoMatrix.cxx:965
 TGeoMatrix.cxx:966
 TGeoMatrix.cxx:967
 TGeoMatrix.cxx:968
 TGeoMatrix.cxx:969
 TGeoMatrix.cxx:970
 TGeoMatrix.cxx:971
 TGeoMatrix.cxx:972
 TGeoMatrix.cxx:973
 TGeoMatrix.cxx:974
 TGeoMatrix.cxx:975
 TGeoMatrix.cxx:976
 TGeoMatrix.cxx:977
 TGeoMatrix.cxx:978
 TGeoMatrix.cxx:979
 TGeoMatrix.cxx:980
 TGeoMatrix.cxx:981
 TGeoMatrix.cxx:982
 TGeoMatrix.cxx:983
 TGeoMatrix.cxx:984
 TGeoMatrix.cxx:985
 TGeoMatrix.cxx:986
 TGeoMatrix.cxx:987
 TGeoMatrix.cxx:988
 TGeoMatrix.cxx:989
 TGeoMatrix.cxx:990
 TGeoMatrix.cxx:991
 TGeoMatrix.cxx:992
 TGeoMatrix.cxx:993
 TGeoMatrix.cxx:994
 TGeoMatrix.cxx:995
 TGeoMatrix.cxx:996
 TGeoMatrix.cxx:997
 TGeoMatrix.cxx:998
 TGeoMatrix.cxx:999
 TGeoMatrix.cxx:1000
 TGeoMatrix.cxx:1001
 TGeoMatrix.cxx:1002
 TGeoMatrix.cxx:1003
 TGeoMatrix.cxx:1004
 TGeoMatrix.cxx:1005
 TGeoMatrix.cxx:1006
 TGeoMatrix.cxx:1007
 TGeoMatrix.cxx:1008
 TGeoMatrix.cxx:1009
 TGeoMatrix.cxx:1010
 TGeoMatrix.cxx:1011
 TGeoMatrix.cxx:1012
 TGeoMatrix.cxx:1013
 TGeoMatrix.cxx:1014
 TGeoMatrix.cxx:1015
 TGeoMatrix.cxx:1016
 TGeoMatrix.cxx:1017
 TGeoMatrix.cxx:1018
 TGeoMatrix.cxx:1019
 TGeoMatrix.cxx:1020
 TGeoMatrix.cxx:1021
 TGeoMatrix.cxx:1022
 TGeoMatrix.cxx:1023
 TGeoMatrix.cxx:1024
 TGeoMatrix.cxx:1025
 TGeoMatrix.cxx:1026
 TGeoMatrix.cxx:1027
 TGeoMatrix.cxx:1028
 TGeoMatrix.cxx:1029
 TGeoMatrix.cxx:1030
 TGeoMatrix.cxx:1031
 TGeoMatrix.cxx:1032
 TGeoMatrix.cxx:1033
 TGeoMatrix.cxx:1034
 TGeoMatrix.cxx:1035
 TGeoMatrix.cxx:1036
 TGeoMatrix.cxx:1037
 TGeoMatrix.cxx:1038
 TGeoMatrix.cxx:1039
 TGeoMatrix.cxx:1040
 TGeoMatrix.cxx:1041
 TGeoMatrix.cxx:1042
 TGeoMatrix.cxx:1043
 TGeoMatrix.cxx:1044
 TGeoMatrix.cxx:1045
 TGeoMatrix.cxx:1046
 TGeoMatrix.cxx:1047
 TGeoMatrix.cxx:1048
 TGeoMatrix.cxx:1049
 TGeoMatrix.cxx:1050
 TGeoMatrix.cxx:1051
 TGeoMatrix.cxx:1052
 TGeoMatrix.cxx:1053
 TGeoMatrix.cxx:1054
 TGeoMatrix.cxx:1055
 TGeoMatrix.cxx:1056
 TGeoMatrix.cxx:1057
 TGeoMatrix.cxx:1058
 TGeoMatrix.cxx:1059
 TGeoMatrix.cxx:1060
 TGeoMatrix.cxx:1061
 TGeoMatrix.cxx:1062
 TGeoMatrix.cxx:1063
 TGeoMatrix.cxx:1064
 TGeoMatrix.cxx:1065
 TGeoMatrix.cxx:1066
 TGeoMatrix.cxx:1067
 TGeoMatrix.cxx:1068
 TGeoMatrix.cxx:1069
 TGeoMatrix.cxx:1070
 TGeoMatrix.cxx:1071
 TGeoMatrix.cxx:1072
 TGeoMatrix.cxx:1073
 TGeoMatrix.cxx:1074
 TGeoMatrix.cxx:1075
 TGeoMatrix.cxx:1076
 TGeoMatrix.cxx:1077
 TGeoMatrix.cxx:1078
 TGeoMatrix.cxx:1079
 TGeoMatrix.cxx:1080
 TGeoMatrix.cxx:1081
 TGeoMatrix.cxx:1082
 TGeoMatrix.cxx:1083
 TGeoMatrix.cxx:1084
 TGeoMatrix.cxx:1085
 TGeoMatrix.cxx:1086
 TGeoMatrix.cxx:1087
 TGeoMatrix.cxx:1088
 TGeoMatrix.cxx:1089
 TGeoMatrix.cxx:1090
 TGeoMatrix.cxx:1091
 TGeoMatrix.cxx:1092
 TGeoMatrix.cxx:1093
 TGeoMatrix.cxx:1094
 TGeoMatrix.cxx:1095
 TGeoMatrix.cxx:1096
 TGeoMatrix.cxx:1097
 TGeoMatrix.cxx:1098
 TGeoMatrix.cxx:1099
 TGeoMatrix.cxx:1100
 TGeoMatrix.cxx:1101
 TGeoMatrix.cxx:1102
 TGeoMatrix.cxx:1103
 TGeoMatrix.cxx:1104
 TGeoMatrix.cxx:1105
 TGeoMatrix.cxx:1106
 TGeoMatrix.cxx:1107
 TGeoMatrix.cxx:1108
 TGeoMatrix.cxx:1109
 TGeoMatrix.cxx:1110
 TGeoMatrix.cxx:1111
 TGeoMatrix.cxx:1112
 TGeoMatrix.cxx:1113
 TGeoMatrix.cxx:1114
 TGeoMatrix.cxx:1115
 TGeoMatrix.cxx:1116
 TGeoMatrix.cxx:1117
 TGeoMatrix.cxx:1118
 TGeoMatrix.cxx:1119
 TGeoMatrix.cxx:1120
 TGeoMatrix.cxx:1121
 TGeoMatrix.cxx:1122
 TGeoMatrix.cxx:1123
 TGeoMatrix.cxx:1124
 TGeoMatrix.cxx:1125
 TGeoMatrix.cxx:1126
 TGeoMatrix.cxx:1127
 TGeoMatrix.cxx:1128
 TGeoMatrix.cxx:1129
 TGeoMatrix.cxx:1130
 TGeoMatrix.cxx:1131
 TGeoMatrix.cxx:1132
 TGeoMatrix.cxx:1133
 TGeoMatrix.cxx:1134
 TGeoMatrix.cxx:1135
 TGeoMatrix.cxx:1136
 TGeoMatrix.cxx:1137
 TGeoMatrix.cxx:1138
 TGeoMatrix.cxx:1139
 TGeoMatrix.cxx:1140
 TGeoMatrix.cxx:1141
 TGeoMatrix.cxx:1142
 TGeoMatrix.cxx:1143
 TGeoMatrix.cxx:1144
 TGeoMatrix.cxx:1145
 TGeoMatrix.cxx:1146
 TGeoMatrix.cxx:1147
 TGeoMatrix.cxx:1148
 TGeoMatrix.cxx:1149
 TGeoMatrix.cxx:1150
 TGeoMatrix.cxx:1151
 TGeoMatrix.cxx:1152
 TGeoMatrix.cxx:1153
 TGeoMatrix.cxx:1154
 TGeoMatrix.cxx:1155
 TGeoMatrix.cxx:1156
 TGeoMatrix.cxx:1157
 TGeoMatrix.cxx:1158
 TGeoMatrix.cxx:1159
 TGeoMatrix.cxx:1160
 TGeoMatrix.cxx:1161
 TGeoMatrix.cxx:1162
 TGeoMatrix.cxx:1163
 TGeoMatrix.cxx:1164
 TGeoMatrix.cxx:1165
 TGeoMatrix.cxx:1166
 TGeoMatrix.cxx:1167
 TGeoMatrix.cxx:1168
 TGeoMatrix.cxx:1169
 TGeoMatrix.cxx:1170
 TGeoMatrix.cxx:1171
 TGeoMatrix.cxx:1172
 TGeoMatrix.cxx:1173
 TGeoMatrix.cxx:1174
 TGeoMatrix.cxx:1175
 TGeoMatrix.cxx:1176
 TGeoMatrix.cxx:1177
 TGeoMatrix.cxx:1178
 TGeoMatrix.cxx:1179
 TGeoMatrix.cxx:1180
 TGeoMatrix.cxx:1181
 TGeoMatrix.cxx:1182
 TGeoMatrix.cxx:1183
 TGeoMatrix.cxx:1184
 TGeoMatrix.cxx:1185
 TGeoMatrix.cxx:1186
 TGeoMatrix.cxx:1187
 TGeoMatrix.cxx:1188
 TGeoMatrix.cxx:1189
 TGeoMatrix.cxx:1190
 TGeoMatrix.cxx:1191
 TGeoMatrix.cxx:1192
 TGeoMatrix.cxx:1193
 TGeoMatrix.cxx:1194
 TGeoMatrix.cxx:1195
 TGeoMatrix.cxx:1196
 TGeoMatrix.cxx:1197
 TGeoMatrix.cxx:1198
 TGeoMatrix.cxx:1199
 TGeoMatrix.cxx:1200
 TGeoMatrix.cxx:1201
 TGeoMatrix.cxx:1202
 TGeoMatrix.cxx:1203
 TGeoMatrix.cxx:1204
 TGeoMatrix.cxx:1205
 TGeoMatrix.cxx:1206
 TGeoMatrix.cxx:1207
 TGeoMatrix.cxx:1208
 TGeoMatrix.cxx:1209
 TGeoMatrix.cxx:1210
 TGeoMatrix.cxx:1211
 TGeoMatrix.cxx:1212
 TGeoMatrix.cxx:1213
 TGeoMatrix.cxx:1214
 TGeoMatrix.cxx:1215
 TGeoMatrix.cxx:1216
 TGeoMatrix.cxx:1217
 TGeoMatrix.cxx:1218
 TGeoMatrix.cxx:1219
 TGeoMatrix.cxx:1220
 TGeoMatrix.cxx:1221
 TGeoMatrix.cxx:1222
 TGeoMatrix.cxx:1223
 TGeoMatrix.cxx:1224
 TGeoMatrix.cxx:1225
 TGeoMatrix.cxx:1226
 TGeoMatrix.cxx:1227
 TGeoMatrix.cxx:1228
 TGeoMatrix.cxx:1229
 TGeoMatrix.cxx:1230
 TGeoMatrix.cxx:1231
 TGeoMatrix.cxx:1232
 TGeoMatrix.cxx:1233
 TGeoMatrix.cxx:1234
 TGeoMatrix.cxx:1235
 TGeoMatrix.cxx:1236
 TGeoMatrix.cxx:1237
 TGeoMatrix.cxx:1238
 TGeoMatrix.cxx:1239
 TGeoMatrix.cxx:1240
 TGeoMatrix.cxx:1241
 TGeoMatrix.cxx:1242
 TGeoMatrix.cxx:1243
 TGeoMatrix.cxx:1244
 TGeoMatrix.cxx:1245
 TGeoMatrix.cxx:1246
 TGeoMatrix.cxx:1247
 TGeoMatrix.cxx:1248
 TGeoMatrix.cxx:1249
 TGeoMatrix.cxx:1250
 TGeoMatrix.cxx:1251
 TGeoMatrix.cxx:1252
 TGeoMatrix.cxx:1253
 TGeoMatrix.cxx:1254
 TGeoMatrix.cxx:1255
 TGeoMatrix.cxx:1256
 TGeoMatrix.cxx:1257
 TGeoMatrix.cxx:1258
 TGeoMatrix.cxx:1259
 TGeoMatrix.cxx:1260
 TGeoMatrix.cxx:1261
 TGeoMatrix.cxx:1262
 TGeoMatrix.cxx:1263
 TGeoMatrix.cxx:1264
 TGeoMatrix.cxx:1265
 TGeoMatrix.cxx:1266
 TGeoMatrix.cxx:1267
 TGeoMatrix.cxx:1268
 TGeoMatrix.cxx:1269
 TGeoMatrix.cxx:1270
 TGeoMatrix.cxx:1271
 TGeoMatrix.cxx:1272
 TGeoMatrix.cxx:1273
 TGeoMatrix.cxx:1274
 TGeoMatrix.cxx:1275
 TGeoMatrix.cxx:1276
 TGeoMatrix.cxx:1277
 TGeoMatrix.cxx:1278
 TGeoMatrix.cxx:1279
 TGeoMatrix.cxx:1280
 TGeoMatrix.cxx:1281
 TGeoMatrix.cxx:1282
 TGeoMatrix.cxx:1283
 TGeoMatrix.cxx:1284
 TGeoMatrix.cxx:1285
 TGeoMatrix.cxx:1286
 TGeoMatrix.cxx:1287
 TGeoMatrix.cxx:1288
 TGeoMatrix.cxx:1289
 TGeoMatrix.cxx:1290
 TGeoMatrix.cxx:1291
 TGeoMatrix.cxx:1292
 TGeoMatrix.cxx:1293
 TGeoMatrix.cxx:1294
 TGeoMatrix.cxx:1295
 TGeoMatrix.cxx:1296
 TGeoMatrix.cxx:1297
 TGeoMatrix.cxx:1298
 TGeoMatrix.cxx:1299
 TGeoMatrix.cxx:1300
 TGeoMatrix.cxx:1301
 TGeoMatrix.cxx:1302
 TGeoMatrix.cxx:1303
 TGeoMatrix.cxx:1304
 TGeoMatrix.cxx:1305
 TGeoMatrix.cxx:1306
 TGeoMatrix.cxx:1307
 TGeoMatrix.cxx:1308
 TGeoMatrix.cxx:1309
 TGeoMatrix.cxx:1310
 TGeoMatrix.cxx:1311
 TGeoMatrix.cxx:1312
 TGeoMatrix.cxx:1313
 TGeoMatrix.cxx:1314
 TGeoMatrix.cxx:1315
 TGeoMatrix.cxx:1316
 TGeoMatrix.cxx:1317
 TGeoMatrix.cxx:1318
 TGeoMatrix.cxx:1319
 TGeoMatrix.cxx:1320
 TGeoMatrix.cxx:1321
 TGeoMatrix.cxx:1322
 TGeoMatrix.cxx:1323
 TGeoMatrix.cxx:1324
 TGeoMatrix.cxx:1325
 TGeoMatrix.cxx:1326
 TGeoMatrix.cxx:1327
 TGeoMatrix.cxx:1328
 TGeoMatrix.cxx:1329
 TGeoMatrix.cxx:1330
 TGeoMatrix.cxx:1331
 TGeoMatrix.cxx:1332
 TGeoMatrix.cxx:1333
 TGeoMatrix.cxx:1334
 TGeoMatrix.cxx:1335
 TGeoMatrix.cxx:1336
 TGeoMatrix.cxx:1337
 TGeoMatrix.cxx:1338
 TGeoMatrix.cxx:1339
 TGeoMatrix.cxx:1340
 TGeoMatrix.cxx:1341
 TGeoMatrix.cxx:1342
 TGeoMatrix.cxx:1343
 TGeoMatrix.cxx:1344
 TGeoMatrix.cxx:1345
 TGeoMatrix.cxx:1346
 TGeoMatrix.cxx:1347
 TGeoMatrix.cxx:1348
 TGeoMatrix.cxx:1349
 TGeoMatrix.cxx:1350
 TGeoMatrix.cxx:1351
 TGeoMatrix.cxx:1352
 TGeoMatrix.cxx:1353
 TGeoMatrix.cxx:1354
 TGeoMatrix.cxx:1355
 TGeoMatrix.cxx:1356
 TGeoMatrix.cxx:1357
 TGeoMatrix.cxx:1358
 TGeoMatrix.cxx:1359
 TGeoMatrix.cxx:1360
 TGeoMatrix.cxx:1361
 TGeoMatrix.cxx:1362
 TGeoMatrix.cxx:1363
 TGeoMatrix.cxx:1364
 TGeoMatrix.cxx:1365
 TGeoMatrix.cxx:1366
 TGeoMatrix.cxx:1367
 TGeoMatrix.cxx:1368
 TGeoMatrix.cxx:1369
 TGeoMatrix.cxx:1370
 TGeoMatrix.cxx:1371
 TGeoMatrix.cxx:1372
 TGeoMatrix.cxx:1373
 TGeoMatrix.cxx:1374
 TGeoMatrix.cxx:1375
 TGeoMatrix.cxx:1376
 TGeoMatrix.cxx:1377
 TGeoMatrix.cxx:1378
 TGeoMatrix.cxx:1379
 TGeoMatrix.cxx:1380
 TGeoMatrix.cxx:1381
 TGeoMatrix.cxx:1382
 TGeoMatrix.cxx:1383
 TGeoMatrix.cxx:1384
 TGeoMatrix.cxx:1385
 TGeoMatrix.cxx:1386
 TGeoMatrix.cxx:1387
 TGeoMatrix.cxx:1388
 TGeoMatrix.cxx:1389
 TGeoMatrix.cxx:1390
 TGeoMatrix.cxx:1391
 TGeoMatrix.cxx:1392
 TGeoMatrix.cxx:1393
 TGeoMatrix.cxx:1394
 TGeoMatrix.cxx:1395
 TGeoMatrix.cxx:1396
 TGeoMatrix.cxx:1397
 TGeoMatrix.cxx:1398
 TGeoMatrix.cxx:1399
 TGeoMatrix.cxx:1400
 TGeoMatrix.cxx:1401
 TGeoMatrix.cxx:1402
 TGeoMatrix.cxx:1403
 TGeoMatrix.cxx:1404
 TGeoMatrix.cxx:1405
 TGeoMatrix.cxx:1406
 TGeoMatrix.cxx:1407
 TGeoMatrix.cxx:1408
 TGeoMatrix.cxx:1409
 TGeoMatrix.cxx:1410
 TGeoMatrix.cxx:1411
 TGeoMatrix.cxx:1412
 TGeoMatrix.cxx:1413
 TGeoMatrix.cxx:1414
 TGeoMatrix.cxx:1415
 TGeoMatrix.cxx:1416
 TGeoMatrix.cxx:1417
 TGeoMatrix.cxx:1418
 TGeoMatrix.cxx:1419
 TGeoMatrix.cxx:1420
 TGeoMatrix.cxx:1421
 TGeoMatrix.cxx:1422
 TGeoMatrix.cxx:1423
 TGeoMatrix.cxx:1424
 TGeoMatrix.cxx:1425
 TGeoMatrix.cxx:1426
 TGeoMatrix.cxx:1427
 TGeoMatrix.cxx:1428
 TGeoMatrix.cxx:1429
 TGeoMatrix.cxx:1430
 TGeoMatrix.cxx:1431
 TGeoMatrix.cxx:1432
 TGeoMatrix.cxx:1433
 TGeoMatrix.cxx:1434
 TGeoMatrix.cxx:1435
 TGeoMatrix.cxx:1436
 TGeoMatrix.cxx:1437
 TGeoMatrix.cxx:1438
 TGeoMatrix.cxx:1439
 TGeoMatrix.cxx:1440
 TGeoMatrix.cxx:1441
 TGeoMatrix.cxx:1442
 TGeoMatrix.cxx:1443
 TGeoMatrix.cxx:1444
 TGeoMatrix.cxx:1445
 TGeoMatrix.cxx:1446
 TGeoMatrix.cxx:1447
 TGeoMatrix.cxx:1448
 TGeoMatrix.cxx:1449
 TGeoMatrix.cxx:1450
 TGeoMatrix.cxx:1451
 TGeoMatrix.cxx:1452
 TGeoMatrix.cxx:1453
 TGeoMatrix.cxx:1454
 TGeoMatrix.cxx:1455
 TGeoMatrix.cxx:1456
 TGeoMatrix.cxx:1457
 TGeoMatrix.cxx:1458
 TGeoMatrix.cxx:1459
 TGeoMatrix.cxx:1460
 TGeoMatrix.cxx:1461
 TGeoMatrix.cxx:1462
 TGeoMatrix.cxx:1463
 TGeoMatrix.cxx:1464
 TGeoMatrix.cxx:1465
 TGeoMatrix.cxx:1466
 TGeoMatrix.cxx:1467
 TGeoMatrix.cxx:1468
 TGeoMatrix.cxx:1469
 TGeoMatrix.cxx:1470
 TGeoMatrix.cxx:1471
 TGeoMatrix.cxx:1472
 TGeoMatrix.cxx:1473
 TGeoMatrix.cxx:1474
 TGeoMatrix.cxx:1475
 TGeoMatrix.cxx:1476
 TGeoMatrix.cxx:1477
 TGeoMatrix.cxx:1478
 TGeoMatrix.cxx:1479
 TGeoMatrix.cxx:1480
 TGeoMatrix.cxx:1481
 TGeoMatrix.cxx:1482
 TGeoMatrix.cxx:1483
 TGeoMatrix.cxx:1484
 TGeoMatrix.cxx:1485
 TGeoMatrix.cxx:1486
 TGeoMatrix.cxx:1487
 TGeoMatrix.cxx:1488
 TGeoMatrix.cxx:1489
 TGeoMatrix.cxx:1490
 TGeoMatrix.cxx:1491
 TGeoMatrix.cxx:1492
 TGeoMatrix.cxx:1493
 TGeoMatrix.cxx:1494
 TGeoMatrix.cxx:1495
 TGeoMatrix.cxx:1496
 TGeoMatrix.cxx:1497
 TGeoMatrix.cxx:1498
 TGeoMatrix.cxx:1499
 TGeoMatrix.cxx:1500
 TGeoMatrix.cxx:1501
 TGeoMatrix.cxx:1502
 TGeoMatrix.cxx:1503
 TGeoMatrix.cxx:1504
 TGeoMatrix.cxx:1505
 TGeoMatrix.cxx:1506
 TGeoMatrix.cxx:1507
 TGeoMatrix.cxx:1508
 TGeoMatrix.cxx:1509
 TGeoMatrix.cxx:1510
 TGeoMatrix.cxx:1511
 TGeoMatrix.cxx:1512
 TGeoMatrix.cxx:1513
 TGeoMatrix.cxx:1514
 TGeoMatrix.cxx:1515
 TGeoMatrix.cxx:1516
 TGeoMatrix.cxx:1517
 TGeoMatrix.cxx:1518
 TGeoMatrix.cxx:1519
 TGeoMatrix.cxx:1520
 TGeoMatrix.cxx:1521
 TGeoMatrix.cxx:1522
 TGeoMatrix.cxx:1523
 TGeoMatrix.cxx:1524
 TGeoMatrix.cxx:1525
 TGeoMatrix.cxx:1526
 TGeoMatrix.cxx:1527
 TGeoMatrix.cxx:1528
 TGeoMatrix.cxx:1529
 TGeoMatrix.cxx:1530
 TGeoMatrix.cxx:1531
 TGeoMatrix.cxx:1532
 TGeoMatrix.cxx:1533
 TGeoMatrix.cxx:1534
 TGeoMatrix.cxx:1535
 TGeoMatrix.cxx:1536
 TGeoMatrix.cxx:1537
 TGeoMatrix.cxx:1538
 TGeoMatrix.cxx:1539
 TGeoMatrix.cxx:1540
 TGeoMatrix.cxx:1541
 TGeoMatrix.cxx:1542
 TGeoMatrix.cxx:1543
 TGeoMatrix.cxx:1544
 TGeoMatrix.cxx:1545
 TGeoMatrix.cxx:1546
 TGeoMatrix.cxx:1547
 TGeoMatrix.cxx:1548
 TGeoMatrix.cxx:1549
 TGeoMatrix.cxx:1550
 TGeoMatrix.cxx:1551
 TGeoMatrix.cxx:1552
 TGeoMatrix.cxx:1553
 TGeoMatrix.cxx:1554
 TGeoMatrix.cxx:1555
 TGeoMatrix.cxx:1556
 TGeoMatrix.cxx:1557
 TGeoMatrix.cxx:1558
 TGeoMatrix.cxx:1559
 TGeoMatrix.cxx:1560
 TGeoMatrix.cxx:1561
 TGeoMatrix.cxx:1562
 TGeoMatrix.cxx:1563
 TGeoMatrix.cxx:1564
 TGeoMatrix.cxx:1565
 TGeoMatrix.cxx:1566
 TGeoMatrix.cxx:1567
 TGeoMatrix.cxx:1568
 TGeoMatrix.cxx:1569
 TGeoMatrix.cxx:1570
 TGeoMatrix.cxx:1571
 TGeoMatrix.cxx:1572
 TGeoMatrix.cxx:1573
 TGeoMatrix.cxx:1574
 TGeoMatrix.cxx:1575
 TGeoMatrix.cxx:1576
 TGeoMatrix.cxx:1577
 TGeoMatrix.cxx:1578
 TGeoMatrix.cxx:1579
 TGeoMatrix.cxx:1580
 TGeoMatrix.cxx:1581
 TGeoMatrix.cxx:1582
 TGeoMatrix.cxx:1583
 TGeoMatrix.cxx:1584
 TGeoMatrix.cxx:1585
 TGeoMatrix.cxx:1586
 TGeoMatrix.cxx:1587
 TGeoMatrix.cxx:1588
 TGeoMatrix.cxx:1589
 TGeoMatrix.cxx:1590
 TGeoMatrix.cxx:1591
 TGeoMatrix.cxx:1592
 TGeoMatrix.cxx:1593
 TGeoMatrix.cxx:1594
 TGeoMatrix.cxx:1595
 TGeoMatrix.cxx:1596
 TGeoMatrix.cxx:1597
 TGeoMatrix.cxx:1598
 TGeoMatrix.cxx:1599
 TGeoMatrix.cxx:1600
 TGeoMatrix.cxx:1601
 TGeoMatrix.cxx:1602
 TGeoMatrix.cxx:1603
 TGeoMatrix.cxx:1604
 TGeoMatrix.cxx:1605
 TGeoMatrix.cxx:1606
 TGeoMatrix.cxx:1607
 TGeoMatrix.cxx:1608
 TGeoMatrix.cxx:1609
 TGeoMatrix.cxx:1610
 TGeoMatrix.cxx:1611
 TGeoMatrix.cxx:1612
 TGeoMatrix.cxx:1613
 TGeoMatrix.cxx:1614
 TGeoMatrix.cxx:1615
 TGeoMatrix.cxx:1616
 TGeoMatrix.cxx:1617
 TGeoMatrix.cxx:1618
 TGeoMatrix.cxx:1619
 TGeoMatrix.cxx:1620
 TGeoMatrix.cxx:1621
 TGeoMatrix.cxx:1622
 TGeoMatrix.cxx:1623
 TGeoMatrix.cxx:1624
 TGeoMatrix.cxx:1625
 TGeoMatrix.cxx:1626
 TGeoMatrix.cxx:1627
 TGeoMatrix.cxx:1628
 TGeoMatrix.cxx:1629
 TGeoMatrix.cxx:1630
 TGeoMatrix.cxx:1631
 TGeoMatrix.cxx:1632
 TGeoMatrix.cxx:1633
 TGeoMatrix.cxx:1634
 TGeoMatrix.cxx:1635
 TGeoMatrix.cxx:1636
 TGeoMatrix.cxx:1637
 TGeoMatrix.cxx:1638
 TGeoMatrix.cxx:1639
 TGeoMatrix.cxx:1640
 TGeoMatrix.cxx:1641
 TGeoMatrix.cxx:1642
 TGeoMatrix.cxx:1643
 TGeoMatrix.cxx:1644
 TGeoMatrix.cxx:1645
 TGeoMatrix.cxx:1646
 TGeoMatrix.cxx:1647
 TGeoMatrix.cxx:1648
 TGeoMatrix.cxx:1649
 TGeoMatrix.cxx:1650
 TGeoMatrix.cxx:1651
 TGeoMatrix.cxx:1652
 TGeoMatrix.cxx:1653
 TGeoMatrix.cxx:1654
 TGeoMatrix.cxx:1655
 TGeoMatrix.cxx:1656
 TGeoMatrix.cxx:1657
 TGeoMatrix.cxx:1658
 TGeoMatrix.cxx:1659
 TGeoMatrix.cxx:1660
 TGeoMatrix.cxx:1661
 TGeoMatrix.cxx:1662
 TGeoMatrix.cxx:1663
 TGeoMatrix.cxx:1664
 TGeoMatrix.cxx:1665
 TGeoMatrix.cxx:1666
 TGeoMatrix.cxx:1667
 TGeoMatrix.cxx:1668
 TGeoMatrix.cxx:1669
 TGeoMatrix.cxx:1670
 TGeoMatrix.cxx:1671
 TGeoMatrix.cxx:1672
 TGeoMatrix.cxx:1673
 TGeoMatrix.cxx:1674
 TGeoMatrix.cxx:1675
 TGeoMatrix.cxx:1676
 TGeoMatrix.cxx:1677
 TGeoMatrix.cxx:1678
 TGeoMatrix.cxx:1679
 TGeoMatrix.cxx:1680
 TGeoMatrix.cxx:1681
 TGeoMatrix.cxx:1682
 TGeoMatrix.cxx:1683
 TGeoMatrix.cxx:1684
 TGeoMatrix.cxx:1685
 TGeoMatrix.cxx:1686
 TGeoMatrix.cxx:1687
 TGeoMatrix.cxx:1688
 TGeoMatrix.cxx:1689
 TGeoMatrix.cxx:1690
 TGeoMatrix.cxx:1691
 TGeoMatrix.cxx:1692
 TGeoMatrix.cxx:1693
 TGeoMatrix.cxx:1694
 TGeoMatrix.cxx:1695
 TGeoMatrix.cxx:1696
 TGeoMatrix.cxx:1697
 TGeoMatrix.cxx:1698
 TGeoMatrix.cxx:1699
 TGeoMatrix.cxx:1700
 TGeoMatrix.cxx:1701
 TGeoMatrix.cxx:1702
 TGeoMatrix.cxx:1703
 TGeoMatrix.cxx:1704
 TGeoMatrix.cxx:1705
 TGeoMatrix.cxx:1706
 TGeoMatrix.cxx:1707
 TGeoMatrix.cxx:1708
 TGeoMatrix.cxx:1709
 TGeoMatrix.cxx:1710
 TGeoMatrix.cxx:1711
 TGeoMatrix.cxx:1712
 TGeoMatrix.cxx:1713
 TGeoMatrix.cxx:1714
 TGeoMatrix.cxx:1715
 TGeoMatrix.cxx:1716
 TGeoMatrix.cxx:1717
 TGeoMatrix.cxx:1718
 TGeoMatrix.cxx:1719
 TGeoMatrix.cxx:1720
 TGeoMatrix.cxx:1721
 TGeoMatrix.cxx:1722
 TGeoMatrix.cxx:1723
 TGeoMatrix.cxx:1724
 TGeoMatrix.cxx:1725
 TGeoMatrix.cxx:1726
 TGeoMatrix.cxx:1727
 TGeoMatrix.cxx:1728
 TGeoMatrix.cxx:1729
 TGeoMatrix.cxx:1730
 TGeoMatrix.cxx:1731
 TGeoMatrix.cxx:1732
 TGeoMatrix.cxx:1733
 TGeoMatrix.cxx:1734
 TGeoMatrix.cxx:1735
 TGeoMatrix.cxx:1736
 TGeoMatrix.cxx:1737
 TGeoMatrix.cxx:1738
 TGeoMatrix.cxx:1739
 TGeoMatrix.cxx:1740
 TGeoMatrix.cxx:1741
 TGeoMatrix.cxx:1742
 TGeoMatrix.cxx:1743
 TGeoMatrix.cxx:1744
 TGeoMatrix.cxx:1745
 TGeoMatrix.cxx:1746
 TGeoMatrix.cxx:1747
 TGeoMatrix.cxx:1748
 TGeoMatrix.cxx:1749
 TGeoMatrix.cxx:1750
 TGeoMatrix.cxx:1751
 TGeoMatrix.cxx:1752
 TGeoMatrix.cxx:1753
 TGeoMatrix.cxx:1754
 TGeoMatrix.cxx:1755
 TGeoMatrix.cxx:1756
 TGeoMatrix.cxx:1757
 TGeoMatrix.cxx:1758
 TGeoMatrix.cxx:1759
 TGeoMatrix.cxx:1760
 TGeoMatrix.cxx:1761
 TGeoMatrix.cxx:1762
 TGeoMatrix.cxx:1763
 TGeoMatrix.cxx:1764
 TGeoMatrix.cxx:1765
 TGeoMatrix.cxx:1766
 TGeoMatrix.cxx:1767
 TGeoMatrix.cxx:1768
 TGeoMatrix.cxx:1769
 TGeoMatrix.cxx:1770
 TGeoMatrix.cxx:1771
 TGeoMatrix.cxx:1772
 TGeoMatrix.cxx:1773
 TGeoMatrix.cxx:1774
 TGeoMatrix.cxx:1775
 TGeoMatrix.cxx:1776
 TGeoMatrix.cxx:1777
 TGeoMatrix.cxx:1778
 TGeoMatrix.cxx:1779
 TGeoMatrix.cxx:1780
 TGeoMatrix.cxx:1781
 TGeoMatrix.cxx:1782
 TGeoMatrix.cxx:1783
 TGeoMatrix.cxx:1784
 TGeoMatrix.cxx:1785
 TGeoMatrix.cxx:1786
 TGeoMatrix.cxx:1787
 TGeoMatrix.cxx:1788
 TGeoMatrix.cxx:1789
 TGeoMatrix.cxx:1790
 TGeoMatrix.cxx:1791
 TGeoMatrix.cxx:1792
 TGeoMatrix.cxx:1793
 TGeoMatrix.cxx:1794
 TGeoMatrix.cxx:1795
 TGeoMatrix.cxx:1796
 TGeoMatrix.cxx:1797
 TGeoMatrix.cxx:1798
 TGeoMatrix.cxx:1799
 TGeoMatrix.cxx:1800
 TGeoMatrix.cxx:1801
 TGeoMatrix.cxx:1802
 TGeoMatrix.cxx:1803
 TGeoMatrix.cxx:1804
 TGeoMatrix.cxx:1805
 TGeoMatrix.cxx:1806
 TGeoMatrix.cxx:1807
 TGeoMatrix.cxx:1808
 TGeoMatrix.cxx:1809
 TGeoMatrix.cxx:1810
 TGeoMatrix.cxx:1811
 TGeoMatrix.cxx:1812
 TGeoMatrix.cxx:1813
 TGeoMatrix.cxx:1814
 TGeoMatrix.cxx:1815
 TGeoMatrix.cxx:1816
 TGeoMatrix.cxx:1817
 TGeoMatrix.cxx:1818
 TGeoMatrix.cxx:1819
 TGeoMatrix.cxx:1820
 TGeoMatrix.cxx:1821
 TGeoMatrix.cxx:1822
 TGeoMatrix.cxx:1823
 TGeoMatrix.cxx:1824
 TGeoMatrix.cxx:1825
 TGeoMatrix.cxx:1826
 TGeoMatrix.cxx:1827
 TGeoMatrix.cxx:1828
 TGeoMatrix.cxx:1829
 TGeoMatrix.cxx:1830
 TGeoMatrix.cxx:1831
 TGeoMatrix.cxx:1832
 TGeoMatrix.cxx:1833
 TGeoMatrix.cxx:1834
 TGeoMatrix.cxx:1835
 TGeoMatrix.cxx:1836
 TGeoMatrix.cxx:1837
 TGeoMatrix.cxx:1838
 TGeoMatrix.cxx:1839
 TGeoMatrix.cxx:1840
 TGeoMatrix.cxx:1841
 TGeoMatrix.cxx:1842
 TGeoMatrix.cxx:1843
 TGeoMatrix.cxx:1844
 TGeoMatrix.cxx:1845
 TGeoMatrix.cxx:1846
 TGeoMatrix.cxx:1847
 TGeoMatrix.cxx:1848
 TGeoMatrix.cxx:1849
 TGeoMatrix.cxx:1850
 TGeoMatrix.cxx:1851
 TGeoMatrix.cxx:1852
 TGeoMatrix.cxx:1853
 TGeoMatrix.cxx:1854
 TGeoMatrix.cxx:1855
 TGeoMatrix.cxx:1856
 TGeoMatrix.cxx:1857
 TGeoMatrix.cxx:1858
 TGeoMatrix.cxx:1859
 TGeoMatrix.cxx:1860
 TGeoMatrix.cxx:1861
 TGeoMatrix.cxx:1862
 TGeoMatrix.cxx:1863
 TGeoMatrix.cxx:1864
 TGeoMatrix.cxx:1865
 TGeoMatrix.cxx:1866
 TGeoMatrix.cxx:1867
 TGeoMatrix.cxx:1868
 TGeoMatrix.cxx:1869
 TGeoMatrix.cxx:1870
 TGeoMatrix.cxx:1871
 TGeoMatrix.cxx:1872
 TGeoMatrix.cxx:1873
 TGeoMatrix.cxx:1874
 TGeoMatrix.cxx:1875
 TGeoMatrix.cxx:1876
 TGeoMatrix.cxx:1877
 TGeoMatrix.cxx:1878
 TGeoMatrix.cxx:1879
 TGeoMatrix.cxx:1880
 TGeoMatrix.cxx:1881
 TGeoMatrix.cxx:1882
 TGeoMatrix.cxx:1883
 TGeoMatrix.cxx:1884
 TGeoMatrix.cxx:1885
 TGeoMatrix.cxx:1886
 TGeoMatrix.cxx:1887
 TGeoMatrix.cxx:1888
 TGeoMatrix.cxx:1889
 TGeoMatrix.cxx:1890
 TGeoMatrix.cxx:1891
 TGeoMatrix.cxx:1892
 TGeoMatrix.cxx:1893
 TGeoMatrix.cxx:1894
 TGeoMatrix.cxx:1895
 TGeoMatrix.cxx:1896
 TGeoMatrix.cxx:1897
 TGeoMatrix.cxx:1898
 TGeoMatrix.cxx:1899
 TGeoMatrix.cxx:1900
 TGeoMatrix.cxx:1901
 TGeoMatrix.cxx:1902
 TGeoMatrix.cxx:1903
 TGeoMatrix.cxx:1904
 TGeoMatrix.cxx:1905
 TGeoMatrix.cxx:1906
 TGeoMatrix.cxx:1907
 TGeoMatrix.cxx:1908
 TGeoMatrix.cxx:1909
 TGeoMatrix.cxx:1910
 TGeoMatrix.cxx:1911
 TGeoMatrix.cxx:1912
 TGeoMatrix.cxx:1913
 TGeoMatrix.cxx:1914
 TGeoMatrix.cxx:1915
 TGeoMatrix.cxx:1916
 TGeoMatrix.cxx:1917
 TGeoMatrix.cxx:1918
 TGeoMatrix.cxx:1919
 TGeoMatrix.cxx:1920
 TGeoMatrix.cxx:1921
 TGeoMatrix.cxx:1922
 TGeoMatrix.cxx:1923
 TGeoMatrix.cxx:1924
 TGeoMatrix.cxx:1925
 TGeoMatrix.cxx:1926
 TGeoMatrix.cxx:1927
 TGeoMatrix.cxx:1928
 TGeoMatrix.cxx:1929
 TGeoMatrix.cxx:1930
 TGeoMatrix.cxx:1931
 TGeoMatrix.cxx:1932
 TGeoMatrix.cxx:1933
 TGeoMatrix.cxx:1934
 TGeoMatrix.cxx:1935
 TGeoMatrix.cxx:1936
 TGeoMatrix.cxx:1937
 TGeoMatrix.cxx:1938
 TGeoMatrix.cxx:1939
 TGeoMatrix.cxx:1940
 TGeoMatrix.cxx:1941
 TGeoMatrix.cxx:1942
 TGeoMatrix.cxx:1943
 TGeoMatrix.cxx:1944
 TGeoMatrix.cxx:1945
 TGeoMatrix.cxx:1946
 TGeoMatrix.cxx:1947
 TGeoMatrix.cxx:1948
 TGeoMatrix.cxx:1949
 TGeoMatrix.cxx:1950
 TGeoMatrix.cxx:1951
 TGeoMatrix.cxx:1952
 TGeoMatrix.cxx:1953
 TGeoMatrix.cxx:1954
 TGeoMatrix.cxx:1955
 TGeoMatrix.cxx:1956
 TGeoMatrix.cxx:1957
 TGeoMatrix.cxx:1958
 TGeoMatrix.cxx:1959
 TGeoMatrix.cxx:1960
 TGeoMatrix.cxx:1961
 TGeoMatrix.cxx:1962
 TGeoMatrix.cxx:1963
 TGeoMatrix.cxx:1964
 TGeoMatrix.cxx:1965
 TGeoMatrix.cxx:1966
 TGeoMatrix.cxx:1967
 TGeoMatrix.cxx:1968
 TGeoMatrix.cxx:1969
 TGeoMatrix.cxx:1970
 TGeoMatrix.cxx:1971
 TGeoMatrix.cxx:1972
 TGeoMatrix.cxx:1973
 TGeoMatrix.cxx:1974
 TGeoMatrix.cxx:1975
 TGeoMatrix.cxx:1976
 TGeoMatrix.cxx:1977
 TGeoMatrix.cxx:1978
 TGeoMatrix.cxx:1979
 TGeoMatrix.cxx:1980
 TGeoMatrix.cxx:1981
 TGeoMatrix.cxx:1982
 TGeoMatrix.cxx:1983
 TGeoMatrix.cxx:1984
 TGeoMatrix.cxx:1985
 TGeoMatrix.cxx:1986
 TGeoMatrix.cxx:1987
 TGeoMatrix.cxx:1988
 TGeoMatrix.cxx:1989
 TGeoMatrix.cxx:1990
 TGeoMatrix.cxx:1991
 TGeoMatrix.cxx:1992
 TGeoMatrix.cxx:1993
 TGeoMatrix.cxx:1994
 TGeoMatrix.cxx:1995
 TGeoMatrix.cxx:1996
 TGeoMatrix.cxx:1997
 TGeoMatrix.cxx:1998
 TGeoMatrix.cxx:1999
 TGeoMatrix.cxx:2000
 TGeoMatrix.cxx:2001
 TGeoMatrix.cxx:2002
 TGeoMatrix.cxx:2003
 TGeoMatrix.cxx:2004
 TGeoMatrix.cxx:2005
 TGeoMatrix.cxx:2006
 TGeoMatrix.cxx:2007
 TGeoMatrix.cxx:2008
 TGeoMatrix.cxx:2009
 TGeoMatrix.cxx:2010
 TGeoMatrix.cxx:2011
 TGeoMatrix.cxx:2012
 TGeoMatrix.cxx:2013
 TGeoMatrix.cxx:2014
 TGeoMatrix.cxx:2015
 TGeoMatrix.cxx:2016
 TGeoMatrix.cxx:2017
 TGeoMatrix.cxx:2018
 TGeoMatrix.cxx:2019
 TGeoMatrix.cxx:2020
 TGeoMatrix.cxx:2021
 TGeoMatrix.cxx:2022
 TGeoMatrix.cxx:2023
 TGeoMatrix.cxx:2024
 TGeoMatrix.cxx:2025
 TGeoMatrix.cxx:2026
 TGeoMatrix.cxx:2027
 TGeoMatrix.cxx:2028
 TGeoMatrix.cxx:2029
 TGeoMatrix.cxx:2030
 TGeoMatrix.cxx:2031
 TGeoMatrix.cxx:2032
 TGeoMatrix.cxx:2033
 TGeoMatrix.cxx:2034
 TGeoMatrix.cxx:2035
 TGeoMatrix.cxx:2036
 TGeoMatrix.cxx:2037
 TGeoMatrix.cxx:2038
 TGeoMatrix.cxx:2039
 TGeoMatrix.cxx:2040
 TGeoMatrix.cxx:2041
 TGeoMatrix.cxx:2042
 TGeoMatrix.cxx:2043
 TGeoMatrix.cxx:2044
 TGeoMatrix.cxx:2045
 TGeoMatrix.cxx:2046
 TGeoMatrix.cxx:2047
 TGeoMatrix.cxx:2048
 TGeoMatrix.cxx:2049
 TGeoMatrix.cxx:2050
 TGeoMatrix.cxx:2051
 TGeoMatrix.cxx:2052
 TGeoMatrix.cxx:2053
 TGeoMatrix.cxx:2054
 TGeoMatrix.cxx:2055
 TGeoMatrix.cxx:2056
 TGeoMatrix.cxx:2057
 TGeoMatrix.cxx:2058
 TGeoMatrix.cxx:2059
 TGeoMatrix.cxx:2060
 TGeoMatrix.cxx:2061
 TGeoMatrix.cxx:2062
 TGeoMatrix.cxx:2063
 TGeoMatrix.cxx:2064
 TGeoMatrix.cxx:2065
 TGeoMatrix.cxx:2066
 TGeoMatrix.cxx:2067
 TGeoMatrix.cxx:2068
 TGeoMatrix.cxx:2069
 TGeoMatrix.cxx:2070
 TGeoMatrix.cxx:2071
 TGeoMatrix.cxx:2072
 TGeoMatrix.cxx:2073
 TGeoMatrix.cxx:2074
 TGeoMatrix.cxx:2075
 TGeoMatrix.cxx:2076
 TGeoMatrix.cxx:2077
 TGeoMatrix.cxx:2078
 TGeoMatrix.cxx:2079
 TGeoMatrix.cxx:2080
 TGeoMatrix.cxx:2081
 TGeoMatrix.cxx:2082
 TGeoMatrix.cxx:2083
 TGeoMatrix.cxx:2084
 TGeoMatrix.cxx:2085
 TGeoMatrix.cxx:2086
 TGeoMatrix.cxx:2087
 TGeoMatrix.cxx:2088
 TGeoMatrix.cxx:2089
 TGeoMatrix.cxx:2090
 TGeoMatrix.cxx:2091
 TGeoMatrix.cxx:2092
 TGeoMatrix.cxx:2093
 TGeoMatrix.cxx:2094
 TGeoMatrix.cxx:2095
 TGeoMatrix.cxx:2096
 TGeoMatrix.cxx:2097
 TGeoMatrix.cxx:2098
 TGeoMatrix.cxx:2099
 TGeoMatrix.cxx:2100
 TGeoMatrix.cxx:2101
 TGeoMatrix.cxx:2102
 TGeoMatrix.cxx:2103
 TGeoMatrix.cxx:2104
 TGeoMatrix.cxx:2105
 TGeoMatrix.cxx:2106
 TGeoMatrix.cxx:2107
 TGeoMatrix.cxx:2108
 TGeoMatrix.cxx:2109
 TGeoMatrix.cxx:2110
 TGeoMatrix.cxx:2111
 TGeoMatrix.cxx:2112
 TGeoMatrix.cxx:2113
 TGeoMatrix.cxx:2114
 TGeoMatrix.cxx:2115
 TGeoMatrix.cxx:2116
 TGeoMatrix.cxx:2117
 TGeoMatrix.cxx:2118
 TGeoMatrix.cxx:2119
 TGeoMatrix.cxx:2120
 TGeoMatrix.cxx:2121
 TGeoMatrix.cxx:2122
 TGeoMatrix.cxx:2123
 TGeoMatrix.cxx:2124
 TGeoMatrix.cxx:2125
 TGeoMatrix.cxx:2126
 TGeoMatrix.cxx:2127
 TGeoMatrix.cxx:2128
 TGeoMatrix.cxx:2129
 TGeoMatrix.cxx:2130
 TGeoMatrix.cxx:2131
 TGeoMatrix.cxx:2132
 TGeoMatrix.cxx:2133
 TGeoMatrix.cxx:2134
 TGeoMatrix.cxx:2135
 TGeoMatrix.cxx:2136
 TGeoMatrix.cxx:2137
 TGeoMatrix.cxx:2138
 TGeoMatrix.cxx:2139
 TGeoMatrix.cxx:2140
 TGeoMatrix.cxx:2141
 TGeoMatrix.cxx:2142
 TGeoMatrix.cxx:2143
 TGeoMatrix.cxx:2144
 TGeoMatrix.cxx:2145
 TGeoMatrix.cxx:2146
 TGeoMatrix.cxx:2147
 TGeoMatrix.cxx:2148
 TGeoMatrix.cxx:2149
 TGeoMatrix.cxx:2150
 TGeoMatrix.cxx:2151
 TGeoMatrix.cxx:2152
 TGeoMatrix.cxx:2153
 TGeoMatrix.cxx:2154
 TGeoMatrix.cxx:2155
 TGeoMatrix.cxx:2156
 TGeoMatrix.cxx:2157
 TGeoMatrix.cxx:2158
 TGeoMatrix.cxx:2159
 TGeoMatrix.cxx:2160
 TGeoMatrix.cxx:2161
 TGeoMatrix.cxx:2162
 TGeoMatrix.cxx:2163
 TGeoMatrix.cxx:2164
 TGeoMatrix.cxx:2165
 TGeoMatrix.cxx:2166
 TGeoMatrix.cxx:2167
 TGeoMatrix.cxx:2168
 TGeoMatrix.cxx:2169
 TGeoMatrix.cxx:2170
 TGeoMatrix.cxx:2171
 TGeoMatrix.cxx:2172
 TGeoMatrix.cxx:2173
 TGeoMatrix.cxx:2174
 TGeoMatrix.cxx:2175
 TGeoMatrix.cxx:2176
 TGeoMatrix.cxx:2177
 TGeoMatrix.cxx:2178
 TGeoMatrix.cxx:2179
 TGeoMatrix.cxx:2180
 TGeoMatrix.cxx:2181
 TGeoMatrix.cxx:2182
 TGeoMatrix.cxx:2183
 TGeoMatrix.cxx:2184
 TGeoMatrix.cxx:2185
 TGeoMatrix.cxx:2186
 TGeoMatrix.cxx:2187
 TGeoMatrix.cxx:2188
 TGeoMatrix.cxx:2189
 TGeoMatrix.cxx:2190
 TGeoMatrix.cxx:2191
 TGeoMatrix.cxx:2192
 TGeoMatrix.cxx:2193
 TGeoMatrix.cxx:2194
 TGeoMatrix.cxx:2195
 TGeoMatrix.cxx:2196
 TGeoMatrix.cxx:2197
 TGeoMatrix.cxx:2198
 TGeoMatrix.cxx:2199
 TGeoMatrix.cxx:2200
 TGeoMatrix.cxx:2201
 TGeoMatrix.cxx:2202
 TGeoMatrix.cxx:2203
 TGeoMatrix.cxx:2204
 TGeoMatrix.cxx:2205
 TGeoMatrix.cxx:2206
 TGeoMatrix.cxx:2207
 TGeoMatrix.cxx:2208
 TGeoMatrix.cxx:2209
 TGeoMatrix.cxx:2210
 TGeoMatrix.cxx:2211
 TGeoMatrix.cxx:2212
 TGeoMatrix.cxx:2213
 TGeoMatrix.cxx:2214
 TGeoMatrix.cxx:2215
 TGeoMatrix.cxx:2216
 TGeoMatrix.cxx:2217
 TGeoMatrix.cxx:2218
 TGeoMatrix.cxx:2219
 TGeoMatrix.cxx:2220
 TGeoMatrix.cxx:2221
 TGeoMatrix.cxx:2222
 TGeoMatrix.cxx:2223
 TGeoMatrix.cxx:2224
 TGeoMatrix.cxx:2225
 TGeoMatrix.cxx:2226
 TGeoMatrix.cxx:2227
 TGeoMatrix.cxx:2228
 TGeoMatrix.cxx:2229
 TGeoMatrix.cxx:2230
 TGeoMatrix.cxx:2231
 TGeoMatrix.cxx:2232
 TGeoMatrix.cxx:2233
 TGeoMatrix.cxx:2234
 TGeoMatrix.cxx:2235
 TGeoMatrix.cxx:2236
 TGeoMatrix.cxx:2237
 TGeoMatrix.cxx:2238
 TGeoMatrix.cxx:2239
 TGeoMatrix.cxx:2240
 TGeoMatrix.cxx:2241
 TGeoMatrix.cxx:2242
 TGeoMatrix.cxx:2243
 TGeoMatrix.cxx:2244
 TGeoMatrix.cxx:2245
 TGeoMatrix.cxx:2246
 TGeoMatrix.cxx:2247
 TGeoMatrix.cxx:2248
 TGeoMatrix.cxx:2249
 TGeoMatrix.cxx:2250
 TGeoMatrix.cxx:2251
 TGeoMatrix.cxx:2252
 TGeoMatrix.cxx:2253
 TGeoMatrix.cxx:2254
 TGeoMatrix.cxx:2255
 TGeoMatrix.cxx:2256
 TGeoMatrix.cxx:2257
 TGeoMatrix.cxx:2258
 TGeoMatrix.cxx:2259
 TGeoMatrix.cxx:2260
 TGeoMatrix.cxx:2261
 TGeoMatrix.cxx:2262
 TGeoMatrix.cxx:2263
 TGeoMatrix.cxx:2264
 TGeoMatrix.cxx:2265
 TGeoMatrix.cxx:2266
 TGeoMatrix.cxx:2267
 TGeoMatrix.cxx:2268
 TGeoMatrix.cxx:2269
 TGeoMatrix.cxx:2270
 TGeoMatrix.cxx:2271
 TGeoMatrix.cxx:2272
 TGeoMatrix.cxx:2273
 TGeoMatrix.cxx:2274
 TGeoMatrix.cxx:2275
 TGeoMatrix.cxx:2276
 TGeoMatrix.cxx:2277
 TGeoMatrix.cxx:2278
 TGeoMatrix.cxx:2279
 TGeoMatrix.cxx:2280
 TGeoMatrix.cxx:2281
 TGeoMatrix.cxx:2282
 TGeoMatrix.cxx:2283
 TGeoMatrix.cxx:2284
 TGeoMatrix.cxx:2285
 TGeoMatrix.cxx:2286
 TGeoMatrix.cxx:2287
 TGeoMatrix.cxx:2288
 TGeoMatrix.cxx:2289
 TGeoMatrix.cxx:2290
 TGeoMatrix.cxx:2291
 TGeoMatrix.cxx:2292
 TGeoMatrix.cxx:2293
 TGeoMatrix.cxx:2294
 TGeoMatrix.cxx:2295
 TGeoMatrix.cxx:2296
 TGeoMatrix.cxx:2297
 TGeoMatrix.cxx:2298
 TGeoMatrix.cxx:2299
 TGeoMatrix.cxx:2300
 TGeoMatrix.cxx:2301
 TGeoMatrix.cxx:2302
 TGeoMatrix.cxx:2303
 TGeoMatrix.cxx:2304
 TGeoMatrix.cxx:2305
 TGeoMatrix.cxx:2306
 TGeoMatrix.cxx:2307
 TGeoMatrix.cxx:2308
 TGeoMatrix.cxx:2309
 TGeoMatrix.cxx:2310
 TGeoMatrix.cxx:2311
 TGeoMatrix.cxx:2312
 TGeoMatrix.cxx:2313
 TGeoMatrix.cxx:2314
 TGeoMatrix.cxx:2315
 TGeoMatrix.cxx:2316
 TGeoMatrix.cxx:2317
 TGeoMatrix.cxx:2318
 TGeoMatrix.cxx:2319
 TGeoMatrix.cxx:2320
 TGeoMatrix.cxx:2321
 TGeoMatrix.cxx:2322
 TGeoMatrix.cxx:2323
 TGeoMatrix.cxx:2324
 TGeoMatrix.cxx:2325
 TGeoMatrix.cxx:2326
 TGeoMatrix.cxx:2327
 TGeoMatrix.cxx:2328
 TGeoMatrix.cxx:2329
 TGeoMatrix.cxx:2330
 TGeoMatrix.cxx:2331
 TGeoMatrix.cxx:2332
 TGeoMatrix.cxx:2333
 TGeoMatrix.cxx:2334
 TGeoMatrix.cxx:2335
 TGeoMatrix.cxx:2336
 TGeoMatrix.cxx:2337
 TGeoMatrix.cxx:2338
 TGeoMatrix.cxx:2339
 TGeoMatrix.cxx:2340
 TGeoMatrix.cxx:2341
 TGeoMatrix.cxx:2342
 TGeoMatrix.cxx:2343
 TGeoMatrix.cxx:2344
 TGeoMatrix.cxx:2345
 TGeoMatrix.cxx:2346
 TGeoMatrix.cxx:2347
 TGeoMatrix.cxx:2348
 TGeoMatrix.cxx:2349
 TGeoMatrix.cxx:2350
 TGeoMatrix.cxx:2351
 TGeoMatrix.cxx:2352
 TGeoMatrix.cxx:2353
 TGeoMatrix.cxx:2354
 TGeoMatrix.cxx:2355
 TGeoMatrix.cxx:2356
 TGeoMatrix.cxx:2357
 TGeoMatrix.cxx:2358
 TGeoMatrix.cxx:2359
 TGeoMatrix.cxx:2360
 TGeoMatrix.cxx:2361
 TGeoMatrix.cxx:2362
 TGeoMatrix.cxx:2363
 TGeoMatrix.cxx:2364
 TGeoMatrix.cxx:2365
 TGeoMatrix.cxx:2366
 TGeoMatrix.cxx:2367
 TGeoMatrix.cxx:2368
 TGeoMatrix.cxx:2369
 TGeoMatrix.cxx:2370
 TGeoMatrix.cxx:2371
 TGeoMatrix.cxx:2372
 TGeoMatrix.cxx:2373
 TGeoMatrix.cxx:2374
 TGeoMatrix.cxx:2375
 TGeoMatrix.cxx:2376
 TGeoMatrix.cxx:2377
 TGeoMatrix.cxx:2378
 TGeoMatrix.cxx:2379
 TGeoMatrix.cxx:2380
 TGeoMatrix.cxx:2381
 TGeoMatrix.cxx:2382
 TGeoMatrix.cxx:2383
 TGeoMatrix.cxx:2384
 TGeoMatrix.cxx:2385
 TGeoMatrix.cxx:2386
 TGeoMatrix.cxx:2387
 TGeoMatrix.cxx:2388
 TGeoMatrix.cxx:2389
 TGeoMatrix.cxx:2390
 TGeoMatrix.cxx:2391
 TGeoMatrix.cxx:2392
 TGeoMatrix.cxx:2393
 TGeoMatrix.cxx:2394
 TGeoMatrix.cxx:2395
 TGeoMatrix.cxx:2396
 TGeoMatrix.cxx:2397
 TGeoMatrix.cxx:2398
 TGeoMatrix.cxx:2399
 TGeoMatrix.cxx:2400
 TGeoMatrix.cxx:2401
 TGeoMatrix.cxx:2402
 TGeoMatrix.cxx:2403
 TGeoMatrix.cxx:2404
 TGeoMatrix.cxx:2405
 TGeoMatrix.cxx:2406
 TGeoMatrix.cxx:2407
 TGeoMatrix.cxx:2408
 TGeoMatrix.cxx:2409
 TGeoMatrix.cxx:2410
 TGeoMatrix.cxx:2411
 TGeoMatrix.cxx:2412
 TGeoMatrix.cxx:2413
 TGeoMatrix.cxx:2414
 TGeoMatrix.cxx:2415
 TGeoMatrix.cxx:2416
 TGeoMatrix.cxx:2417
 TGeoMatrix.cxx:2418
 TGeoMatrix.cxx:2419
 TGeoMatrix.cxx:2420
 TGeoMatrix.cxx:2421
 TGeoMatrix.cxx:2422
 TGeoMatrix.cxx:2423
 TGeoMatrix.cxx:2424
 TGeoMatrix.cxx:2425
 TGeoMatrix.cxx:2426
 TGeoMatrix.cxx:2427
 TGeoMatrix.cxx:2428
 TGeoMatrix.cxx:2429
 TGeoMatrix.cxx:2430
 TGeoMatrix.cxx:2431
 TGeoMatrix.cxx:2432
 TGeoMatrix.cxx:2433
 TGeoMatrix.cxx:2434
 TGeoMatrix.cxx:2435
 TGeoMatrix.cxx:2436
 TGeoMatrix.cxx:2437