ROOT logo
// @(#)root/geom:$Id$
// Author: Mihaela Gheata   30/05/07

/*************************************************************************
 * 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.             *
 *************************************************************************/
 
//_____________________________________________________________________________
// TGeoNavigator
//===============
//
//   Class providing navigation API for TGeo geometries. Several instances are 
// allowed for a single geometry.
// A default navigator is provided for any geometry but one may add several 
// others for parallel navigation:
//
// TGeoNavigator *navig = new TGeoNavigator(gGeoManager);
// Int_t inav = gGeoManager->AddNavigator(navig);
// gGeoManager->SetCurrentNavigator(inav);
//
// .... and then switch back to the default navigator:
//
// gGeoManager->SetCurrentNavigator(0);
//_____________________________________________________________________________

#include "TGeoNavigator.h"

#include "TGeoManager.h"
#include "TGeoMatrix.h"
#include "TGeoNode.h"
#include "TGeoVolume.h"
#include "TGeoPatternFinder.h"
#include "TGeoVoxelFinder.h"
#include "TMath.h"
#include "TGeoParallelWorld.h"
#include "TGeoPhysicalNode.h"

static Double_t gTolerance = TGeoShape::Tolerance();
const char *kGeoOutsidePath = " ";
const Int_t kN3 = 3*sizeof(Double_t);

ClassImp(TGeoNavigator)

//_____________________________________________________________________________
TGeoNavigator::TGeoNavigator()
              :fStep(0.),
               fSafety(0.),
               fLastSafety(0.),
               fThreadId(0),
               fLevel(0),
               fNmany(0),
               fNextDaughterIndex(0),
               fOverlapSize(0),
               fOverlapMark(0),
               fOverlapClusters(0),
               fSearchOverlaps(kFALSE),
               fCurrentOverlapping(kFALSE),
               fStartSafe(kFALSE),
               fIsEntering(kFALSE),
               fIsExiting(kFALSE),
               fIsStepEntering(kFALSE),
               fIsStepExiting(kFALSE),
               fIsOutside(kFALSE),
               fIsOnBoundary(kFALSE),
               fIsSameLocation(kFALSE),
               fIsNullStep(kFALSE),
               fGeometry(0),
               fCache(0),
               fCurrentVolume(0),
               fCurrentNode(0),
               fTopNode(0),
               fLastNode(0),
               fNextNode(0),
               fForcedNode(0),
               fBackupState(0),
               fCurrentMatrix(0),
               fGlobalMatrix(0),
               fDivMatrix(0),
               fPath()
                
{
// dummy constructor
   for (Int_t i=0; i<3; i++) {
      fNormal[i] = 0.;
      fCldir[i] = 0.;
      fCldirChecked[i] = 0.;
      fPoint[i] = 0.;
      fDirection[i] = 0.;
      fLastPoint[i] = 0.;
   }
}

//_____________________________________________________________________________
TGeoNavigator::TGeoNavigator(TGeoManager* geom)
              :fStep(0.),
               fSafety(0.),
               fLastSafety(0.),
               fThreadId(0),
               fLevel(0),
               fNmany(0),
               fNextDaughterIndex(-2),
               fOverlapSize(1000),
               fOverlapMark(0),
               fOverlapClusters(0),
               fSearchOverlaps(kFALSE),
               fCurrentOverlapping(kFALSE),
               fStartSafe(kTRUE),
               fIsEntering(kFALSE),
               fIsExiting(kFALSE),
               fIsStepEntering(kFALSE),
               fIsStepExiting(kFALSE),
               fIsOutside(kFALSE),
               fIsOnBoundary(kFALSE),
               fIsSameLocation(kTRUE),
               fIsNullStep(kFALSE),
               fGeometry(geom),
               fCache(0),
               fCurrentVolume(0),
               fCurrentNode(0),
               fTopNode(0),
               fLastNode(0),
               fNextNode(0),
               fForcedNode(0),
               fBackupState(0),
               fCurrentMatrix(0),
               fGlobalMatrix(0),
               fDivMatrix(0),
               fPath()
                
{
// Default constructor.
   fThreadId = TGeoManager::ThreadId();
   // printf("Navigator: threadId=%d\n", fThreadId);
   for (Int_t i=0; i<3; i++) {
      fNormal[i] = 0.;
      fCldir[i] = 0.;
      fCldirChecked[i] = 0;
      fPoint[i] = 0.;
      fDirection[i] = 0.;
      fLastPoint[i] = 0.;
   }
   fCurrentMatrix = new TGeoHMatrix();
   fCurrentMatrix->RegisterYourself();
   fDivMatrix = new TGeoHMatrix();
   fDivMatrix->RegisterYourself();
   fOverlapClusters = new Int_t[fOverlapSize];
   ResetAll();
}      

//_____________________________________________________________________________
TGeoNavigator::TGeoNavigator(const TGeoNavigator& gm)
              :TObject(gm),
               fStep(gm.fStep),
               fSafety(gm.fSafety),
               fLastSafety(gm.fLastSafety),
               fThreadId(0),
               fLevel(gm.fLevel),
               fNmany(gm.fNmany),
               fNextDaughterIndex(gm.fNextDaughterIndex),
               fOverlapSize(gm.fOverlapSize),
               fOverlapMark(gm.fOverlapMark),
               fOverlapClusters(gm.fOverlapClusters),
               fSearchOverlaps(gm.fSearchOverlaps),
               fCurrentOverlapping(gm.fCurrentOverlapping),
               fStartSafe(gm.fStartSafe),
               fIsEntering(gm.fIsEntering),
               fIsExiting(gm.fIsExiting),
               fIsStepEntering(gm.fIsStepEntering),
               fIsStepExiting(gm.fIsStepExiting),
               fIsOutside(gm.fIsOutside),
               fIsOnBoundary(gm.fIsOnBoundary),
               fIsSameLocation(gm.fIsSameLocation),
               fIsNullStep(gm.fIsNullStep),
               fGeometry(gm.fGeometry),
               fCache(gm.fCache),
               fCurrentVolume(gm.fCurrentVolume),
               fCurrentNode(gm.fCurrentNode),
               fTopNode(gm.fTopNode),
               fLastNode(gm.fLastNode),
               fNextNode(gm.fNextNode),
               fForcedNode(gm.fForcedNode),
               fBackupState(gm.fBackupState),
               fCurrentMatrix(gm.fCurrentMatrix),
               fGlobalMatrix(gm.fGlobalMatrix),
               fPath(gm.fPath)               
{
// Copy constructor.
   fThreadId = TGeoManager::ThreadId();
   for (Int_t i=0; i<3; i++) {
      fNormal[i] = gm.fNormal[i];
      fCldir[i] = gm.fCldir[i];
      fCldirChecked[i] = gm.fCldirChecked[i];
      fPoint[i] = gm.fPoint[i];
      fDirection[i] = gm.fDirection[i];
      fLastPoint[i] = gm.fLastPoint[i];
   }
   fDivMatrix = new TGeoHMatrix();
   fDivMatrix->RegisterYourself();
}      

//_____________________________________________________________________________
TGeoNavigator& TGeoNavigator::operator=(const TGeoNavigator& gm)
{
   //assignment operator
   if(this!=&gm) {
      TObject::operator=(gm);
      fStep = gm.fStep;
      fSafety = gm.fSafety;
      fLastSafety = gm.fLastSafety;
      fThreadId = TGeoManager::ThreadId();
      fLevel = gm.fLevel;
      fNmany = gm.fNmany;
      fNextDaughterIndex = gm.fNextDaughterIndex;
      fOverlapSize=gm.fOverlapSize;
      fOverlapMark=gm.fOverlapMark;
      fOverlapClusters=gm.fOverlapClusters;
      fSearchOverlaps = gm.fSearchOverlaps;
      fCurrentOverlapping = gm.fCurrentOverlapping;
      fStartSafe = gm.fStartSafe;
      fIsEntering = gm.fIsEntering;
      fIsExiting = gm.fIsExiting;
      fIsStepEntering = gm.fIsStepEntering;
      fIsStepExiting = gm.fIsStepExiting;
      fIsOutside = gm.fIsOutside;
      fIsOnBoundary = gm.fIsOnBoundary;
      fIsSameLocation = gm.fIsSameLocation;
      fIsNullStep = gm.fIsNullStep;
      fGeometry = gm.fGeometry;
      fCache = gm.fCache;
      fCurrentVolume = gm.fCurrentVolume;
      fCurrentNode = gm.fCurrentNode;
      fTopNode = gm.fTopNode;
      fLastNode = gm.fLastNode;
      fNextNode = gm.fNextNode;
      fForcedNode = gm.fForcedNode;
      fBackupState = gm.fBackupState;
      fCurrentMatrix = gm.fCurrentMatrix;
      fGlobalMatrix = gm.fGlobalMatrix;
      fPath = gm.fPath;
      for (Int_t i=0; i<3; i++) {
         fNormal[i] = gm.fNormal[i];
         fCldir[i] = gm.fCldir[i];
         fCldirChecked[i] = gm.fCldirChecked[i];
         fPoint[i] = gm.fPoint[i];
         fDirection[i] = gm.fDirection[i];
         fLastPoint[i] = gm.fLastPoint[i];
      }
      fDivMatrix = new TGeoHMatrix();
      fDivMatrix->RegisterYourself();
   }
   return *this;   
}

//_____________________________________________________________________________
TGeoNavigator::~TGeoNavigator()
{
// Destructor.
   if (fCache) delete fCache;
   if (fBackupState) delete fBackupState;
   if (fOverlapClusters) delete [] fOverlapClusters;
}
   
//_____________________________________________________________________________
void TGeoNavigator::BuildCache(Bool_t /*dummy*/, Bool_t nodeid)
{
// Builds the cache for physical nodes and global matrices.
   static Bool_t first = kTRUE;
   Int_t verbose = TGeoManager::GetVerboseLevel();
   Int_t nlevel = fGeometry->GetMaxLevel();
   if (nlevel<=0) nlevel = 100;
   if (!fCache) {
      if (nlevel==100) {
         if (first && verbose>0) Info("BuildCache","--- Maximum geometry depth set to 100");
      } else {
         if (first && verbose>0) Info("BuildCache","--- Maximum geometry depth is %i", nlevel);   
      }   
      // build cache
      fCache = new TGeoNodeCache(fGeometry->GetTopNode(), nodeid, nlevel+1);
      fGlobalMatrix = fCache->GetCurrentMatrix();
      fBackupState = new TGeoCacheState(nlevel+1);
   }
   first = kFALSE;
}

//_____________________________________________________________________________
Bool_t TGeoNavigator::cd(const char *path)
{
// Browse the tree of nodes starting from top node according to pathname.
// Changes the path accordingly. The path is changed to point to the top node
// in case of failure.
   CdTop();
   if (!path[0]) return kTRUE;
   TString spath = path;
   TGeoVolume *vol;
   Int_t length = spath.Length();
   Int_t ind1 = spath.Index("/");
   if (ind1 == length-1) ind1 = -1;
   Int_t ind2 = 0;
   Bool_t end = kFALSE;
   Bool_t first = kTRUE;
   TString name;
   TGeoNode *node;
   while (!end) {
      ind2 = spath.Index("/", ind1+1);
      if (ind2<0 || ind2==length-1) {
         if (ind2<0) ind2 = length;
         end  = kTRUE;
      }
      name = spath(ind1+1, ind2-ind1-1);
      vol = fCurrentNode->GetVolume();
      if (first) {
         first = kFALSE;
         if (name.BeginsWith(vol->GetName())) {
            ind1 = ind2;
            continue;
         }
      }
      node = vol->GetNode(name.Data());
      if (!node) {
         Error("cd", "Path %s not valid", path);
         return kFALSE;
      }
      CdDown(vol->GetIndex(node));
      ind1 = ind2;
   }
   return kTRUE;
}

