ROOT logo
// @(#)root/geom:$Id: TGeoVoxelFinder.cxx 27731 2009-03-09 17:40:56Z brun $
// Author: Andrei Gheata   04/02/02

/*************************************************************************
 * 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.             *
 *************************************************************************/

////////////////////////////////////////////////////////////////////////////////
// Full description with examples and pictures
//
//
//
//
//Begin_Html
/*
<img src="gif/t_finder.jpg">
<img src="gif/t_voxelfind.jpg">
<img src="gif/t_voxtree.jpg">
*/
//End_Html
#include "TObject.h"
#include "TGeoMatrix.h"
#include "TGeoBBox.h"
#include "TGeoNode.h"
#include "TGeoManager.h"
#include "TMath.h"

#include "TGeoVoxelFinder.h"

/*************************************************************************
 * TGeoVoxelFinder - finder class handling voxels 
 *  
 *************************************************************************/

ClassImp(TGeoVoxelFinder)


//_____________________________________________________________________________
TGeoVoxelFinder::TGeoVoxelFinder()
{
// Default constructor
   fVolume  = 0;
   fNboxes  = 0;
   fIbx     = 0;
   fIby     = 0;
   fIbz     = 0;
   fNox     = 0;
   fNoy     = 0;
   fNoz     = 0;
   fNex     = 0;
   fNey     = 0;
   fNez     = 0;
   fNx      = 0;
   fNy      = 0;
   fNz      = 0;
   fBoxes   = 0;
   fXb      = 0;
   fYb      = 0;
   fZb      = 0;
   fOBx     = 0;
   fOBy     = 0;
   fOBz     = 0;
   fOEx     = 0;
   fOEy     = 0;
   fOEz     = 0;
   fIndcX   = 0;
   fIndcY   = 0;
   fIndcZ   = 0;
   fExtraX  = 0;
   fExtraY  = 0;
   fExtraZ  = 0;
   fNsliceX = 0;
   fNsliceY = 0;
   fNsliceZ = 0;
   fCheckList    = 0;
   fNcandidates  = 0;
   fCurrentVoxel = 0;
   fBits1    = 0;
   SetInvalid(kFALSE);
}
//_____________________________________________________________________________
TGeoVoxelFinder::TGeoVoxelFinder(TGeoVolume *vol)
{
// Default constructor
   if (!vol) return;
   fVolume  = vol;
   fVolume->SetCylVoxels(kFALSE);
   fNboxes   = 0;
   fIbx      = 0;
   fIby      = 0;
   fIbz      = 0;
   fNox      = 0;
   fNoy      = 0;
   fNoz      = 0;
   fNex     = 0;
   fNey     = 0;
   fNez     = 0;
   fNx       = 0;
   fNy       = 0;
   fNz       = 0;
   fBoxes    = 0;
   fXb       = 0;
   fYb       = 0;
   fZb       = 0;
   fOBx      = 0;
   fOBy      = 0;
   fOBz      = 0;
   fOEx     = 0;
   fOEy     = 0;
   fOEz     = 0;
   fIndcX   = 0;
   fIndcY   = 0;
   fIndcZ   = 0;
   fExtraX  = 0;
   fExtraY  = 0;
   fExtraZ  = 0;
   fNsliceX = 0;
   fNsliceY = 0;
   fNsliceZ = 0;
   fCheckList = 0;
   fNcandidates  = 0;
   fCurrentVoxel = 0;
   fBits1    = 0;
   SetNeedRebuild();
}

//_____________________________________________________________________________
TGeoVoxelFinder::TGeoVoxelFinder(const TGeoVoxelFinder& vf) :
  TObject(vf),
  fVolume(vf.fVolume),
  fNcandidates(vf.fNcandidates),
  fCurrentVoxel(vf.fCurrentVoxel),
  fIbx(vf.fIbx),
  fIby(vf.fIby),
  fIbz(vf.fIbz),
  fNboxes(vf.fNboxes),
  fNox(vf.fNox),
  fNoy(vf.fNoy),
  fNoz(vf.fNoz),
  fNex(vf.fNex),
  fNey(vf.fNey),
  fNez(vf.fNez),
  fNx(vf.fNx),
  fNy(vf.fNy),
  fNz(vf.fNz),
  fBoxes(vf.fBoxes),
  fXb(vf.fXb),
  fYb(vf.fYb),
  fZb(vf.fZb),
  fOBx(vf.fOBx),
  fOBy(vf.fOBy),
  fOBz(vf.fOBz),
  fOEx(vf.fOEx),
  fOEy(vf.fOEy),
  fOEz(vf.fOEz),
  fExtraX(vf.fExtraX),
  fExtraY(vf.fExtraY),
  fExtraZ(vf.fExtraZ),
  fNsliceX(vf.fNsliceX),
  fNsliceY(vf.fNsliceY),
  fNsliceZ(vf.fNsliceZ),
  fIndcX(vf.fIndcX),
  fIndcY(vf.fIndcY),
  fIndcZ(vf.fIndcZ),
  fCheckList(vf.fCheckList),
  fBits1(vf.fBits1)
{
   //copy constructor
   for(Int_t i=0; i<3; i++) {
      fPriority[i]=vf.fPriority[i];
      fSlices[i]=vf.fSlices[i];
      fInc[i]=vf.fInc[i];
      fInvdir[i]=vf.fInvdir[i];
      fLimits[i]=vf.fLimits[i];
   }
}

//_____________________________________________________________________________
TGeoVoxelFinder& TGeoVoxelFinder::operator=(const TGeoVoxelFinder& vf)
{
   //assignment operator
   if(this!=&vf) {
      TObject::operator=(vf);
      fVolume=vf.fVolume;
      fNcandidates=vf.fNcandidates;
      fCurrentVoxel=vf.fCurrentVoxel;
      fIbx=vf.fIbx;
      fIby=vf.fIby;
      fIbz=vf.fIbz;
      fNboxes=vf.fNboxes;
      fNox=vf.fNox;
      fNoy=vf.fNoy;
      fNoz=vf.fNoz;
      fNex=vf.fNex;
      fNey=vf.fNey;
      fNez=vf.fNez;
      fNx=vf.fNx;
      fNy=vf.fNy;
      fNz=vf.fNz;
      for(Int_t i=0; i<3; i++) {
         fPriority[i]=vf.fPriority[i];
         fSlices[i]=vf.fSlices[i];
         fInc[i]=vf.fInc[i];
         fInvdir[i]=vf.fInvdir[i];
         fLimits[i]=vf.fLimits[i];
      }
      fBoxes=vf.fBoxes;
      fXb=vf.fXb;
      fYb=vf.fYb;
      fZb=vf.fZb;
      fOBx=vf.fOBx;
      fOBy=vf.fOBy;
      fOBz=vf.fOBz;
      fOEx=vf.fOEx;
      fOEy=vf.fOEy;
      fOEz=vf.fOEz;
      fNsliceX=vf.fNsliceX;
      fNsliceY=vf.fNsliceY;
      fNsliceZ=vf.fNsliceZ;
      fIndcX=vf.fIndcX;
      fIndcY=vf.fIndcY;
      fIndcZ=vf.fIndcZ;
      fExtraX=vf.fExtraX;
      fExtraY=vf.fExtraY;
      fExtraZ=vf.fExtraZ;
      fCheckList=vf.fCheckList;
      fBits1=vf.fBits1;
   } 
   return *this;
}

//_____________________________________________________________________________
TGeoVoxelFinder::~TGeoVoxelFinder()
{
// Destructor
//   printf("deleting finder of %s\n", fVolume->GetName());
   if (fOBx) delete [] fOBx;
   if (fOBy) delete [] fOBy;
   if (fOBz) delete [] fOBz;
   if (fOEx) delete [] fOEx;
   if (fOEy) delete [] fOEy;
   if (fOEz) delete [] fOEz;
//   printf("OBx OBy OBz...\n");
   if (fBoxes) delete [] fBoxes;
//   printf("boxes...\n");
   if (fXb) delete [] fXb;
   if (fYb) delete [] fYb;
   if (fZb) delete [] fZb;
//   printf("Xb Yb Zb...\n");
   if (fNsliceX) delete [] fNsliceX;
   if (fNsliceY) delete [] fNsliceY;
   if (fNsliceZ) delete [] fNsliceZ;
   if (fIndcX) delete [] fIndcX;
   if (fIndcY) delete [] fIndcY;
   if (fIndcZ) delete [] fIndcZ;
   if (fExtraX) delete [] fExtraX;
   if (fExtraY) delete [] fExtraY;
   if (fExtraZ) delete [] fExtraZ;
//   printf("IndX IndY IndZ...\n");
   if (fCheckList) delete [] fCheckList;
   if (fBits1) delete [] fBits1;
//   printf("checklist...\n");
}
//_____________________________________________________________________________
void TGeoVoxelFinder::BuildVoxelLimits()
{
// build the array of bounding boxes of the nodes inside
   Int_t nd = fVolume->GetNdaughters();
   if (!nd) return;
   Int_t id;
   TGeoNode *node;
   if (fBoxes) delete [] fBoxes;
   if (fBits1) delete [] fBits1;
   fBits1 = new UChar_t[1+((nd-1)>>3)];
   fNboxes = 6*nd;
   fBoxes = new Double_t[fNboxes];
   if (fCheckList) delete [] fCheckList;
   fCheckList = new Int_t[nd];
   Double_t vert[24];
   Double_t pt[3];
   Double_t xyz[6];
//   printf("boundaries for %s :\n", GetName());
   TGeoBBox *box = 0;
   for (id=0; id<nd; id++) {
      node = fVolume->GetNode(id);
//      if (!strcmp(node->ClassName(), "TGeoNodeOffset") continue;
      box = (TGeoBBox*)node->GetVolume()->GetShape();
      box->SetBoxPoints(&vert[0]);
      for (Int_t point=0; point<8; point++) {
         DaughterToMother(id, &vert[3*point], &pt[0]);
         if (!point) {
            xyz[0] = xyz[1] = pt[0];
            xyz[2] = xyz[3] = pt[1];
            xyz[4] = xyz[5] = pt[2];
            continue;
         }
         for (Int_t j=0; j<3; j++) {
            if (pt[j] < xyz[2*j]) xyz[2*j]=pt[j];
            if (pt[j] > xyz[2*j+1]) xyz[2*j+1]=pt[j];
         }
      }
      fBoxes[6*id]   = 0.5*(xyz[1]-xyz[0]); // dX
      fBoxes[6*id+1] = 0.5*(xyz[3]-xyz[2]); // dY
      fBoxes[6*id+2] = 0.5*(xyz[5]-xyz[4]); // dZ
      fBoxes[6*id+3] = 0.5*(xyz[0]+xyz[1]); // Ox
      fBoxes[6*id+4] = 0.5*(xyz[2]+xyz[3]); // Oy
      fBoxes[6*id+5] = 0.5*(xyz[4]+xyz[5]); // Oz
   }
}
//_____________________________________________________________________________
void TGeoVoxelFinder::CreateCheckList()
{
// Initializes check list.
   if (NeedRebuild()) {
      Voxelize();
      fVolume->FindOverlaps();
   }   
   Int_t nd = fVolume->GetNdaughters();
   if (!nd) return;
   if (!fCheckList) fCheckList = new Int_t[nd];
   if (!fBits1) fBits1 = new UChar_t[1+((nd-1)>>3)];
}      
//_____________________________________________________________________________
void TGeoVoxelFinder::DaughterToMother(Int_t id, Double_t *local, Double_t *master) const
{
// convert a point from the local reference system of node id to reference
// system of mother volume
   TGeoMatrix *mat = fVolume->GetNode(id)->GetMatrix();
   if (!mat) memcpy(master,local,3*sizeof(Double_t));
   else      mat->LocalToMaster(local, master);
}
//_____________________________________________________________________________
Bool_t TGeoVoxelFinder::IsSafeVoxel(Double_t *point, Int_t inode, Double_t minsafe) const
{
// Computes squared distance from POINT to the voxel(s) containing node INODE. Returns 0
// if POINT inside voxel(s).
   if (NeedRebuild()) {
      TGeoVoxelFinder *vox = (TGeoVoxelFinder*)this;
      vox->Voxelize();
      fVolume->FindOverlaps();
   }   
   Double_t dxyz, minsafe2=minsafe*minsafe;
   Int_t ist = 6*inode;
   Int_t i;
   Double_t rsq = 0;
   for (i=0; i<3; i++) {
      dxyz = TMath::Abs(point[i]-fBoxes[ist+i+3])-fBoxes[ist+i];
      if (dxyz>-1E-6) rsq+=dxyz*dxyz;
      if (rsq > minsafe2*(1.+TGeoShape::Tolerance())) return kTRUE;
   }
   return kFALSE;
}      

