ROOT logo
// @(#)root/geom:$Id$// Author: Andrei Gheata   24/10/01

// Contains() and DistFromOutside/Out() implemented by Mihaela Gheata

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

//--------------------------------------------------------------------------
// TGeoBBox - box class. All shape primitives inherit from this, their 
//   constructor filling automatically the parameters of the box that bounds
//   the given shape. Defined by 6 parameters :
//      fDX, fDY, fDZ - half lengths on X, Y and Z axis
//      fOrigin[3]    - position of box origin
//
//--------------------------------------------------------------------------
//
//
//--- Building boxes
//  ==================
//  Normally a box has to be build only with 3 parameters : dx, dy, dz
// representing the half lengths on X, Y and Z axis. In this case, the origin 
// of the box will match the one of its reference frame. The translation of the
// origin is used only by the constructors of all other shapes in order to
// define their own bounding boxes. Users should be aware that building a
// translated box that will represent a physical shape by itself will affect any
// further positioning of other shapes inside. Therefore in order to build a
// positioned box one should follow the recipe described in class TGeoNode.
//
// Creation of boxes
// 1.   TGeoBBox *box = new TGeoBBox("BOX", 20, 30, 40);
//Begin_Html
/*
<img src="gif/t_box.gif">
*/
//End_Html
//
// 2. A volume having a box shape can be built in one step:
//      TGeoVolume *vbox = gGeoManager->MakeBox("vbox", ptrMed, 20,30,40);
//
// Divisions of boxes.
//
//   Volumes having box shape can be divided with equal-length slices on 
// X, Y or Z axis. The following options are supported:
// a) Dividing the full range of one axis in N slices
//      TGeoVolume *divx = vbox->Divide("SLICEX", 1, N);
//   - here 1 stands for the division axis (1-X, 2-Y, 3-Z)
//Begin_Html
/*
<img src="gif/t_boxdivX.gif">
*/
//End_Html
//
// b) Dividing in a limited range - general case.
//      TGeoVolume *divy = vbox->Divide("SLICEY",2,N,start,step);
//   - start = starting offset within (-fDY, fDY)
//   - step  = slicing step
//
//Begin_Html
/*
<img src="gif/t_boxdivstepZ.gif">
*/
//End_Html
//
// Both cases are supported by all shapes.
//   See also class TGeoShape for utility methods provided by any particular 
// shape.
//_____________________________________________________________________________

#include "Riostream.h"

#include "TGeoManager.h"
#include "TGeoMatrix.h"
#include "TGeoVolume.h"
#include "TVirtualGeoPainter.h"
#include "TGeoBBox.h"
#include "TVirtualPad.h"
#include "TBuffer3D.h"
#include "TBuffer3DTypes.h"
#include "TMath.h"
#include "TRandom.h"

ClassImp(TGeoBBox)
   
//_____________________________________________________________________________
TGeoBBox::TGeoBBox()
{
// Default constructor
   SetShapeBit(TGeoShape::kGeoBox);
   fDX = fDY = fDZ = 0;
   fOrigin[0] = fOrigin[1] = fOrigin[2] = 0.0;
}   

//_____________________________________________________________________________
TGeoBBox::TGeoBBox(Double_t dx, Double_t dy, Double_t dz, Double_t *origin)
         :TGeoShape("")
{
// Constructor where half-lengths are provided.
   SetShapeBit(TGeoShape::kGeoBox);
   fOrigin[0] = fOrigin[1] = fOrigin[2] = 0.0;
   SetBoxDimensions(dx, dy, dz, origin);
}

//_____________________________________________________________________________
TGeoBBox::TGeoBBox(const char *name, Double_t dx, Double_t dy, Double_t dz, Double_t *origin)
         :TGeoShape(name)
{
// Constructor with shape name.
   SetShapeBit(TGeoShape::kGeoBox);
   fOrigin[0] = fOrigin[1] = fOrigin[2] = 0.0;
   SetBoxDimensions(dx, dy, dz, origin);
}

//_____________________________________________________________________________
TGeoBBox::TGeoBBox(Double_t *param)
         :TGeoShape("")
{
// Constructor based on the array of parameters
// param[0] - half-length in x
// param[1] - half-length in y
// param[2] - half-length in z
   SetShapeBit(TGeoShape::kGeoBox);
   fOrigin[0] = fOrigin[1] = fOrigin[2] = 0.0;
   SetDimensions(param);
}   

//_____________________________________________________________________________
TGeoBBox::~TGeoBBox()
{
// Destructor
}

//_____________________________________________________________________________
Bool_t TGeoBBox::AreOverlapping(const TGeoBBox *box1, const TGeoMatrix *mat1, const TGeoBBox *box2, const TGeoMatrix *mat2)
{
// Check if 2 positioned boxes overlap.
   Double_t master[3];
   Double_t local[3];
   Double_t ldir1[3], ldir2[3];
   const Double_t *o1 = box1->GetOrigin();
   const Double_t *o2 = box2->GetOrigin();
   // Convert center of first box to the local frame of second
   mat1->LocalToMaster(o1, master);
   mat2->MasterToLocal(master, local);
   if (TGeoBBox::Contains(local,box2->GetDX(),box2->GetDY(),box2->GetDZ(),o2)) return kTRUE;
   Double_t distsq = (local[0]-o2[0])*(local[0]-o2[0]) +
                     (local[1]-o2[1])*(local[1]-o2[1]) +
                     (local[2]-o2[2])*(local[2]-o2[2]);
   // Compute distance between box centers and compare with max value
   Double_t rmaxsq = (box1->GetDX()+box2->GetDX())*(box1->GetDX()+box2->GetDX()) +
                     (box1->GetDY()+box2->GetDY())*(box1->GetDY()+box2->GetDY()) +
                     (box1->GetDZ()+box2->GetDZ())*(box1->GetDZ()+box2->GetDZ());
   if (distsq > rmaxsq + TGeoShape::Tolerance()) return kFALSE;
   // We are still not sure: shoot a ray from the center of "1" towards the
   // center of 2.
   Double_t dir[3];
   mat1->LocalToMaster(o1, ldir1);
   mat2->LocalToMaster(o2, ldir2);
   distsq = 1./TMath::Sqrt(distsq);
   dir[0] = (ldir2[0]-ldir1[0])*distsq;
   dir[1] = (ldir2[1]-ldir1[1])*distsq;
   dir[2] = (ldir2[2]-ldir1[2])*distsq;
   mat1->MasterToLocalVect(dir, ldir1);
   mat2->MasterToLocalVect(dir, ldir2);
   // Distance to exit from o1
   Double_t dist1 = TGeoBBox::DistFromInside(o1,ldir1,box1->GetDX(),box1->GetDY(),box1->GetDZ(),o1);
   // Distance to enter from o2
   Double_t dist2 = TGeoBBox::DistFromOutside(local,ldir2,box2->GetDX(),box2->GetDY(),box2->GetDZ(),o2);
   if (dist1 > dist2) return kTRUE;
   return kFALSE;
}

//_____________________________________________________________________________
Double_t TGeoBBox::Capacity() const
{
// Computes capacity of the shape in [length^3].
   return (8.*fDX*fDY*fDZ);
}

//_____________________________________________________________________________
void TGeoBBox::ComputeNormal(const Double_t *point, const Double_t *dir, Double_t *norm)
{
// Computes normal to closest surface from POINT. 
   memset(norm,0,3*sizeof(Double_t));
   Double_t saf[3];
   Int_t i;
   saf[0]=TMath::Abs(TMath::Abs(point[0]-fOrigin[0])-fDX);
   saf[1]=TMath::Abs(TMath::Abs(point[1]-fOrigin[1])-fDY);
   saf[2]=TMath::Abs(TMath::Abs(point[2]-fOrigin[2])-fDZ);
   i = TMath::LocMin(3,saf);
   norm[i] = (dir[i]>0)?1:(-1);
}

//_____________________________________________________________________________
Bool_t TGeoBBox::CouldBeCrossed(const Double_t *point, const Double_t *dir) const
{
// Decides fast if the bounding box could be crossed by a vector.
   Double_t mind = fDX;
   if (fDY<mind) mind=fDY;
   if (fDZ<mind) mind=fDZ;
   Double_t dx = fOrigin[0]-point[0];
   Double_t dy = fOrigin[1]-point[1];
   Double_t dz = fOrigin[2]-point[2];
   Double_t do2 = dx*dx+dy*dy+dz*dz;
   if (do2<=(mind*mind)) return kTRUE;
   Double_t rmax2 = fDX*fDX+fDY*fDY+fDZ*fDZ;
   if (do2<=rmax2) return kTRUE;
   // inside bounding sphere
   Double_t doct = dx*dir[0]+dy*dir[1]+dz*dir[2];
   // leaving ray
   if (doct<=0) return kFALSE;
   Double_t dirnorm=dir[0]*dir[0]+dir[1]*dir[1]+dir[2]*dir[2];   
   if ((doct*doct)>=(do2-rmax2)*dirnorm) return kTRUE;
   return kFALSE;
}

//_____________________________________________________________________________
Int_t TGeoBBox::DistancetoPrimitive(Int_t px, Int_t py)
{
// Compute closest distance from point px,py to each corner.
   const Int_t numPoints = 8;
   return ShapeDistancetoPrimitive(numPoints, px, py);
}