//_____________________________________________________________________________
Bool_t TGeoNavigator::CheckPath(const char *path) const
{
// Check if a geometry path is valid without changing the state of the navigator.
   if (!path[0]) return kTRUE;
   TGeoNode *crtnode = fGeometry->GetTopNode();
   TString spath = path;
   TGeoVolume *vol;
   Int_t length = spath.Length();
   Int_t ind1 = spath.Index("/");
   if (ind1 == length-1) ind1 = -1;
   Int_t ind2 = 0;
   Bool_t end = kFALSE;
   Bool_t first = kTRUE;
   TString name;
   TGeoNode *node;
   while (!end) {
      ind2 = spath.Index("/", ind1+1);
      if (ind2<0 || ind2==length-1) {
         if (ind2<0) ind2 = length;
         end  = kTRUE;
      }
      name = spath(ind1+1, ind2-ind1-1);
      vol = crtnode->GetVolume();
      if (first) {
         first = kFALSE;
         if (name.BeginsWith(vol->GetName())) {
            ind1 = ind2;
            continue;
         }
      }
      node = vol->GetNode(name.Data());
      if (!node) return kFALSE;
      crtnode = node;
      ind1 = ind2;
   }
   return kTRUE;
}    

//_____________________________________________________________________________
void TGeoNavigator::CdNode(Int_t nodeid)
{
// Change current path to point to the node having this id.
// Node id has to be in range : 0 to fNNodes-1 (no check for performance reasons)
   if (fCache) {
      fCache->CdNode(nodeid);
      fGlobalMatrix = fCache->GetCurrentMatrix();
   }   
}

//_____________________________________________________________________________
void TGeoNavigator::CdDown(Int_t index)
{
// Make a daughter of current node current. Can be called only with a valid
// daughter index (no check). Updates cache accordingly.
   TGeoNode *node = fCurrentNode->GetDaughter(index);
   Bool_t is_offset = node->IsOffset();
   if (is_offset)
      node->cd();
   else
      fCurrentOverlapping = node->IsOverlapping();
   fCache->CdDown(index);
   fCurrentNode = node;
   fGlobalMatrix = fCache->GetCurrentMatrix();
   if (fCurrentOverlapping) fNmany++;
   fLevel++;
}

//_____________________________________________________________________________
void TGeoNavigator::CdDown(TGeoNode *node)
{
// Make a daughter of current node current. Can be called only with a valid
// daughter node (no check). Updates cache accordingly.
   Bool_t is_offset = node->IsOffset();
   if (is_offset)
      node->cd();
   else
      fCurrentOverlapping = node->IsOverlapping();
   fCache->CdDown(node);
   fCurrentNode = node;
   fGlobalMatrix = fCache->GetCurrentMatrix();
   if (fCurrentOverlapping) fNmany++;
   fLevel++;
}

//_____________________________________________________________________________
void TGeoNavigator::CdUp()
{
// Go one level up in geometry. Updates cache accordingly.
// Determine the overlapping state of current node.
   if (!fLevel || !fCache) return;
   fLevel--;
   if (!fLevel) {
      CdTop();
      return;
   }
   fCache->CdUp();
   if (fCurrentOverlapping) {
      fLastNode = fCurrentNode;
      fNmany--;
   }   
   fCurrentNode = fCache->GetNode();
   fGlobalMatrix = fCache->GetCurrentMatrix();
   if (!fCurrentNode->IsOffset()) {
      fCurrentOverlapping = fCurrentNode->IsOverlapping();
   } else {
      Int_t up = 1;
      Bool_t offset = kTRUE;
      TGeoNode *mother = 0;
      while  (offset) {
         mother = GetMother(up++);
         offset = mother->IsOffset();
      }
      fCurrentOverlapping = mother->IsOverlapping();
   }      
}

//_____________________________________________________________________________
void TGeoNavigator::CdTop()
{
// Make top level node the current node. Updates the cache accordingly.
// Determine the overlapping state of current node.
   if (!fCache) return;
   fLevel = 0;
   fNmany = 0;
   if (fCurrentOverlapping) fLastNode = fCurrentNode;
   fCurrentNode = fGeometry->GetTopNode();
   fCache->CdTop();
   fGlobalMatrix = fCache->GetCurrentMatrix();
   fCurrentOverlapping = fCurrentNode->IsOverlapping();
   if (fCurrentOverlapping) fNmany++;
}

//_____________________________________________________________________________
void TGeoNavigator::CdNext()
{
// Do a cd to the node found next by FindNextBoundary
   if (fNextDaughterIndex == -2 || !fCache) return;
   if (fNextDaughterIndex ==  -3) {
      // Next node is a many - restore it
      DoRestoreState();
      fNextDaughterIndex = -2;
      return;
   }   
   if (fNextDaughterIndex == -1) {
      CdUp();
      while (fCurrentNode->GetVolume()->IsAssembly()) CdUp();
      fNextDaughterIndex--;
      return;
   }
   if (fCurrentNode && fNextDaughterIndex<fCurrentNode->GetNdaughters()) {
      CdDown(fNextDaughterIndex);
      Int_t nextindex = fCurrentNode->GetVolume()->GetNextNodeIndex();
      while (nextindex>=0) {
         CdDown(nextindex);
         nextindex = fCurrentNode->GetVolume()->GetNextNodeIndex();
      }   
   }
   fNextDaughterIndex = -2;
}   

//_____________________________________________________________________________
void TGeoNavigator::GetBranchNames(Int_t *names) const
{
// Fill volume names of current branch into an array.
   fCache->GetBranchNames(names);
}

//_____________________________________________________________________________
void TGeoNavigator::GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const
{
// Fill node copy numbers of current branch into an array.
   fCache->GetBranchNumbers(copyNumbers, volumeNumbers);
}

//_____________________________________________________________________________
void TGeoNavigator::GetBranchOnlys(Int_t *isonly) const
{
// Fill node copy numbers of current branch into an array.
   fCache->GetBranchOnlys(isonly);
}

//_____________________________________________________________________________
TGeoNode *TGeoNavigator::CrossDivisionCell()
{
// Cross a division cell. Distance to exit contained in fStep, current node
// points to the cell node.
   TGeoPatternFinder *finder = fCurrentNode->GetFinder();
   if (!finder) {
      Fatal("CrossDivisionCell", "Volume has no pattern finder");
      return 0;
   }
   // Mark current node and go up to the level of the divided volume
   TGeoNode *skip = fCurrentNode;
   CdUp();
   Double_t point[3], newpoint[3], dir[3];
   fGlobalMatrix->MasterToLocal(fPoint, newpoint);
   fGlobalMatrix->MasterToLocalVect(fDirection, dir);
   // Does step cross a boundary along division axis ?
   Bool_t onbound = finder->IsOnBoundary(newpoint);
   if (onbound) {
      // Work along division axis
      // Get the starting point
      point[0] = newpoint[0] - dir[0]*fStep*(1.-gTolerance);
      point[1] = newpoint[1] - dir[1]*fStep*(1.-gTolerance);
      point[2] = newpoint[2] - dir[2]*fStep*(1.-gTolerance);
      // Find which is the next crossed cell.
      finder->FindNode(point, dir);
      Int_t inext = finder->GetNext();
      if (inext<0) {
         // step fully exits the division along the division axis
         // Do step exits in a mother cell ?
         if (fCurrentNode->IsOffset()) {
            Double_t dist = fCurrentNode->GetVolume()->GetShape()->DistFromInside(point,dir,3);
            // Do step exit also from mother cell ?
            if (dist < fStep+2.*gTolerance) {
               // Step exits mother on its own division axis
               return CrossDivisionCell();
            }
            // We end up here
            return fCurrentNode;
         }   
         // Exiting in a non-divided volume
         while (fCurrentNode->GetVolume()->IsAssembly()) {
            // Move always to mother for assemblies
            skip = fCurrentNode;
            if (!fLevel) break;
            CdUp();
         } 
         return CrossBoundaryAndLocate(kFALSE, skip);
      }
      // step enters a new cell
      CdDown(inext+finder->GetDivIndex());
      skip = fCurrentNode;
      return CrossBoundaryAndLocate(kTRUE, skip);
   }
   // step exits on an axis other than the division axis -> get next slice
   if (fCurrentNode->IsOffset()) return CrossDivisionCell();
   return CrossBoundaryAndLocate(kFALSE, skip);
}
   
//_____________________________________________________________________________
TGeoNode *TGeoNavigator::CrossBoundaryAndLocate(Bool_t downwards, TGeoNode *skipnode)
{
// Cross next boundary and locate within current node
// The current point must be on the boundary of fCurrentNode.

// Extrapolate current point with estimated error.
   Double_t *tr = fGlobalMatrix->GetTranslation();
   Double_t trmax = 1.+TMath::Abs(tr[0])+TMath::Abs(tr[1])+TMath::Abs(tr[2]);
   Double_t extra = 100.*(trmax+fStep)*gTolerance;
   const Int_t idebug = TGeoManager::GetVerboseLevel();
   fPoint[0] += extra*fDirection[0];
   fPoint[1] += extra*fDirection[1];
   fPoint[2] += extra*fDirection[2];
   TGeoNode *current = SearchNode(downwards, skipnode);
   fForcedNode = 0;
   fPoint[0] -= extra*fDirection[0];
   fPoint[1] -= extra*fDirection[1];
   fPoint[2] -= extra*fDirection[2];
   if (!current) return 0;
   if (downwards) {
      Int_t nextindex = current->GetVolume()->GetNextNodeIndex();
      while (nextindex>=0) {
         CdDown(nextindex);
         current = fCurrentNode;
         nextindex = fCurrentNode->GetVolume()->GetNextNodeIndex();
      }
      if (idebug>4) {
         printf("CrossBoundaryAndLocate: entered %s\n", GetPath());
      }   
      return current;   
   }   
     
   if ((skipnode && current == skipnode) || current->GetVolume()->IsAssembly()) {
      if (!fLevel) {
         fIsOutside = kTRUE;
         if (idebug>4) {
            printf("CrossBoundaryAndLocate: Exited geometry\n");
         }   
         return fGeometry->GetCurrentNode();
      }
      CdUp();
      while (fLevel && fCurrentNode->GetVolume()->IsAssembly()) CdUp();
      if (!fLevel && fCurrentNode->GetVolume()->IsAssembly()) {
         fIsOutside = kTRUE;
         if (idebug>4) {
            printf("CrossBoundaryAndLocate: Exited geometry\n");
         }   
         if (idebug>4) {
            printf("CrossBoundaryAndLocate: entered %s\n", GetPath());
         }   
         return fCurrentNode;
      }
      return fCurrentNode;
   }
   if (idebug>4) {
      printf("CrossBoundaryAndLocate: entered %s\n", GetPath());
   }   
   return current;
}   
   