//_____________________________________________________________________________
Double_t TGeoVoxelFinder::Efficiency()
{
//--- Compute voxelization efficiency.
   printf("Voxelization efficiency for %s\n", fVolume->GetName());
   if (NeedRebuild()) {
      Voxelize();
      fVolume->FindOverlaps();
   }   
   Double_t nd = Double_t(fVolume->GetNdaughters());
   Double_t eff = 0;
   Double_t effslice = 0;
   Int_t id;
   if (fPriority[0]) {
      for (id=0; id<fIbx-1; id++) {  // loop on boundaries
         effslice += fNsliceX[id];
      }
      if (!TGeoShape::IsSameWithinTolerance(effslice,0)) effslice = nd/effslice;
      else printf("Woops : slice X\n");
   }
   printf("X efficiency : %g\n", effslice);
   eff += effslice;
   effslice = 0;
   if (fPriority[1]) {
      for (id=0; id<fIby-1; id++) {  // loop on boundaries
         effslice += fNsliceY[id];
      }
      if (!TGeoShape::IsSameWithinTolerance(effslice,0)) effslice = nd/effslice;
      else printf("Woops : slice X\n");
   }
   printf("Y efficiency : %g\n", effslice);
   eff += effslice;
   effslice = 0;
   if (fPriority[2]) {
      for (id=0; id<fIbz-1; id++) {  // loop on boundaries
         effslice += fNsliceZ[id];
      }
      if (!TGeoShape::IsSameWithinTolerance(effslice,0)) effslice = nd/effslice;
      else printf("Woops : slice X\n");
   }
   printf("Z efficiency : %g\n", effslice);
   eff += effslice;
   eff /= 3.;
   printf("Total efficiency : %g\n", eff);
   return eff;
}
//_____________________________________________________________________________
void TGeoVoxelFinder::FindOverlaps(Int_t inode) const
{
// create the list of nodes for which the bboxes overlap with inode's bbox
   if (!fBoxes) return;
   Double_t xmin, xmax, ymin, ymax, zmin, zmax;
   Double_t xmin1, xmax1, ymin1, ymax1, zmin1, zmax1;
   Double_t ddx1, ddx2;
   Int_t nd = fVolume->GetNdaughters();
   Int_t *ovlps = 0;
   Int_t *otmp = new Int_t[nd-1]; 
   Int_t novlp = 0;
   TGeoNode *node = fVolume->GetNode(inode);
   xmin = fBoxes[6*inode+3] - fBoxes[6*inode];
   xmax = fBoxes[6*inode+3] + fBoxes[6*inode];
   ymin = fBoxes[6*inode+4] - fBoxes[6*inode+1];
   ymax = fBoxes[6*inode+4] + fBoxes[6*inode+1];
   zmin = fBoxes[6*inode+5] - fBoxes[6*inode+2];
   zmax = fBoxes[6*inode+5] + fBoxes[6*inode+2];
   // loop on brothers
   for (Int_t ib=0; ib<nd; ib++) {
      if (ib == inode) continue; // everyone overlaps with itself
      xmin1 = fBoxes[6*ib+3] - fBoxes[6*ib];
      xmax1 = fBoxes[6*ib+3] + fBoxes[6*ib];
      ymin1 = fBoxes[6*ib+4] - fBoxes[6*ib+1];
      ymax1 = fBoxes[6*ib+4] + fBoxes[6*ib+1];
      zmin1 = fBoxes[6*ib+5] - fBoxes[6*ib+2];
      zmax1 = fBoxes[6*ib+5] + fBoxes[6*ib+2];

      ddx1 = xmax-xmin1;
      ddx2 = xmax1-xmin;
      if (ddx1*ddx2 <= 0.) continue;
      ddx1 = ymax-ymin1;
      ddx2 = ymax1-ymin;
      if (ddx1*ddx2 <= 0.) continue;
      ddx1 = zmax-zmin1;
      ddx2 = zmax1-zmin;
      if (ddx1*ddx2 <= 0.) continue;
      otmp[novlp++] = ib;
   }
   if (!novlp) {
      delete [] otmp;
      node->SetOverlaps(ovlps, 0);
      return;
   }
   ovlps = new Int_t[novlp];
   memcpy(ovlps, otmp, novlp*sizeof(Int_t));
   delete [] otmp;
   node->SetOverlaps(ovlps, novlp);
}

//_____________________________________________________________________________
Bool_t TGeoVoxelFinder::GetIndices(Double_t *point)
{
// Getindices for current slices on x, y, z
   fSlices[0] = -2; // -2 means 'all daughters in slice'
   fSlices[1] = -2;
   fSlices[2] = -2;
   Bool_t flag=kTRUE;
   if (fPriority[0]) {
      fSlices[0] = TMath::BinarySearch(fIbx, fXb, point[0]);
      if ((fSlices[0]<0) || (fSlices[0]>=fIbx-1)) {
         // outside slices
         flag=kFALSE;
      } else {   
         if (fPriority[0]==2) {
            // nothing in current slice 
            if (!fNsliceX[fSlices[0]]) flag = kFALSE;
         }   
      }
   }   
   if (fPriority[1]) {
      fSlices[1] = TMath::BinarySearch(fIby, fYb, point[1]);
      if ((fSlices[1]<0) || (fSlices[1]>=fIby-1)) {
         // outside slices
         flag=kFALSE;
      } else {   
         if (fPriority[1]==2) {
            // nothing in current slice 
            if (!fNsliceY[fSlices[1]]) flag = kFALSE;
         }
      }
   }   
   if (fPriority[2]) {
      fSlices[2] = TMath::BinarySearch(fIbz, fZb, point[2]);
      if ((fSlices[2]<0) || (fSlices[2]>=fIbz-1)) return kFALSE;
      if (fPriority[2]==2) {
         // nothing in current slice 
         if (!fNsliceZ[fSlices[2]]) return kFALSE;
      }
   }       
   return flag;
}

//_____________________________________________________________________________
Int_t *TGeoVoxelFinder::GetExtraX(Int_t islice, Bool_t left, Int_t &nextra) const
{
//--- Return the list of extra candidates in a given X slice compared to
// another (left or right)
   Int_t *list = 0;
   nextra = 0;
   if (fPriority[0]!=2) return list;
   if (left) {
      nextra = fExtraX[fOEx[islice]];
      list = &fExtraX[fOEx[islice]+2];
   } else {
      nextra = fExtraX[fOEx[islice]+1];
      list = &fExtraX[fOEx[islice]+2+fExtraX[fOEx[islice]]];
   }
   return list;   
}
         
//_____________________________________________________________________________
Int_t *TGeoVoxelFinder::GetExtraY(Int_t islice, Bool_t left, Int_t &nextra) const
{
//--- Return the list of extra candidates in a given Y slice compared to
// another (left or right)
   Int_t *list = 0;
   nextra = 0;
   if (fPriority[1]!=2) return list;
   if (left) {
      nextra = fExtraY[fOEy[islice]];
      list = &fExtraY[fOEy[islice]+2];
   } else {
      nextra = fExtraY[fOEy[islice]+1];
      list = &fExtraY[fOEy[islice]+2+fExtraY[fOEy[islice]]];
   }
   return list;   
}
         
//_____________________________________________________________________________
Int_t *TGeoVoxelFinder::GetExtraZ(Int_t islice, Bool_t left, Int_t &nextra) const
{
//--- Return the list of extra candidates in a given Z slice compared to
// another (left or right)
   Int_t *list = 0;
   nextra = 0;
   if (fPriority[2]!=2) return list;
   if (left) {
      nextra = fExtraZ[fOEz[islice]];
      list = &fExtraZ[fOEz[islice]+2];
   } else {
      nextra = fExtraZ[fOEz[islice]+1];
      list = &fExtraZ[fOEz[islice]+2+fExtraZ[fOEz[islice]]];
   }
   return list;   
}

//_____________________________________________________________________________
Int_t *TGeoVoxelFinder::GetValidExtra(Int_t *list, Int_t &ncheck)
{
// Get extra candidates that are not contained in current check list
//   UChar_t *bits = gGeoManager->GetBits();
   fNcandidates = 0;
   Int_t icand;
   UInt_t bitnumber, loc;
   UChar_t bit, byte;
   for (icand=0; icand<ncheck; icand++) {
      bitnumber = (UInt_t)list[icand];
      loc = bitnumber>>3;
      bit = bitnumber%8;
      byte = (~fBits1[loc]) & (1<<bit);
      if (byte) fCheckList[fNcandidates++]=list[icand];
   }
   ncheck = fNcandidates;
   return fCheckList;        
}      

//_____________________________________________________________________________
Int_t *TGeoVoxelFinder::GetValidExtra(Int_t /*n1*/, UChar_t *array1, Int_t *list, Int_t &ncheck)
{
// Get extra candidates that are contained in array1 but not in current check list
//   UChar_t *bits = gGeoManager->GetBits();
   fNcandidates = 0;
   Int_t icand;
   UInt_t bitnumber, loc;
   UChar_t bit, byte;
   for (icand=0; icand<ncheck; icand++) {
      bitnumber = (UInt_t)list[icand];
      loc = bitnumber>>3;
      bit = bitnumber%8;
      byte = (~fBits1[loc]) & array1[loc] & (1<<bit);
      if (byte) fCheckList[fNcandidates++]=list[icand];
   }
   ncheck = fNcandidates;
   return fCheckList;        
}      