//_____________________________________________________________________________
TGeoVolume *TGeoBBox::Divide(TGeoVolume *voldiv, const char *divname, Int_t iaxis, Int_t ndiv, 
                             Double_t start, Double_t step) 
{
//--- Divide this box shape belonging to volume "voldiv" into ndiv equal volumes
// called divname, from start position with the given step. Returns pointer
// to created division cell volume. In case a wrong division axis is supplied,
// returns pointer to volume to be divided.
   TGeoShape *shape;           //--- shape to be created
   TGeoVolume *vol;            //--- division volume to be created
   TGeoVolumeMulti *vmulti;    //--- generic divided volume
   TGeoPatternFinder *finder;  //--- finder to be attached
   TString opt = "";           //--- option to be attached
   Double_t end = start+ndiv*step;
   switch (iaxis) {
      case 1:                  //--- divide on X
         shape = new TGeoBBox(step/2., fDY, fDZ); 
         finder = new TGeoPatternX(voldiv, ndiv, start, end);
         opt = "X";
         break;
      case 2:                  //--- divide on Y
         shape = new TGeoBBox(fDX, step/2., fDZ); 
         finder = new TGeoPatternY(voldiv, ndiv, start, end);
         opt = "Y";
         break;
      case 3:                  //--- divide on Z
         shape = new TGeoBBox(fDX, fDY, step/2.); 
         finder = new TGeoPatternZ(voldiv, ndiv, start, end);
         opt = "Z";
         break;
      default:
         Error("Divide", "Wrong axis type for division");
         return 0;
   }
   vol = new TGeoVolume(divname, shape, voldiv->GetMedium());
   vmulti = gGeoManager->MakeVolumeMulti(divname, voldiv->GetMedium());
   vmulti->AddVolume(vol);
   voldiv->SetFinder(finder);
   finder->SetDivIndex(voldiv->GetNdaughters());
   for (Int_t ic=0; ic<ndiv; ic++) {
      voldiv->AddNodeOffset(vol, ic, start+step/2.+ic*step, opt.Data());
      ((TGeoNodeOffset*)voldiv->GetNodes()->At(voldiv->GetNdaughters()-1))->SetFinder(finder);
   }
   return vmulti;
}     

//_____________________________________________________________________________
void TGeoBBox::ComputeBBox()
{
// Compute bounding box - nothing to do in this case.
}   

//_____________________________________________________________________________
Bool_t TGeoBBox::Contains(const Double_t *point) const
{
// Test if point is inside this shape.
   if (TMath::Abs(point[2]-fOrigin[2]) > fDZ) return kFALSE;
   if (TMath::Abs(point[0]-fOrigin[0]) > fDX) return kFALSE;
   if (TMath::Abs(point[1]-fOrigin[1]) > fDY) return kFALSE;
   return kTRUE;
}

//_____________________________________________________________________________
Bool_t TGeoBBox::Contains(const Double_t *point, Double_t dx, Double_t dy, Double_t dz, const Double_t *origin)
{
// Static method to check if point[3] is located inside a box of having dx, dy, dz
// as half-lengths.
   if (TMath::Abs(point[2]-origin[2]) > dz) return kFALSE;
   if (TMath::Abs(point[0]-origin[0]) > dx) return kFALSE;
   if (TMath::Abs(point[1]-origin[1]) > dy) return kFALSE;
   return kTRUE;
}

//_____________________________________________________________________________
Double_t TGeoBBox::DistFromInside(const Double_t *point, const Double_t *dir, Int_t iact, Double_t step, Double_t *safe) const
{
// Compute distance from inside point to surface of the box.
// Boundary safe algorithm.
   Double_t s,smin,saf[6];
   Double_t newpt[3];
   Int_t i;
   for (i=0; i<3; i++) newpt[i] = point[i] - fOrigin[i];
   saf[0] = fDX+newpt[0];
   saf[1] = fDX-newpt[0];
   saf[2] = fDY+newpt[1];
   saf[3] = fDY-newpt[1];
   saf[4] = fDZ+newpt[2];
   saf[5] = fDZ-newpt[2];
   if (iact<3 && safe) {
      smin = saf[0];
      // compute safe distance
      for (i=1;i<6;i++) if (saf[i] < smin) smin = saf[i];
      *safe = smin;
      if (smin<0) *safe = 0.0;
      if (iact==0) return TGeoShape::Big();
      if (iact==1 && step<*safe) return TGeoShape::Big();
   }
   // compute distance to surface
   smin=TGeoShape::Big();
   for (i=0; i<3; i++) {
      if (dir[i]!=0) {
         s = (dir[i]>0)?(saf[(i<<1)+1]/dir[i]):(-saf[i<<1]/dir[i]);
         if (s < 0) return 0.0;
         if (s < smin) smin = s;
      }
   }
   return smin;
}

//_____________________________________________________________________________
Double_t TGeoBBox::DistFromInside(const Double_t *point,const Double_t *dir, 
                                  Double_t dx, Double_t dy, Double_t dz, const Double_t *origin, Double_t /*stepmax*/)
{
// Compute distance from inside point to surface of the box.
// Boundary safe algorithm.
   Double_t s,smin,saf[6];
   Double_t newpt[3];
   Int_t i;
   for (i=0; i<3; i++) newpt[i] = point[i] - origin[i];
   saf[0] = dx+newpt[0];
   saf[1] = dx-newpt[0];
   saf[2] = dy+newpt[1];
   saf[3] = dy-newpt[1];
   saf[4] = dz+newpt[2];
   saf[5] = dz-newpt[2];
   // compute distance to surface
   smin=TGeoShape::Big();
   for (i=0; i<3; i++) {
      if (dir[i]!=0) {
         s = (dir[i]>0)?(saf[(i<<1)+1]/dir[i]):(-saf[i<<1]/dir[i]);
         if (s < 0) return 0.0;
         if (s < smin) smin = s;
      }
   }
   return smin;
}

//_____________________________________________________________________________
Double_t TGeoBBox::DistFromOutside(const Double_t *point, const Double_t *dir, Int_t iact, Double_t step, Double_t *safe) const
{
// Compute distance from outside point to surface of the box.
// Boundary safe algorithm.
   Bool_t in = kTRUE;
   Double_t saf[3];
   Double_t par[3];
   Double_t newpt[3];
   Int_t i,j;
   for (i=0; i<3; i++) newpt[i] = point[i] - fOrigin[i];
   par[0] = fDX;
   par[1] = fDY;
   par[2] = fDZ;
   for (i=0; i<3; i++) {
      saf[i] = TMath::Abs(newpt[i])-par[i];
      if (saf[i]>=step) return TGeoShape::Big();
      if (in && saf[i]>0) in=kFALSE;
   }   
   if (iact<3 && safe) {
      // compute safe distance
      if (in) {
         *safe = 0.0;
      } else {   
         *safe = saf[0];
         if (saf[1] > *safe) *safe = saf[1];
         if (saf[2] > *safe) *safe = saf[2];
      }   
      if (iact==0) return TGeoShape::Big();
      if (iact==1 && step<*safe) return TGeoShape::Big();
   }
   // compute distance from point to box
   Double_t coord, snxt=TGeoShape::Big();
   Int_t ibreak=0;
   // protection in case point is actually inside box
   if (in) {
      j = 0;
      Double_t ss = saf[0];
      if (saf[1]>ss) {
         ss = saf[1];
         j = 1;
      }
      if (saf[2]>ss) j = 2;
      if (newpt[j]*dir[j]>0) return TGeoShape::Big(); // in fact exiting
      return 0.0;   
   }
   for (i=0; i<3; i++) {
      if (saf[i]<0) continue;
      if (newpt[i]*dir[i] >= 0) continue;
      snxt = saf[i]/TMath::Abs(dir[i]);
      ibreak = 0;
      for (j=0; j<3; j++) {
         if (j==i) continue;
         coord=newpt[j]+snxt*dir[j];
         if (TMath::Abs(coord)>par[j]) {
            ibreak=1;
            break;
         }
      }
      if (!ibreak) return snxt;
   }
   return TGeoShape::Big();
}

//_____________________________________________________________________________
Double_t TGeoBBox::DistFromOutside(const Double_t *point,const Double_t *dir, 
                                   Double_t dx, Double_t dy, Double_t dz, const Double_t *origin, Double_t stepmax)
{
// Compute distance from outside point to surface of the box.
// Boundary safe algorithm.
   Bool_t in = kTRUE;
   Double_t saf[3];
   Double_t par[3];
   Double_t newpt[3];
   Int_t i,j;
   for (i=0; i<3; i++) newpt[i] = point[i] - origin[i];
   par[0] = dx;
   par[1] = dy;
   par[2] = dz;
   for (i=0; i<3; i++) {
      saf[i] = TMath::Abs(newpt[i])-par[i];
      if (saf[i]>=stepmax) return TGeoShape::Big();
      if (in && saf[i]>0) in=kFALSE;
   }   
   // In case point is inside return ZERO
   if (in) return 0.0;
   Double_t coord, snxt=TGeoShape::Big();
   Int_t ibreak=0;
   for (i=0; i<3; i++) {
      if (saf[i]<0) continue;
      if (newpt[i]*dir[i] >= 0) continue;
      snxt = saf[i]/TMath::Abs(dir[i]);
      ibreak = 0;
      for (j=0; j<3; j++) {
         if (j==i) continue;
         coord=newpt[j]+snxt*dir[j];
         if (TMath::Abs(coord)>par[j]) {
            ibreak=1;
            break;
         }
      }
      if (!ibreak) return snxt;
   }
   return TGeoShape::Big();
}

//_____________________________________________________________________________
const char *TGeoBBox::GetAxisName(Int_t iaxis) const
{
// Returns name of axis IAXIS.
   switch (iaxis) {
      case 1:
         return "X";
      case 2:
         return "Y";
      case 3:
         return "Z";
      default:
         return "UNDEFINED";
   }
}   

//_____________________________________________________________________________
Double_t TGeoBBox::GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const
{
// Get range of shape for a given axis.
   xlo = 0;
   xhi = 0;
   Double_t dx = 0;
   switch (iaxis) {
      case 1:
         xlo = fOrigin[0]-fDX;
         xhi = fOrigin[0]+fDX;
         dx = 2*fDX;
         return dx;
      case 2:
         xlo = fOrigin[1]-fDY;
         xhi = fOrigin[1]+fDY;
         dx = 2*fDY;
         return dx;
      case 3:
         xlo = fOrigin[2]-fDZ;
         xhi = fOrigin[2]+fDZ;
         dx = 2*fDZ;
         return dx;
   }
   return dx;
}         
            