//_____________________________________________________________________________
TGeoNode *TGeoNavigator::FindNextBoundary(Double_t stepmax, const char *path, Bool_t frombdr)
{
// Find distance to next boundary and store it in fStep. Returns node to which this
// boundary belongs. If PATH is specified, compute only distance to the node to which
// PATH points. If STEPMAX is specified, compute distance only in case fSafety is smaller
// than this value. STEPMAX represent the step to be made imposed by other reasons than
// geometry (usually physics processes). Therefore in this case this method provides the
// answer to the question : "Is STEPMAX a safe step ?" returning a NULL node and filling
// fStep with a big number.
// In case frombdr=kTRUE, the isotropic safety is set to zero.
// Note : safety distance for the current point is computed ONLY in case STEPMAX is
//        specified, otherwise users have to call explicitly TGeoManager::Safety() if
//        they want this computed for the current point.

   // convert current point and direction to local reference
   Int_t iact = 3;
   Int_t idebug = TGeoManager::GetVerboseLevel();
   fNextDaughterIndex = -2;
   fStep = TGeoShape::Big();
   fIsStepEntering = kFALSE;
   fIsStepExiting = kFALSE;
   fForcedNode = 0;
   Bool_t computeGlobal = kFALSE;
   fIsOnBoundary = frombdr;
   fSafety = 0.;
   TGeoNode *top_node = fGeometry->GetTopNode();
   TGeoVolume *top_volume = top_node->GetVolume();
   // If inside an assembly, go logically up in the hierarchy
   while (fCurrentNode->GetVolume()->IsAssembly() && fLevel) CdUp();
   if (stepmax<1E29) {
      if (stepmax <= 0) {
         stepmax = - stepmax;
         computeGlobal = kTRUE;
      }
//      if (fLastSafety>0 && IsSamePoint(fPoint[0], fPoint[1], fPoint[2])) fSafety = fLastSafety;
      fSafety = Safety();
      // Try to get out easy if proposed step within safe region
      if (!frombdr && (fSafety>0) && IsSafeStep(stepmax+gTolerance, fSafety)) {
         fStep = stepmax;
         fNextNode = fCurrentNode;
         return fCurrentNode;
      }
      fSafety = TMath::Abs(fSafety);
      memcpy(fLastPoint, fPoint, kN3);
      fLastSafety = fSafety;
      if (fSafety<gTolerance) fIsOnBoundary = kTRUE;
      else fIsOnBoundary = kFALSE;
      fStep = stepmax;
      if (stepmax+gTolerance<fSafety) {
         fNextNode = fCurrentNode;
         return fCurrentNode;
      }
   }
   if (computeGlobal) fCurrentMatrix->CopyFrom(fGlobalMatrix);
   Double_t snext  = TGeoShape::Big();
   Double_t safe;
   Double_t point[3];
   Double_t dir[3];
   if (idebug>4) {
      printf("TGeoManager::FindNextBoundary:  point=(%19.16f, %19.16f, %19.16f)\n",
             fPoint[0],fPoint[1],fPoint[2]);
      printf("                                dir=  (%19.16f, %19.16f, %19.16f)\n",
             fDirection[0], fDirection[1], fDirection[2]);
      printf("  pstep=%9.6g  path=%s\n", stepmax, GetPath());
   }   
   if (path[0]) {
      PushPath();
      if (!cd(path)) {
         PopPath();
         return 0;
      }
      if (computeGlobal) fCurrentMatrix->CopyFrom(fGlobalMatrix);
      fNextNode = fCurrentNode;
      TGeoVolume *tvol=fCurrentNode->GetVolume();
      fGlobalMatrix->MasterToLocal(fPoint, &point[0]);
      fGlobalMatrix->MasterToLocalVect(fDirection, &dir[0]);
      if (idebug>4) {
         printf("=== To path: %s\n", path);
         printf("=== local to %s: (%19.16f, %19.16f, %19.16f, %19.16f, %19.16f, %19.16f)\n",
                tvol->GetName(), point[0],point[1],point[2],dir[0],dir[1],dir[2]);
      }          
      if (tvol->Contains(point)) {
         if (idebug>4) printf("=== volume %s contains point\n", tvol->GetName());
         fStep=tvol->GetShape()->DistFromInside(&point[0], &dir[0], iact, fStep, &safe);
      } else {
         fStep=tvol->GetShape()->DistFromOutside(&point[0], &dir[0], iact, fStep, &safe);
         if (idebug>4) {
            printf("=== volume %s does not contain point\n", tvol->GetName());
            printf("=== distance to path: %g\n", fStep);
            tvol->InspectShape();
            if (fStep<1.E20) {
               Double_t newpt[3];
               newpt[0] = point[0] + fStep*dir[0];
               newpt[1] = point[1] + fStep*dir[1];
               newpt[2] = point[2] + fStep*dir[2];
               printf("=== Propagated point: (%19.16f, %19.16f, %19.16f)", newpt[0],newpt[1],newpt[2]);
            }   
            while (fLevel) {
               CdUp();
               tvol = fCurrentNode->GetVolume();
               fGlobalMatrix->MasterToLocal(fPoint, &point[0]);
               fGlobalMatrix->MasterToLocalVect(fDirection, &dir[0]);
               printf("=== local to %s: (%19.16f, %19.16f, %19.16f, %19.16f, %19.16f, %19.16f)\n",
                      tvol->GetName(), point[0],point[1],point[2],dir[0],dir[1],dir[2]);               
               if (tvol->Contains(point)) {
                  printf("=== volume %s contains point\n", tvol->GetName());
               } else {
                  printf("=== volume %s does not contain point\n", tvol->GetName());
                  snext = tvol->GetShape()->DistFromOutside(&point[0], &dir[0], iact, 1.E30, &safe);
               }
            }   
         }   
      }
      PopPath();
      return fNextNode;
   }
   // compute distance to exit point from current node and the distance to its
   // closest boundary
   // if point is outside, just check the top node
   if (fIsOutside) {
      snext = top_volume->GetShape()->DistFromOutside(fPoint, fDirection, iact, fStep, &safe);
      fNextNode = top_node;
      if (snext < fStep-gTolerance) {
         fIsStepEntering = kTRUE;
         fStep = snext;
         Int_t indnext = fNextNode->GetVolume()->GetNextNodeIndex();
         fNextDaughterIndex = indnext;
         while (indnext>=0) {
            fNextNode = fNextNode->GetDaughter(indnext);
            if (computeGlobal) fCurrentMatrix->Multiply(fNextNode->GetMatrix());
            indnext = fNextNode->GetVolume()->GetNextNodeIndex();
         }
         return fNextNode;
      }
      return 0;
   }
   fGlobalMatrix->MasterToLocal(fPoint, &point[0]);
   fGlobalMatrix->MasterToLocalVect(fDirection, &dir[0]);
   TGeoVolume *vol = fCurrentNode->GetVolume();
   if (idebug>4) {
      printf("   -> from local=(%19.16f, %19.16f, %19.16f)\n",
             point[0],point[1],point[2]);
      printf("           ldir =(%19.16f, %19.16f, %19.16f)\n",
             dir[0],dir[1],dir[2]);             
   }           
   // find distance to exiting current node
   snext = vol->GetShape()->DistFromInside(&point[0], &dir[0], iact, fStep, &safe);
   if (idebug>4) {
      printf("      exiting %s shape %s at snext=%g\n", vol->GetName(), vol->GetShape()->ClassName(),snext);
   }   
   if (snext < fStep-gTolerance) {
      fNextNode = fCurrentNode;
      fNextDaughterIndex = -1;
      fIsStepExiting  = kTRUE;
      fStep = snext;
      fIsStepEntering = kFALSE;
      if (fStep<1E-6) return fCurrentNode;
   }
   fNextNode = (fStep<1E20)?fCurrentNode:0;
   // Find next daughter boundary for the current volume
   Int_t idaughter = -1;
   FindNextDaughterBoundary(point,dir,idaughter,computeGlobal);
   if (idaughter>=0) fNextDaughterIndex = idaughter;
   TGeoNode *current = 0;
   TGeoNode *dnode = 0;
   TGeoVolume *mother = 0;
   // if we are in an overlapping node, check also the mother(s)
   if (fNmany) {
      Double_t mothpt[3];
      Double_t vecpt[3];
      Double_t dpt[3], dvec[3];
      Int_t novlps;
      Int_t idovlp = -1;
      Int_t safelevel = GetSafeLevel();
      PushPath(safelevel+1);
      while (fCurrentOverlapping) {
         Int_t *ovlps = fCurrentNode->GetOverlaps(novlps);
         CdUp();
         mother = fCurrentNode->GetVolume();
         fGlobalMatrix->MasterToLocal(fPoint, &mothpt[0]);
         fGlobalMatrix->MasterToLocalVect(fDirection, &vecpt[0]);
         // check distance to out
         snext = TGeoShape::Big();
         if (!mother->IsAssembly()) snext = mother->GetShape()->DistFromInside(&mothpt[0], &vecpt[0], iact, fStep, &safe);
         if (snext<fStep-gTolerance) {
            fIsStepExiting  = kTRUE;
            fIsStepEntering = kFALSE;
            fStep = snext;
            if (computeGlobal) fCurrentMatrix->CopyFrom(fGlobalMatrix);
            fNextNode = fCurrentNode;
            fNextDaughterIndex = -3;
            DoBackupState();
         }
         // check overlapping nodes
         for (Int_t i=0; i<novlps; i++) {
            current = mother->GetNode(ovlps[i]);
            if (!current->IsOverlapping()) {
               current->cd();
               current->MasterToLocal(&mothpt[0], &dpt[0]);
               current->MasterToLocalVect(&vecpt[0], &dvec[0]);
               // Current point may be inside the other node - geometry error that we ignore
               snext = TGeoShape::Big();
               if (!current->GetVolume()->Contains(dpt))
                  snext = current->GetVolume()->GetShape()->DistFromOutside(&dpt[0], &dvec[0], iact, fStep, &safe);
               if (snext<fStep-gTolerance) {
                  if (computeGlobal) {
                     fCurrentMatrix->CopyFrom(fGlobalMatrix);
                     fCurrentMatrix->Multiply(current->GetMatrix());
                  }
                  fIsStepExiting  = kTRUE;
                  fIsStepEntering = kFALSE;
                  fStep = snext;
                  fNextNode = current;
                  fNextDaughterIndex = -3;
                  CdDown(ovlps[i]);
                  DoBackupState();
                  CdUp();
               }
            } else {
               // another many - check if point is in or out
               current->cd();
               current->MasterToLocal(&mothpt[0], &dpt[0]);
               current->MasterToLocalVect(&vecpt[0], &dvec[0]);
               if (current->GetVolume()->Contains(dpt)) {
                  if (current->GetVolume()->GetNdaughters()) {
                     CdDown(ovlps[i]);
                     fIsStepEntering  = kFALSE;
                     fIsStepExiting  = kTRUE;
                     dnode = FindNextDaughterBoundary(dpt,dvec,idovlp,computeGlobal);
                     if (dnode) {
                        if (computeGlobal) {
                           fCurrentMatrix->CopyFrom(fGlobalMatrix);
                           fCurrentMatrix->Multiply(dnode->GetMatrix());
                        }   
                        fNextNode = dnode;
                        fNextDaughterIndex = -3;
                        CdDown(idovlp);
                        Int_t indnext = fCurrentNode->GetVolume()->GetNextNodeIndex();
                        Int_t iup=0;
                        while (indnext>=0) {
                           CdDown(indnext);
                           iup++;
                           indnext = fCurrentNode->GetVolume()->GetNextNodeIndex();
                        }   
                        DoBackupState();
                        while (iup>0) {
                           CdUp();
                           iup--;
                        }   
                        CdUp();
                     }
                     CdUp();
                  }   
               } else {
                  snext = current->GetVolume()->GetShape()->DistFromOutside(&dpt[0], &dvec[0], iact, fStep, &safe);
                  if (snext<fStep-gTolerance) {
                     if (computeGlobal) {
                        fCurrentMatrix->CopyFrom(fGlobalMatrix);
                        fCurrentMatrix->Multiply(current->GetMatrix());
                     }
                     fIsStepExiting  = kTRUE;
                     fIsStepEntering = kFALSE;
                     fStep = snext;
                     fNextNode = current;
                     fNextDaughterIndex = -3;
                     CdDown(ovlps[i]);
                     DoBackupState();
                     CdUp();
                  }               
               }  
            }
         }
      }
      // Now we are in a non-overlapping node
      if (fNmany) {
      // We have overlaps up in the branch, check distance to exit
         Int_t up = 1;
         Int_t imother;
         Int_t nmany = fNmany;
         Bool_t ovlp = kFALSE;
         Bool_t nextovlp = kFALSE;
         Bool_t offset = kFALSE;
         TGeoNode *currentnode = fCurrentNode;
         TGeoNode *mothernode, *mup;
         TGeoHMatrix *matrix;
         while (nmany) {
            mothernode = GetMother(up);
            if (!mothernode) {
               Fatal("FindNextBoundary", "Cannot find mother node");
               return 0;
            }   
            mup = mothernode;
            imother = up+1;
            offset = kFALSE;
            while (mup->IsOffset()) {
               mup = GetMother(imother++);
               offset = kTRUE;
            }   
            nextovlp = mup->IsOverlapping();
            if (offset) {
               mothernode = mup;
               if (nextovlp) nmany -= imother-up;
               up = imother-1;
            } else {    
               if (ovlp) nmany--;
            }   
            if (ovlp || nextovlp) {
               matrix = GetMotherMatrix(up);
               if (!matrix) {
                  Fatal("FindNextBoundary", "Cannot find mother matrix");
                  return 0;
               }   
               matrix->MasterToLocal(fPoint,dpt);
               matrix->MasterToLocalVect(fDirection,dvec);
               snext = TGeoShape::Big();
               if (!mothernode->GetVolume()->IsAssembly()) snext = mothernode->GetVolume()->GetShape()->DistFromInside(dpt,dvec,iact,fStep);
               if (snext<fStep-gTolerance) {
                  fIsStepEntering  = kFALSE;
                  fIsStepExiting  = kTRUE;
                  fStep = snext;
                  fNextNode = mothernode;
                  fNextDaughterIndex = -3;
                  if (computeGlobal) fCurrentMatrix->CopyFrom(matrix);
                  while (up--) CdUp();
                  DoBackupState();
                  up = 1;
                  currentnode = fCurrentNode;
                  ovlp = currentnode->IsOverlapping();
                  continue;
               }   
            }   
            currentnode = mothernode;
            ovlp = nextovlp;
            up++;            
         }
      }      
      PopPath();
   }
   // Compute now the distance in case we have a parallel world
   Double_t parstep = TGeoShape::Big();
   if (fGeometry->IsParallelWorldNav()) {
//      printf("path: %s next node %s at %g\n", GetPath(), fNextNode->GetName(), fStep);
      TGeoPhysicalNode *pnode = fGeometry->GetParallelWorld()->FindNextBoundary(fPoint, fDirection, parstep, fStep);
      if (pnode) {
         // A boundary is hit at less than fPStep
         fStep = parstep;
         fNextNode = pnode->GetNode();
         fNextDaughterIndex = -2; // No way to store it for CdNext
         fIsStepEntering  = kTRUE;
         fIsStepExiting  = kFALSE;
         Int_t nextindex = fNextNode->GetVolume()->GetNextNodeIndex();
         while (nextindex>=0) {
            fNextNode = fNextNode->GetDaughter(nextindex);
            nextindex = fNextNode->GetVolume()->GetNextNodeIndex();
         }
      }
   }
   return fNextNode;
}