//_____________________________________________________________________________
Int_t *TGeoVoxelFinder::GetValidExtra(Int_t /*n1*/, UChar_t *array1, Int_t /*n2*/, UChar_t *array2, Int_t *list, Int_t &ncheck)
{
// Get extra candidates that are contained in array1 but not in current check list
//   UChar_t *bits = gGeoManager->GetBits();
   fNcandidates = 0;
   Int_t icand;
   UInt_t bitnumber, loc;
   UChar_t bit, byte;
   for (icand=0; icand<ncheck; icand++) {
      bitnumber = (UInt_t)list[icand];
      loc = bitnumber>>3;
      bit = bitnumber%8;
      byte = (~fBits1[loc]) & array1[loc] & array2[loc] & (1<<bit);
      if (byte) fCheckList[fNcandidates++]=list[icand];
   }
   ncheck = fNcandidates;
   return fCheckList;        
}      


//_____________________________________________________________________________
Int_t *TGeoVoxelFinder::GetNextCandidates(Double_t *point, Int_t &ncheck)
{
// Returns list of new candidates in next voxel. If NULL, nowhere to
// go next. 
   if (NeedRebuild()) {
      Voxelize();
      fVolume->FindOverlaps();
   }   
   ncheck = 0;
   if (fLimits[0]<0) return 0;
   if (fLimits[1]<0) return 0;
   if (fLimits[2]<0) return 0;
   Int_t dind[3]; // new slices
   //---> start from old slices
   memcpy(&dind[0], &fSlices[0], 3*sizeof(Int_t));
   Double_t dmin[3]; // distances to get to next X,Y, Z slices.
   dmin[0] = dmin[1] = dmin[2] = TGeoShape::Big();
   //---> max. possible step to be considered
   Double_t maxstep = TMath::Min(gGeoManager->GetStep(), fLimits[TMath::LocMin(3, fLimits)]);
//   printf("1- maxstep=%g\n", maxstep);
   Bool_t isXlimit=kFALSE, isYlimit=kFALSE, isZlimit=kFALSE;
   Bool_t isForcedX=kFALSE, isForcedY=kFALSE, isForcedZ=kFALSE;
   Double_t dforced[3];
   dforced[0] = dforced[1] = dforced[2] = TGeoShape::Big();
   Int_t iforced = 0;
   //
   //---> work on X
   if (fPriority[0] && fInc[0]) {
      //---> increment/decrement slice
      dind[0] += fInc[0];
      if (fInc[0]==1) {
         if (dind[0]<0 || dind[0]>fIbx-1) return 0; // outside range
         dmin[0] = (fXb[dind[0]]-point[0])*fInvdir[0];
      } else {
         if (fSlices[0]<0 || fSlices[0]>fIbx-1) return 0; // outside range
         dmin[0] = (fXb[fSlices[0]]-point[0])*fInvdir[0];
      }
      isXlimit = (dmin[0]>maxstep)?kTRUE:kFALSE;
//      printf("---> X : priority=%i, slice=%i/%i inc=%i\n",
//             fPriority[0], fSlices[0], fIbx-2, fInc[0]);
//      printf("2- step to next X (%i) = %g\n", (Int_t)isXlimit, dmin[0]);
      //---> check if propagation to next slice on this axis is forced
      if ((fSlices[0]==-1) || (fSlices[0]==fIbx-1)) {
         isForcedX = kTRUE;
         dforced[0] = dmin[0];
         iforced++;
//         printf("   FORCED 1\n");
         if (isXlimit) return 0;
      } else {
         if (fPriority[0]==2) {
            // if no candidates in current slice, force next slice
            if (fNsliceX[fSlices[0]]==0) {
               isForcedX = kTRUE;
               dforced[0] = dmin[0];
               iforced++;
//               printf("   FORCED 2\n");
               if (isXlimit) return 0;
            }
         }
      }         
   } else {
      // no slices on this axis -> bounding box limit
//      printf("   No slice on X\n");
      dmin[0] = fLimits[0];
      isXlimit = kTRUE;
   }   
   //---> work on Y
   if (fPriority[1] && fInc[1]) {
      //---> increment/decrement slice
      dind[1] += fInc[1];
      if (fInc[1]==1) {
         if (dind[1]<0 || dind[1]>fIby-1) return 0; // outside range
         dmin[1] = (fYb[dind[1]]-point[1])*fInvdir[1];
      } else {
         if (fSlices[1]<0 || fSlices[1]>fIby-1) return 0; // outside range
         dmin[1] = (fYb[fSlices[1]]-point[1])*fInvdir[1];
      }
      isYlimit = (dmin[1]>maxstep)?kTRUE:kFALSE;
//      printf("---> Y : priority=%i, slice=%i/%i inc=%i\n",
//             fPriority[1], fSlices[1], fIby-2, fInc[1]);
//      printf("3- step to next Y (%i) = %g\n", (Int_t)isYlimit, dmin[1]);
      
      //---> check if propagation to next slice on this axis is forced
      if ((fSlices[1]==-1) || (fSlices[1]==fIby-1)) {
         isForcedY = kTRUE;
         dforced[1] = dmin[1];
         iforced++;
//         printf("   FORCED 1\n");
         if (isYlimit) return 0;
      } else {
         if (fPriority[1]==2) {
            // if no candidates in current slice, force next slice
            if (fNsliceY[fSlices[1]]==0) {
               isForcedY = kTRUE;
               dforced[1] = dmin[1];
               iforced++;
//               printf("   FORCED 2\n");
               if (isYlimit) return 0;
            }
         }
      }   
   } else {
      // no slices on this axis -> bounding box limit
//      printf("   No slice on Y\n");
      dmin[1] = fLimits[1];
      isYlimit = kTRUE;
   }   
   //---> work on Z
   if (fPriority[2] && fInc[2]) {
      //---> increment/decrement slice
      dind[2] += fInc[2];
      if (fInc[2]==1) {
         if (dind[2]<0 || dind[2]>fIbz-1) return 0; // outside range
         dmin[2] = (fZb[dind[2]]-point[2])*fInvdir[2];
      } else {
         if (fSlices[2]<0 || fSlices[2]>fIbz-1) return 0; // outside range
         dmin[2] = (fZb[fSlices[2]]-point[2])*fInvdir[2];
      }
      isZlimit = (dmin[2]>maxstep)?kTRUE:kFALSE;
//      printf("---> Z : priority=%i, slice=%i/%i inc=%i\n",
//             fPriority[2], fSlices[2], fIbz-2, fInc[2]);
//      printf("4- step to next Z (%i) = %g\n", (Int_t)isZlimit, dmin[2]);
      
      //---> check if propagation to next slice on this axis is forced
      if ((fSlices[2]==-1) || (fSlices[2]==fIbz-1)) {
         isForcedZ = kTRUE;
         dforced[2] = dmin[2];
         iforced++;
//         printf("   FORCED 1\n");
         if (isZlimit) return 0;
      } else {
         if (fPriority[2]==2) {
            // if no candidates in current slice, force next slice
            if (fNsliceZ[fSlices[2]]==0) {
               isForcedZ = kTRUE;
               dforced[2] = dmin[2];
               iforced++;
//               printf("   FORCED 2\n");
               if (isZlimit) return 0;
            }
         }
      }
   } else {
      // no slices on this axis -> bounding box limit
//      printf("   No slice on Z\n");
      dmin[2] = fLimits[2];
      isZlimit = kTRUE;
   }   
   //---> We are done with checking. See which is the closest slice.
   // First check if some slice is forced
   
   Double_t dslice = 0;
   Int_t islice = 0;
   if (iforced) {
   // some slice is forced
      if (isForcedX) {
      // X forced
         dslice = dforced[0];
         islice = 0;
         if (isForcedY) {
         // X+Y forced
            if (dforced[1]>dslice) {
               dslice = dforced[1];
               islice = 1;
            }
            if (isForcedZ) {
            // X+Y+Z forced
               if (dforced[2]>dslice) {
                  dslice = dforced[2];
                  islice = 2;
               }
            }
         } else {
         // X forced
            if (isForcedZ) {
            // X+Z forced
               if (dforced[2]>dslice) {
                  dslice = dforced[2];
                  islice = 2;
               }
            }
         }   
      } else {
         if (isForcedY) {
         // Y forced
            dslice = dforced[1];
            islice = 1;
            if (isForcedZ) {
            // Y+Z forced
               if (dforced[2]>dslice) {
                  dslice = dforced[2];
                  islice = 2;
               }
            }
         } else {
         // Z forced
            dslice = dforced[2];
            islice = 2;
         }   
      }                     
   } else {
   // Nothing forced -> get minimum distance
      islice = TMath::LocMin(3, dmin);
      dslice = dmin[islice];
      if (dslice>=maxstep) {
//         printf("DSLICE > MAXSTEP -> EXIT\n");      
         return 0;
      }   
   }
//   printf("5- islicenext=%i  DSLICE=%g\n", islice, dslice);
   Double_t xptnew;
   Int_t *new_list; // list of new candidates
   UChar_t *slice1 = 0;
   UChar_t *slice2 = 0;
   Int_t ndd[2] = {0,0};
   Int_t islices = 0;
   Bool_t left;
   switch (islice) {
      case 0:
         if (isXlimit) return 0;
         // increment/decrement X slice
         fSlices[0]=dind[0];
         if (iforced) {
         // we have to recompute Y and Z slices
            if (dslice>fLimits[1]) return 0;
            if (dslice>fLimits[2]) return 0;
            if ((dslice>dmin[1]) && fInc[1]) {
               xptnew = point[1]+dslice/fInvdir[1];
//               printf("   recomputing Y slice, pos=%g\n", xptnew);
               while (1) {
                  fSlices[1] += fInc[1];
                  if (fInc[1]==1) {
  		     if (fSlices[1]<-1 || fSlices[1]>fIby-2) break; // outside range
                     if (fYb[fSlices[1]+1]>=xptnew) break;
                  } else {
                     if (fSlices[1]<0 || fSlices[1]>fIby-1) break; // outside range
                     if (fYb[fSlices[1]]<= xptnew) break;
                  }
               }
//               printf("   %i/%i\n", fSlices[1], fIby-2);
            }
            if ((dslice>dmin[2]) && fInc[2]) {             
               xptnew = point[2]+dslice/fInvdir[2];
//               printf("   recomputing Z slice, pos=%g\n", xptnew);
               while (1) {
                  fSlices[2] += fInc[2];
                  if (fInc[2]==1) {
  		     if (fSlices[2]<-1 || fSlices[2]>fIbz-2) break; // outside range
                     if (fZb[fSlices[2]+1]>=xptnew) break;
                  } else {
                     if (fSlices[2]<0 || fSlices[2]>fIbz-1) break; // outside range
                     if (fZb[fSlices[2]]<= xptnew) break;
                  }
               }          
//               printf("   %i/%i\n", fSlices[2], fIbz-2);
            }
         }
         // new indices are set -> Get new candidates   
         if (fPriority[0]==1) {
         // we are entering the unique slice on this axis
         //---> intersect and store Y and Z
            if (fPriority[1]==2) {
               if (fSlices[1]<0 || fSlices[1]>=fIby-1) return fCheckList; // outside range
               ndd[0] = fNsliceY[fSlices[1]];
               if (!ndd[0]) return fCheckList;
               slice1 = &fIndcY[fOBy[fSlices[1]]];
               islices++;
            }
            if (fPriority[2]==2) {
               if (fSlices[2]<0 || fSlices[2]>=fIbz-1) return fCheckList; // outside range
               ndd[1] = fNsliceZ[fSlices[2]];
               if (!ndd[1]) return fCheckList;
               islices++;
               if (slice1) {
                  slice2 = &fIndcZ[fOBz[fSlices[2]]];
               } else {
                  slice1 = &fIndcZ[fOBz[fSlices[2]]];
                  ndd[0] = ndd[1];
               }
            }
            if (islices==1) {
               IntersectAndStore(ndd[0], slice1);
            } else {
               IntersectAndStore(ndd[0], slice1, ndd[1], slice2);
            }
            ncheck = fNcandidates;
            return fCheckList;   
         }
         // We got into a new slice -> Get only new candidates
         left = (fInc[0]>0)?kTRUE:kFALSE;
         new_list = GetExtraX(fSlices[0], left, ncheck);
//         printf("   New list on X : %i new candidates\n", ncheck);
         if (!ncheck) return fCheckList;
         if (fPriority[1]==2) {
            if (fSlices[1]<0 || fSlices[1]>=fIby-1) {
               ncheck = 0;
               return fCheckList; // outside range
            }
            ndd[0] = fNsliceY[fSlices[1]];
            if (!ndd[0]) {
               ncheck = 0;
               return fCheckList;
            }   
            slice1 = &fIndcY[fOBy[fSlices[1]]];
            islices++;
         }
         if (fPriority[2]==2) {
            if (fSlices[2]<0 || fSlices[2]>=fIbz-1) {
               ncheck = 0;
               return fCheckList; // outside range
            }
            ndd[1] = fNsliceZ[fSlices[2]];
            if (!ndd[1]) {
               ncheck = 0;
               return fCheckList;
            }   
            islices++;
            if (slice1) {
               slice2 = &fIndcZ[fOBz[fSlices[2]]];
            } else {
               slice1 = &fIndcZ[fOBz[fSlices[2]]];
               ndd[0] = ndd[1];
            }
         }
         if (!islices) return GetValidExtra(new_list, ncheck);
         if (islices==1) {
            return GetValidExtra(ndd[0], slice1, new_list, ncheck);
         } else {
            return GetValidExtra(ndd[0], slice1, ndd[1], slice2, new_list, ncheck);
         }
      case 1:
         if (isYlimit) return 0;
         // increment/decrement Y slice
         fSlices[1]=dind[1];
         if (iforced) {
         // we have to recompute X and Z slices
            if (dslice>fLimits[0]) return 0;
            if (dslice>fLimits[2]) return 0;
            if ((dslice>dmin[0]) && fInc[0]) {
               xptnew = point[0]+dslice/fInvdir[0];
//               printf("   recomputing X slice, pos=%g\n", xptnew);
               while (1) {
                  fSlices[0] += fInc[0];
                  if (fInc[0]==1) {
                     if (fSlices[0]<-1 || fSlices[0]>fIbx-2) break; // outside range
                     if (fXb[fSlices[0]+1]>=xptnew) break;
                  } else {
                     if (fSlices[0]<0 || fSlices[0]>fIbx-1) break; // outside range
                     if (fXb[fSlices[0]]<= xptnew) break;
                  }
               }
//               printf("   %i/%i\n", fSlices[0], fIbx-2);
            }
            if ((dslice>dmin[2]) && fInc[2]) {             
               xptnew = point[2]+dslice/fInvdir[2];
//               printf("   recomputing Z slice, pos=%g\n", xptnew);
               while (1) {
                  fSlices[2] += fInc[2];
                  if (fInc[2]==1) {
                     if (fSlices[2]<-1 || fSlices[2]>fIbz-2) break; // outside range
                     if (fZb[fSlices[2]+1]>=xptnew) break;
                  } else {
                     if (fSlices[2]<0 || fSlices[2]>fIbz-1) break; // outside range
                     if (fZb[fSlices[2]]<= xptnew) break;
                  }
               }          
//               printf("   %i/%i\n", fSlices[2], fIbz-2);
            }
         }
         // new indices are set -> Get new candidates   
         if (fPriority[1]==1) {
         // we are entering the unique slice on this axis
         //---> intersect and store X and Z
            if (fPriority[0]==2) {
               if (fSlices[0]<0 || fSlices[0]>=fIbx-1) return fCheckList; // outside range
               ndd[0] = fNsliceX[fSlices[0]];
               if (!ndd[0]) return fCheckList;
               slice1 = &fIndcX[fOBx[fSlices[0]]];
               islices++;
            }
            if (fPriority[2]==2) {
               if (fSlices[2]<0 || fSlices[2]>=fIbz-1) return fCheckList; // outside range
               ndd[1] = fNsliceZ[fSlices[2]];
               if (!ndd[1]) return fCheckList;
               islices++;
               if (slice1) {
                  slice2 = &fIndcZ[fOBz[fSlices[2]]];
               } else {
                  slice1 = &fIndcZ[fOBz[fSlices[2]]];
                  ndd[0] = ndd[1];
               }
            }
            if (islices==1) {
               IntersectAndStore(ndd[0], slice1);
            } else {
               IntersectAndStore(ndd[0], slice1, ndd[1], slice2);
            }
            ncheck = fNcandidates;
            return fCheckList;   
         }
         // We got into a new slice -> Get only new candidates
         left = (fInc[1]>0)?kTRUE:kFALSE;
         new_list = GetExtraY(fSlices[1], left, ncheck);
//         printf("   New list on Y : %i new candidates\n", ncheck);
         if (!ncheck) return fCheckList;
         if (fPriority[0]==2) {
            if (fSlices[0]<0 || fSlices[0]>=fIbx-1) {
               ncheck = 0;
               return fCheckList; // outside range
            }
            ndd[0] = fNsliceX[fSlices[0]];
            if (!ndd[0]) {
               ncheck = 0;
               return fCheckList;
            }   
            slice1 = &fIndcX[fOBx[fSlices[0]]];
            islices++;
         }
         if (fPriority[2]==2) {
            if (fSlices[2]<0 || fSlices[2]>=fIbz-1) {
               ncheck = 0;
               return fCheckList; // outside range
            }
            ndd[1] = fNsliceZ[fSlices[2]];
            if (!ndd[1]) {
               ncheck = 0;
               return fCheckList;
            }   
            islices++;
            if (slice1) {
               slice2 = &fIndcZ[fOBz[fSlices[2]]];
            } else {
               slice1 = &fIndcZ[fOBz[fSlices[2]]];
               ndd[0] = ndd[1];
            }
         }
         if (!islices) return GetValidExtra(new_list, ncheck);
         if (islices==1) {
            return GetValidExtra(ndd[0], slice1, new_list, ncheck);
         } else {
            return GetValidExtra(ndd[0], slice1, ndd[1], slice2, new_list, ncheck);
         }
      case 2:
         if (isZlimit) return 0;
         // increment/decrement Z slice
         fSlices[2]=dind[2];
         if (iforced) {
         // we have to recompute Y and X slices
            if (dslice>fLimits[1]) return 0;
            if (dslice>fLimits[0]) return 0;
            if ((dslice>dmin[1]) && fInc[1]) {
               xptnew = point[1]+dslice/fInvdir[1];
//               printf("   recomputing Y slice, pos=%g\n", xptnew);
               while (1) {
                  fSlices[1] += fInc[1];
                  if (fInc[1]==1) {
  		     if (fSlices[1]<-1 || fSlices[1]>fIby-2) break; // outside range
                     if (fYb[fSlices[1]+1]>=xptnew) break;
                  } else {
                     if (fSlices[1]<0 || fSlices[1]>fIby-1) break; // outside range
                     if (fYb[fSlices[1]]<= xptnew) break;
                  }
               }
//               printf("   %i/%i\n", fSlices[1], fIby-2);
            }
            if ((dslice>dmin[0]) && fInc[0]) {             
               xptnew = point[0]+dslice/fInvdir[0];
//               printf("   recomputing X slice, pos=%g\n", xptnew);
               while (1) {
                  fSlices[0] += fInc[0];
                  if (fInc[0]==1) {
                     if (fSlices[0]<-1 || fSlices[0]>fIbx-2) break; // outside range
                     if (fXb[fSlices[0]+1]>=xptnew) break;
                  } else {
                     if (fSlices[0]<0 || fSlices[0]>fIbx-1) break; // outside range
                     if (fXb[fSlices[0]]<= xptnew) break;
                  }
               }          
//               printf("   %i/%i\n", fSlices[0], fIbx-2);
            }
         }
         // new indices are set -> Get new candidates   
         if (fPriority[2]==1) {
         // we are entering the unique slice on this axis
         //---> intersect and store Y and X
            if (fPriority[1]==2) {
               if (fSlices[1]<0 || fSlices[1]>=fIby-1) return fCheckList; // outside range
               ndd[0] = fNsliceY[fSlices[1]];
               if (!ndd[0]) return fCheckList;
               slice1 = &fIndcY[fOBy[fSlices[1]]];
               islices++;
            }
            if (fPriority[0]==2) {
               if (fSlices[0]<0 || fSlices[0]>=fIbx-1) return fCheckList; // outside range
               ndd[1] = fNsliceX[fSlices[0]];
               if (!ndd[1]) return fCheckList;
               islices++;
               if (slice1) {
                  slice2 = &fIndcX[fOBx[fSlices[0]]];
               } else {
                  slice1 = &fIndcX[fOBx[fSlices[0]]];
                  ndd[0] = ndd[1];
               }
            }
            if (islices==1) {
               IntersectAndStore(ndd[0], slice1);
            } else {
               IntersectAndStore(ndd[0], slice1, ndd[1], slice2);
            }
            ncheck = fNcandidates;
            return fCheckList;   
         }
         // We got into a new slice -> Get only new candidates
         left = (fInc[2]>0)?kTRUE:kFALSE;
         new_list = GetExtraZ(fSlices[2], left, ncheck);
//         printf("   New list on Z : %i new candidates\n", ncheck);
         if (!ncheck) return fCheckList;
         if (fPriority[1]==2) {
            if (fSlices[1]<0 || fSlices[1]>=fIby-1) {
               ncheck = 0;
               return fCheckList; // outside range
            }
            ndd[0] = fNsliceY[fSlices[1]];
            if (!ndd[0]) {
               ncheck = 0;
               return fCheckList;
            }   
            slice1 = &fIndcY[fOBy[fSlices[1]]];
            islices++;
         }
         if (fPriority[0]==2) {
            if (fSlices[0]<0 || fSlices[0]>=fIbx-1) {
               ncheck = 0;
               return fCheckList; // outside range
            }
            ndd[1] = fNsliceX[fSlices[0]];
            if (!ndd[1]) {
               ncheck = 0;
               return fCheckList;
            }   
            islices++;
            if (slice1) {
               slice2 = &fIndcX[fOBx[fSlices[0]]];
            } else {
               slice1 = &fIndcX[fOBx[fSlices[0]]];
               ndd[0] = ndd[1];
            }
         }
         if (!islices) return GetValidExtra(new_list, ncheck);
         if (islices==1) {
            return GetValidExtra(ndd[0], slice1, new_list, ncheck);
         } else {
            return GetValidExtra(ndd[0], slice1, ndd[1], slice2, new_list, ncheck);
         }
      default:
         Error("GetNextCandidates", "Invalid islice=%i inside %s", islice, fVolume->GetName());
   }      
   return 0;            
}