//_____________________________________________________________________________
void TGeoBBox::GetBoundingCylinder(Double_t *param) const
{
// Fill vector param[4] with the bounding cylinder parameters. The order
// is the following : Rmin, Rmax, Phi1, Phi2
   param[0] = 0.;                  // Rmin
   param[1] = fDX*fDX+fDY*fDY;     // Rmax
   param[2] = 0.;                  // Phi1
   param[3] = 360.;                // Phi2
}

//_____________________________________________________________________________
Double_t TGeoBBox::GetFacetArea(Int_t index) const
{
// Get area in internal units of the facet with a given index. 
// Possible index values:
//    0 - all facets togeather
//    1 to 6 - facet index from bottom to top Z
   Double_t area = 0.;
   switch (index) {
      case 0:
         area = 8.*(fDX*fDY + fDX*fDZ + fDY*fDZ);
         return area;
      case 1:
      case 6:
         area = 4.*fDX*fDY;
         return area;
      case 2:
      case 4:
         area = 4.*fDX*fDZ;
         return area;
      case 3:
      case 5:
         area = 4.*fDY*fDZ;
         return area;
   }
   return area;
}         

//_____________________________________________________________________________
Bool_t TGeoBBox::GetPointsOnFacet(Int_t index, Int_t npoints, Double_t *array) const
{
// Fills array with n random points located on the surface of indexed facet.
// The output array must be provided with a length of minimum 3*npoints. Returns
// true if operation succeeded.
// Possible index values:
//    0 - all facets togeather
//    1 to 6 - facet index from bottom to top Z
   if (index<0 || index>6) return kFALSE;
   Double_t surf[6];
   Double_t area = 0.;
   if (index==0) {
      for (Int_t isurf=0; isurf<6; isurf++) {
         surf[isurf] = TGeoBBox::GetFacetArea(isurf+1);
         if (isurf>0) surf[isurf] += surf[isurf-1];
      }   
      area = surf[5];
   }
   
   for (Int_t i=0; i<npoints; i++) {
   // Generate randomly a surface index if needed.
      Double_t *point = &array[3*i];
      Int_t surfindex = index;
      if (surfindex==0) {
         Double_t val = area*gRandom->Rndm();
         surfindex = 2+TMath::BinarySearch(6, surf, val);
         if (surfindex>6) surfindex=6;
      } 
      switch (surfindex) {
         case 1:
            point[0] = -fDX + 2*fDX*gRandom->Rndm();
            point[1] = -fDY + 2*fDY*gRandom->Rndm();
            point[2] = -fDZ;
            break;
         case 2:
            point[0] = -fDX + 2*fDX*gRandom->Rndm();
            point[1] = -fDY;
            point[2] = -fDZ + 2*fDZ*gRandom->Rndm();
            break;
         case 3:
            point[0] = -fDX;
            point[1] = -fDY + 2*fDY*gRandom->Rndm();
            point[2] = -fDZ + 2*fDZ*gRandom->Rndm();
            break;
         case 4:
            point[0] = -fDX + 2*fDX*gRandom->Rndm();
            point[1] = fDY;
            point[2] = -fDZ + 2*fDZ*gRandom->Rndm();
            break;
         case 5:
            point[0] = fDX;
            point[1] = -fDY + 2*fDY*gRandom->Rndm();
            point[2] = -fDZ + 2*fDZ*gRandom->Rndm();
            break;
         case 6:
            point[0] = -fDX + 2*fDX*gRandom->Rndm();
            point[1] = -fDY + 2*fDY*gRandom->Rndm();
            point[2] = fDZ;
            break;
      }
   }
   return kTRUE;
}      

//_____________________________________________________________________________
Bool_t TGeoBBox::GetPointsOnSegments(Int_t npoints, Double_t *array) const
{
// Fills array with n random points located on the line segments of the shape mesh.
// The output array must be provided with a length of minimum 3*npoints. Returns
// true if operation is implemented.
   if (npoints<GetNmeshVertices()) {
      Error("GetPointsOnSegments", "You should require at least %d points", GetNmeshVertices());
      return kFALSE;
   }
   TBuffer3D &buff = (TBuffer3D &)GetBuffer3D(TBuffer3D::kRawSizes | TBuffer3D::kRaw, kTRUE);
   Int_t npnts = buff.NbPnts();
   Int_t nsegs = buff.NbSegs();
   // Copy buffered points  in the array
   memcpy(array, buff.fPnts, 3*npnts*sizeof(Double_t));
   Int_t ipoints = npoints - npnts;
   Int_t icrt = 3*npnts;
   Int_t nperseg = (Int_t)(Double_t(ipoints)/nsegs);
   Double_t *p0, *p1;
   Double_t x,y,z, dx,dy,dz;
   for (Int_t i=0; i<nsegs; i++) {
      p0 = &array[3*buff.fSegs[3*i+1]];
      p1 = &array[3*buff.fSegs[3*i+2]];
      if (i==(nsegs-1)) nperseg = ipoints;
      dx = (p1[0]-p0[0])/(nperseg+1);
      dy = (p1[1]-p0[1])/(nperseg+1);
      dz = (p1[2]-p0[2])/(nperseg+1);
      for (Int_t j=0; j<nperseg; j++) {
         x = p0[0] + (j+1)*dx;
         y = p0[1] + (j+1)*dy;
         z = p0[2] + (j+1)*dz;
         array[icrt++] = x; array[icrt++] = y; array[icrt++] = z;
         ipoints--;
      }
   }
   return kTRUE;
}      
            
//_____________________________________________________________________________
Int_t TGeoBBox::GetFittingBox(const TGeoBBox *parambox, TGeoMatrix *mat, Double_t &dx, Double_t &dy, Double_t &dz) const
{
// Fills real parameters of a positioned box inside this one. Returns 0 if successfull.
   dx=dy=dz=0;
   if (mat->IsRotation()) {
      Error("GetFittingBox", "cannot handle parametrized rotated volumes");
      return 1; // ### rotation not accepted ###
   }
   //--> translate the origin of the parametrized box to the frame of this box.
   Double_t origin[3];
   mat->LocalToMaster(parambox->GetOrigin(), origin);
   if (!Contains(origin)) {
      Error("GetFittingBox", "wrong matrix - parametrized box is outside this");
      return 1; // ### wrong matrix ###
   }
   //--> now we have to get the valid range for all parametrized axis
   Double_t xlo=0, xhi=0;
   Double_t dd[3];
   dd[0] = parambox->GetDX();
   dd[1] = parambox->GetDY();
   dd[2] = parambox->GetDZ();
   for (Int_t iaxis=0; iaxis<3; iaxis++) {
      if (dd[iaxis]>=0) continue;
      TGeoBBox::GetAxisRange(iaxis+1, xlo, xhi);
      //-> compute best fitting parameter
      dd[iaxis] = TMath::Min(origin[iaxis]-xlo, xhi-origin[iaxis]); 
      if (dd[iaxis]<0) {
         Error("GetFittingBox", "wrong matrix");
         return 1;
      }   
   }
   dx = dd[0];
   dy = dd[1];
   dz = dd[2];
   return 0;
}

//_____________________________________________________________________________
TGeoShape *TGeoBBox::GetMakeRuntimeShape(TGeoShape *mother, TGeoMatrix *mat) const
{
// In case shape has some negative parameters, these has to be computed
// in order to fit the mother
   if (!TestShapeBit(kGeoRunTimeShape)) return 0;
   Double_t dx, dy, dz;
   Int_t ierr = mother->GetFittingBox(this, mat, dx, dy, dz);
   if (ierr) {
      Error("GetMakeRuntimeShape", "cannot fit this to mother");
      return 0;
   }   
   return (new TGeoBBox(dx, dy, dz));
}

//_____________________________________________________________________________
void TGeoBBox::GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t &npols) const
{
// Returns numbers of vertices, segments and polygons composing the shape mesh.
   nvert = 8;
   nsegs = 12;
   npols = 6;
}

//_____________________________________________________________________________
void TGeoBBox::InspectShape() const
{
// Prints shape parameters
   printf("*** Shape %s: TGeoBBox ***\n", GetName());
   printf("    dX = %11.5f\n", fDX);
   printf("    dY = %11.5f\n", fDY);
   printf("    dZ = %11.5f\n", fDZ);
   printf("    origin: x=%11.5f y=%11.5f z=%11.5f\n", fOrigin[0], fOrigin[1], fOrigin[2]);
}

//_____________________________________________________________________________
TBuffer3D *TGeoBBox::MakeBuffer3D() const
{
// Creates a TBuffer3D describing *this* shape.
// Coordinates are in local reference frame.   
   TBuffer3D* buff = new TBuffer3D(TBuffer3DTypes::kGeneric, 8, 24, 12, 36, 6, 36);
   if (buff)
   {
      SetPoints(buff->fPnts);
      SetSegsAndPols(*buff);
   }

   return buff;   
}