//_____________________________________________________________________________
TGeoNode *TGeoNavigator::FindNextDaughterBoundary(Double_t *point, Double_t *dir, Int_t &idaughter, Bool_t compmatrix)
{
// Computes as fStep the distance to next daughter of the current volume. 
// The point and direction must be converted in the coordinate system of the current volume.
// The proposed step limit is fStep.

   Double_t snext = TGeoShape::Big();
   Int_t idebug = TGeoManager::GetVerboseLevel();
   idaughter = -1; // nothing crossed
   TGeoNode *nodefound = 0;
   // Get number of daughters. If no daughters we are done.

   TGeoVolume *vol = fCurrentNode->GetVolume();
   Int_t nd = vol->GetNdaughters();
   if (!nd) return 0;  // No daughter 
   if (fGeometry->IsActivityEnabled() && !vol->IsActiveDaughters()) return 0;
   Double_t lpoint[3], ldir[3];
   TGeoNode *current = 0;
   Int_t i=0;
   // if current volume is divided, we are in the non-divided region. We
   // check first if we are inside a cell in which case compute distance to next cell
   TGeoPatternFinder *finder = vol->GetFinder();
   if (finder) {
      Int_t ifirst = finder->GetDivIndex();
      Int_t ilast = ifirst+finder->GetNdiv()-1;
      current = finder->FindNode(point);
      if (current) {
         // Point inside a cell: find distance to next cell
         Int_t index = current->GetIndex();
         if ((index-1) >= ifirst) ifirst = index-1;
         else                     ifirst = -1;
         if ((index+1) <= ilast)  ilast  = index+1;
         else                     ilast  = -1;
      }
      if (ifirst>=0) {   
         current = vol->GetNode(ifirst);
         current->cd();
         current->MasterToLocal(&point[0], lpoint);
         current->MasterToLocalVect(&dir[0], ldir);
         snext = current->GetVolume()->GetShape()->DistFromOutside(lpoint, ldir, 3, fStep);
         if (snext<fStep-gTolerance) {
            if (compmatrix) {
               fCurrentMatrix->CopyFrom(fGlobalMatrix);
               fCurrentMatrix->Multiply(current->GetMatrix());
            }
            fIsStepExiting  = kFALSE;
            fIsStepEntering = kTRUE;
            fStep=snext;
            fNextNode = current;
            nodefound = current;
            idaughter = ifirst;
         }
      }   
      if (ilast==ifirst) return nodefound;
      if (ilast>=0) { 
         current = vol->GetNode(ilast);
         current->cd();
         current->MasterToLocal(&point[0], lpoint);
         current->MasterToLocalVect(&dir[0], ldir);
         snext = current->GetVolume()->GetShape()->DistFromOutside(lpoint, ldir, 3, fStep);
         if (snext<fStep-gTolerance) {
            if (compmatrix) {
               fCurrentMatrix->CopyFrom(fGlobalMatrix);
               fCurrentMatrix->Multiply(current->GetMatrix());
            }
            fIsStepExiting  = kFALSE;
            fIsStepEntering = kTRUE;
            fStep=snext;
            fNextNode = current;
            nodefound = current;
            idaughter = ilast;
         }
      }   
      return nodefound;
   }
   // if only few daughters, check all and exit
   TGeoVoxelFinder *voxels = vol->GetVoxels();
   Int_t indnext;
   if (idebug>4) printf("   Checking distance to %d daughters...\n",nd);
   if (nd<5 || !voxels) {
      for (i=0; i<nd; i++) {
         current = vol->GetNode(i);
         if (fGeometry->IsActivityEnabled() && !current->GetVolume()->IsActive()) continue;
         current->cd();
         if (voxels && voxels->IsSafeVoxel(point, i, fStep)) continue;
         current->MasterToLocal(point, lpoint);
         current->MasterToLocalVect(dir, ldir);
         if (current->IsOverlapping() && current->GetVolume()->Contains(lpoint)) continue;
         snext = current->GetVolume()->GetShape()->DistFromOutside(lpoint, ldir, 3, fStep);
         if (snext<fStep-gTolerance) {
            if (idebug>4) {
               printf("   -> from local=(%19.16f, %19.16f, %19.16f)\n",
                      lpoint[0],lpoint[1],lpoint[2]);
               printf("           ldir =(%19.16f, %19.16f, %19.16f)\n",
                      ldir[0],ldir[1],ldir[2]);             
               printf("   -> to: %s shape %s snext=%g\n", current->GetName(),
                      current->GetVolume()->GetShape()->ClassName(), snext);        
            }           
            indnext = current->GetVolume()->GetNextNodeIndex();
            if (compmatrix) {
               fCurrentMatrix->CopyFrom(fGlobalMatrix);
               fCurrentMatrix->Multiply(current->GetMatrix());
            }    
            fIsStepExiting  = kFALSE;
            fIsStepEntering = kTRUE;
            fStep=snext;
            fNextNode = current;
            nodefound = fNextNode;   
            idaughter = i;   
            while (indnext>=0) {
               current = current->GetDaughter(indnext);
               if (compmatrix) fCurrentMatrix->Multiply(current->GetMatrix());
               fNextNode = current;
               nodefound = current;
               indnext = current->GetVolume()->GetNextNodeIndex();
            }
         }
      }
      if (vol->IsAssembly()) ((TGeoVolumeAssembly*)vol)->SetNextNodeIndex(idaughter);
      return nodefound;
   }
   // if current volume is voxelized, first get current voxel
   Int_t ncheck = 0;
   Int_t sumchecked = 0;
   Int_t *vlist = 0;
   TGeoStateInfo &info = *fCache->GetInfo();
   voxels->SortCrossedVoxels(point, dir, info);
   while ((sumchecked<nd) && (vlist=voxels->GetNextVoxel(point, dir, ncheck, info))) {
      for (i=0; i<ncheck; i++) {
         current = vol->GetNode(vlist[i]);
         if (fGeometry->IsActivityEnabled() && !current->GetVolume()->IsActive()) continue;
         current->cd();
         current->MasterToLocal(point, lpoint);
         current->MasterToLocalVect(dir, ldir);
         if (current->IsOverlapping() && current->GetVolume()->Contains(lpoint)) continue;
         snext = current->GetVolume()->GetShape()->DistFromOutside(lpoint, ldir, 3, fStep);
         sumchecked++;
//         printf("checked %d from %d : snext=%g\n", sumchecked, nd, snext);
         if (snext<fStep-gTolerance) {
            if (idebug>4) {
               printf("   -> from local=(%19.16f, %19.16f, %19.16f)\n",
                      lpoint[0],lpoint[1],lpoint[2]);
               printf("           ldir =(%19.16f, %19.16f, %19.16f)\n",
                      ldir[0],ldir[1],ldir[2]);             
               printf("   -> to: %s shape %s snext=%g\n", current->GetName(),
                      current->GetVolume()->GetShape()->ClassName(), snext);        
            }           
            indnext = current->GetVolume()->GetNextNodeIndex();
            if (compmatrix) {
               fCurrentMatrix->CopyFrom(fGlobalMatrix);
               fCurrentMatrix->Multiply(current->GetMatrix());
            }
            fIsStepExiting  = kFALSE;
            fIsStepEntering = kTRUE;
            fStep=snext;
            fNextNode = current;
            nodefound = fNextNode;
            idaughter = vlist[i];
            while (indnext>=0) {
               current = current->GetDaughter(indnext);
               if (compmatrix) fCurrentMatrix->Multiply(current->GetMatrix());
               fNextNode = current;
               nodefound = current;
               indnext = current->GetVolume()->GetNextNodeIndex();
            }
         }
      }
   }
   fCache->ReleaseInfo();
   if (vol->IsAssembly()) ((TGeoVolumeAssembly*)vol)->SetNextNodeIndex(idaughter);
   return nodefound;
}