//_____________________________________________________________________________
void TGeoVoxelFinder::SortCrossedVoxels(Double_t *point, Double_t *dir)
{
// get the list in the next voxel crossed by a ray
   if (NeedRebuild()) {
      TGeoVoxelFinder *vox = (TGeoVoxelFinder*)this;
      vox->Voxelize();
      fVolume->FindOverlaps();
   }   
   fCurrentVoxel = 0;
//   printf("###Sort crossed voxels for %s\n", fVolume->GetName());
   fNcandidates = 0;
   Int_t  loc = 1+((fVolume->GetNdaughters()-1)>>3);
//   printf("   LOC=%i\n", loc*sizeof(UChar_t));
//   UChar_t *bits = gGeoManager->GetBits();
   memset(fBits1, 0, loc);
   memset(fInc, 0, 3*sizeof(Int_t));
   for (Int_t i=0; i<3; i++) {
      fInvdir[i] = TGeoShape::Big();
      if (TMath::Abs(dir[i])<1E-10) continue;
      fInc[i] = (dir[i]>0)?1:-1;
      fInvdir[i] = 1./dir[i];
   }
   Bool_t flag = GetIndices(point);
   TGeoBBox *box = (TGeoBBox*)(fVolume->GetShape());
   const Double_t *box_orig = box->GetOrigin();
   if (fInc[0]==0) {
      fLimits[0] = TGeoShape::Big();
   } else {   
      if (fSlices[0]==-2) {
         // no slice on this axis -> get limit to bounding box limit
         fLimits[0] = (box_orig[0]-point[0]+fInc[0]*box->GetDX())*fInvdir[0];
      } else {
         if (fInc[0]==1) {
            fLimits[0] = (fXb[fIbx-1]-point[0])*fInvdir[0];
         } else {
            fLimits[0] = (fXb[0]-point[0])*fInvdir[0];
         }
      }
   }                
   if (fInc[1]==0) {
      fLimits[1] = TGeoShape::Big();
   } else {   
      if (fSlices[1]==-2) {
         // no slice on this axis -> get limit to bounding box limit
         fLimits[1] = (box_orig[1]-point[1]+fInc[1]*box->GetDY())*fInvdir[1];
      } else {
         if (fInc[1]==1) {
            fLimits[1] = (fYb[fIby-1]-point[1])*fInvdir[1];
         } else {
            fLimits[1] = (fYb[0]-point[1])*fInvdir[1];
         }
      }
   }                
   if (fInc[2]==0) {
      fLimits[2] = TGeoShape::Big();
   } else {   
      if (fSlices[2]==-2) {
         // no slice on this axis -> get limit to bounding box limit
         fLimits[2] = (box_orig[2]-point[2]+fInc[2]*box->GetDZ())*fInvdir[2];
      } else {
         if (fInc[2]==1) {
            fLimits[2] = (fZb[fIbz-1]-point[2])*fInvdir[2];
         } else {
            fLimits[2] = (fZb[0]-point[2])*fInvdir[2];
         }
      }
   }                
   
   if (!flag) {
//      printf("   NO candidates in first voxel\n");
//      printf("   bits[0]=%i\n", bits[0]);
      return;
   }
//   printf("   current slices : %i   %i  %i\n", fSlices[0], fSlices[1], fSlices[2]);
   Int_t nd[3];
   Int_t islices = 0;
   memset(&nd[0], 0, 3*sizeof(Int_t));
   UChar_t *slicex = 0;
   if (fPriority[0]==2) {
      nd[0] = fNsliceX[fSlices[0]];
      slicex=&fIndcX[fOBx[fSlices[0]]];
      islices++;
   }   
   UChar_t *slicey = 0;
   if (fPriority[1]==2) {
      nd[1] = fNsliceY[fSlices[1]];
      islices++;
      if (slicex) {
         slicey=&fIndcY[fOBy[fSlices[1]]];
      } else {
         slicex=&fIndcY[fOBy[fSlices[1]]];
         nd[0] = nd[1];
      } 
   }   
   UChar_t *slicez = 0;
   if (fPriority[2]==2) {
      nd[2] = fNsliceZ[fSlices[2]];
      islices++;
      if (slicex && slicey) {
         slicez=&fIndcZ[fOBz[fSlices[2]]];
      } else {
         if (slicex) {
            slicey=&fIndcZ[fOBz[fSlices[2]]];
            nd[1] = nd[2];   
         } else {
            slicex=&fIndcZ[fOBz[fSlices[2]]];
            nd[0] = nd[2];
         }
      }         
   } 
//   printf("Ndaughters in first voxel : %i %i %i\n", nd[0], nd[1], nd[2]);
   switch (islices) {
      case 0:
         Error("SortCrossedVoxels", "no slices for %s", fVolume->GetName());
//         printf("Slices :(%i,%i,%i) Priority:(%i,%i,%i)\n", fSlices[0], fSlices[1], fSlices[2], fPriority[0], fPriority[1], fPriority[2]);
         return;
      case 1:
         IntersectAndStore(nd[0], slicex);
         break;
      case 2:
         IntersectAndStore(nd[0], slicex, nd[1], slicey);
         break;
      default:
         IntersectAndStore(nd[0], slicex, nd[1], slicey, nd[2], slicez);    
   }      
//   printf("   bits[0]=%i  END\n", bits[0]);
//   if (fNcandidates) {
//      printf("   candidates for first voxel :\n");
//      for (Int_t i=0; i<fNcandidates; i++) printf("    %i\n", fCheckList[i]);
//   }   
}   
//_____________________________________________________________________________
Int_t *TGeoVoxelFinder::GetCheckList(Double_t *point, Int_t &nelem)
{
// get the list of daughter indices for which point is inside their bbox
   if (NeedRebuild()) {
      Voxelize();
      fVolume->FindOverlaps();
   }   
   if (fVolume->GetNdaughters() == 1) {
      if (fXb) {
         if (point[0]<fXb[0] || point[0]>fXb[1]) return 0;
      }
      if (fYb) {
         if (point[1]<fYb[0] || point[1]>fYb[1]) return 0;
      }   

      if (fZb) {
         if (point[2]<fZb[0] || point[2]>fZb[1]) return 0;
      }   
      fCheckList[0] = 0;
      nelem = 1;
      return fCheckList;
   }
   Int_t nslices = 0;
   UChar_t *slice1 = 0;
   UChar_t *slice2 = 0; 
   UChar_t *slice3 = 0;
   Int_t nd[3] = {0,0,0};
   Int_t im;
   if (fPriority[0]) {
      im = TMath::BinarySearch(fIbx, fXb, point[0]);
      if ((im==-1) || (im==fIbx-1)) return 0;
      if (fPriority[0]==2) {
         nd[0] = fNsliceX[im];
         if (!nd[0]) return 0;
         nslices++;
         slice1 = &fIndcX[fOBx[im]];
      }   
   }

   if (fPriority[1]) {
      im = TMath::BinarySearch(fIby, fYb, point[1]);
      if ((im==-1) || (im==fIby-1)) return 0;
      if (fPriority[1]==2) {
         nd[1] = fNsliceY[im];
         if (!nd[1]) return 0;
         nslices++;
         if (slice1) {
            slice2 = &fIndcY[fOBy[im]];
         } else {
            slice1 = &fIndcY[fOBy[im]];
            nd[0] = nd[1];
         }   
      }   
   }

   if (fPriority[2]) {
      im = TMath::BinarySearch(fIbz, fZb, point[2]);
      if ((im==-1) || (im==fIbz-1)) return 0;
      if (fPriority[2]==2) {
         nd[2] = fNsliceZ[im];
         if (!nd[2]) return 0;
         nslices++;
         if (slice1 && slice2) {
            slice3 = &fIndcZ[fOBz[im]];
         } else {
            if (slice1) {
               slice2 = &fIndcZ[fOBz[im]];
               nd[1] = nd[2];
            } else {
               slice1 = &fIndcZ[fOBz[im]];
               nd[0] = nd[2];
            }   
         }      
      }   
   }
   nelem = 0;
//   Int_t i = 0;
   Bool_t intersect = kFALSE;
   switch (nslices) {
      case 0:
         Error("GetCheckList", "No slices for %s", fVolume->GetName());
         return 0;
      case 1:
         intersect = Intersect(nd[0], slice1, nelem, fCheckList);
         break;
      case 2:
         intersect = Intersect(nd[0], slice1, nd[1], slice2, nelem, fCheckList);
         break;
      default:         
         intersect = Intersect(nd[0], slice1, nd[1], slice2, nd[2], slice3, nelem, fCheckList);
   }      
   if (intersect) return fCheckList;
   return 0;   
}