//_____________________________________________________________________________
void TGeoBBox::SetSegsAndPols(TBuffer3D &buff) const
{
// Fills TBuffer3D structure for segments and polygons.
   Int_t c = GetBasicColor();
   
   buff.fSegs[ 0] = c   ; buff.fSegs[ 1] = 0   ; buff.fSegs[ 2] = 1   ;
   buff.fSegs[ 3] = c+1 ; buff.fSegs[ 4] = 1   ; buff.fSegs[ 5] = 2   ;
   buff.fSegs[ 6] = c+1 ; buff.fSegs[ 7] = 2   ; buff.fSegs[ 8] = 3   ;
   buff.fSegs[ 9] = c   ; buff.fSegs[10] = 3   ; buff.fSegs[11] = 0   ;
   buff.fSegs[12] = c+2 ; buff.fSegs[13] = 4   ; buff.fSegs[14] = 5   ;
   buff.fSegs[15] = c+2 ; buff.fSegs[16] = 5   ; buff.fSegs[17] = 6   ;
   buff.fSegs[18] = c+3 ; buff.fSegs[19] = 6   ; buff.fSegs[20] = 7   ;
   buff.fSegs[21] = c+3 ; buff.fSegs[22] = 7   ; buff.fSegs[23] = 4   ;
   buff.fSegs[24] = c   ; buff.fSegs[25] = 0   ; buff.fSegs[26] = 4   ;
   buff.fSegs[27] = c+2 ; buff.fSegs[28] = 1   ; buff.fSegs[29] = 5   ;
   buff.fSegs[30] = c+1 ; buff.fSegs[31] = 2   ; buff.fSegs[32] = 6   ;
   buff.fSegs[33] = c+3 ; buff.fSegs[34] = 3   ; buff.fSegs[35] = 7   ;
   
   buff.fPols[ 0] = c   ; buff.fPols[ 1] = 4   ;  buff.fPols[ 2] = 0  ;
   buff.fPols[ 3] = 9   ; buff.fPols[ 4] = 4   ;  buff.fPols[ 5] = 8  ;
   buff.fPols[ 6] = c+1 ; buff.fPols[ 7] = 4   ;  buff.fPols[ 8] = 1  ;
   buff.fPols[ 9] = 10  ; buff.fPols[10] = 5   ;  buff.fPols[11] = 9  ;
   buff.fPols[12] = c   ; buff.fPols[13] = 4   ;  buff.fPols[14] = 2  ;
   buff.fPols[15] = 11  ; buff.fPols[16] = 6   ;  buff.fPols[17] = 10 ;
   buff.fPols[18] = c+1 ; buff.fPols[19] = 4   ;  buff.fPols[20] = 3  ;
   buff.fPols[21] = 8   ; buff.fPols[22] = 7   ;  buff.fPols[23] = 11 ;
   buff.fPols[24] = c+2 ; buff.fPols[25] = 4   ;  buff.fPols[26] = 0  ;
   buff.fPols[27] = 3   ; buff.fPols[28] = 2   ;  buff.fPols[29] = 1  ;
   buff.fPols[30] = c+3 ; buff.fPols[31] = 4   ;  buff.fPols[32] = 4  ;
   buff.fPols[33] = 5   ; buff.fPols[34] = 6   ;  buff.fPols[35] = 7  ;
}

//_____________________________________________________________________________
Double_t TGeoBBox::Safety(const Double_t *point, Bool_t in) const
{
// Computes the closest distance from given point to this shape.

   Double_t safe, safy, safz;
   if (in) {
      safe = fDX - TMath::Abs(point[0]-fOrigin[0]);
      safy = fDY - TMath::Abs(point[1]-fOrigin[1]);
      safz = fDZ - TMath::Abs(point[2]-fOrigin[2]);
      if (safy < safe) safe = safy;
      if (safz < safe) safe = safz;
   } else {
      safe = -fDX + TMath::Abs(point[0]-fOrigin[0]);
      safy = -fDY + TMath::Abs(point[1]-fOrigin[1]);
      safz = -fDZ + TMath::Abs(point[2]-fOrigin[2]);
      if (safy > safe) safe = safy;
      if (safz > safe) safe = safz;
   }
   return safe;
}

//_____________________________________________________________________________
void TGeoBBox::SavePrimitive(std::ostream &out, Option_t * /*option*/ /*= ""*/)
{
// Save a primitive as a C++ statement(s) on output stream "out".
   if (TObject::TestBit(kGeoSavePrimitive)) return;
   out << "   // Shape: " << GetName() << " type: " << ClassName() << std::endl;
   out << "   dx = " << fDX << ";" << std::endl;
   out << "   dy = " << fDY << ";" << std::endl;
   out << "   dz = " << fDZ << ";" << std::endl;
   if (!TGeoShape::IsSameWithinTolerance(fOrigin[0],0) || 
       !TGeoShape::IsSameWithinTolerance(fOrigin[1],0) || 
       !TGeoShape::IsSameWithinTolerance(fOrigin[2],0)) { 
      out << "   origin[0] = " << fOrigin[0] << ";" << std::endl;
      out << "   origin[1] = " << fOrigin[1] << ";" << std::endl;
      out << "   origin[2] = " << fOrigin[2] << ";" << std::endl;
      out << "   TGeoShape *" << GetPointerName() << " = new TGeoBBox(\"" << GetName() << "\", dx,dy,dz,origin);" << std::endl;
   } else {   
      out << "   TGeoShape *" << GetPointerName() << " = new TGeoBBox(\"" << GetName() << "\", dx,dy,dz);" << std::endl;
   }
   TObject::SetBit(TGeoShape::kGeoSavePrimitive);
}         

//_____________________________________________________________________________
void TGeoBBox::SetBoxDimensions(Double_t dx, Double_t dy, Double_t dz, Double_t *origin)
{
// Set parameters of the box.
   fDX = dx;
   fDY = dy;
   fDZ = dz;
   if (origin) {
      fOrigin[0] = origin[0];
      fOrigin[1] = origin[1];
      fOrigin[2] = origin[2];
   }   
   if (TMath::Abs(fDX)<TGeoShape::Tolerance() && 
       TMath::Abs(fDY)<TGeoShape::Tolerance() &&
       TMath::Abs(fDZ)<TGeoShape::Tolerance()) return;
   if ((fDX<0) || (fDY<0) || (fDZ<0)) SetShapeBit(kGeoRunTimeShape);
}        

//_____________________________________________________________________________
void TGeoBBox::SetDimensions(Double_t *param)
{
// Set dimensions based on the array of parameters
// param[0] - half-length in x
// param[1] - half-length in y
// param[2] - half-length in z
   if (!param) {
      Error("SetDimensions", "null parameters");
      return;
   }
   fDX = param[0];
   fDY = param[1];
   fDZ = param[2];
   if (TMath::Abs(fDX)<TGeoShape::Tolerance() && 
       TMath::Abs(fDY)<TGeoShape::Tolerance() &&
       TMath::Abs(fDZ)<TGeoShape::Tolerance()) return;
   if ((fDX<0) || (fDY<0) || (fDZ<0)) SetShapeBit(kGeoRunTimeShape);
}   

//_____________________________________________________________________________
void TGeoBBox::SetBoxPoints(Double_t *points) const
{
// Fill box vertices to an array.
   TGeoBBox::SetPoints(points);
}

//_____________________________________________________________________________
void TGeoBBox::SetPoints(Double_t *points) const
{
// Fill box points.
   if (!points) return;
   Double_t xmin,xmax,ymin,ymax,zmin,zmax;
   xmin = -fDX+fOrigin[0];
   xmax =  fDX+fOrigin[0];
   ymin = -fDY+fOrigin[1];
   ymax =  fDY+fOrigin[1];
   zmin = -fDZ+fOrigin[2];
   zmax =  fDZ+fOrigin[2];
   points[ 0] = xmin; points[ 1] = ymin; points[ 2] = zmin;
   points[ 3] = xmin; points[ 4] = ymax; points[ 5] = zmin;
   points[ 6] = xmax; points[ 7] = ymax; points[ 8] = zmin;
   points[ 9] = xmax; points[10] = ymin; points[11] = zmin;
   points[12] = xmin; points[13] = ymin; points[14] = zmax;
   points[15] = xmin; points[16] = ymax; points[17] = zmax;
   points[18] = xmax; points[19] = ymax; points[20] = zmax;
   points[21] = xmax; points[22] = ymin; points[23] = zmax;
}

//_____________________________________________________________________________
void TGeoBBox::SetPoints(Float_t *points) const
{
// Fill box points.
   if (!points) return;
   Double_t xmin,xmax,ymin,ymax,zmin,zmax;
   xmin = -fDX+fOrigin[0];
   xmax =  fDX+fOrigin[0];
   ymin = -fDY+fOrigin[1];
   ymax =  fDY+fOrigin[1];
   zmin = -fDZ+fOrigin[2];
   zmax =  fDZ+fOrigin[2];
   points[ 0] = xmin; points[ 1] = ymin; points[ 2] = zmin;
   points[ 3] = xmin; points[ 4] = ymax; points[ 5] = zmin;
   points[ 6] = xmax; points[ 7] = ymax; points[ 8] = zmin;
   points[ 9] = xmax; points[10] = ymin; points[11] = zmin;
   points[12] = xmin; points[13] = ymin; points[14] = zmax;
   points[15] = xmin; points[16] = ymax; points[17] = zmax;
   points[18] = xmax; points[19] = ymax; points[20] = zmax;
   points[21] = xmax; points[22] = ymin; points[23] = zmax;
}

//_____________________________________________________________________________
void TGeoBBox::Sizeof3D() const
{
///// fill size of this 3-D object
///    TVirtualGeoPainter *painter = gGeoManager->GetGeomPainter();
///    if (painter) painter->AddSize3D(8, 12, 6);
}

//_____________________________________________________________________________
const TBuffer3D & TGeoBBox::GetBuffer3D(Int_t reqSections, Bool_t localFrame) const
{
// Fills a static 3D buffer and returns a reference.
   static TBuffer3D buffer(TBuffer3DTypes::kGeneric);

   FillBuffer3D(buffer, reqSections, localFrame);

   // TODO: A box itself has has nothing more as already described
   // by bounding box. How will viewer interpret?
   if (reqSections & TBuffer3D::kRawSizes) {
      if (buffer.SetRawSizes(8, 3*8, 12, 3*12, 6, 6*6)) {
         buffer.SetSectionsValid(TBuffer3D::kRawSizes);
      }
   }
   if ((reqSections & TBuffer3D::kRaw) && buffer.SectionsValid(TBuffer3D::kRawSizes)) {
      SetPoints(buffer.fPnts);
      if (!buffer.fLocalFrame) {
         TransformPoints(buffer.fPnts, buffer.NbPnts());
      }

      SetSegsAndPols(buffer);
      buffer.SetSectionsValid(TBuffer3D::kRaw);
   }
      
   return buffer;
}