//_____________________________________________________________________________
TGeoNode *TGeoNavigator::FindNextBoundaryAndStep(Double_t stepmax, Bool_t compsafe)
{
// Compute distance to next boundary within STEPMAX. If no boundary is found,
// propagate current point along current direction with fStep=STEPMAX. Otherwise
// propagate with fStep=SNEXT (distance to boundary) and locate/return the next 
// node.
   static Int_t icount = 0;
   icount++;
   Int_t iact = 3;
   Int_t idebug = TGeoManager::GetVerboseLevel();
   Int_t nextindex;
   Bool_t is_assembly;
   fForcedNode = 0;
   fIsStepExiting  = kFALSE;
   TGeoNode *skip;
   fIsStepEntering = kFALSE;
   fStep = stepmax;
   Double_t snext = TGeoShape::Big();
   // If inside an assembly, go logically up in the hierarchy
   while (fCurrentNode->GetVolume()->IsAssembly() && fLevel) CdUp();
   if (compsafe) {
      // Try to get out easy if proposed step within safe region
      fIsOnBoundary = kFALSE;
      if (IsSafeStep(stepmax+gTolerance, fSafety)) {
         fPoint[0] += stepmax*fDirection[0];
         fPoint[1] += stepmax*fDirection[1];
         fPoint[2] += stepmax*fDirection[2];
         return fCurrentNode;
      }   
      Safety();
      fLastSafety = fSafety;
      memcpy(fLastPoint, fPoint, kN3);
      // If proposed step less than safety, nothing to check
      if (fSafety > stepmax+gTolerance) {
         fPoint[0] += stepmax*fDirection[0];
         fPoint[1] += stepmax*fDirection[1];
         fPoint[2] += stepmax*fDirection[2];
         return fCurrentNode;
      }   
   }   
   Double_t extra = (fIsOnBoundary)?gTolerance:0.0;
   fIsOnBoundary = kFALSE;
   fPoint[0] += extra*fDirection[0];
   fPoint[1] += extra*fDirection[1];
   fPoint[2] += extra*fDirection[2];
   fCurrentMatrix->CopyFrom(fGlobalMatrix);
   if (idebug>4) {
      printf("TGeoManager::FindNextBAndStep:  point=(%19.16f, %19.16f, %19.16f)\n",
             fPoint[0],fPoint[1],fPoint[2]);
      printf("                                dir=  (%19.16f, %19.16f, %19.16f)\n",
             fDirection[0], fDirection[1], fDirection[2]);
      printf("  pstep=%9.6g  path=%s\n", stepmax, GetPath());
   }   
   
   if (fIsOutside) {
      snext = fGeometry->GetTopVolume()->GetShape()->DistFromOutside(fPoint, fDirection, iact, fStep);
      if (snext < fStep-gTolerance) {
         if (snext<=0) {
            snext = 0.0;
            fStep = snext;
            fPoint[0] -= extra*fDirection[0];
            fPoint[1] -= extra*fDirection[1];
            fPoint[2] -= extra*fDirection[2];
         } else {
            fStep = snext+extra;
         }   
         fIsStepEntering = kTRUE;
         fNextNode = fGeometry->GetTopNode();
         nextindex = fNextNode->GetVolume()->GetNextNodeIndex();
         while (nextindex>=0) {
            CdDown(nextindex);
            fNextNode = fCurrentNode;
            nextindex = fNextNode->GetVolume()->GetNextNodeIndex();
            if (nextindex<0) fCurrentMatrix->CopyFrom(fGlobalMatrix);
         }   
         // Update global point
         fPoint[0] += snext*fDirection[0];
         fPoint[1] += snext*fDirection[1];
         fPoint[2] += snext*fDirection[2];
         fIsOnBoundary = kTRUE;
         fIsOutside = kFALSE;
         fForcedNode = fCurrentNode;
         return CrossBoundaryAndLocate(kTRUE, fCurrentNode);
      }
      if (snext<TGeoShape::Big()) {
         // New point still outside, but the top node is reachable
         fNextNode = fGeometry->GetTopNode();
         fPoint[0] += (fStep-extra)*fDirection[0];
         fPoint[1] += (fStep-extra)*fDirection[1];
         fPoint[2] += (fStep-extra)*fDirection[2];
         return fNextNode;
      }      
      // top node not reachable from current point/direction
      fNextNode = 0;
      fIsOnBoundary = kFALSE;
      return 0;
   }
   Double_t point[3],dir[3];
   Int_t icrossed = -2;
   fGlobalMatrix->MasterToLocal(fPoint, &point[0]);
   fGlobalMatrix->MasterToLocalVect(fDirection, &dir[0]);
   TGeoVolume *vol = fCurrentNode->GetVolume();
   // find distance to exiting current node
   if (idebug>4) {
      printf("   -> from local=(%19.16f, %19.16f, %19.16f)\n",
             point[0],point[1],point[2]);
      printf("           ldir =(%19.16f, %19.16f, %19.16f)\n",
             dir[0],dir[1],dir[2]);             
   }           
   // find distance to exiting current node
   snext = vol->GetShape()->DistFromInside(point, dir, iact, fStep);
   if (idebug>4) {
      printf("      exiting %s shape %s at snext=%g\n", vol->GetName(), vol->GetShape()->ClassName(),snext);
   }   
   fNextNode = fCurrentNode;
   if (snext <= gTolerance) {
      // Current point on the boundary while track exiting
      snext = gTolerance;
      fStep = snext;
      fIsOnBoundary = kTRUE;
      fIsStepEntering = kFALSE;
      fIsStepExiting = kTRUE;
      skip = fCurrentNode;
      fPoint[0] += fStep*fDirection[0];
      fPoint[1] += fStep*fDirection[1];
      fPoint[2] += fStep*fDirection[2];
      is_assembly = fCurrentNode->GetVolume()->IsAssembly();
      if (!fLevel && !is_assembly) {
         fIsOutside = kTRUE;
         return 0;
      }
      if (fCurrentNode->IsOffset()) return CrossDivisionCell();   
      if (fLevel) CdUp();
      else        skip = 0;
      return CrossBoundaryAndLocate(kFALSE, skip);
   }   

   if (snext < fStep-gTolerance) {
      // Currently the minimum step chosen is the exiting one
      icrossed = -1;
      fStep = snext;
      fIsStepEntering = kFALSE;
      fIsStepExiting = kTRUE;
   }
   // Find next daughter boundary for the current volume
   Int_t idaughter = -1;
   TGeoNode *crossed = FindNextDaughterBoundary(point,dir, idaughter, kTRUE);
   if (crossed) {
      fIsStepExiting = kFALSE;
      icrossed = idaughter;
      fIsStepEntering = kTRUE;
   }   
   TGeoNode *current = 0;
   TGeoNode *dnode = 0;
   TGeoVolume *mother = 0;
   // if we are in an overlapping node, check also the mother(s)
   if (fNmany) {
      Double_t mothpt[3];
      Double_t vecpt[3];
      Double_t dpt[3], dvec[3];
      Int_t novlps;
      Int_t safelevel = GetSafeLevel();
      PushPath(safelevel+1);
      while (fCurrentOverlapping) {
         Int_t *ovlps = fCurrentNode->GetOverlaps(novlps);
         CdUp();
         mother = fCurrentNode->GetVolume();
         fGlobalMatrix->MasterToLocal(fPoint, &mothpt[0]);
         fGlobalMatrix->MasterToLocalVect(fDirection, &vecpt[0]);
         // check distance to out
         snext = TGeoShape::Big();
         if (!mother->IsAssembly()) snext = mother->GetShape()->DistFromInside(mothpt, vecpt, iact, fStep);
         if (snext<fStep-gTolerance) {
            // exiting mother first (extrusion)
            icrossed = -1;
            PopDummy();
            PushPath(safelevel+1);
            fIsStepEntering = kFALSE;
            fIsStepExiting = kTRUE;
            fStep = snext;
            fCurrentMatrix->CopyFrom(fGlobalMatrix);
            fNextNode = fCurrentNode;
         }
         // check overlapping nodes
         for (Int_t i=0; i<novlps; i++) {
            current = mother->GetNode(ovlps[i]);
            if (!current->IsOverlapping()) {
               current->cd();
               current->MasterToLocal(&mothpt[0], &dpt[0]);
               current->MasterToLocalVect(&vecpt[0], &dvec[0]);
               // Current point may be inside the other node - geometry error that we ignore
               snext = TGeoShape::Big();
               if (!current->GetVolume()->Contains(dpt))
                  snext = current->GetVolume()->GetShape()->DistFromOutside(dpt, dvec, iact, fStep);
               if (snext<fStep-gTolerance) {
                  PopDummy();
                  PushPath(safelevel+1);
                  fCurrentMatrix->CopyFrom(fGlobalMatrix);
                  fCurrentMatrix->Multiply(current->GetMatrix());
                  fIsStepEntering = kFALSE;
                  fIsStepExiting = kTRUE;
                  icrossed = ovlps[i];
                  fStep = snext;
                  fNextNode = current;
               }
            } else {
               // another many - check if point is in or out
               current->cd();
               current->MasterToLocal(&mothpt[0], &dpt[0]);
               current->MasterToLocalVect(&vecpt[0], &dvec[0]);
               if (current->GetVolume()->Contains(dpt)) {
                  if (current->GetVolume()->GetNdaughters()) {
                     CdDown(ovlps[i]);
                     dnode = FindNextDaughterBoundary(dpt,dvec,idaughter,kFALSE);
                     if (dnode) {
                        fCurrentMatrix->CopyFrom(fGlobalMatrix);
                        fCurrentMatrix->Multiply(dnode->GetMatrix());
                        icrossed = idaughter;
                        PopDummy();
                        PushPath(safelevel+1);
                        fIsStepEntering = kFALSE;
                        fIsStepExiting = kTRUE;
                        fNextNode = dnode;
                     }   
                     CdUp();
                  }   
               } else {
                  snext = current->GetVolume()->GetShape()->DistFromOutside(dpt, dvec, iact, fStep);
                  if (snext<fStep-gTolerance) {
                     fCurrentMatrix->CopyFrom(fGlobalMatrix);
                     fCurrentMatrix->Multiply(current->GetMatrix());
                     fIsStepEntering = kFALSE;
                     fIsStepExiting = kTRUE;
                     fStep = snext;
                     fNextNode = current;
                     icrossed = ovlps[i];
                     PopDummy();
                     PushPath(safelevel+1);
                  }               
               }  
            }
         }
      }
      // Now we are in a non-overlapping node
      if (fNmany) {
      // We have overlaps up in the branch, check distance to exit
         Int_t up = 1;
         Int_t imother;
         Int_t nmany = fNmany;
         Bool_t ovlp = kFALSE;
         Bool_t nextovlp = kFALSE;
         Bool_t offset = kFALSE;
         TGeoNode *currentnode = fCurrentNode;
         TGeoNode *mothernode, *mup;
         TGeoHMatrix *matrix;
         while (nmany) {
            mothernode = GetMother(up);
            mup = mothernode;
            imother = up+1;
            offset = kFALSE;
            while (mup->IsOffset()) {
               mup = GetMother(imother++);
               offset = kTRUE;
            }   
            nextovlp = mup->IsOverlapping();
            if (offset) {
               mothernode = mup;
               if (nextovlp) nmany -= imother-up;
               up = imother-1;
            } else {    
               if (ovlp) nmany--;
            }
            if (ovlp || nextovlp) {
               matrix = GetMotherMatrix(up);
               matrix->MasterToLocal(fPoint,dpt);
               matrix->MasterToLocalVect(fDirection,dvec);
               snext = TGeoShape::Big();
               if (!mothernode->GetVolume()->IsAssembly()) snext = mothernode->GetVolume()->GetShape()->DistFromInside(dpt,dvec,iact,fStep);
                  fIsStepEntering = kFALSE;
                  fIsStepExiting  = kTRUE;
               if (snext<fStep-gTolerance) {
                  fNextNode = mothernode;
                  fCurrentMatrix->CopyFrom(matrix);
                  fStep = snext;
                  while (up--) CdUp();
                  PopDummy();
                  PushPath();
                  icrossed = -1;
                  up = 1;
                  currentnode = fCurrentNode;
                  ovlp = currentnode->IsOverlapping();
                  continue;
               }   
            }   
            currentnode = mothernode;
            ovlp = nextovlp;
            up++;            
         }
      }      
      PopPath();
   }
   // Compute now the distance in case we have a parallel world
   Double_t parstep = TGeoShape::Big();
   TGeoPhysicalNode *pnode = 0;
   if (fGeometry->IsParallelWorldNav()) {
      pnode = fGeometry->GetParallelWorld()->FindNextBoundary(fPoint, fDirection, parstep, fStep);
      if (pnode) {
         // A boundary is hit at less than fPStep
         fStep = parstep;
         fPoint[0] += fStep*fDirection[0];
         fPoint[1] += fStep*fDirection[1];
         fPoint[2] += fStep*fDirection[2];
         fNextNode = pnode->GetNode();
//         icrossed = -4; //
         fIsStepEntering  = kTRUE;
         fIsStepExiting  = kFALSE;
         cd(pnode->GetName());
         nextindex = fCurrentNode->GetVolume()->GetNextNodeIndex();
         while (nextindex>=0) {
            current = fCurrentNode;
            CdDown(nextindex);
            nextindex = fCurrentNode->GetVolume()->GetNextNodeIndex();
         }
         return fCurrentNode;
      }
   }
   fPoint[0] += fStep*fDirection[0];
   fPoint[1] += fStep*fDirection[1];
   fPoint[2] += fStep*fDirection[2];
   fStep += extra;      
   if (icrossed == -2) {
      // Nothing crossed within stepmax -> propagate and return same location   
      fIsOnBoundary = kFALSE;
      return fCurrentNode;
   }
   fIsOnBoundary = kTRUE;
   if (icrossed == -1) {
      // Exiting current node.
      skip = fCurrentNode;
      is_assembly = fCurrentNode->GetVolume()->IsAssembly();
      if (!fLevel && !is_assembly) {
         fIsOutside = kTRUE;
         return 0;
      }   
      if (fCurrentNode->IsOffset()) return CrossDivisionCell();   
      if (fLevel) CdUp();
      else        skip = 0;
      return CrossBoundaryAndLocate(kFALSE, skip);
   }   
   
   CdDown(icrossed);
   nextindex = fCurrentNode->GetVolume()->GetNextNodeIndex();
   while (nextindex>=0) {
      current = fCurrentNode;
      CdDown(nextindex);
      nextindex = fCurrentNode->GetVolume()->GetNextNodeIndex();
   }   
   fForcedNode = fCurrentNode;
   return CrossBoundaryAndLocate(kTRUE, current);
}   

//_____________________________________________________________________________
TGeoNode *TGeoNavigator::FindNode(Bool_t safe_start)
{
// Returns deepest node containing current point.
   fSafety = 0;
   fSearchOverlaps = kFALSE;
   fIsOutside = kFALSE;
   fIsEntering = fIsExiting = kFALSE;
   fIsOnBoundary = kFALSE;
   fStartSafe = safe_start;
   fIsSameLocation = kTRUE;
   TGeoNode *last = fCurrentNode;
   TGeoNode *found = SearchNode();
   if (found != last) {
      fIsSameLocation = kFALSE;
   } else {   
      if (last->IsOverlapping()) fIsSameLocation = kTRUE;
   }   
   return found;
}