//_____________________________________________________________________________
Int_t *TGeoVoxelFinder::GetVoxelCandidates(Int_t i, Int_t j, Int_t k, Int_t &ncheck)
{
// get the list of candidates in voxel (i,j,k) - no check
   UChar_t *slice1 = 0;
   UChar_t *slice2 = 0; 
   UChar_t *slice3 = 0;
   Int_t nd[3] = {0,0,0};
   Int_t nslices = 0;
   if (fPriority[0]==2) {   
      nd[0] = fNsliceX[i];
      if (!nd[0]) return 0;
      nslices++;
      slice1 = &fIndcX[fOBx[i]];
   }   

   if (fPriority[1]==2) {   
      nd[1] = fNsliceY[j];
      if (!nd[1]) return 0;
      nslices++;
      if (slice1) {
         slice2 = &fIndcY[fOBy[j]];
      } else {
         slice1 = &fIndcY[fOBy[j]];
         nd[0] = nd[1];
      }   
   }   

   if (fPriority[2]==2) {
      nd[2] = fNsliceZ[k];
      if (!nd[2]) return 0;
      nslices++;
      if (slice1 && slice2) {
         slice3 = &fIndcZ[fOBz[k]];
      } else {
         if (slice1) {
            slice2 = &fIndcZ[fOBz[k]];
            nd[1] = nd[2];
         } else {
            slice1 = &fIndcZ[fOBz[k]];
            nd[0] = nd[2];
         }   
      }      
   }   
   Bool_t intersect = kFALSE;
   switch (nslices) {
      case 0:
         Error("GetCheckList", "No slices for %s", fVolume->GetName());
         return 0;
      case 1:
         intersect = Intersect(nd[0], slice1, ncheck, fCheckList);
         break;
      case 2:
         intersect = Intersect(nd[0], slice1, nd[1], slice2, ncheck, fCheckList);
         break;
      default:         
         intersect = Intersect(nd[0], slice1, nd[1], slice2, nd[2], slice3, ncheck, fCheckList);
   }      
   if (intersect) return fCheckList;
   return 0; 
}     