//_____________________________________________________________________________
void TGeoBBox::FillBuffer3D(TBuffer3D & buffer, Int_t reqSections, Bool_t localFrame) const
{
// Fills the supplied buffer, with sections in desired frame
// See TBuffer3D.h for explanation of sections, frame etc.
   TGeoShape::FillBuffer3D(buffer, reqSections, localFrame);

   if (reqSections & TBuffer3D::kBoundingBox) {
      Double_t halfLengths[3] = { fDX, fDY, fDZ };
      buffer.SetAABoundingBox(fOrigin, halfLengths);

      if (!buffer.fLocalFrame) {
         TransformPoints(buffer.fBBVertex[0], 8);
      }
      buffer.SetSectionsValid(TBuffer3D::kBoundingBox);
   }
}

//_____________________________________________________________________________
void TGeoBBox::Contains_v(const Double_t *points, Bool_t *inside, Int_t vecsize) const
{
// Check the inside status for each of the points in the array.
// Input: Array of point coordinates + vector size
// Output: Array of Booleans for the inside of each point
   for (Int_t i=0; i<vecsize; i++) inside[i] = Contains(&points[3*i]);
}

//_____________________________________________________________________________
void TGeoBBox::ComputeNormal_v(const Double_t *points, const Double_t *dirs, Double_t *norms, Int_t vecsize)
{
// Compute the normal for an array o points so that norm.dot.dir is positive
// Input: Arrays of point coordinates and directions + vector size
// Output: Array of normal directions
   for (Int_t i=0; i<vecsize; i++) ComputeNormal(&points[3*i], &dirs[3*i], &norms[3*i]);
}

//_____________________________________________________________________________
void TGeoBBox::DistFromInside_v(const Double_t *points, const Double_t *dirs, Double_t *dists, Int_t vecsize, Double_t* step) const
{
// Compute distance from array of input points having directions specisied by dirs. Store output in dists
   for (Int_t i=0; i<vecsize; i++) dists[i] = DistFromInside(&points[3*i], &dirs[3*i], 3, step[i]);
}

//_____________________________________________________________________________
void TGeoBBox::DistFromOutside_v(const Double_t *points, const Double_t *dirs, Double_t *dists, Int_t vecsize, Double_t* step) const
{
// Compute distance from array of input points having directions specisied by dirs. Store output in dists
   for (Int_t i=0; i<vecsize; i++) dists[i] = DistFromOutside(&points[3*i], &dirs[3*i], 3, step[i]);
}