//_____________________________________________________________________________
TGeoNode *TGeoNavigator::FindNode(Double_t x, Double_t y, Double_t z)
{
// Returns deepest node containing current point.
   fPoint[0] = x;
   fPoint[1] = y;
   fPoint[2] = z;
   fSafety = 0;
   fSearchOverlaps = kFALSE;
   fIsOutside = kFALSE;
   fIsEntering = fIsExiting = kFALSE;
   fIsOnBoundary = kFALSE;
   fStartSafe = kTRUE;
   fIsSameLocation = kTRUE;
   TGeoNode *last = fCurrentNode;
   TGeoNode *found = SearchNode();
   if (found != last) {
      fIsSameLocation = kFALSE;
   } else {   
      if (last->IsOverlapping()) fIsSameLocation = kTRUE;
   }   
   return found;
}

//_____________________________________________________________________________
Double_t *TGeoNavigator::FindNormalFast()
{
// Computes fast normal to next crossed boundary, assuming that the current point
// is close enough to the boundary. Works only after calling FindNextBoundary.
   if (!fNextNode) return 0;
   Double_t local[3];
   Double_t ldir[3];
   Double_t lnorm[3];
   fCurrentMatrix->MasterToLocal(fPoint, local);
   fCurrentMatrix->MasterToLocalVect(fDirection, ldir);
   fNextNode->GetVolume()->GetShape()->ComputeNormal(local, ldir,lnorm);
   fCurrentMatrix->LocalToMasterVect(lnorm, fNormal);
   return fNormal;
}

//_____________________________________________________________________________
Double_t *TGeoNavigator::FindNormal(Bool_t /*forward*/)
{
// Computes normal vector to the next surface that will be or was already
// crossed when propagating on a straight line from a given point/direction.
// Returns the normal vector cosines in the MASTER coordinate system. The dot
// product of the normal and the current direction is positive defined.
   return FindNormalFast();
}

//_____________________________________________________________________________
TGeoNode *TGeoNavigator::InitTrack(const Double_t *point, const Double_t *dir)
{
// Initialize current point and current direction vector (normalized)
// in MARS. Return corresponding node.
   SetCurrentPoint(point);
   SetCurrentDirection(dir);
   return FindNode();
}

//_____________________________________________________________________________
TGeoNode *TGeoNavigator::InitTrack(Double_t x, Double_t y, Double_t z, Double_t nx, Double_t ny, Double_t nz)
{
// Initialize current point and current direction vector (normalized)
// in MARS. Return corresponding node.
   SetCurrentPoint(x,y,z);
   SetCurrentDirection(nx,ny,nz);
   return FindNode();
}

//_____________________________________________________________________________
void TGeoNavigator::ResetState()
{
// Reset current state flags.
   fSearchOverlaps = kFALSE;
   fIsOutside = kFALSE;
   fIsEntering = fIsExiting = kFALSE;
   fIsOnBoundary = kFALSE;
   fIsStepEntering = fIsStepExiting = kFALSE;
}

//_____________________________________________________________________________
Double_t TGeoNavigator::Safety(Bool_t inside)
{
// Compute safe distance from the current point. This represent the distance
// from POINT to the closest boundary.

   if (fIsOnBoundary) {
      fSafety = 0;
      return fSafety;
   }
   Double_t point[3];
   Double_t safpar = TGeoShape::Big();
   if (!inside) fSafety = TGeoShape::Big();
   // Check if parallel navigation is enabled
   if (fGeometry->IsParallelWorldNav()) {
      safpar = fGeometry->GetParallelWorld()->Safety(fPoint);
   }   

   if (fIsOutside) {
      fSafety = fGeometry->GetTopVolume()->GetShape()->Safety(fPoint,kFALSE);
      if (fSafety < gTolerance) {
         fSafety = 0;
         fIsOnBoundary = kTRUE;
         return fSafety;
      }
      return TMath::Min(fSafety,safpar);
   }
   //---> convert point to local reference frame of current node
   fGlobalMatrix->MasterToLocal(fPoint, point);

   //---> compute safety to current node
   TGeoVolume *vol = fCurrentNode->GetVolume();
   if (!inside) {
      fSafety = vol->GetShape()->Safety(point, kTRUE);
      //---> if we were just entering, return this safety
      if (fSafety < gTolerance) {
         fSafety = 0;
         fIsOnBoundary = kTRUE;
         return fSafety;
      }
   }

   //---> Check against the parallel geometry safety
   if (safpar < fSafety) fSafety = safpar;

   //---> if we were just exiting, return this safety
   TObjArray *nodes = vol->GetNodes();
   Int_t nd = fCurrentNode->GetNdaughters();
   if (!nd && !fCurrentOverlapping) return fSafety;
   TGeoNode *node;
   Double_t safe;
   Int_t id;

   // if current volume is divided, we are in the non-divided region. We
   // check only the first and the last cell
   TGeoPatternFinder *finder = vol->GetFinder();
   if (finder) {
      Int_t ifirst = finder->GetDivIndex();
      node = (TGeoNode*)nodes->UncheckedAt(ifirst);
      node->cd();
      safe = node->Safety(point, kFALSE);
      if (safe < gTolerance) {
         fSafety=0;
         fIsOnBoundary = kTRUE;
         return fSafety;
      }
      if (safe<fSafety) fSafety=safe;
      Int_t ilast = ifirst+finder->GetNdiv()-1;
      if (ilast==ifirst) return fSafety;
      node = (TGeoNode*)nodes->UncheckedAt(ilast);
      node->cd();
      safe = node->Safety(point, kFALSE);
      if (safe < gTolerance) {
         fSafety=0;
         fIsOnBoundary = kTRUE;
         return fSafety;
      }
      if (safe<fSafety) fSafety=safe;
      if (fCurrentOverlapping  && !inside) SafetyOverlaps();
      return fSafety;
   }

   //---> If no voxels just loop daughters
   TGeoVoxelFinder *voxels = vol->GetVoxels();
   if (!voxels) {
      for (id=0; id<nd; id++) {
         node = (TGeoNode*)nodes->UncheckedAt(id);
         safe = node->Safety(point, kFALSE);
         if (safe < gTolerance) {
            fSafety=0;
            fIsOnBoundary = kTRUE;
            return fSafety;
         }
         if (safe<fSafety) fSafety=safe;
      }
      if (fNmany && !inside) SafetyOverlaps();
      return fSafety;
   } else {
      if (voxels->NeedRebuild()) {
         voxels->Voxelize();
         vol->FindOverlaps();
      }
   }      

   //---> check fast unsafe voxels
   Double_t *boxes = voxels->GetBoxes();
   for (id=0; id<nd; id++) {
      Int_t ist = 6*id;
      Double_t dxyz = 0.;
      Double_t dxyz0 = TMath::Abs(point[0]-boxes[ist+3])-boxes[ist];
      if (dxyz0 > fSafety) continue;
      Double_t dxyz1 = TMath::Abs(point[1]-boxes[ist+4])-boxes[ist+1];
      if (dxyz1 > fSafety) continue;
      Double_t dxyz2 = TMath::Abs(point[2]-boxes[ist+5])-boxes[ist+2];
      if (dxyz2 > fSafety) continue;
      if (dxyz0>0) dxyz+=dxyz0*dxyz0;
      if (dxyz1>0) dxyz+=dxyz1*dxyz1;
      if (dxyz2>0) dxyz+=dxyz2*dxyz2;
      if (dxyz >= fSafety*fSafety) continue;
      node = (TGeoNode*)nodes->UncheckedAt(id);
      safe = node->Safety(point, kFALSE);
      if (safe<gTolerance) {
         fSafety=0;
         fIsOnBoundary = kTRUE;
         return fSafety;
      }
      if (safe<fSafety) fSafety = safe;
   }
   if (fNmany  && !inside) SafetyOverlaps();
   return fSafety;
}

//_____________________________________________________________________________
void TGeoNavigator::SafetyOverlaps()
{
// Compute safe distance from the current point within an overlapping node
   Double_t point[3], local[3];
   Double_t safe;
   Bool_t contains;
   TGeoNode *nodeovlp;
   TGeoVolume *vol;
   Int_t novlp, io;
   Int_t *ovlp;
   Int_t safelevel = GetSafeLevel();
   PushPath(safelevel+1);
   while (fCurrentOverlapping) {
      ovlp = fCurrentNode->GetOverlaps(novlp);
      CdUp();
      vol = fCurrentNode->GetVolume();
      fGeometry->MasterToLocal(fPoint, point);
      contains = fCurrentNode->GetVolume()->Contains(point);
      safe = fCurrentNode->GetVolume()->GetShape()->Safety(point, contains);
      if (safe<fSafety && safe>=0) fSafety=safe;
      if (!novlp || !contains) continue;
      // we are now in the container, check safety to all candidates
      for (io=0; io<novlp; io++) {
         nodeovlp = vol->GetNode(ovlp[io]);
         nodeovlp->GetMatrix()->MasterToLocal(point,local);
         contains = nodeovlp->GetVolume()->Contains(local);
         if (contains) {
            CdDown(ovlp[io]);
            safe = Safety(kTRUE);
            CdUp();
         } else {
            safe = nodeovlp->GetVolume()->GetShape()->Safety(local, kFALSE);
         }
         if (safe<fSafety && safe>=0) fSafety=safe;
      }
   }
   if (fNmany) {
   // We have overlaps up in the branch, check distance to exit
      Int_t up = 1;
      Int_t imother;
      Int_t nmany = fNmany;
      Bool_t crtovlp = kFALSE;
      Bool_t nextovlp = kFALSE;
      TGeoNode *mother, *mup;
      TGeoHMatrix *matrix;
      while (nmany) {
         mother = GetMother(up);
         mup = mother;
         imother = up+1;
         while (mup->IsOffset()) mup = GetMother(imother++);
         nextovlp = mup->IsOverlapping();
         if (crtovlp) nmany--;
         if (crtovlp || nextovlp) {
            matrix = GetMotherMatrix(up);
            matrix->MasterToLocal(fPoint,local);
            safe = mother->GetVolume()->GetShape()->Safety(local,kTRUE);
            if (safe<fSafety) fSafety = safe;
            crtovlp = nextovlp;
         }
         up++;
      }      
   }
   PopPath();
   if (fSafety < gTolerance) {
      fSafety = 0.;
      fIsOnBoundary = kTRUE;
   }   
}