//_____________________________________________________________________________
Int_t *TGeoVoxelFinder::GetNextVoxel(Double_t *point, Double_t * /*dir*/, Int_t &ncheck)
{
// get the list of new candidates for the next voxel crossed by current ray
//   printf("### GetNextVoxel\n");
   if (NeedRebuild()) {
      Voxelize();
      fVolume->FindOverlaps();
   }   
   if (fCurrentVoxel==0) {
//      printf(">>> first voxel, %i candidates\n", ncheck);
//      printf("   bits[0]=%i\n", gGeoManager->GetBits()[0]);
      fCurrentVoxel++;
      ncheck = fNcandidates;
      return fCheckList;
   }
   fCurrentVoxel++;
//   printf(">>> voxel %i\n", fCurrentVoxel);
   // Get slices for next voxel
//   printf("before - fSlices : %i %i %i\n", fSlices[0], fSlices[1], fSlices[2]);
   return GetNextCandidates(point, ncheck);
} 

//_____________________________________________________________________________
Bool_t TGeoVoxelFinder::Intersect(Int_t n1, UChar_t *array1, Int_t &nf, Int_t *result)
{
// return the list of nodes corresponding to one array of bits
   Int_t nd = fVolume->GetNdaughters(); // also number of bits to scan
   nf = 0;
   Int_t nbytes = 1+((nd-1)>>3);
   Int_t current_byte;
   Int_t current_bit;
   UChar_t byte;
   Bool_t ibreak = kFALSE;
   for (current_byte=0; current_byte<nbytes; current_byte++) {
      byte = array1[current_byte];
      if (!byte) continue;
      for (current_bit=0; current_bit<8; current_bit++) {
         if (byte & (1<<current_bit)) {
            result[nf++] = (current_byte<<3)+current_bit;
            if (nf==n1) {
               ibreak = kTRUE;
               break;
            }   
         }
      }
      if (ibreak) return kTRUE;
   }
   return kTRUE;        
}      

//_____________________________________________________________________________
Bool_t TGeoVoxelFinder::IntersectAndStore(Int_t n1, UChar_t *array1)
{
// return the list of nodes corresponding to one array of bits
   Int_t nd = fVolume->GetNdaughters(); // also number of bits to scan
//   UChar_t *bits = gGeoManager->GetBits();
   fNcandidates = 0;
   Int_t nbytes = 1+((nd-1)>>3);
   memcpy(fBits1, array1, nbytes*sizeof(UChar_t)); 
   Int_t current_byte;
   Int_t current_bit;
   UChar_t byte;
   Bool_t ibreak = kFALSE;
   Int_t icand;
   for (current_byte=0; current_byte<nbytes; current_byte++) {
      byte = array1[current_byte];
      icand = current_byte<<3;
      if (!byte) continue;
      for (current_bit=0; current_bit<8; current_bit++) {
         if (byte & (1<<current_bit)) {
            fCheckList[fNcandidates++] = icand+current_bit;
            if (fNcandidates==n1) {
               ibreak = kTRUE;
               break;
            }   
         }
      }
      if (ibreak) return kTRUE;
   }
   return kTRUE;        
}      

//_____________________________________________________________________________
Bool_t TGeoVoxelFinder::Union(Int_t n1, UChar_t *array1)
{
// make union of older bits with new array
//   printf("Union - one slice\n");
   Int_t nd = fVolume->GetNdaughters(); // also number of bits to scan
//   UChar_t *bits = gGeoManager->GetBits();
   fNcandidates = 0;
   Int_t nbytes = 1+((nd-1)>>3);
   Int_t current_byte;
   Int_t current_bit;
   UChar_t byte;
   Bool_t ibreak = kFALSE;
   for (current_byte=0; current_byte<nbytes; current_byte++) {
//      printf("   byte %i : bits=%i array=%i\n", current_byte, bits[current_byte], array1[current_byte]);
      byte = (~fBits1[current_byte]) & array1[current_byte];
      if (!byte) continue;
      for (current_bit=0; current_bit<8; current_bit++) {
         if (byte & (1<<current_bit)) {
            fCheckList[fNcandidates++] = (current_byte<<3)+current_bit;
            if (fNcandidates==n1) {
               ibreak = kTRUE;
               break;
            }   
         }
      }
      fBits1[current_byte] |= byte;
      if (ibreak) return kTRUE;
   }
   return (fNcandidates>0);        
}      

//_____________________________________________________________________________
Bool_t TGeoVoxelFinder::Union(Int_t /*n1*/, UChar_t *array1, Int_t /*n2*/, UChar_t *array2)
{
// make union of older bits with new array
//   printf("Union - two slices\n");
   Int_t nd = fVolume->GetNdaughters(); // also number of bits to scan
//   UChar_t *bits = gGeoManager->GetBits();
   fNcandidates = 0;
   Int_t nbytes = 1+((nd-1)>>3);
   Int_t current_byte;
   Int_t current_bit;
   UChar_t byte;
   for (current_byte=0; current_byte<nbytes; current_byte++) {
      byte = (~fBits1[current_byte]) & (array1[current_byte] & array2[current_byte]);
      if (!byte) continue;
      for (current_bit=0; current_bit<8; current_bit++) {
         if (byte & (1<<current_bit)) {
            fCheckList[fNcandidates++] = (current_byte<<3)+current_bit;
         }
      }
      fBits1[current_byte] |= byte;
   }
   return (fNcandidates>0);        
}      

//_____________________________________________________________________________
Bool_t TGeoVoxelFinder::Union(Int_t /*n1*/, UChar_t *array1, Int_t /*n2*/, UChar_t *array2, Int_t /*n3*/, UChar_t *array3)
{
// make union of older bits with new array
//   printf("Union - three slices\n");
//   printf("n1=%i n2=%i n3=%i\n", n1,n2,n3);
   Int_t nd = fVolume->GetNdaughters(); // also number of bits to scan
//   UChar_t *bits = gGeoManager->GetBits();
   fNcandidates = 0;
   Int_t nbytes = 1+((nd-1)>>3);
   Int_t current_byte;
   Int_t current_bit;
   UChar_t byte;
   for (current_byte=0; current_byte<nbytes; current_byte++) {
      byte = (~fBits1[current_byte]) & (array1[current_byte] & array2[current_byte] & array3[current_byte]);
      if (!byte) continue;
      for (current_bit=0; current_bit<8; current_bit++) {
         if (byte & (1<<current_bit)) {
            fCheckList[fNcandidates++] = (current_byte<<3)+current_bit;
         }
      }
      fBits1[current_byte] |= byte;
   }
   return (fNcandidates>0);        
}      

//_____________________________________________________________________________
Bool_t TGeoVoxelFinder::Intersect(Int_t n1, UChar_t *array1, Int_t n2, UChar_t *array2, Int_t &nf, Int_t *result)
{
// return the list of nodes corresponding to the intersection of two arrays of bits
   Int_t nd = fVolume->GetNdaughters(); // also number of bits to scan
   nf = 0;
   Int_t nbytes = 1+((nd-1)>>3);
   Int_t current_byte;
   Int_t current_bit;
   UChar_t byte;
   Bool_t ibreak = kFALSE;
   for (current_byte=0; current_byte<nbytes; current_byte++) {
      byte = array1[current_byte] & array2[current_byte];
      if (!byte) continue;
      for (current_bit=0; current_bit<8; current_bit++) {
         if (byte & (1<<current_bit)) {
            result[nf++] = (current_byte<<3)+current_bit;
            if ((nf==n1) || (nf==n2)) {
               ibreak = kTRUE;
               break;
            }   
         }
      }
      if (ibreak) return kTRUE;
   }
   return (nf>0);
}

//_____________________________________________________________________________
Bool_t TGeoVoxelFinder::IntersectAndStore(Int_t /*n1*/, UChar_t *array1, Int_t /*n2*/, UChar_t *array2)
{
// return the list of nodes corresponding to the intersection of two arrays of bits
   Int_t nd = fVolume->GetNdaughters(); // also number of bits to scan
//   UChar_t *bits = gGeoManager->GetBits();
   fNcandidates = 0;
   Int_t nbytes = 1+((nd-1)>>3);
//   memset(bits, 0, nbytes*sizeof(UChar_t));
   Int_t current_byte;
   Int_t current_bit;
   Int_t icand;
   UChar_t byte;
   for (current_byte=0; current_byte<nbytes; current_byte++) {
      byte = array1[current_byte] & array2[current_byte];
      icand = current_byte<<3;
      fBits1[current_byte] = byte;
      if (!byte) continue;
      for (current_bit=0; current_bit<8; current_bit++) {
         if (byte & (1<<current_bit)) {
            fCheckList[fNcandidates++] = icand+current_bit;
         }
      }
   }
   return (fNcandidates>0);
}

//_____________________________________________________________________________
Bool_t TGeoVoxelFinder::Intersect(Int_t n1, UChar_t *array1, Int_t n2, UChar_t *array2, Int_t n3, UChar_t *array3, Int_t &nf, Int_t *result)
{
// return the list of nodes corresponding to the intersection of three arrays of bits
   Int_t nd = fVolume->GetNdaughters(); // also number of bits to scan
   nf = 0;
   Int_t nbytes = 1+((nd-1)>>3);
   Int_t current_byte;
   Int_t current_bit;
   UChar_t byte;
   Bool_t ibreak = kFALSE;
   for (current_byte=0; current_byte<nbytes; current_byte++) {
      byte = array1[current_byte] & array2[current_byte] & array3[current_byte];
      if (!byte) continue;
      for (current_bit=0; current_bit<8; current_bit++) {
         if (byte & (1<<current_bit)) {
            result[nf++] = (current_byte<<3)+current_bit;
            if ((nf==n1) || (nf==n2) || (nf==n3)) {
               ibreak = kTRUE;
               break;
            }   
         }
      }
      if (ibreak) return kTRUE;
   }
   return (nf>0);
}