//_____________________________________________________________________________
void TGeoBBox::Safety_v(const Double_t *points, const Bool_t *inside, Double_t *safe, Int_t vecsize) const
{
// Compute safe distance from each of the points in the input array.
// Input: Array of point coordinates, array of statuses for these points, size of the arrays
// Output: Safety values
   for (Int_t i=0; i<vecsize; i++) safe[i] = Safety(&points[3*i], inside[i]);
}
 TGeoBBox.cxx:1
 TGeoBBox.cxx:2
 TGeoBBox.cxx:3
 TGeoBBox.cxx:4
 TGeoBBox.cxx:5
 TGeoBBox.cxx:6
 TGeoBBox.cxx:7
 TGeoBBox.cxx:8
 TGeoBBox.cxx:9
 TGeoBBox.cxx:10
 TGeoBBox.cxx:11
 TGeoBBox.cxx:12
 TGeoBBox.cxx:13
 TGeoBBox.cxx:14
 TGeoBBox.cxx:15
 TGeoBBox.cxx:16
 TGeoBBox.cxx:17
 TGeoBBox.cxx:18
 TGeoBBox.cxx:19
 TGeoBBox.cxx:20
 TGeoBBox.cxx:21
 TGeoBBox.cxx:22
 TGeoBBox.cxx:23
 TGeoBBox.cxx:24
 TGeoBBox.cxx:25
 TGeoBBox.cxx:26
 TGeoBBox.cxx:27
 TGeoBBox.cxx:28
 TGeoBBox.cxx:29
 TGeoBBox.cxx:30
 TGeoBBox.cxx:31
 TGeoBBox.cxx:32
 TGeoBBox.cxx:33
 TGeoBBox.cxx:34
 TGeoBBox.cxx:35
 TGeoBBox.cxx:36
 TGeoBBox.cxx:37
 TGeoBBox.cxx:38
 TGeoBBox.cxx:39
 TGeoBBox.cxx:40
 TGeoBBox.cxx:41
 TGeoBBox.cxx:42
 TGeoBBox.cxx:43
 TGeoBBox.cxx:44
 TGeoBBox.cxx:45
 TGeoBBox.cxx:46
 TGeoBBox.cxx:47
 TGeoBBox.cxx:48
 TGeoBBox.cxx:49
 TGeoBBox.cxx:50
 TGeoBBox.cxx:51
 TGeoBBox.cxx:52
 TGeoBBox.cxx:53
 TGeoBBox.cxx:54
 TGeoBBox.cxx:55
 TGeoBBox.cxx:56
 TGeoBBox.cxx:57
 TGeoBBox.cxx:58
 TGeoBBox.cxx:59
 TGeoBBox.cxx:60
 TGeoBBox.cxx:61
 TGeoBBox.cxx:62
 TGeoBBox.cxx:63
 TGeoBBox.cxx:64
 TGeoBBox.cxx:65
 TGeoBBox.cxx:66
 TGeoBBox.cxx:67
 TGeoBBox.cxx:68
 TGeoBBox.cxx:69
 TGeoBBox.cxx:70
 TGeoBBox.cxx:71
 TGeoBBox.cxx:72
 TGeoBBox.cxx:73
 TGeoBBox.cxx:74
 TGeoBBox.cxx:75
 TGeoBBox.cxx:76
 TGeoBBox.cxx:77
 TGeoBBox.cxx:78
 TGeoBBox.cxx:79
 TGeoBBox.cxx:80
 TGeoBBox.cxx:81
 TGeoBBox.cxx:82
 TGeoBBox.cxx:83
 TGeoBBox.cxx:84
 TGeoBBox.cxx:85
 TGeoBBox.cxx:86
 TGeoBBox.cxx:87
 TGeoBBox.cxx:88
 TGeoBBox.cxx:89
 TGeoBBox.cxx:90
 TGeoBBox.cxx:91
 TGeoBBox.cxx:92
 TGeoBBox.cxx:93
 TGeoBBox.cxx:94
 TGeoBBox.cxx:95
 TGeoBBox.cxx:96
 TGeoBBox.cxx:97
 TGeoBBox.cxx:98
 TGeoBBox.cxx:99
 TGeoBBox.cxx:100
 TGeoBBox.cxx:101
 TGeoBBox.cxx:102
 TGeoBBox.cxx:103
 TGeoBBox.cxx:104
 TGeoBBox.cxx:105
 TGeoBBox.cxx:106
 TGeoBBox.cxx:107
 TGeoBBox.cxx:108
 TGeoBBox.cxx:109
 TGeoBBox.cxx:110
 TGeoBBox.cxx:111
 TGeoBBox.cxx:112
 TGeoBBox.cxx:113
 TGeoBBox.cxx:114
 TGeoBBox.cxx:115
 TGeoBBox.cxx:116
 TGeoBBox.cxx:117
 TGeoBBox.cxx:118
 TGeoBBox.cxx:119
 TGeoBBox.cxx:120
 TGeoBBox.cxx:121
 TGeoBBox.cxx:122
 TGeoBBox.cxx:123
 TGeoBBox.cxx:124
 TGeoBBox.cxx:125
 TGeoBBox.cxx:126
 TGeoBBox.cxx:127
 TGeoBBox.cxx:128
 TGeoBBox.cxx:129
 TGeoBBox.cxx:130
 TGeoBBox.cxx:131
 TGeoBBox.cxx:132
 TGeoBBox.cxx:133
 TGeoBBox.cxx:134
 TGeoBBox.cxx:135
 TGeoBBox.cxx:136
 TGeoBBox.cxx:137
 TGeoBBox.cxx:138
 TGeoBBox.cxx:139
 TGeoBBox.cxx:140
 TGeoBBox.cxx:141
 TGeoBBox.cxx:142
 TGeoBBox.cxx:143
 TGeoBBox.cxx:144
 TGeoBBox.cxx:145
 TGeoBBox.cxx:146
 TGeoBBox.cxx:147
 TGeoBBox.cxx:148
 TGeoBBox.cxx:149
 TGeoBBox.cxx:150
 TGeoBBox.cxx:151
 TGeoBBox.cxx:152
 TGeoBBox.cxx:153
 TGeoBBox.cxx:154
 TGeoBBox.cxx:155
 TGeoBBox.cxx:156
 TGeoBBox.cxx:157
 TGeoBBox.cxx:158
 TGeoBBox.cxx:159
 TGeoBBox.cxx:160
 TGeoBBox.cxx:161
 TGeoBBox.cxx:162
 TGeoBBox.cxx:163
 TGeoBBox.cxx:164
 TGeoBBox.cxx:165
 TGeoBBox.cxx:166
 TGeoBBox.cxx:167
 TGeoBBox.cxx:168
 TGeoBBox.cxx:169
 TGeoBBox.cxx:170
 TGeoBBox.cxx:171
 TGeoBBox.cxx:172
 TGeoBBox.cxx:173
 TGeoBBox.cxx:174
 TGeoBBox.cxx:175
 TGeoBBox.cxx:176
 TGeoBBox.cxx:177
 TGeoBBox.cxx:178
 TGeoBBox.cxx:179
 TGeoBBox.cxx:180
 TGeoBBox.cxx:181
 TGeoBBox.cxx:182
 TGeoBBox.cxx:183
 TGeoBBox.cxx:184
 TGeoBBox.cxx:185
 TGeoBBox.cxx:186
 TGeoBBox.cxx:187
 TGeoBBox.cxx:188
 TGeoBBox.cxx:189
 TGeoBBox.cxx:190
 TGeoBBox.cxx:191
 TGeoBBox.cxx:192
 TGeoBBox.cxx:193
 TGeoBBox.cxx:194
 TGeoBBox.cxx:195
 TGeoBBox.cxx:196
 TGeoBBox.cxx:197
 TGeoBBox.cxx:198
 TGeoBBox.cxx:199
 TGeoBBox.cxx:200
 TGeoBBox.cxx:201
 TGeoBBox.cxx:202
 TGeoBBox.cxx:203
 TGeoBBox.cxx:204
 TGeoBBox.cxx:205
 TGeoBBox.cxx:206
 TGeoBBox.cxx:207
 TGeoBBox.cxx:208
 TGeoBBox.cxx:209
 TGeoBBox.cxx:210
 TGeoBBox.cxx:211
 TGeoBBox.cxx:212
 TGeoBBox.cxx:213
 TGeoBBox.cxx:214
 TGeoBBox.cxx:215
 TGeoBBox.cxx:216
 TGeoBBox.cxx:217
 TGeoBBox.cxx:218
 TGeoBBox.cxx:219
 TGeoBBox.cxx:220
 TGeoBBox.cxx:221
 TGeoBBox.cxx:222
 TGeoBBox.cxx:223
 TGeoBBox.cxx:224
 TGeoBBox.cxx:225
 TGeoBBox.cxx:226
 TGeoBBox.cxx:227
 TGeoBBox.cxx:228
 TGeoBBox.cxx:229
 TGeoBBox.cxx:230
 TGeoBBox.cxx:231
 TGeoBBox.cxx:232
 TGeoBBox.cxx:233
 TGeoBBox.cxx:234
 TGeoBBox.cxx:235
 TGeoBBox.cxx:236
 TGeoBBox.cxx:237
 TGeoBBox.cxx:238
 TGeoBBox.cxx:239
 TGeoBBox.cxx:240
 TGeoBBox.cxx:241
 TGeoBBox.cxx:242
 TGeoBBox.cxx:243
 TGeoBBox.cxx:244
 TGeoBBox.cxx:245
 TGeoBBox.cxx:246
 TGeoBBox.cxx:247
 TGeoBBox.cxx:248
 TGeoBBox.cxx:249
 TGeoBBox.cxx:250
 TGeoBBox.cxx:251
 TGeoBBox.cxx:252
 TGeoBBox.cxx:253
 TGeoBBox.cxx:254
 TGeoBBox.cxx:255
 TGeoBBox.cxx:256
 TGeoBBox.cxx:257
 TGeoBBox.cxx:258
 TGeoBBox.cxx:259
 TGeoBBox.cxx:260
 TGeoBBox.cxx:261
 TGeoBBox.cxx:262
 TGeoBBox.cxx:263
 TGeoBBox.cxx:264
 TGeoBBox.cxx:265
 TGeoBBox.cxx:266
 TGeoBBox.cxx:267
 TGeoBBox.cxx:268
 TGeoBBox.cxx:269
 TGeoBBox.cxx:270
 TGeoBBox.cxx:271
 TGeoBBox.cxx:272
 TGeoBBox.cxx:273
 TGeoBBox.cxx:274
 TGeoBBox.cxx:275
 TGeoBBox.cxx:276
 TGeoBBox.cxx:277
 TGeoBBox.cxx:278
 TGeoBBox.cxx:279
 TGeoBBox.cxx:280
 TGeoBBox.cxx:281
 TGeoBBox.cxx:282
 TGeoBBox.cxx:283
 TGeoBBox.cxx:284
 TGeoBBox.cxx:285
 TGeoBBox.cxx:286
 TGeoBBox.cxx:287
 TGeoBBox.cxx:288
 TGeoBBox.cxx:289
 TGeoBBox.cxx:290
 TGeoBBox.cxx:291
 TGeoBBox.cxx:292
 TGeoBBox.cxx:293
 TGeoBBox.cxx:294
 TGeoBBox.cxx:295
 TGeoBBox.cxx:296
 TGeoBBox.cxx:297
 TGeoBBox.cxx:298
 TGeoBBox.cxx:299
 TGeoBBox.cxx:300
 TGeoBBox.cxx:301
 TGeoBBox.cxx:302
 TGeoBBox.cxx:303
 TGeoBBox.cxx:304
 TGeoBBox.cxx:305
 TGeoBBox.cxx:306
 TGeoBBox.cxx:307
 TGeoBBox.cxx:308
 TGeoBBox.cxx:309
 TGeoBBox.cxx:310
 TGeoBBox.cxx:311
 TGeoBBox.cxx:312
 TGeoBBox.cxx:313
 TGeoBBox.cxx:314
 TGeoBBox.cxx:315
 TGeoBBox.cxx:316
 TGeoBBox.cxx:317
 TGeoBBox.cxx:318
 TGeoBBox.cxx:319
 TGeoBBox.cxx:320
 TGeoBBox.cxx:321
 TGeoBBox.cxx:322
 TGeoBBox.cxx:323
 TGeoBBox.cxx:324
 TGeoBBox.cxx:325
 TGeoBBox.cxx:326
 TGeoBBox.cxx:327
 TGeoBBox.cxx:328
 TGeoBBox.cxx:329
 TGeoBBox.cxx:330
 TGeoBBox.cxx:331
 TGeoBBox.cxx:332
 TGeoBBox.cxx:333
 TGeoBBox.cxx:334
 TGeoBBox.cxx:335
 TGeoBBox.cxx:336
 TGeoBBox.cxx:337
 TGeoBBox.cxx:338
 TGeoBBox.cxx:339
 TGeoBBox.cxx:340
 TGeoBBox.cxx:341
 TGeoBBox.cxx:342
 TGeoBBox.cxx:343
 TGeoBBox.cxx:344
 TGeoBBox.cxx:345
 TGeoBBox.cxx:346
 TGeoBBox.cxx:347
 TGeoBBox.cxx:348
 TGeoBBox.cxx:349
 TGeoBBox.cxx:350
 TGeoBBox.cxx:351
 TGeoBBox.cxx:352
 TGeoBBox.cxx:353
 TGeoBBox.cxx:354
 TGeoBBox.cxx:355
 TGeoBBox.cxx:356
 TGeoBBox.cxx:357
 TGeoBBox.cxx:358
 TGeoBBox.cxx:359
 TGeoBBox.cxx:360
 TGeoBBox.cxx:361
 TGeoBBox.cxx:362
 TGeoBBox.cxx:363
 TGeoBBox.cxx:364
 TGeoBBox.cxx:365
 TGeoBBox.cxx:366
 TGeoBBox.cxx:367
 TGeoBBox.cxx:368
 TGeoBBox.cxx:369
 TGeoBBox.cxx:370
 TGeoBBox.cxx:371
 TGeoBBox.cxx:372
 TGeoBBox.cxx:373
 TGeoBBox.cxx:374
 TGeoBBox.cxx:375
 TGeoBBox.cxx:376
 TGeoBBox.cxx:377
 TGeoBBox.cxx:378
 TGeoBBox.cxx:379
 TGeoBBox.cxx:380
 TGeoBBox.cxx:381
 TGeoBBox.cxx:382
 TGeoBBox.cxx:383
 TGeoBBox.cxx:384
 TGeoBBox.cxx:385
 TGeoBBox.cxx:386
 TGeoBBox.cxx:387
 TGeoBBox.cxx:388
 TGeoBBox.cxx:389
 TGeoBBox.cxx:390
 TGeoBBox.cxx:391
 TGeoBBox.cxx:392
 TGeoBBox.cxx:393
 TGeoBBox.cxx:394
 TGeoBBox.cxx:395
 TGeoBBox.cxx:396
 TGeoBBox.cxx:397
 TGeoBBox.cxx:398
 TGeoBBox.cxx:399
 TGeoBBox.cxx:400
 TGeoBBox.cxx:401
 TGeoBBox.cxx:402
 TGeoBBox.cxx:403
 TGeoBBox.cxx:404
 TGeoBBox.cxx:405
 TGeoBBox.cxx:406
 TGeoBBox.cxx:407
 TGeoBBox.cxx:408
 TGeoBBox.cxx:409
 TGeoBBox.cxx:410
 TGeoBBox.cxx:411
 TGeoBBox.cxx:412
 TGeoBBox.cxx:413
 TGeoBBox.cxx:414
 TGeoBBox.cxx:415
 TGeoBBox.cxx:416
 TGeoBBox.cxx:417
 TGeoBBox.cxx:418
 TGeoBBox.cxx:419
 TGeoBBox.cxx:420
 TGeoBBox.cxx:421
 TGeoBBox.cxx:422
 TGeoBBox.cxx:423
 TGeoBBox.cxx:424
 TGeoBBox.cxx:425
 TGeoBBox.cxx:426
 TGeoBBox.cxx:427
 TGeoBBox.cxx:428
 TGeoBBox.cxx:429
 TGeoBBox.cxx:430
 TGeoBBox.cxx:431
 TGeoBBox.cxx:432
 TGeoBBox.cxx:433
 TGeoBBox.cxx:434
 TGeoBBox.cxx:435
 TGeoBBox.cxx:436
 TGeoBBox.cxx:437
 TGeoBBox.cxx:438
 TGeoBBox.cxx:439
 TGeoBBox.cxx:440
 TGeoBBox.cxx:441
 TGeoBBox.cxx:442
 TGeoBBox.cxx:443
 TGeoBBox.cxx:444
 TGeoBBox.cxx:445
 TGeoBBox.cxx:446
 TGeoBBox.cxx:447
 TGeoBBox.cxx:448
 TGeoBBox.cxx:449
 TGeoBBox.cxx:450
 TGeoBBox.cxx:451
 TGeoBBox.cxx:452
 TGeoBBox.cxx:453
 TGeoBBox.cxx:454
 TGeoBBox.cxx:455
 TGeoBBox.cxx:456
 TGeoBBox.cxx:457
 TGeoBBox.cxx:458
 TGeoBBox.cxx:459
 TGeoBBox.cxx:460
 TGeoBBox.cxx:461
 TGeoBBox.cxx:462
 TGeoBBox.cxx:463
 TGeoBBox.cxx:464
 TGeoBBox.cxx:465
 TGeoBBox.cxx:466
 TGeoBBox.cxx:467
 TGeoBBox.cxx:468
 TGeoBBox.cxx:469
 TGeoBBox.cxx:470
 TGeoBBox.cxx:471
 TGeoBBox.cxx:472
 TGeoBBox.cxx:473
 TGeoBBox.cxx:474
 TGeoBBox.cxx:475
 TGeoBBox.cxx:476
 TGeoBBox.cxx:477
 TGeoBBox.cxx:478
 TGeoBBox.cxx:479
 TGeoBBox.cxx:480
 TGeoBBox.cxx:481
 TGeoBBox.cxx:482
 TGeoBBox.cxx:483
 TGeoBBox.cxx:484
 TGeoBBox.cxx:485
 TGeoBBox.cxx:486
 TGeoBBox.cxx:487
 TGeoBBox.cxx:488
 TGeoBBox.cxx:489
 TGeoBBox.cxx:490
 TGeoBBox.cxx:491
 TGeoBBox.cxx:492
 TGeoBBox.cxx:493
 TGeoBBox.cxx:494
 TGeoBBox.cxx:495
 TGeoBBox.cxx:496
 TGeoBBox.cxx:497
 TGeoBBox.cxx:498
 TGeoBBox.cxx:499
 TGeoBBox.cxx:500
 TGeoBBox.cxx:501
 TGeoBBox.cxx:502
 TGeoBBox.cxx:503
 TGeoBBox.cxx:504
 TGeoBBox.cxx:505
 TGeoBBox.cxx:506
 TGeoBBox.cxx:507
 TGeoBBox.cxx:508
 TGeoBBox.cxx:509
 TGeoBBox.cxx:510
 TGeoBBox.cxx:511
 TGeoBBox.cxx:512
 TGeoBBox.cxx:513
 TGeoBBox.cxx:514
 TGeoBBox.cxx:515
 TGeoBBox.cxx:516
 TGeoBBox.cxx:517
 TGeoBBox.cxx:518
 TGeoBBox.cxx:519
 TGeoBBox.cxx:520
 TGeoBBox.cxx:521
 TGeoBBox.cxx:522
 TGeoBBox.cxx:523
 TGeoBBox.cxx:524
 TGeoBBox.cxx:525
 TGeoBBox.cxx:526
 TGeoBBox.cxx:527
 TGeoBBox.cxx:528
 TGeoBBox.cxx:529
 TGeoBBox.cxx:530
 TGeoBBox.cxx:531
 TGeoBBox.cxx:532
 TGeoBBox.cxx:533
 TGeoBBox.cxx:534
 TGeoBBox.cxx:535
 TGeoBBox.cxx:536
 TGeoBBox.cxx:537
 TGeoBBox.cxx:538
 TGeoBBox.cxx:539
 TGeoBBox.cxx:540
 TGeoBBox.cxx:541
 TGeoBBox.cxx:542
 TGeoBBox.cxx:543
 TGeoBBox.cxx:544
 TGeoBBox.cxx:545
 TGeoBBox.cxx:546
 TGeoBBox.cxx:547
 TGeoBBox.cxx:548
 TGeoBBox.cxx:549
 TGeoBBox.cxx:550
 TGeoBBox.cxx:551
 TGeoBBox.cxx:552
 TGeoBBox.cxx:553
 TGeoBBox.cxx:554
 TGeoBBox.cxx:555
 TGeoBBox.cxx:556
 TGeoBBox.cxx:557
 TGeoBBox.cxx:558
 TGeoBBox.cxx:559
 TGeoBBox.cxx:560
 TGeoBBox.cxx:561
 TGeoBBox.cxx:562
 TGeoBBox.cxx:563
 TGeoBBox.cxx:564
 TGeoBBox.cxx:565
 TGeoBBox.cxx:566
 TGeoBBox.cxx:567
 TGeoBBox.cxx:568
 TGeoBBox.cxx:569
 TGeoBBox.cxx:570
 TGeoBBox.cxx:571
 TGeoBBox.cxx:572
 TGeoBBox.cxx:573
 TGeoBBox.cxx:574
 TGeoBBox.cxx:575
 TGeoBBox.cxx:576
 TGeoBBox.cxx:577
 TGeoBBox.cxx:578
 TGeoBBox.cxx:579
 TGeoBBox.cxx:580
 TGeoBBox.cxx:581
 TGeoBBox.cxx:582
 TGeoBBox.cxx:583
 TGeoBBox.cxx:584
 TGeoBBox.cxx:585
 TGeoBBox.cxx:586
 TGeoBBox.cxx:587
 TGeoBBox.cxx:588
 TGeoBBox.cxx:589
 TGeoBBox.cxx:590
 TGeoBBox.cxx:591
 TGeoBBox.cxx:592
 TGeoBBox.cxx:593
 TGeoBBox.cxx:594
 TGeoBBox.cxx:595
 TGeoBBox.cxx:596
 TGeoBBox.cxx:597
 TGeoBBox.cxx:598
 TGeoBBox.cxx:599
 TGeoBBox.cxx:600
 TGeoBBox.cxx:601
 TGeoBBox.cxx:602
 TGeoBBox.cxx:603
 TGeoBBox.cxx:604
 TGeoBBox.cxx:605
 TGeoBBox.cxx:606
 TGeoBBox.cxx:607
 TGeoBBox.cxx:608
 TGeoBBox.cxx:609
 TGeoBBox.cxx:610
 TGeoBBox.cxx:611
 TGeoBBox.cxx:612
 TGeoBBox.cxx:613
 TGeoBBox.cxx:614
 TGeoBBox.cxx:615
 TGeoBBox.cxx:616
 TGeoBBox.cxx:617
 TGeoBBox.cxx:618
 TGeoBBox.cxx:619
 TGeoBBox.cxx:620
 TGeoBBox.cxx:621
 TGeoBBox.cxx:622
 TGeoBBox.cxx:623
 TGeoBBox.cxx:624
 TGeoBBox.cxx:625
 TGeoBBox.cxx:626
 TGeoBBox.cxx:627
 TGeoBBox.cxx:628
 TGeoBBox.cxx:629
 TGeoBBox.cxx:630
 TGeoBBox.cxx:631
 TGeoBBox.cxx:632
 TGeoBBox.cxx:633
 TGeoBBox.cxx:634
 TGeoBBox.cxx:635
 TGeoBBox.cxx:636
 TGeoBBox.cxx:637
 TGeoBBox.cxx:638
 TGeoBBox.cxx:639
 TGeoBBox.cxx:640
 TGeoBBox.cxx:641
 TGeoBBox.cxx:642
 TGeoBBox.cxx:643
 TGeoBBox.cxx:644
 TGeoBBox.cxx:645
 TGeoBBox.cxx:646
 TGeoBBox.cxx:647
 TGeoBBox.cxx:648
 TGeoBBox.cxx:649
 TGeoBBox.cxx:650
 TGeoBBox.cxx:651
 TGeoBBox.cxx:652
 TGeoBBox.cxx:653
 TGeoBBox.cxx:654
 TGeoBBox.cxx:655
 TGeoBBox.cxx:656
 TGeoBBox.cxx:657
 TGeoBBox.cxx:658
 TGeoBBox.cxx:659
 TGeoBBox.cxx:660
 TGeoBBox.cxx:661
 TGeoBBox.cxx:662
 TGeoBBox.cxx:663
 TGeoBBox.cxx:664
 TGeoBBox.cxx:665
 TGeoBBox.cxx:666
 TGeoBBox.cxx:667
 TGeoBBox.cxx:668
 TGeoBBox.cxx:669
 TGeoBBox.cxx:670
 TGeoBBox.cxx:671
 TGeoBBox.cxx:672
 TGeoBBox.cxx:673
 TGeoBBox.cxx:674
 TGeoBBox.cxx:675
 TGeoBBox.cxx:676
 TGeoBBox.cxx:677
 TGeoBBox.cxx:678
 TGeoBBox.cxx:679
 TGeoBBox.cxx:680
 TGeoBBox.cxx:681
 TGeoBBox.cxx:682
 TGeoBBox.cxx:683
 TGeoBBox.cxx:684
 TGeoBBox.cxx:685
 TGeoBBox.cxx:686
 TGeoBBox.cxx:687
 TGeoBBox.cxx:688
 TGeoBBox.cxx:689
 TGeoBBox.cxx:690
 TGeoBBox.cxx:691
 TGeoBBox.cxx:692
 TGeoBBox.cxx:693
 TGeoBBox.cxx:694
 TGeoBBox.cxx:695
 TGeoBBox.cxx:696
 TGeoBBox.cxx:697
 TGeoBBox.cxx:698
 TGeoBBox.cxx:699
 TGeoBBox.cxx:700
 TGeoBBox.cxx:701
 TGeoBBox.cxx:702
 TGeoBBox.cxx:703
 TGeoBBox.cxx:704
 TGeoBBox.cxx:705
 TGeoBBox.cxx:706
 TGeoBBox.cxx:707
 TGeoBBox.cxx:708
 TGeoBBox.cxx:709
 TGeoBBox.cxx:710
 TGeoBBox.cxx:711
 TGeoBBox.cxx:712
 TGeoBBox.cxx:713
 TGeoBBox.cxx:714
 TGeoBBox.cxx:715
 TGeoBBox.cxx:716
 TGeoBBox.cxx:717
 TGeoBBox.cxx:718
 TGeoBBox.cxx:719
 TGeoBBox.cxx:720
 TGeoBBox.cxx:721
 TGeoBBox.cxx:722
 TGeoBBox.cxx:723
 TGeoBBox.cxx:724
 TGeoBBox.cxx:725
 TGeoBBox.cxx:726
 TGeoBBox.cxx:727
 TGeoBBox.cxx:728
 TGeoBBox.cxx:729
 TGeoBBox.cxx:730
 TGeoBBox.cxx:731
 TGeoBBox.cxx:732
 TGeoBBox.cxx:733
 TGeoBBox.cxx:734
 TGeoBBox.cxx:735
 TGeoBBox.cxx:736
 TGeoBBox.cxx:737
 TGeoBBox.cxx:738
 TGeoBBox.cxx:739
 TGeoBBox.cxx:740
 TGeoBBox.cxx:741
 TGeoBBox.cxx:742
 TGeoBBox.cxx:743
 TGeoBBox.cxx:744
 TGeoBBox.cxx:745
 TGeoBBox.cxx:746
 TGeoBBox.cxx:747
 TGeoBBox.cxx:748
 TGeoBBox.cxx:749
 TGeoBBox.cxx:750
 TGeoBBox.cxx:751
 TGeoBBox.cxx:752
 TGeoBBox.cxx:753
 TGeoBBox.cxx:754
 TGeoBBox.cxx:755
 TGeoBBox.cxx:756
 TGeoBBox.cxx:757
 TGeoBBox.cxx:758
 TGeoBBox.cxx:759
 TGeoBBox.cxx:760
 TGeoBBox.cxx:761
 TGeoBBox.cxx:762
 TGeoBBox.cxx:763
 TGeoBBox.cxx:764
 TGeoBBox.cxx:765
 TGeoBBox.cxx:766
 TGeoBBox.cxx:767
 TGeoBBox.cxx:768
 TGeoBBox.cxx:769
 TGeoBBox.cxx:770
 TGeoBBox.cxx:771
 TGeoBBox.cxx:772
 TGeoBBox.cxx:773
 TGeoBBox.cxx:774
 TGeoBBox.cxx:775
 TGeoBBox.cxx:776
 TGeoBBox.cxx:777
 TGeoBBox.cxx:778
 TGeoBBox.cxx:779
 TGeoBBox.cxx:780
 TGeoBBox.cxx:781
 TGeoBBox.cxx:782
 TGeoBBox.cxx:783
 TGeoBBox.cxx:784
 TGeoBBox.cxx:785
 TGeoBBox.cxx:786
 TGeoBBox.cxx:787
 TGeoBBox.cxx:788
 TGeoBBox.cxx:789
 TGeoBBox.cxx:790
 TGeoBBox.cxx:791
 TGeoBBox.cxx:792
 TGeoBBox.cxx:793
 TGeoBBox.cxx:794
 TGeoBBox.cxx:795
 TGeoBBox.cxx:796
 TGeoBBox.cxx:797
 TGeoBBox.cxx:798
 TGeoBBox.cxx:799
 TGeoBBox.cxx:800
 TGeoBBox.cxx:801
 TGeoBBox.cxx:802
 TGeoBBox.cxx:803
 TGeoBBox.cxx:804
 TGeoBBox.cxx:805
 TGeoBBox.cxx:806
 TGeoBBox.cxx:807
 TGeoBBox.cxx:808
 TGeoBBox.cxx:809
 TGeoBBox.cxx:810
 TGeoBBox.cxx:811
 TGeoBBox.cxx:812
 TGeoBBox.cxx:813
 TGeoBBox.cxx:814
 TGeoBBox.cxx:815
 TGeoBBox.cxx:816
 TGeoBBox.cxx:817
 TGeoBBox.cxx:818
 TGeoBBox.cxx:819
 TGeoBBox.cxx:820
 TGeoBBox.cxx:821
 TGeoBBox.cxx:822
 TGeoBBox.cxx:823
 TGeoBBox.cxx:824
 TGeoBBox.cxx:825
 TGeoBBox.cxx:826
 TGeoBBox.cxx:827
 TGeoBBox.cxx:828
 TGeoBBox.cxx:829
 TGeoBBox.cxx:830
 TGeoBBox.cxx:831
 TGeoBBox.cxx:832
 TGeoBBox.cxx:833
 TGeoBBox.cxx:834
 TGeoBBox.cxx:835
 TGeoBBox.cxx:836
 TGeoBBox.cxx:837
 TGeoBBox.cxx:838
 TGeoBBox.cxx:839
 TGeoBBox.cxx:840
 TGeoBBox.cxx:841
 TGeoBBox.cxx:842
 TGeoBBox.cxx:843
 TGeoBBox.cxx:844
 TGeoBBox.cxx:845
 TGeoBBox.cxx:846
 TGeoBBox.cxx:847
 TGeoBBox.cxx:848
 TGeoBBox.cxx:849
 TGeoBBox.cxx:850
 TGeoBBox.cxx:851
 TGeoBBox.cxx:852
 TGeoBBox.cxx:853
 TGeoBBox.cxx:854
 TGeoBBox.cxx:855
 TGeoBBox.cxx:856
 TGeoBBox.cxx:857
 TGeoBBox.cxx:858
 TGeoBBox.cxx:859
 TGeoBBox.cxx:860
 TGeoBBox.cxx:861
 TGeoBBox.cxx:862
 TGeoBBox.cxx:863
 TGeoBBox.cxx:864
 TGeoBBox.cxx:865
 TGeoBBox.cxx:866
 TGeoBBox.cxx:867
 TGeoBBox.cxx:868
 TGeoBBox.cxx:869
 TGeoBBox.cxx:870
 TGeoBBox.cxx:871
 TGeoBBox.cxx:872
 TGeoBBox.cxx:873
 TGeoBBox.cxx:874
 TGeoBBox.cxx:875
 TGeoBBox.cxx:876
 TGeoBBox.cxx:877
 TGeoBBox.cxx:878
 TGeoBBox.cxx:879
 TGeoBBox.cxx:880
 TGeoBBox.cxx:881
 TGeoBBox.cxx:882
 TGeoBBox.cxx:883
 TGeoBBox.cxx:884
 TGeoBBox.cxx:885
 TGeoBBox.cxx:886
 TGeoBBox.cxx:887
 TGeoBBox.cxx:888
 TGeoBBox.cxx:889
 TGeoBBox.cxx:890
 TGeoBBox.cxx:891
 TGeoBBox.cxx:892
 TGeoBBox.cxx:893
 TGeoBBox.cxx:894
 TGeoBBox.cxx:895
 TGeoBBox.cxx:896
 TGeoBBox.cxx:897
 TGeoBBox.cxx:898
 TGeoBBox.cxx:899
 TGeoBBox.cxx:900
 TGeoBBox.cxx:901
 TGeoBBox.cxx:902
 TGeoBBox.cxx:903
 TGeoBBox.cxx:904
 TGeoBBox.cxx:905
 TGeoBBox.cxx:906
 TGeoBBox.cxx:907
 TGeoBBox.cxx:908
 TGeoBBox.cxx:909
 TGeoBBox.cxx:910
 TGeoBBox.cxx:911
 TGeoBBox.cxx:912
 TGeoBBox.cxx:913
 TGeoBBox.cxx:914
 TGeoBBox.cxx:915
 TGeoBBox.cxx:916
 TGeoBBox.cxx:917
 TGeoBBox.cxx:918
 TGeoBBox.cxx:919
 TGeoBBox.cxx:920
 TGeoBBox.cxx:921
 TGeoBBox.cxx:922
 TGeoBBox.cxx:923
 TGeoBBox.cxx:924
 TGeoBBox.cxx:925
 TGeoBBox.cxx:926
 TGeoBBox.cxx:927
 TGeoBBox.cxx:928
 TGeoBBox.cxx:929
 TGeoBBox.cxx:930
 TGeoBBox.cxx:931
 TGeoBBox.cxx:932
 TGeoBBox.cxx:933
 TGeoBBox.cxx:934
 TGeoBBox.cxx:935
 TGeoBBox.cxx:936
 TGeoBBox.cxx:937
 TGeoBBox.cxx:938
 TGeoBBox.cxx:939
 TGeoBBox.cxx:940
 TGeoBBox.cxx:941
 TGeoBBox.cxx:942
 TGeoBBox.cxx:943
 TGeoBBox.cxx:944
 TGeoBBox.cxx:945
 TGeoBBox.cxx:946
 TGeoBBox.cxx:947
 TGeoBBox.cxx:948
 TGeoBBox.cxx:949
 TGeoBBox.cxx:950
 TGeoBBox.cxx:951
 TGeoBBox.cxx:952
 TGeoBBox.cxx:953
 TGeoBBox.cxx:954
 TGeoBBox.cxx:955
 TGeoBBox.cxx:956
 TGeoBBox.cxx:957
 TGeoBBox.cxx:958
 TGeoBBox.cxx:959
 TGeoBBox.cxx:960
 TGeoBBox.cxx:961
 TGeoBBox.cxx:962
 TGeoBBox.cxx:963
 TGeoBBox.cxx:964
 TGeoBBox.cxx:965
 TGeoBBox.cxx:966
 TGeoBBox.cxx:967
 TGeoBBox.cxx:968
 TGeoBBox.cxx:969
 TGeoBBox.cxx:970
 TGeoBBox.cxx:971
 TGeoBBox.cxx:972
 TGeoBBox.cxx:973
 TGeoBBox.cxx:974
 TGeoBBox.cxx:975
 TGeoBBox.cxx:976
 TGeoBBox.cxx:977
 TGeoBBox.cxx:978
 TGeoBBox.cxx:979
 TGeoBBox.cxx:980
 TGeoBBox.cxx:981
 TGeoBBox.cxx:982
 TGeoBBox.cxx:983
 TGeoBBox.cxx:984
 TGeoBBox.cxx:985
 TGeoBBox.cxx:986
 TGeoBBox.cxx:987
 TGeoBBox.cxx:988
 TGeoBBox.cxx:989
 TGeoBBox.cxx:990
 TGeoBBox.cxx:991
 TGeoBBox.cxx:992
 TGeoBBox.cxx:993
 TGeoBBox.cxx:994
 TGeoBBox.cxx:995
 TGeoBBox.cxx:996
 TGeoBBox.cxx:997
 TGeoBBox.cxx:998
 TGeoBBox.cxx:999
 TGeoBBox.cxx:1000
 TGeoBBox.cxx:1001
 TGeoBBox.cxx:1002
 TGeoBBox.cxx:1003
 TGeoBBox.cxx:1004