//_____________________________________________________________________________
TGeoNode *TGeoNavigator::SearchNode(Bool_t downwards, const TGeoNode *skipnode)
{
// Returns the deepest node containing fPoint, which must be set a priori.
   // Check if parallel world navigation is enabled
   if (fGeometry->IsParallelWorldNav()) {
      TGeoPhysicalNode *pnode = fGeometry->GetParallelWorld()->FindNode(fPoint);
      if (pnode) {
         // A node from the parallel world contains the point -> stop the search
         // and synchronize with navigation state
         pnode->cd();
         Int_t crtindex = fCurrentNode->GetVolume()->GetCurrentNodeIndex();
         while (crtindex>=0) {
        // Make sure we did not end up in an assembly.
            CdDown(crtindex);
            crtindex = fCurrentNode->GetVolume()->GetCurrentNodeIndex();
         }   
         return fCurrentNode;
      }
   }
   Double_t point[3];
   fNextDaughterIndex = -2;
   TGeoVolume *vol = 0;
   Int_t idebug = TGeoManager::GetVerboseLevel();
   Bool_t inside_current = (fCurrentNode==skipnode)?kTRUE:kFALSE;
   if (!downwards) {
   // we are looking upwards until inside current node or exit
      if (fGeometry->IsActivityEnabled() && !fCurrentNode->GetVolume()->IsActive()) {
         // We are inside an inactive volume-> go upwards
         CdUp();
         fIsSameLocation = kFALSE;
         return SearchNode(kFALSE, skipnode);
      }
      // Check if the current point is still inside the current volume
      vol=fCurrentNode->GetVolume();
      if (vol->IsAssembly()) inside_current=kTRUE;
      // If the current node is not to be skipped
      if (!inside_current) {
         fGlobalMatrix->MasterToLocal(fPoint, point);
         inside_current = vol->Contains(point);
      }   
      // Point might be inside an overlapping node
      if (fNmany) {
         inside_current = GotoSafeLevel();
      }   
      if (!inside_current) {
         // If not, go upwards
         fIsSameLocation = kFALSE;
         TGeoNode *skip = fCurrentNode;  // skip current node at next search
         // check if we can go up
         if (!fLevel) {
            fIsOutside = kTRUE;
            return 0;
         }
         CdUp();
         return SearchNode(kFALSE, skip);
      }
   }
   vol = fCurrentNode->GetVolume();
   fGlobalMatrix->MasterToLocal(fPoint, point);
   if (!inside_current && downwards) {
   // we are looking downwards
      if (fCurrentNode == fForcedNode) inside_current = kTRUE;
      else inside_current = vol->Contains(point);
      if (!inside_current) {
         fIsSameLocation = kFALSE;
         return 0;
      } else {
         if (fIsOutside) {
            fIsOutside = kFALSE;
            fIsSameLocation = kFALSE;
         }
         if (idebug>4) {
            printf("Search node local=(%19.16f, %19.16f, %19.16f) -> %s\n",
                   point[0],point[1],point[2], fCurrentNode->GetName());
         }                    
      }      
   }
   // point inside current (safe) node -> search downwards
   TGeoNode *node;
   Int_t ncheck = 0;
   // if inside an non-overlapping node, reset overlap searches
   if (!fCurrentOverlapping) {
      fSearchOverlaps = kFALSE;
   }

   Int_t crtindex = vol->GetCurrentNodeIndex();
   while (crtindex>=0 && downwards) {
      // Make sure we did not end up in an assembly.
      CdDown(crtindex);
      vol = fCurrentNode->GetVolume();
      crtindex = vol->GetCurrentNodeIndex();
      if (crtindex<0) fGlobalMatrix->MasterToLocal(fPoint, point);
   }   
      
   Int_t nd = vol->GetNdaughters();
   // in case there are no daughters
   if (!nd) return fCurrentNode;
   if (fGeometry->IsActivityEnabled() && !vol->IsActiveDaughters()) return fCurrentNode;

   TGeoPatternFinder *finder = vol->GetFinder();
   // point is inside the current node
   // first check if inside a division
   if (finder) {
      node=finder->FindNode(point);
      if (!node && fForcedNode) {
         // Point *HAS* to be inside a cell
         Double_t dir[3];
         fGlobalMatrix->MasterToLocalVect(fDirection, dir);
         finder->FindNode(point,dir);
         node = finder->CdNext();
         if (!node) return fCurrentNode;  // inside divided volume but not in a cell
      }   
      if (node && node!=skipnode) {
         // go inside the division cell and search downwards
         fIsSameLocation = kFALSE;
         CdDown(node->GetIndex());
         fForcedNode = 0;
         return SearchNode(kTRUE, node);
      }
      // point is not inside the division, but might be in other nodes
      // at the same level (NOT SUPPORTED YET)
      while (fCurrentNode && fCurrentNode->IsOffset()) CdUp();
      return fCurrentNode;
   }
   // second, look if current volume is voxelized
   TGeoVoxelFinder *voxels = vol->GetVoxels();
   Int_t *check_list = 0;
   Int_t id;
   if (voxels) {
      // get the list of nodes passing thorough the current voxel
      check_list = voxels->GetCheckList(&point[0], ncheck, *fCache->GetInfo());
      // if none in voxel, see if this is the last one
      if (!check_list) {
         if (!fCurrentNode->GetVolume()->IsAssembly()) {
            fCache->ReleaseInfo();
            return fCurrentNode;
         }   
         // Point in assembly - go up
         node = fCurrentNode;
         if (!fLevel) {
            fIsOutside = kTRUE;
            fCache->ReleaseInfo();
            return 0;
         }
         CdUp();
         fCache->ReleaseInfo();
         return SearchNode(kFALSE,node);
      }   
      // loop all nodes in voxel
      for (id=0; id<ncheck; id++) {
         node = vol->GetNode(check_list[id]);
         if (node==skipnode) continue;
         if (fGeometry->IsActivityEnabled() && !node->GetVolume()->IsActive()) continue;
         if ((id<(ncheck-1)) && node->IsOverlapping()) {
         // make the cluster of overlaps
            if (ncheck+fOverlapMark > fOverlapSize) {
               fOverlapSize = 2*(ncheck+fOverlapMark);
               delete [] fOverlapClusters;
               fOverlapClusters = new Int_t[fOverlapSize];
            }
            Int_t *cluster = fOverlapClusters + fOverlapMark;
            Int_t nc = GetTouchedCluster(id, &point[0], check_list, ncheck, cluster);
            if (nc>1) {
               fOverlapMark += nc;
               node = FindInCluster(cluster, nc);
               fOverlapMark -= nc;
               fCache->ReleaseInfo();
               return node;
            }
         }
         CdDown(check_list[id]);
         fForcedNode = 0;
         node = SearchNode(kTRUE);
         if (node) {
            fIsSameLocation = kFALSE;
            fCache->ReleaseInfo();
            return node;
         }
         CdUp();
      }
      if (!fCurrentNode->GetVolume()->IsAssembly()) {
         fCache->ReleaseInfo();
         return fCurrentNode;
      }   
      node = fCurrentNode;
      if (!fLevel) {
         fIsOutside = kTRUE;
         fCache->ReleaseInfo();
         return 0;
      }
      CdUp();
      fCache->ReleaseInfo();
      return SearchNode(kFALSE,node);
   }
   // if there are no voxels just loop all daughters
   for (id=0; id<nd; id++) {
      node=fCurrentNode->GetDaughter(id);
      if (node==skipnode) continue;  
      if (fGeometry->IsActivityEnabled() && !node->GetVolume()->IsActive()) continue;
      CdDown(id);
      fForcedNode = 0;
      node = SearchNode(kTRUE);
      if (node) {
         fIsSameLocation = kFALSE;
         return node;
      }
      CdUp();
   }      
   // point is not inside one of the daughters, so it is in the current vol
   if (fCurrentNode->GetVolume()->IsAssembly()) {
      node = fCurrentNode;
      if (!fLevel) {
         fIsOutside = kTRUE;
         return 0;
      }
      CdUp();
      return SearchNode(kFALSE,node);
   }      
   return fCurrentNode;
}

//_____________________________________________________________________________
TGeoNode *TGeoNavigator::FindInCluster(Int_t *cluster, Int_t nc)
{
// Find a node inside a cluster of overlapping nodes. Current node must
// be on top of all the nodes in cluster. Always nc>1.
   TGeoNode *clnode = 0;
   TGeoNode *priority = fLastNode;
   // save current node
   TGeoNode *current = fCurrentNode;
   TGeoNode *found = 0;
   // save path
   Int_t ipop = PushPath();
   // mark this search
   fSearchOverlaps = kTRUE;
   Int_t deepest = fLevel;
   Int_t deepest_virtual = fLevel-GetVirtualLevel();
   Int_t found_virtual = 0;
   Bool_t replace = kFALSE;
   Bool_t added = kFALSE;
   Int_t i;
   for (i=0; i<nc; i++) {
      clnode = current->GetDaughter(cluster[i]);
      CdDown(cluster[i]);
      Bool_t max_priority = (clnode==fNextNode)?kTRUE:kFALSE;
      found = SearchNode(kTRUE, clnode);
      if (!fSearchOverlaps || max_priority) {
      // an only was found during the search -> exiting
      // The node given by FindNextBoundary returned -> exiting
         PopDummy(ipop);
         return found;
      }
      found_virtual = fLevel-GetVirtualLevel();
      if (added) {
      // we have put something in stack -> check it
         if (found_virtual>deepest_virtual) {
            replace = kTRUE;
         } else {
            if (found_virtual==deepest_virtual) {
               if (fLevel>deepest) {
                  replace = kTRUE;
               } else {
                  if ((fLevel==deepest) && (clnode==priority)) replace=kTRUE;
                  else                                          replace = kFALSE;
               }
            } else                 replace = kFALSE;
         }
         // if this was the last checked node
         if (i==(nc-1)) {
            if (replace) {
               PopDummy(ipop);
               return found;
            } else {
               fCurrentOverlapping = PopPath();
               PopDummy(ipop);
               return fCurrentNode;
            }
         }
         // we still have to go on
         if (replace) {
            // reset stack
            PopDummy();
            PushPath();
            deepest = fLevel;
            deepest_virtual = found_virtual;
         }
         // restore top of cluster
         fCurrentOverlapping = PopPath(ipop);
      } else {
      // the stack was clean, push new one
         PushPath();
         added = kTRUE;
         deepest = fLevel;
         deepest_virtual = found_virtual;
         // restore original path
         fCurrentOverlapping = PopPath(ipop);
      }
   }
   PopDummy(ipop);
   return fCurrentNode;
}

//_____________________________________________________________________________
Int_t TGeoNavigator::GetTouchedCluster(Int_t start, Double_t *point,
                              Int_t *check_list, Int_t ncheck, Int_t *result)
{
// Make the cluster of overlapping nodes in a voxel, containing point in reference
// of the mother. Returns number of nodes containing the point. Nodes should not be
// offsets.

   // we are in the mother reference system
   TGeoNode *current = fCurrentNode->GetDaughter(check_list[start]);
   Int_t novlps = 0;
   Int_t *ovlps = current->GetOverlaps(novlps);
   if (!ovlps) return 0;
   Double_t local[3];
   // intersect check list with overlap list
   Int_t ntotal = 0;
   current->MasterToLocal(point, &local[0]);
   if (current->GetVolume()->Contains(&local[0])) {
      result[ntotal++]=check_list[start];
   }

   Int_t jst=0, i, j;
   while ((ovlps[jst]<=check_list[start]) && (jst<novlps))  jst++;
   if (jst==novlps) return 0;
   for (i=start; i<ncheck; i++) {
      for (j=jst; j<novlps; j++) {
         if (check_list[i]==ovlps[j]) {
         // overlapping node in voxel -> check if touched
            current = fCurrentNode->GetDaughter(check_list[i]);
            if (fGeometry->IsActivityEnabled() && !current->GetVolume()->IsActive()) continue;
            current->MasterToLocal(point, &local[0]);
            if (current->GetVolume()->Contains(&local[0])) {
               result[ntotal++]=check_list[i];
            }
         }
      }
   }
   return ntotal;
}

//_____________________________________________________________________________
TGeoNode *TGeoNavigator::Step(Bool_t is_geom, Bool_t cross)
{
// Make a rectiliniar step of length fStep from current point (fPoint) on current
// direction (fDirection). If the step is imposed by geometry, is_geom flag
// must be true (default). The cross flag specifies if the boundary should be
// crossed in case of a geometry step (default true). Returns new node after step.
// Set also on boundary condition.
   Double_t epsil = 0;
   if (fStep<1E-6) {
      fIsNullStep=kTRUE;
      if (fStep<0) fStep = 0.;
   } else {
      fIsNullStep=kFALSE;
   }
   if (is_geom) epsil=(cross)?1E-6:-1E-6;
   TGeoNode *old = fCurrentNode;
   Int_t idold = GetNodeId();
   if (fIsOutside) old = 0;
   fStep += epsil;
   for (Int_t i=0; i<3; i++) fPoint[i]+=fStep*fDirection[i];
   TGeoNode *current = FindNode();
   if (is_geom) {
      fIsEntering = (current==old)?kFALSE:kTRUE;
      if (!fIsEntering) {
         Int_t id = GetNodeId();
         fIsEntering = (id==idold)?kFALSE:kTRUE;
      }
      fIsExiting  = !fIsEntering;
      if (fIsEntering && fIsNullStep) fIsNullStep = kFALSE;
      fIsOnBoundary = kTRUE;
   } else {
      fIsEntering = fIsExiting = kFALSE;
      fIsOnBoundary = kFALSE;
   }
   return current;
}