//_____________________________________________________________________________
Bool_t TGeoVoxelFinder::IntersectAndStore(Int_t /*n1*/, UChar_t *array1, Int_t /*n2*/, UChar_t *array2, Int_t /*n3*/, UChar_t *array3)
{
// return the list of nodes corresponding to the intersection of three arrays of bits
   Int_t nd = fVolume->GetNdaughters(); // also number of bits to scan
//   UChar_t *bits = gGeoManager->GetBits();
   fNcandidates = 0;
   Int_t nbytes = 1+((nd-1)>>3);
//   memset(bits, 0, nbytes*sizeof(UChar_t));
   Int_t current_byte;
   Int_t current_bit;
   Int_t icand;
   UChar_t byte;
   for (current_byte=0; current_byte<nbytes; current_byte++) {
      byte = array1[current_byte] & array2[current_byte] & array3[current_byte];
      icand = current_byte<<3;
      fBits1[current_byte] = byte;
      if (!byte) continue;
      for (current_bit=0; current_bit<8; current_bit++) {
         if (byte & (1<<current_bit)) {
            fCheckList[fNcandidates++] = icand+current_bit;
         }
      }
   }
   return (fNcandidates>0);
}
//_____________________________________________________________________________
void TGeoVoxelFinder::SortAll(Option_t *)
{
// order bounding boxes along x, y, z
   Int_t nd = fVolume->GetNdaughters();
   Int_t nperslice  = 1+(nd-1)/(8*sizeof(UChar_t)); /*Nbytes per slice*/
   Int_t nmaxslices = 2*nd+1; // max number of slices on each axis
   Double_t *boundaries = new Double_t[6*nd]; // list of different boundaries
   Double_t xmin, xmax, ymin, ymax, zmin, zmax;
   TGeoBBox *box = (TGeoBBox*)fVolume->GetShape(); // bounding box for volume
   // compute range on X, Y, Z according to volume bounding box
   xmin = (box->GetOrigin())[0] - box->GetDX();
   xmax = (box->GetOrigin())[0] + box->GetDX();
   ymin = (box->GetOrigin())[1] - box->GetDY();
   ymax = (box->GetOrigin())[1] + box->GetDY();
   zmin = (box->GetOrigin())[2] - box->GetDZ();
   zmax = (box->GetOrigin())[2] + box->GetDZ();
   if ((xmin>=xmax) || (ymin>=ymax) || (zmin>=zmax)) {
      Error("SortAll", "Wrong bounding box for volume %s", fVolume->GetName());
      return;
   }   
   Int_t id;
   // compute boundaries coordinates on X,Y,Z
   for (id=0; id<nd; id++) {
      // x boundaries
      boundaries[2*id] = fBoxes[6*id+3]-fBoxes[6*id];
      boundaries[2*id+1] = fBoxes[6*id+3]+fBoxes[6*id];
      // y boundaries
      boundaries[2*id+2*nd] = fBoxes[6*id+4]-fBoxes[6*id+1];
      boundaries[2*id+2*nd+1] = fBoxes[6*id+4]+fBoxes[6*id+1];
      // z boundaries
      boundaries[2*id+4*nd] = fBoxes[6*id+5]-fBoxes[6*id+2];
      boundaries[2*id+4*nd+1] = fBoxes[6*id+5]+fBoxes[6*id+2];
   }
   Int_t *index = new Int_t[2*nd]; // indexes for sorted boundaries on one axis
   UChar_t *ind = new UChar_t[nmaxslices*nperslice]; // ind[fOBx[i]] = ndghts in slice fInd[i]--fInd[i+1]
   Int_t *extra = new Int_t[nmaxslices*4]; 
   // extra[fOEx[i]]   = nextra_to_left (i/i-1)
   // extra[fOEx[i]+1] = nextra_to_right (i/i+1)
   // Int_t *extra_to_left  = extra[fOEx[i]+2]
   // Int_t *extra_to_right = extra[fOEx[i]+2+nextra_to_left]
   Double_t *temp = new Double_t[2*nd]; // temporary array to store sorted boundary positions
   Int_t current  = 0;
   Int_t indextra = 0;
   Int_t nleft, nright;
   Int_t *extra_left  = new Int_t[nd];
   Int_t *extra_right = new Int_t[nd];
   Double_t xxmin, xxmax, xbmin, xbmax, ddx1, ddx2;
   UChar_t *bits;
   UInt_t loc, bitnumber;
   UChar_t bit;

   // sort x boundaries
   Int_t ib = 0; // total number of DIFFERENT boundaries
   TMath::Sort(2*nd, &boundaries[0], &index[0], kFALSE);
   // compact common boundaries
   for (id=0; id<2*nd; id++) {
      if (!ib) {temp[ib++] = boundaries[index[id]]; continue;}
      if (TMath::Abs(temp[ib-1]-boundaries[index[id]])>1E-10)
         temp[ib++] = boundaries[index[id]];
   }
   // now find priority
   if (ib < 2) {
      Error("SortAll", "Cannot voxelize %s :less than 2 boundaries on X", fVolume->GetName());
      delete [] index;
      delete [] ind;
      delete [] temp;
      delete [] extra;
      delete [] extra_left;
      delete [] extra_right;
      SetInvalid();
      return;
   }   
   if (ib == 2) {
   // check range
      if (((temp[0]-xmin)<1E-10) && ((temp[1]-xmax)>-1E-10)) {
      // ordering on this axis makes no sense. Clear all arrays.
         fPriority[0] = 0;  // always skip this axis
         if (fIndcX) delete [] fIndcX; 
         fIndcX = 0;
         fNx = 0;
         if (fXb) delete [] fXb;   
         fXb = 0;
         fIbx = 0;
         if (fOBx) delete [] fOBx;  
         fOBx = 0;
         fNox = 0;
      } else {
         fPriority[0] = 1; // all in one slice
      }
   } else {
      fPriority[0] = 2;    // check all
   }
   // store compacted boundaries
   if (fPriority[0]) {
      if (fXb) delete [] fXb;
      fXb = new Double_t[ib];
      memcpy(fXb, &temp[0], ib*sizeof(Double_t));
      fIbx = ib;
   }   
   
   //--- now build the lists of nodes in each slice of X axis
   if (fPriority[0]==2) {
      memset(ind, 0, (nmaxslices*nperslice)*sizeof(UChar_t));
      if (fOBx) delete [] fOBx;
      fNox = fIbx-1; // number of different slices
      fOBx = new Int_t[fNox]; // offsets in ind
      if (fOEx) delete [] fOEx;
      fOEx = new Int_t[fNox]; // offsets in extra
      if (fNsliceX) delete [] fNsliceX;
      fNsliceX = new Int_t[fNox];
      current  = 0;
      indextra = 0;
      //--- now loop all slices
      for (id=0; id<fNox; id++) {
         fOBx[id] = current; // offset in dght list for this slice
         fOEx[id] = indextra; // offset in exta list for this slice
         fNsliceX[id] = 0; // ndght in this slice
         extra[indextra] = extra[indextra+1] = 0; // no extra left/right
         nleft = nright = 0;
         bits = &ind[current]; // adress of bits for this slice
         xxmin = fXb[id];
         xxmax = fXb[id+1];
         for (Int_t ic=0; ic<nd; ic++) {
            xbmin = fBoxes[6*ic+3]-fBoxes[6*ic];   
            xbmax = fBoxes[6*ic+3]+fBoxes[6*ic];
            ddx1 = xbmin-xxmax;
            if (ddx1>-1E-10) continue;
            ddx2 = xbmax-xxmin;
            if (ddx2<1E-10) continue;
            // daughter ic in interval
            //---> set the bit
            fNsliceX[id]++;
            bitnumber = (UInt_t)ic;
            loc = bitnumber/8;
            bit = bitnumber%8;
            bits[loc] |= 1<<bit;
            //---> chech if it is extra to left/right
            //--- left
            ddx1 = xbmin-xxmin;
            ddx2 = xbmax-xxmax;
            if ((id==0) || (ddx1>-1E-10)) {
               extra_left[nleft++] = ic;
            }   
            //---right
            if ((id==(fNoz-1)) || (ddx2<1E-10)) {
               extra_right[nright++] = ic;
            }   
         }
         //--- compute offset of next slice
         if (fNsliceX[id]>0) current += nperslice;
         //--- copy extra candidates
         extra[indextra] = nleft;
         extra[indextra+1] = nright;
         if (nleft)  memcpy(&extra[indextra+2], extra_left, nleft*sizeof(Int_t));
         if (nright) memcpy(&extra[indextra+2+nleft], extra_right, nright*sizeof(Int_t));  
         indextra += 2+nleft+nright;
      }
      if (fIndcX) delete [] fIndcX;
      fNx = current;
      fIndcX = new UChar_t[current];
      memcpy(fIndcX, ind, current*sizeof(UChar_t));
      if (fExtraX) delete [] fExtraX;
      fNex = indextra;
      if (indextra>nmaxslices*4) printf("Woops!!!\n");
      fExtraX = new Int_t[indextra];
      memcpy(fExtraX, extra, indextra*sizeof(Int_t));
   }   

   // sort y boundaries
   ib = 0;
   TMath::Sort(2*nd, &boundaries[2*nd], &index[0], kFALSE);
   // compact common boundaries
   for (id=0; id<2*nd; id++) {
      if (!ib) {temp[ib++] = boundaries[2*nd+index[id]]; continue;}
      if (TMath::Abs(temp[ib-1]-boundaries[2*nd+index[id]])>1E-10) 
         temp[ib++]=boundaries[2*nd+index[id]];
   }
   // now find priority on Y
   if (ib < 2) {
      Error("SortAll", "Cannot voxelize %s :less than 2 boundaries on Y", fVolume->GetName());
      delete [] index;
      delete [] ind;
      delete [] temp;
      delete [] extra;
      delete [] extra_left;
      delete [] extra_right;
      SetInvalid();
      return;
   }   
   if (ib == 2) {
   // check range
      if (((temp[0]-ymin)<1E-10) && ((temp[1]-ymax)>-1E-10)) {
      // ordering on this axis makes no sense. Clear all arrays.
         fPriority[1] = 0; // always skip this axis
         if (fIndcY) delete [] fIndcY; 
         fIndcY = 0;
         fNy = 0;
         if (fYb) delete [] fYb;   
         fYb = 0;
         fIby = 0;
         if (fOBy) delete [] fOBy;  
         fOBy = 0;
         fNoy = 0;
      } else {
         fPriority[1] = 1; // all in one slice
      }
   } else {
      fPriority[1] = 2;    // check all
   }

   // store compacted boundaries
   if (fPriority[1]) {
      if (fYb) delete [] fYb;
      fYb = new Double_t[ib];
      memcpy(fYb, &temp[0], ib*sizeof(Double_t));
      fIby = ib;   
   }   


   if (fPriority[1]==2) {
   //--- now build the lists of nodes in each slice of Y axis
      memset(ind, 0, (nmaxslices*nperslice)*sizeof(UChar_t));
      if (fOBy) delete [] fOBy;
      fNoy = fIby-1; // number of different slices
      fOBy = new Int_t[fNoy]; // offsets in ind
      if (fOEy) delete [] fOEy;
      fOEy = new Int_t[fNoy]; // offsets in extra
      if (fNsliceY) delete [] fNsliceY;
      fNsliceY = new Int_t[fNoy];
      current = 0;
      indextra = 0;
      //--- now loop all slices
      for (id=0; id<fNoy; id++) {
         fOBy[id] = current; // offset of dght list
         fOEy[id] = indextra; // offset in exta list for this slice
         fNsliceY[id] = 0; // ndght in this slice
         extra[indextra] = extra[indextra+1] = 0; // no extra left/right
         nleft = nright = 0;
         bits = &ind[current]; // adress of bits for this slice
         xxmin = fYb[id];
         xxmax = fYb[id+1];
         for (Int_t ic=0; ic<nd; ic++) {
            xbmin = fBoxes[6*ic+4]-fBoxes[6*ic+1];   
            xbmax = fBoxes[6*ic+4]+fBoxes[6*ic+1];   
            ddx1 = xbmin-xxmax;
            if (ddx1>-1E-10) continue;
            ddx2 = xbmax-xxmin;
            if (ddx2<1E-10) continue;
            // daughter ic in interval
            //---> set the bit
            fNsliceY[id]++;
            bitnumber = (UInt_t)ic;
            loc = bitnumber/8;
            bit = bitnumber%8;
            bits[loc] |= 1<<bit;
            //---> chech if it is extra to left/right
            //--- left
            ddx1 = xbmin-xxmin;
            ddx2 = xbmax-xxmax;
            if ((id==0) || (ddx1>-1E-10)) {
               extra_left[nleft++] = ic;
            }   
            //---right
            if ((id==(fNoz-1)) || (ddx2<1E-10)) {
               extra_right[nright++] = ic;
            }   
         }
         //--- compute offset of next slice
         if (fNsliceY[id]>0) current += nperslice;
         //--- copy extra candidates
         extra[indextra] = nleft;
         extra[indextra+1] = nright;
         if (nleft)  memcpy(&extra[indextra+2], extra_left, nleft*sizeof(Int_t));
         if (nright) memcpy(&extra[indextra+2+nleft], extra_right, nright*sizeof(Int_t));  
         indextra += 2+nleft+nright;
      }
      if (fIndcY) delete [] fIndcY;
      fNy = current;
      fIndcY = new UChar_t[current];
      memcpy(fIndcY, &ind[0], current*sizeof(UChar_t));
      if (fExtraY) delete [] fExtraY;
      fNey = indextra;
      if (indextra>nmaxslices*4) printf("Woops!!!\n");
      fExtraY = new Int_t[indextra];
      memcpy(fExtraY, extra, indextra*sizeof(Int_t));
   }
   
   // sort z boundaries
   ib = 0;
   TMath::Sort(2*nd, &boundaries[4*nd], &index[0], kFALSE);
   // compact common boundaries
   for (id=0; id<2*nd; id++) {
      if (!ib) {temp[ib++] = boundaries[4*nd+index[id]]; continue;}
      if ((TMath::Abs(temp[ib-1]-boundaries[4*nd+index[id]]))>1E-10) 
         temp[ib++]=boundaries[4*nd+index[id]];
   }      
   // now find priority on Z
   if (ib < 2) {
      Error("SortAll", "Cannot voxelize %s :less than 2 boundaries on Z", fVolume->GetName());
      delete [] index;
      delete [] ind;
      delete [] temp;
      delete [] extra;
      delete [] extra_left;
      delete [] extra_right;
      SetInvalid();
      return;
   }   
   if (ib == 2) {
   // check range
      if (((temp[0]-zmin)<1E-10) && ((temp[1]-zmax)>-1E-10)) {
      // ordering on this axis makes no sense. Clear all arrays.
         fPriority[2] = 0;
         if (fIndcZ) delete [] fIndcZ; 
         fIndcZ = 0;
         fNz = 0;
         if (fZb) delete [] fZb;   
         fZb = 0;
         fIbz = 0;
         if (fOBz) delete [] fOBz;  
         fOBz = 0;
         fNoz = 0;
      } else {
         fPriority[2] = 1; // all in one slice
      }
   } else {
      fPriority[2] = 2;    // check all
   }

   // store compacted boundaries
   if (fPriority[2]) {
      if (fZb) delete [] fZb;
      fZb = new Double_t[ib];
      memcpy(fZb, &temp[0], ib*sizeof(Double_t));
      fIbz = ib;   
   }   


   if (fPriority[2]==2) {
   //--- now build the lists of nodes in each slice of Y axis
      memset(ind, 0, (nmaxslices*nperslice)*sizeof(UChar_t));
      if (fOBz) delete [] fOBz;
      fNoz = fIbz-1; // number of different slices
      fOBz = new Int_t[fNoz]; // offsets in ind
      if (fOEz) delete [] fOEz;
      fOEz = new Int_t[fNoz]; // offsets in extra
      if (fNsliceZ) delete [] fNsliceZ;
      fNsliceZ = new Int_t[fNoz];
      current = 0;
      indextra = 0;
      //--- now loop all slices
      for (id=0; id<fNoz; id++) {
         fOBz[id] = current; // offset of dght list
         fOEz[id] = indextra; // offset in exta list for this slice
         fNsliceZ[id] = 0; // ndght in this slice
         extra[indextra] = extra[indextra+1] = 0; // no extra left/right
         nleft = nright = 0;
         bits = &ind[current]; // adress of bits for this slice
         xxmin = fZb[id];
         xxmax = fZb[id+1];
         for (Int_t ic=0; ic<nd; ic++) {
            xbmin = fBoxes[6*ic+5]-fBoxes[6*ic+2];   
            xbmax = fBoxes[6*ic+5]+fBoxes[6*ic+2];   
            ddx1 = xbmin-xxmax;
            if (ddx1>-1E-10) continue;
            ddx2 = xbmax-xxmin;
            if (ddx2<1E-10) continue;
            // daughter ic in interval
            //---> set the bit
            fNsliceZ[id]++;
            bitnumber = (UInt_t)ic;
            loc = bitnumber/8;
            bit = bitnumber%8;
            bits[loc] |= 1<<bit;
            //---> chech if it is extra to left/right
            //--- left
            ddx1 = xbmin-xxmin;
            ddx2 = xbmax-xxmax;
            if ((id==0) || (ddx1>-1E-10)) {
               extra_left[nleft++] = ic;
            }   
            //---right
            if ((id==(fNoz-1)) || (ddx2<1E-10)) {
               extra_right[nright++] = ic;
            }   
         }
         //--- compute offset of next slice
         if (fNsliceZ[id]>0) current += nperslice;
         //--- copy extra candidates
         extra[indextra] = nleft;
         extra[indextra+1] = nright;
         if (nleft)  memcpy(&extra[indextra+2], extra_left, nleft*sizeof(Int_t));
         if (nright) memcpy(&extra[indextra+2+nleft], extra_right, nright*sizeof(Int_t));  
         indextra += 2+nleft+nright;
      }
      if (fIndcZ) delete [] fIndcZ;
      fNz = current;
      fIndcZ = new UChar_t[current];
      memcpy(fIndcZ, &ind[0], current*sizeof(UChar_t));
      if (fExtraZ) delete [] fExtraZ;
      fNez = indextra;
      if (indextra>nmaxslices*4) printf("Woops!!!\n");
      fExtraZ = new Int_t[indextra];
      memcpy(fExtraZ, extra, indextra*sizeof(Int_t));
   }   
   delete [] boundaries;   
   delete [] index;
   delete [] temp;
   delete [] ind;
   delete [] extra;
   delete [] extra_left;
   delete [] extra_right;

   if ((!fPriority[0]) && (!fPriority[1]) && (!fPriority[2])) {
      SetInvalid();
      if (nd>1) Error("SortAll", "Volume %s: Cannot make slices on any axis", fVolume->GetName());
   } 
}

//_____________________________________________________________________________
void TGeoVoxelFinder::Print(Option_t *) const
{
// Print the voxels.
   if (NeedRebuild()) {
      TGeoVoxelFinder *vox = (TGeoVoxelFinder*)this;
      vox->Voxelize();
      fVolume->FindOverlaps();
   }   
   Int_t id, i;
   Int_t nd = fVolume->GetNdaughters();
   printf("Voxels for volume %s (nd=%i)\n", fVolume->GetName(), fVolume->GetNdaughters());
   printf("priority : x=%i y=%i z=%i\n", fPriority[0], fPriority[1], fPriority[2]);
//   return;
   Int_t nextra;
   Int_t nbytes = 1+((fVolume->GetNdaughters()-1)>>3);
   UChar_t byte, bit;
   UChar_t *slice;
   printf("XXX\n");
   if (fPriority[0]==2) {
      for (id=0; id<fIbx; id++) {
         printf("%15.10f\n",fXb[id]);
         if (id == (fIbx-1)) break;
         printf("slice %i : %i\n", id, fNsliceX[id]);
         if (fNsliceX[id]) {
            slice = &fIndcX[fOBx[id]];
            for (i=0; i<nbytes; i++) {
               byte = slice[i];
               for (bit=0; bit<8; bit++) {
                  if (byte & (1<<bit)) printf(" %i ", 8*i+bit);
               }
            }
            printf("\n");
         }         
         GetExtraX(id,kTRUE,nextra);
         printf("   extra_about_left  = %i\n", nextra); 
         GetExtraX(id,kFALSE,nextra);
         printf("   extra_about_right = %i\n", nextra); 
      }
   } else if (fPriority[0]==1) {
      printf("%15.10f\n",fXb[0]);
      for (id=0; id<nd; id++) printf(" %i ",id);
      printf("\n");
      printf("%15.10f\n",fXb[1]);
   }
   printf("YYY\n"); 
   if (fPriority[1]==2) { 
      for (id=0; id<fIby; id++) {
         printf("%15.10f\n", fYb[id]);
         if (id == (fIby-1)) break;
         printf("slice %i : %i\n", id, fNsliceY[id]);
         if (fNsliceY[id]) {
            slice = &fIndcY[fOBy[id]];
            for (i=0; i<nbytes; i++) {
               byte = slice[i];
               for (bit=0; bit<8; bit++) {
                  if (byte & (1<<bit)) printf(" %i ", 8*i+bit);
               }
            }
         }         
         GetExtraY(id,kTRUE,nextra);
         printf("   extra_about_left  = %i\n", nextra); 
         GetExtraY(id,kFALSE,nextra);
         printf("   extra_about_right = %i\n", nextra); 
      }
   } else if (fPriority[1]==1) {
      printf("%15.10f\n",fYb[0]);
      for (id=0; id<nd; id++) printf(" %i ",id);
      printf("\n");
      printf("%15.10f\n",fYb[1]);
   }

   printf("ZZZ\n"); 
   if (fPriority[2]==2) { 
      for (id=0; id<fIbz; id++) {
         printf("%15.10f\n", fZb[id]);
         if (id == (fIbz-1)) break;
         printf("slice %i : %i\n", id, fNsliceZ[id]);
         if (fNsliceZ[id]) {
            slice = &fIndcZ[fOBz[id]];
            for (i=0; i<nbytes; i++) {
               byte = slice[i];
               for (bit=0; bit<8; bit++) {
                  if (byte & (1<<bit)) printf(" %i ", 8*i+bit);
               }
            }
            printf("\n");
         }         
         GetExtraZ(id,kTRUE,nextra);
         printf("   extra_about_left  = %i\n", nextra); 
         GetExtraZ(id,kFALSE,nextra);
         printf("   extra_about_right = %i\n", nextra); 
      }
   } else if (fPriority[2]==1) {
      printf("%15.10f\n",fZb[0]);
      for (id=0; id<nd; id++) printf(" %i ",id);
      printf("\n");
      printf("%15.10f\n",fZb[1]);
   }
}

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