//_____________________________________________________________________________
Int_t TGeoNavigator::GetVirtualLevel()
{
// Find level of virtuality of current overlapping node (number of levels
// up having the same tracking media.

   // return if the current node is ONLY
   if (!fCurrentOverlapping) return 0;
   Int_t new_media = 0;
   TGeoMedium *medium = fCurrentNode->GetMedium();
   Int_t virtual_level = 1;
   TGeoNode *mother = 0;

   while ((mother=GetMother(virtual_level))) {
      if (!mother->IsOverlapping() && !mother->IsOffset()) {
         if (!new_media) new_media=(mother->GetMedium()==medium)?0:virtual_level;
         break;
      }
      if (!new_media) new_media=(mother->GetMedium()==medium)?0:virtual_level;
      virtual_level++;
   }
   return (new_media==0)?virtual_level:(new_media-1);
}

//_____________________________________________________________________________
Bool_t TGeoNavigator::GotoSafeLevel()
{
// Go upwards the tree until a non-overlaping node
   while (fCurrentOverlapping && fLevel) CdUp();
   Double_t point[3];
   fGlobalMatrix->MasterToLocal(fPoint, point);
   if (!fCurrentNode->GetVolume()->Contains(point)) return kFALSE;
   if (fNmany) {
   // We still have overlaps on the branch
      Int_t up = 1;
      Int_t imother;
      Int_t nmany = fNmany;
      Bool_t ovlp = kFALSE;
      Bool_t nextovlp = kFALSE;
      TGeoNode *mother, *mup;
      TGeoHMatrix *matrix;
      while (nmany) {
         mother = GetMother(up);
         if (!mother) return kTRUE;
         mup = mother;
         imother = up+1;
         while (mup->IsOffset()) mup = GetMother(imother++);
         nextovlp = mup->IsOverlapping();
         if (ovlp) nmany--;
         if (ovlp || nextovlp) {
         // check if the point is in the next node up
            matrix = GetMotherMatrix(up);
            matrix->MasterToLocal(fPoint,point);
            if (!mother->GetVolume()->Contains(point)) {
               up++;
               while (up--) CdUp();
               return GotoSafeLevel();
            }
         }   
         ovlp = nextovlp;
         up++;
      }            
   }      
   return kTRUE;         
}

//_____________________________________________________________________________
Int_t TGeoNavigator::GetSafeLevel() const
{
// Go upwards the tree until a non-overlaping node
   Bool_t overlapping = fCurrentOverlapping;
   if (!overlapping) return fLevel;
   Int_t level = fLevel;
   TGeoNode *node;
   while (overlapping && level) {
      level--;
      node = GetMother(fLevel-level);
      if (!node->IsOffset()) overlapping = node->IsOverlapping();
   }
   return level;
}

//_____________________________________________________________________________
void TGeoNavigator::InspectState() const
{
// Inspects path and all flags for the current state.
   Info("InspectState","Current path is: %s",GetPath());
   Int_t level;
   TGeoNode *node;
   Bool_t is_offset, is_overlapping;
   for (level=0; level<fLevel+1; level++) {
      node = GetMother(fLevel-level);
      if (!node) continue;
      is_offset = node->IsOffset();
      is_overlapping = node->IsOverlapping();
      Info("InspectState","level %i: %s  div=%i  many=%i",level,node->GetName(),is_offset,is_overlapping);
   }
   Info("InspectState","on_bound=%i   entering=%i", fIsOnBoundary, fIsEntering);
}      

//_____________________________________________________________________________
Bool_t TGeoNavigator::IsSameLocation(Double_t x, Double_t y, Double_t z, Bool_t change)
{
// Checks if point (x,y,z) is still in the current node.
   // check if this is an overlapping node
   Double_t oldpt[3];
   if (fLastSafety>0) {
      Double_t dx = (x-fLastPoint[0]);
      Double_t dy = (y-fLastPoint[1]);
      Double_t dz = (z-fLastPoint[2]);
      Double_t dsq = dx*dx+dy*dy+dz*dz;
      if (dsq<fLastSafety*fLastSafety) {
         if (change) {
            fPoint[0] = x;
            fPoint[1] = y;
            fPoint[2] = z;
            memcpy(fLastPoint, fPoint, 3*sizeof(Double_t));
            fLastSafety -= TMath::Sqrt(dsq);
         }
         return kTRUE;
      }  
      if (change) fLastSafety = 0;
   }
   if (fCurrentOverlapping) {
//      TGeoNode *current = fCurrentNode;
      Int_t cid = GetCurrentNodeId();
      if (!change) PushPoint();
      memcpy(oldpt, fPoint, kN3);
      SetCurrentPoint(x,y,z);
      SearchNode();
      memcpy(fPoint, oldpt, kN3);
      Bool_t same = (cid==GetCurrentNodeId())?kTRUE:kFALSE;
      if (!change) PopPoint();
      return same;
   }

   Double_t point[3];
   point[0] = x;
   point[1] = y;
   point[2] = z;
   if (change) memcpy(fPoint, point, kN3);
   TGeoVolume *vol = fCurrentNode->GetVolume();
   if (fIsOutside) {
      if (vol->GetShape()->Contains(point)) {
         if (!change) return kFALSE;
         FindNode(x,y,z);
         return kFALSE;
      }
      return kTRUE;
   }
   Double_t local[3];
   // convert to local frame
   fGlobalMatrix->MasterToLocal(point,local);
   // check if still in current volume.
   if (!vol->GetShape()->Contains(local)) {
      if (!change) return kFALSE;
      CdUp();
      FindNode(x,y,z);
      return kFALSE;
   }
   
   // Check if the point is in a parallel world volume
   if (fGeometry->IsParallelWorldNav()) {
      TGeoPhysicalNode *pnode = fGeometry->GetParallelWorld()->FindNode(fPoint);
      if (pnode) {
         if (!change) return kFALSE;
         pnode->cd();
         Int_t crtindex = fCurrentNode->GetVolume()->GetCurrentNodeIndex();
         while (crtindex>=0) {
        // Make sure we did not end up in an assembly.
            CdDown(crtindex);
            crtindex = fCurrentNode->GetVolume()->GetCurrentNodeIndex();
         }
         return kFALSE;
      }
   }      
   // check if there are daughters
   Int_t nd = vol->GetNdaughters();
   if (!nd) return kTRUE;

   TGeoNode *node;
   TGeoPatternFinder *finder = vol->GetFinder();
   if (finder) {
      node=finder->FindNode(local);
      if (node) {
         if (!change) return kFALSE;
         CdDown(node->GetIndex());
         SearchNode(kTRUE,node);
         return kFALSE;
      }
      return kTRUE;
   }
   // if we are not allowed to do changes, save the current path
   TGeoVoxelFinder *voxels = vol->GetVoxels();
   Int_t *check_list = 0;
   Int_t ncheck = 0;
   Double_t local1[3];
   if (voxels) {
      check_list = voxels->GetCheckList(local, ncheck, *fCache->GetInfo());
      if (!check_list) {
         fCache->ReleaseInfo();
         return kTRUE;
      }   
      if (!change) PushPath();
      for (Int_t id=0; id<ncheck; id++) {
//         node = vol->GetNode(check_list[id]);
         CdDown(check_list[id]);
         fGlobalMatrix->MasterToLocal(point,local1);
         if (fCurrentNode->GetVolume()->GetShape()->Contains(local1)) {
            if (!change) {
               PopPath();
               fCache->ReleaseInfo();
               return kFALSE;
            }
            SearchNode(kTRUE);
            fCache->ReleaseInfo();
            return kFALSE;
         }
         CdUp();
      }
      if (!change) PopPath();
      fCache->ReleaseInfo();
      return kTRUE;
   }
   Int_t id = 0;
   if (!change) PushPath();
   while (fCurrentNode && fCurrentNode->GetDaughter(id++)) {
      CdDown(id-1);
      fGlobalMatrix->MasterToLocal(point,local1);
      if (fCurrentNode->GetVolume()->GetShape()->Contains(local1)) {
         if (!change) {
            PopPath();
            return kFALSE;
         }
         SearchNode(kTRUE);
         return kFALSE;
      }
      CdUp();
      if (id == nd) {
         if (!change) PopPath();
         return kTRUE;
      }
   }
   if (!change) PopPath();
   return kTRUE;
}

//_____________________________________________________________________________
Bool_t TGeoNavigator::IsSafeStep(Double_t proposed, Double_t &newsafety) const
{
// In case a previous safety value was computed, check if the safety region is
// still safe for the current point and proposed step. Return value changed only
// if proposed distance is safe.

   // Last safety not computed.
   if (fLastSafety < gTolerance) return kFALSE;
   // Proposed step too small
   if (proposed < gTolerance) {
      newsafety = fLastSafety - proposed;
      return kTRUE;
   }
   // Normal step
   Double_t dist = (fPoint[0]-fLastPoint[0])*(fPoint[0]-fLastPoint[0])+
                   (fPoint[1]-fLastPoint[1])*(fPoint[1]-fLastPoint[1])+
                   (fPoint[2]-fLastPoint[2])*(fPoint[2]-fLastPoint[2]);
   dist = TMath::Sqrt(dist);
   Double_t safe =  fLastSafety - dist;
   if (safe < proposed) return kFALSE;
   newsafety = safe;
   return kTRUE;
}

//_____________________________________________________________________________
Bool_t TGeoNavigator::IsSamePoint(Double_t x, Double_t y, Double_t z) const
{
// Check if a new point with given coordinates is the same as the last located one.
   if (TMath::Abs(x-fLastPoint[0]) < 1.E-20) {
      if (TMath::Abs(y-fLastPoint[1]) < 1.E-20) {
         if (TMath::Abs(z-fLastPoint[2]) < 1.E-20) return kTRUE;
      }
   }
   return kFALSE;
}
  
//_____________________________________________________________________________
void TGeoNavigator::DoBackupState()
{
// Backup the current state without affecting the cache stack.
   if (fBackupState) fBackupState->SetState(fLevel,0, fNmany, fCurrentOverlapping);
}

//_____________________________________________________________________________
void TGeoNavigator::DoRestoreState()
{
// Restore a backed-up state without affecting the cache stack.
   if (fBackupState && fCache) {
      fCurrentOverlapping = fCache->RestoreState(fNmany, fBackupState);
      fCurrentNode=fCache->GetNode();
      fGlobalMatrix = fCache->GetCurrentMatrix();
      fLevel=fCache->GetLevel();
   }   
}

//_____________________________________________________________________________
TGeoHMatrix *TGeoNavigator::GetHMatrix()
{
// Return stored current matrix (global matrix of the next touched node).
   if (!fCurrentMatrix) {
      fCurrentMatrix = new TGeoHMatrix();
      fCurrentMatrix->RegisterYourself();
   }   
   return fCurrentMatrix;
}

//_____________________________________________________________________________
const char *TGeoNavigator::GetPath() const
{
// Get path to the current node in the form /node0/node1/...
   if (fIsOutside) return kGeoOutsidePath;
   return fCache->GetPath();
}

//______________________________________________________________________________
void TGeoNavigator::MasterToTop(const Double_t *master, Double_t *top) const
{
// Convert coordinates from master volume frame to top.
   fCurrentMatrix->MasterToLocal(master, top);
}

//______________________________________________________________________________
void TGeoNavigator::TopToMaster(const Double_t *top, Double_t *master) const
{
// Convert coordinates from top volume frame to master.
   fCurrentMatrix->LocalToMaster(top, master);
}

//______________________________________________________________________________
void TGeoNavigator::ResetAll()
{
// Reset the navigator.
   GetHMatrix();
   *fCurrentMatrix = gGeoIdentity;
   fCurrentNode = fGeometry->GetTopNode();
   ResetState();
   fStep = 0.;
   fSafety = 0.;
   fLastSafety = 0.;
   fLevel = 0;
   fNmany = 0;
   fNextDaughterIndex = -2;
   fCurrentOverlapping = kFALSE;
   fStartSafe = kFALSE;
   fIsSameLocation = kFALSE;
   fIsNullStep = kFALSE;
   fCurrentVolume = fGeometry->GetTopVolume();
   fCurrentNode = fGeometry->GetTopNode();
   fLastNode = 0;
   fNextNode = 0;
   fPath = "";
   if (fCache) {
      Bool_t dummy=fCache->IsDummy();
      Bool_t nodeid = fCache->HasIdArray();
      delete fCache;
      delete fBackupState;
      fCache = 0;
      BuildCache(dummy,nodeid);
   }
}

ClassImp(TGeoNavigatorArray)

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