ROOT logo
// @(#)root/geom:$Id: TGeoXtru.cxx 27731 2009-03-09 17:40:56Z brun $
// Author: Mihaela Gheata   24/01/04

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

//_____________________________________________________________________________
// TGeoXtru 
//==========
//   An extrusion with fixed outline shape in x-y and a sequence
// of z extents (segments).  The overall scale of the outline scales
// linearly between z points and the center can have an x-y offset.
//
// Creation of TGeoXtru shape
//=============================
//   A TGeoXtru represents a polygonal extrusion. It is defined by the:
// a. 'Blueprint' of the arbitrary polygon representing any Z section. This
//    is an arbytrary polygon (convex or not) defined by the X/Y positions of
//    its vertices.
// b. A sequence of Z sections ordered on the Z axis. Each section defines the
//   'actual' parameters of the polygon at a given Z. The sections may be 
//    translated with respect to the blueprint and/or scaled. The TGeoXtru
//   segment in between 2 Z sections is a solid represented by the linear 
//   extrusion between the 2 polygons. Two consecutive sections may be defined
//   at same Z position.
//
// 1. TGeoXtru *xtru = TGeoXtru(Int_t nz);
//   where nz=number of Z planes
// 2. Double_t x[nvertices]; // array of X positions of blueprint polygon vertices
//    Double_t y[nvertices]; // array of Y positions of blueprint polygon vertices
// 3. xtru->DefinePolygon(nvertices,x,y);
// 4. DefineSection(0, z0, x0, y0, scale0); // Z position, offset and scale for first section
//    DefineSection(1, z1, x1, y1, scale1); // -''- secons section
//    ....
//    DefineSection(nz-1, zn, xn, yn, scalen); // parameters for last section
//
// *NOTES*
// Currently navigation functionality not fully implemented (only Contains()).
// Decomposition in concave polygons not implemented - drawing in solid mode
// within x3d produces incorrect end-faces
//_____________________________________________________________________________

#include "Riostream.h"

#include "TGeoManager.h"
#include "TGeoVolume.h"
#include "TGeoPolygon.h"
#include "TVirtualGeoPainter.h"
#include "TGeoXtru.h"
#include "TVirtualPad.h"
#include "TBuffer3D.h"
#include "TBuffer3DTypes.h"
#include "TClass.h"
#include "TMath.h"

ClassImp(TGeoXtru)

//_____________________________________________________________________________
TGeoXtru::TGeoXtru()
{
// dummy ctor
   SetShapeBit(TGeoShape::kGeoXtru);
   fNvert = 0;
   fNz = 0;
   fZcurrent = 0.;
   fPoly = 0;
   fX = 0;
   fY = 0;
   fXc = 0;
   fYc = 0;
   fZ = 0;
   fScale = 0;
   fX0 = 0;
   fY0 = 0;
   fSeg = 0;
   fIz = 0;
}   

//_____________________________________________________________________________
TGeoXtru::TGeoXtru(Int_t nz)
         :TGeoBBox(0, 0, 0)
{
// Default constructor
   SetShapeBit(TGeoShape::kGeoXtru);
   if (nz<2) {
      Error("ctor", "Cannot create TGeoXtru %s with less than 2 Z planes", GetName());
      SetShapeBit(TGeoShape::kGeoBad);
      return;
   }
   fNvert = 0;
   fNz = nz;   
   fZcurrent = 0.;
   fPoly = 0;
   fX = 0;
   fY = 0;
   fXc = 0;
   fYc = 0;
   fZ = new Double_t[nz];
   fScale = new Double_t[nz];
   fX0 = new Double_t[nz];
   fY0 = new Double_t[nz];
   fSeg = 0;
   fIz = 0;
}

//_____________________________________________________________________________
TGeoXtru::TGeoXtru(Double_t *param)
         :TGeoBBox(0, 0, 0)
{
// Default constructor in GEANT3 style
// param[0] = nz  // number of z planes
//
// param[1] = z1  // Z position of first plane
// param[2] = x1  // X position of first plane
// param[3] = y1  // Y position of first plane
// param[4] = scale1  // scale factor for first plane
// ...
// param[4*(nz-1]+1] = zn
// param[4*(nz-1)+2] = xn
// param[4*(nz-1)+3] = yn
// param[4*(nz-1)+4] = scalen
   SetShapeBit(TGeoShape::kGeoXtru);
   fNvert = 0;
   fNz = 0;
   fZcurrent = 0.;
   fPoly = 0;
   fX = 0;
   fY = 0;
   fXc = 0;
   fYc = 0;
   fZ = 0;
   fScale = 0;
   fX0 = 0;
   fY0 = 0;
   fSeg = 0;
   fIz = 0;
   SetDimensions(param);
}

//_____________________________________________________________________________
TGeoXtru::TGeoXtru(const TGeoXtru& xt) :
  TGeoBBox(xt),
  fNvert(xt.fNvert),
  fNz(xt.fNz),
  fZcurrent(xt.fZcurrent),
  fPoly(xt.fPoly),
  fX(xt.fX),
  fY(xt.fY),
  fXc(xt.fXc),
  fYc(xt.fYc),
  fZ(xt.fZ),
  fScale(xt.fScale),
  fX0(xt.fX0),
  fY0(xt.fY0),
  fSeg(xt.fSeg),
  fIz(xt.fIz)
{ 
   //copy constructor
}

//_____________________________________________________________________________
TGeoXtru& TGeoXtru::operator=(const TGeoXtru& xt)
{
   //assignment operator
   if(this!=&xt) {
      TGeoBBox::operator=(xt);
      fNvert=xt.fNvert;
      fNz=xt.fNz;
      fZcurrent=xt.fZcurrent;
      fPoly=xt.fPoly;
      fX=xt.fX;
      fY=xt.fY;
      fXc=xt.fXc;
      fYc=xt.fYc;
      fZ=xt.fZ;
      fScale=xt.fScale;
      fX0=xt.fX0;
      fY0=xt.fY0;
      fSeg=xt.fSeg;
      fIz=xt.fIz;
   } 
   return *this;
}

//_____________________________________________________________________________
TGeoXtru::~TGeoXtru()
{
// destructor
   if (fX)  {delete[] fX; fX = 0;}
   if (fY)  {delete[] fY; fY = 0;}
   if (fXc) {delete[] fXc; fXc = 0;}
   if (fYc) {delete[] fYc; fYc = 0;}
   if (fZ)  {delete[] fZ; fZ = 0;}
   if (fScale) {delete[] fScale; fScale = 0;}
   if (fX0)  {delete[] fX0; fX0 = 0;}
   if (fY0)  {delete[] fY0; fY0 = 0;}
}

//_____________________________________________________________________________   
Double_t TGeoXtru::Capacity() const
{
// Compute capacity [length^3] of this shape.
   Int_t iz;
   Double_t capacity = 0;
   Double_t area, dz, sc1, sc2;
   TGeoXtru *xtru = (TGeoXtru*)this;
   xtru->SetCurrentVertices(0.,0.,1.);  
   area = fPoly->Area();
   for (iz=0; iz<fNz-1; iz++) {
      dz = fZ[iz+1]-fZ[iz];
      if (TGeoShape::IsSameWithinTolerance(dz,0)) continue;
      sc1 = fScale[iz];
      sc2 = fScale[iz+1];
      capacity += (area*dz/3.)*(sc1*sc1+sc1*sc2+sc2*sc2);
   }
   return capacity;
}      

//_____________________________________________________________________________   
void TGeoXtru::ComputeBBox()
{
// compute bounding box of the pcon
   if (!fX || !fZ || !fNvert) {
      Error("ComputeBBox", "In shape %s polygon not defined", GetName());
      SetShapeBit(TGeoShape::kGeoBad);
      return;
   }   
   Double_t zmin = fZ[0];
   Double_t zmax = fZ[fNz-1];
   Double_t xmin = TGeoShape::Big();
   Double_t xmax = -TGeoShape::Big();
   Double_t ymin = TGeoShape::Big();
   Double_t ymax = -TGeoShape::Big();
   for (Int_t i=0; i<fNz; i++) {
      SetCurrentVertices(fX0[i], fY0[i], fScale[i]);
      for (Int_t j=0; j<fNvert; j++) {
         if (fXc[j]<xmin) xmin=fXc[j];
         if (fXc[j]>xmax) xmax=fXc[j];
         if (fYc[j]<ymin) ymin=fYc[j];
         if (fYc[j]>ymax) ymax=fYc[j];
      }
   }
   fOrigin[0] = 0.5*(xmin+xmax);      
   fOrigin[1] = 0.5*(ymin+ymax);      
   fOrigin[2] = 0.5*(zmin+zmax);      
   fDX = 0.5*(xmax-xmin);
   fDY = 0.5*(ymax-ymin);
   fDZ = 0.5*(zmax-zmin);
}   

//_____________________________________________________________________________   
void TGeoXtru::ComputeNormal(Double_t * /*point*/, Double_t *dir, Double_t *norm)
{
// Compute normal to closest surface from POINT. 
   if (fIz<0) {  
      memset(norm,0,3*sizeof(Double_t));
      norm[2] = (dir[2]>0)?1:-1;
      return;
   }
   Double_t vert[12];      
   GetPlaneVertices(fIz, fSeg, vert);
   GetPlaneNormal(vert, norm);
   Double_t ndotd = norm[0]*dir[0]+norm[1]*dir[1]+norm[2]*dir[2];
   if (ndotd<0) {
      norm[0] = -norm[0];
      norm[1] = -norm[1];
      norm[2] = -norm[2];
   }   
}

//_____________________________________________________________________________
Bool_t TGeoXtru::Contains(Double_t *point) const
{
// test if point is inside this shape
   // Check Z range
   TGeoXtru *xtru = (TGeoXtru*)this;
   if (point[2]<fZ[0]) return kFALSE;   
   if (point[2]>fZ[fNz-1]) return kFALSE; 
   Int_t iz = TMath::BinarySearch(fNz, fZ, point[2]);
   if (iz<0 || iz==fNz-1) return kFALSE;
   if (TGeoShape::IsSameWithinTolerance(point[2],fZ[iz])) {
      xtru->SetIz(-1);
      xtru->SetCurrentVertices(fX0[iz],fY0[iz], fScale[iz]);
      if (fPoly->Contains(point)) return kTRUE;
      if (iz>1 && TGeoShape::IsSameWithinTolerance(fZ[iz],fZ[iz-1])) {
         xtru->SetCurrentVertices(fX0[iz-1],fY0[iz-1], fScale[iz-1]);
         return fPoly->Contains(point);
      } else if (iz<fNz-2 && TGeoShape::IsSameWithinTolerance(fZ[iz],fZ[iz+1])) {
         xtru->SetCurrentVertices(fX0[iz+1],fY0[iz+1], fScale[iz+1]);
         return fPoly->Contains(point);
      }      
   }      
   xtru->SetCurrentZ(point[2], iz);
   if (TMath::Abs(point[2]-fZ[iz])<TGeoShape::Tolerance() ||
       TMath::Abs(fZ[iz+1]-point[2])<TGeoShape::Tolerance())  xtru->SetIz(-1);
   // Now fXc,fYc represent the vertices of the section at point[2]
   return fPoly->Contains(point);
}

//_____________________________________________________________________________
Int_t TGeoXtru::DistancetoPrimitive(Int_t px, Int_t py)
{
// compute closest distance from point px,py to each corner
   const Int_t numPoints = fNvert*fNz;
   return ShapeDistancetoPrimitive(numPoints, px, py);
}
//_____________________________________________________________________________
Double_t TGeoXtru::DistToPlane(Double_t *point, Double_t *dir, Int_t iz, Int_t ivert, Double_t stepmax, Bool_t in) const
{
// Compute distance to a Xtru lateral surface.
   Double_t snext;
   Double_t vert[12];
   Double_t norm[3];
   Double_t znew;
   Double_t pt[3];
   Double_t safe;
   if (TGeoShape::IsSameWithinTolerance(fZ[iz],fZ[iz+1]) && !in) {
      TGeoXtru *xtru = (TGeoXtru*)this;
      snext = (fZ[iz]-point[2])/dir[2];
      if (snext<0) return TGeoShape::Big();
      pt[0] = point[0]+snext*dir[0];
      pt[1] = point[1]+snext*dir[1];
      pt[2] = point[2]+snext*dir[2];
      if (dir[2] < 0.) xtru->SetCurrentVertices(fX0[iz], fY0[iz], fScale[iz]);
      else             xtru->SetCurrentVertices(fX0[iz+1], fY0[iz+1], fScale[iz+1]);
      if (!fPoly->Contains(pt)) return TGeoShape::Big();
      return snext;
   }      
   GetPlaneVertices(iz, ivert, vert);
   GetPlaneNormal(vert, norm);
   Double_t ndotd = norm[0]*dir[0]+norm[1]*dir[1]+norm[2]*dir[2];
   if (in) {
      if (ndotd<=0) return TGeoShape::Big();
      safe = (vert[0]-point[0])*norm[0]+
             (vert[1]-point[1])*norm[1]+
             (vert[2]-point[2])*norm[2];
      if (safe<0) return TGeoShape::Big(); // direction outwards plane
   } else {
      ndotd = -ndotd;
      if (ndotd<=0) return TGeoShape::Big(); 
      safe = (point[0]-vert[0])*norm[0]+
             (point[1]-vert[1])*norm[1]+
             (point[2]-vert[2])*norm[2];
      if (safe<0) return TGeoShape::Big(); // direction outwards plane
   }      
   snext = safe/ndotd;
   if (snext>stepmax) return TGeoShape::Big();
   if (fZ[iz]<fZ[iz+1]) {
      znew = point[2] + snext*dir[2];
      if (znew<fZ[iz]) return TGeoShape::Big();
      if (znew>fZ[iz+1]) return TGeoShape::Big();
   }
   pt[0] = point[0]+snext*dir[0];
   pt[1] = point[1]+snext*dir[1];
   pt[2] = point[2]+snext*dir[2];
   if (!IsPointInsidePlane(pt, vert, norm)) return TGeoShape::Big();
   return snext;         
}

//_____________________________________________________________________________
Double_t TGeoXtru::DistFromInside(Double_t *point, Double_t *dir, Int_t iact, Double_t step, Double_t *safe) const
{
// compute distance from inside point to surface of the polycone
   // locate Z segment
   if (iact<3 && safe) {
      *safe = Safety(point, kTRUE);
      if (iact==0) return TGeoShape::Big();
      if (iact==1 && step<*safe) return TGeoShape::Big();
   }   
   TGeoXtru *xtru = (TGeoXtru*)this;
   Int_t iz = TMath::BinarySearch(fNz, fZ, point[2]);
   if (iz < 0) {
      if (dir[2]<=0) {
         xtru->SetIz(-1);
         return 0.;
      }
      iz = 0;
   }            
   if (iz==fNz-1) {
      if (dir[2]>=0) {
         xtru->SetIz(-1);
         return 0.;
      }   
      iz--;
   } else {   
      if (iz>0) {
         if (TGeoShape::IsSameWithinTolerance(point[2],fZ[iz])) {
            if (TGeoShape::IsSameWithinTolerance(fZ[iz],fZ[iz+1]) && dir[2]<0) iz++;
            else if (TGeoShape::IsSameWithinTolerance(fZ[iz],fZ[iz-1]) && dir[2]>0) iz--;
         }   
      }
   }   
   Bool_t convex = fPoly->IsConvex();
//   Double_t stepmax = step;
//   if (stepmax>TGeoShape::Big()) stepmax = TGeoShape::Big();
   Double_t snext = TGeoShape::Big();
   Double_t dist, sz;
   Double_t pt[3];
   Int_t iv, ipl, inext;
   // we treat the special case when dir[2]=0
   if (TGeoShape::IsSameWithinTolerance(dir[2],0)) {
      for (iv=0; iv<fNvert; iv++) {
         xtru->SetIz(-1);
         dist = DistToPlane(point,dir,iz,iv,TGeoShape::Big(),kTRUE);
         if (dist<snext) {
            snext = dist;
            xtru->SetSeg(iv);
            if (convex) return snext;
         }   
      }
      return TGeoShape::Tolerance();
   }      
   
   // normal case   
   Int_t incseg = (dir[2]>0)?1:-1; 
   Int_t iznext = iz;
   Bool_t zexit = kFALSE;  
   while (iz>=0 && iz<fNz-1) {
      // find the distance  to current segment end Z surface
      ipl = iz+((incseg+1)>>1); // next plane
      inext = ipl+incseg; // next next plane
      sz = (fZ[ipl]-point[2])/dir[2];
      if (sz<snext) {
         iznext += incseg;
         // we cross the next Z section before stepmax
         pt[0] = point[0]+sz*dir[0];
         pt[1] = point[1]+sz*dir[1];
         xtru->SetCurrentVertices(fX0[ipl],fY0[ipl],fScale[ipl]);
         if (fPoly->Contains(pt)) {
            // ray gets through next polygon - is it the last one?
            if (ipl==0 || ipl==fNz-1) {
               xtru->SetIz(-1);
               if (convex) return sz;
               zexit = kTRUE;
               snext = sz;
            }   
            // maybe a Z discontinuity - check this
            if (!zexit && TGeoShape::IsSameWithinTolerance(fZ[ipl],fZ[inext])) {
               xtru->SetCurrentVertices(fX0[inext],fY0[inext],fScale[inext]);
               // if we do not cross the next polygone, we are out
               if (!fPoly->Contains(pt)) {
                  xtru->SetIz(-1);
                  if (convex) return sz;
                  zexit = kTRUE;
                  snext = sz;
               } else {  
                  iznext = inext;
               }   
            } 
         }
      } else {
         iznext = fNz-1;   // stop
      }   
      // ray may cross the lateral surfaces of section iz      
      xtru->SetIz(iz);
      for (iv=0; iv<fNvert; iv++) {
         dist = DistToPlane(point,dir,iz,iv,TGeoShape::Big(),kTRUE); 
         if (dist<snext) {
            xtru->SetSeg(iv);
            snext = dist;
            if (convex) return snext;
            zexit = kTRUE;
         }   
      }
      if (zexit) return snext;
      iz = iznext;
   }
   return TGeoShape::Tolerance();
}

//_____________________________________________________________________________
Double_t TGeoXtru::DistFromOutside(Double_t *point, Double_t *dir, Int_t iact, Double_t step, Double_t *safe) const
{
// compute distance from outside point to surface of the tube
//   Warning("DistFromOutside", "not implemented");
   if (iact<3 && safe) {
      *safe = Safety(point, kTRUE);
      if (iact==0) return TGeoShape::Big();
      if (iact==1 && step<*safe) return TGeoShape::Big();
   }   
// Check if the bounding box is crossed within the requested distance
   Double_t sdist = TGeoBBox::DistFromOutside(point,dir, fDX, fDY, fDZ, fOrigin, step);
   if (sdist>=step) return TGeoShape::Big();
   Double_t stepmax = step;
   if (stepmax>TGeoShape::Big()) stepmax = TGeoShape::Big();
   Double_t snext = 0.;
   Double_t dist = TGeoShape::Big();
   Int_t i, iv;
   Double_t pt[3];
   memcpy(pt,point,3*sizeof(Double_t));
   TGeoXtru *xtru = (TGeoXtru*)this;
   // We might get out easy with Z checks
   Int_t iz = TMath::BinarySearch(fNz, fZ, point[2]);
   if (iz<0) {
      if (dir[2]<=0) return TGeoShape::Big();
      // propagate to first Z plane
      snext = (fZ[0] - point[2])/dir[2];
      if (snext>stepmax) return TGeoShape::Big();
      for (i=0; i<3; i++) pt[i] = point[i] + snext*dir[i];
      xtru->SetCurrentVertices(fX0[0],fY0[0],fScale[0]);
      if (fPoly->Contains(pt)) {
         xtru->SetIz(-1);
         return snext;
      }   
      iz=0; // valid starting value = first segment
      stepmax -= snext;
   } else {
      if (iz==fNz-1) {
         if (dir[2]>=0) return TGeoShape::Big();
         // propagate to last Z plane
         snext = (fZ[fNz-1] - point[2])/dir[2];
         if (snext>stepmax) return TGeoShape::Big();
         for (i=0; i<3; i++) pt[i] = point[i] + snext*dir[i];
         xtru->SetCurrentVertices(fX0[fNz-1],fY0[fNz-1],fScale[fNz-1]);
         if (fPoly->Contains(pt)) {
            xtru->SetIz(-1);
            return snext;
         }   
         iz = fNz-2; // valid value = last segment
         stepmax -= snext;
      }
   }      
   // Check if the bounding box is missed by the track
   if (!TGeoBBox::Contains(pt)) {
      dist = TGeoBBox::DistFromOutside(pt,dir,3);
      if (dist>stepmax) return TGeoShape::Big();
      if (dist>1E-6) dist-=1E-6; // decrease snext to make sure we do not cross the xtru
      for (i=0; i<3; i++) pt[i] += dist*dir[i]; // we are now closer
      iz = TMath::BinarySearch(fNz, fZ, pt[2]);      
      if (iz<0) iz=0;
      else if (iz==fNz-1) iz = fNz-2;
      snext += dist;
      stepmax -= dist;
   }   
   // not the case - we have to do some work...
   // Start trackink from current iz
   // - first solve particular case dir[2]=0
   Bool_t convex = fPoly->IsConvex();
   Bool_t hit = kFALSE;
   if (TGeoShape::IsSameWithinTolerance(dir[2],0)) {
      // loop lateral planes to see if we cross something
      xtru->SetIz(iz);
      for (iv=0; iv<fNvert; iv++) {
         dist = DistToPlane(pt,dir,iz,iv,stepmax,kFALSE);
         if (dist<stepmax) {
            xtru->SetSeg(iv);
            if (convex) return (snext+dist);
            stepmax = dist;
            hit = kTRUE;
         }   
      }
      if (hit) return (snext+stepmax);
      return TGeoShape::Big();
   }   
   // general case
   Int_t incseg = (dir[2]>0)?1:-1;
   while (iz>=0 && iz<fNz-1) {
      // compute distance to lateral planes
      xtru->SetIz(iz);
      if (TGeoShape::IsSameWithinTolerance(fZ[iz],fZ[iz+1])) xtru->SetIz(-1);
      for (iv=0; iv<fNvert; iv++) {
         dist = DistToPlane(pt,dir,iz,iv,stepmax,kFALSE);
         if (dist<stepmax) {
            // HIT
            xtru->SetSeg(iv);
            if (convex) return (snext+dist);
            stepmax = dist;
            hit = kTRUE;
         }   
      }
      if (hit) return (snext+stepmax);
      iz += incseg;
   }   
   return TGeoShape::Big();  
}

//_____________________________________________________________________________
Bool_t TGeoXtru::DefinePolygon(Int_t nvert, const Double_t *xv, const Double_t *yv)
{
// Creates the polygon representing the blueprint of any Xtru section.
//   nvert     = number of vertices >2
//   xv[nvert] = array of X vertex positions 
//   yv[nvert] = array of Y vertex positions 
// *NOTE* should be called before DefineSection or ctor with 'param'
   if (nvert<3) {
      Error("DefinePolygon","In shape %s cannot create polygon with less than 3 vertices", GetName());
      SetShapeBit(TGeoShape::kGeoBad);
      return kFALSE;
   }
   for (Int_t i=0; i<nvert-1; i++) {
      for (Int_t j=i+1; j<nvert; j++) {
         if (TMath::Abs(xv[i]-xv[j])<TGeoShape::Tolerance() &&
             TMath::Abs(yv[i]-yv[j])<TGeoShape::Tolerance()) {
             Error("DefinePolygon","In shape %s 2 vertices cannot be identical",GetName());
             SetShapeBit(TGeoShape::kGeoBad);
//             return kFALSE;
          }   
      }
   }
   fNvert = nvert;
   if (fX) delete [] fX;
   fX = new Double_t[nvert];
   if (fY) delete [] fY;
   fY = new Double_t[nvert];
   if (fXc) delete [] fXc;
   fXc = new Double_t[nvert];
   if (fYc) delete [] fYc;
   fYc = new Double_t[nvert];
   memcpy(fX,xv,nvert*sizeof(Double_t));
   memcpy(fXc,xv,nvert*sizeof(Double_t));
   memcpy(fY,yv,nvert*sizeof(Double_t));
   memcpy(fYc,yv,nvert*sizeof(Double_t));
   
   if (fPoly) delete fPoly;
   fPoly = new TGeoPolygon(nvert);
   fPoly->SetXY(fXc,fYc); // initialize with current coordinates
   fPoly->FinishPolygon();
   if (fPoly->IsIllegalCheck()) {
      Error("DefinePolygon", "Shape %s of type XTRU has an illegal polygon.", GetName());
   }   
   return kTRUE;
}

//_____________________________________________________________________________
void TGeoXtru::DefineSection(Int_t snum, Double_t z, Double_t x0, Double_t y0, Double_t scale)
{
// defines z position of a section plane, rmin and rmax at this z.
   if ((snum<0) || (snum>=fNz)) return;
   fZ[snum]  = z;
   fX0[snum] = x0;
   fY0[snum] = y0;
   fScale[snum] = scale;
   if (snum) {
      if (fZ[snum]<fZ[snum-1]) {
         Warning("DefineSection", "In shape: %s, Z position of section "
                 "%i, z=%e, not in increasing order, %i, z=%e",
                 GetName(),snum,fZ[snum],snum-1,fZ[snum-1]);
         return;
      }   
   }
   if (snum==(fNz-1)) {
      ComputeBBox();
      if (TestShapeBit(TGeoShape::kGeoBad)) InspectShape();
   }   
}
            
//_____________________________________________________________________________
Double_t TGeoXtru::GetZ(Int_t ipl) const
{
// Return the Z coordinate for segment ipl.
   if (ipl<0 || ipl>(fNz-1)) {
      Error("GetZ","In shape %s, ipl=%i out of range (0,%i)",GetName(),ipl,0,fNz-1);
      return 0.;
   }
   return fZ[ipl];
}      
//_____________________________________________________________________________
void TGeoXtru::GetPlaneNormal(const Double_t *vert, Double_t *norm) const
{
// Returns normal vector to the planar quadrilateral defined by vector VERT.
// The normal points outwards the xtru.
   Double_t cross = 0.;
   Double_t v1[3], v2[3];
   v1[0] = vert[9]-vert[0];
   v1[1] = vert[10]-vert[1];
   v1[2] = vert[11]-vert[2];
   v2[0] = vert[3]-vert[0];
   v2[1] = vert[4]-vert[1];
   v2[2] = vert[5]-vert[2];
   norm[0] = v1[1]*v2[2]-v1[2]*v2[1];
   cross += norm[0]*norm[0];
   norm[1] = v1[2]*v2[0]-v1[0]*v2[2];
   cross += norm[1]*norm[1];
   norm[2] = v1[0]*v2[1]-v1[1]*v2[0];
   cross += norm[2]*norm[2];
   if (cross < TGeoShape::Tolerance()) return;
   cross = 1./TMath::Sqrt(cross);
   for (Int_t i=0; i<3; i++) norm[i] *= cross;
}   

//_____________________________________________________________________________
void TGeoXtru::GetPlaneVertices(Int_t iz, Int_t ivert, Double_t *vert) const
{
// Returns (x,y,z) of 3 vertices of the surface defined by Z sections (iz, iz+1)
// and polygon vertices (ivert, ivert+1). No range check.
   Double_t x,y,z1,z2;
   Int_t iv1 = (ivert+1)%fNvert;
   Int_t icrt = 0;
   z1 = fZ[iz];
   z2 = fZ[iz+1];
   if (fPoly->IsClockwise()) {
      x = fX[ivert]*fScale[iz]+fX0[iz];
      y = fY[ivert]*fScale[iz]+fY0[iz];
      vert[icrt++] = x;
      vert[icrt++] = y;
      vert[icrt++] = z1;
      x = fX[iv1]*fScale[iz]+fX0[iz];
      y = fY[iv1]*fScale[iz]+fY0[iz];
      vert[icrt++] = x;
      vert[icrt++] = y;
      vert[icrt++] = z1;
      x = fX[iv1]*fScale[iz+1]+fX0[iz+1];
      y = fY[iv1]*fScale[iz+1]+fY0[iz+1];
      vert[icrt++] = x;
      vert[icrt++] = y;
      vert[icrt++] = z2;
      x = fX[ivert]*fScale[iz+1]+fX0[iz+1];
      y = fY[ivert]*fScale[iz+1]+fY0[iz+1];
      vert[icrt++] = x;
      vert[icrt++] = y;
      vert[icrt++] = z2;
   } else {
      x = fX[iv1]*fScale[iz]+fX0[iz];
      y = fY[iv1]*fScale[iz]+fY0[iz];
      vert[icrt++] = x;
      vert[icrt++] = y;
      vert[icrt++] = z1;
      x = fX[ivert]*fScale[iz]+fX0[iz];
      y = fY[ivert]*fScale[iz]+fY0[iz];
      vert[icrt++] = x;
      vert[icrt++] = y;
      vert[icrt++] = z1;
      x = fX[ivert]*fScale[iz+1]+fX0[iz+1];
      y = fY[ivert]*fScale[iz+1]+fY0[iz+1];
      vert[icrt++] = x;
      vert[icrt++] = y;
      vert[icrt++] = z2;
      x = fX[iv1]*fScale[iz+1]+fX0[iz+1];
      y = fY[iv1]*fScale[iz+1]+fY0[iz+1];
      vert[icrt++] = x;
      vert[icrt++] = y;
      vert[icrt++] = z2;
   }
}
//_____________________________________________________________________________
Bool_t TGeoXtru::IsPointInsidePlane(Double_t *point, Double_t *vert, Double_t *norm) const
{
// Check if the quadrilateral defined by VERT contains a coplanar POINT.
   Double_t v1[3], v2[3];
   Double_t cross;
   Int_t j,k;
   for (Int_t i=0; i<4; i++) { // loop vertices
      j = 3*i;
      k = 3*((i+1)%4);
      v1[0] = point[0]-vert[j];
      v1[1] = point[1]-vert[j+1];
      v1[2] = point[2]-vert[j+2];
      v2[0] = vert[k]-vert[j];
      v2[1] = vert[k+1]-vert[j+1];
      v2[2] = vert[k+2]-vert[j+2];
      cross = (v1[1]*v2[2]-v1[2]*v2[1])*norm[0]+
              (v1[2]*v2[0]-v1[0]*v2[2])*norm[1]+
              (v1[0]*v2[1]-v1[1]*v2[0])*norm[2];
      if (cross<0) return kFALSE;
   }
   return kTRUE;   
}

//_____________________________________________________________________________
void TGeoXtru::InspectShape() const
{
// Print actual Xtru parameters.
   printf("*** Shape %s: TGeoXtru ***\n", GetName());
   printf("    Nz    = %i\n", fNz);
   printf("    List of (x,y) of polygon vertices:\n");
   for (Int_t ivert = 0; ivert<fNvert; ivert++)
      printf("    x = %11.5f  y = %11.5f\n", fX[ivert],fY[ivert]);
   for (Int_t ipl=0; ipl<fNz; ipl++)
      printf("     plane %i: z=%11.5f x0=%11.5f y0=%11.5f scale=%11.5f\n", ipl, fZ[ipl], fX0[ipl], fY0[ipl], fScale[ipl]);
   printf(" Bounding box:\n");
   TGeoBBox::InspectShape();
}

//_____________________________________________________________________________
TBuffer3D *TGeoXtru::MakeBuffer3D() const
{ 
   // Creates a TBuffer3D describing *this* shape.
   // Coordinates are in local reference frame.
   Int_t nz = GetNz();
   Int_t nvert = GetNvert();
   Int_t nbPnts = nz*nvert;
   Int_t nbSegs = nvert*(2*nz-1);
   Int_t nbPols = nvert*(nz-1)+2;

   TBuffer3D* buff = new TBuffer3D(TBuffer3DTypes::kGeneric,
                                   nbPnts, 3*nbPnts, nbSegs, 3*nbSegs, nbPols, 6*(nbPols-2)+2*(2+nvert));
   if (buff)
   {
      SetPoints(buff->fPnts);   
      SetSegsAndPols(*buff);
   }

   return buff; 
}

//_____________________________________________________________________________
void TGeoXtru::SetSegsAndPols(TBuffer3D &buff) const
{
// Fill TBuffer3D structure for segments and polygons.
   Int_t nz = GetNz();
   Int_t nvert = GetNvert();
   Int_t c = GetBasicColor();

   Int_t i,j;
   Int_t indx, indx2, k;
   indx = indx2 = 0;
   for (i=0; i<nz; i++) {
      // loop Z planes
      indx2 = i*nvert;
      // loop polygon segments
      for (j=0; j<nvert; j++) {
         k = (j+1)%nvert;
         buff.fSegs[indx++] = c;
         buff.fSegs[indx++] = indx2+j;
         buff.fSegs[indx++] = indx2+k;
      }
   } // total: nz*nvert polygon segments
   for (i=0; i<nz-1; i++) {
      // loop Z planes
      indx2 = i*nvert;
      // loop polygon segments
      for (j=0; j<nvert; j++) {
         k = j + nvert;
         buff.fSegs[indx++] = c;
         buff.fSegs[indx++] = indx2+j;
         buff.fSegs[indx++] = indx2+k;
      }
   } // total (nz-1)*nvert lateral segments

   indx = 0;

   // fill lateral polygons
   for (i=0; i<nz-1; i++) {
      indx2 = i*nvert;
      for (j=0; j<nvert; j++) {
      k = (j+1)%nvert;
      buff.fPols[indx++] = c+j%3;
      buff.fPols[indx++] = 4;
      buff.fPols[indx++] = indx2+j;
      buff.fPols[indx++] = nz*nvert+indx2+k;
      buff.fPols[indx++] = indx2+nvert+j;
      buff.fPols[indx++] = nz*nvert+indx2+j;
      }
   } // total (nz-1)*nvert polys
   buff.fPols[indx++] = c+2;
   buff.fPols[indx++] = nvert;
   indx2 = 0;
   for (j = nvert - 1; j >= 0; --j) {
      buff.fPols[indx++] = indx2+j;
   }

   buff.fPols[indx++] = c;
   buff.fPols[indx++] = nvert;
   indx2 = (nz-1)*nvert;
 
   for (j=0; j<nvert; j++) {
      buff.fPols[indx++] = indx2+j;
   }
}

//_____________________________________________________________________________
Double_t TGeoXtru::SafetyToSector(Double_t *point, Int_t iz, Double_t safmin)
{
// Compute safety to sector iz, returning also the closest segment index.
   Double_t safz = TGeoShape::Big();
   Double_t saf1, saf2;
   Bool_t in1, in2;
   Int_t iseg;
   Double_t safe = TGeoShape::Big();
   // segment-break case
   if (TGeoShape::IsSameWithinTolerance(fZ[iz],fZ[iz+1])) {
      safz = TMath::Abs(point[2]-fZ[iz]);
      if (safz>safmin) return TGeoShape::Big();
      SetCurrentVertices(fX0[iz], fY0[iz], fScale[iz]);
      saf1 = fPoly->Safety(point, iseg);
      in1 = fPoly->Contains(point);
      if (!in1 && saf1>safmin) return TGeoShape::Big(); 
      SetCurrentVertices(fX0[iz+1], fY0[iz+1], fScale[iz+1]);
      saf2 = fPoly->Safety(point, iseg);
      in2 = fPoly->Contains(point);
      if ((in1&!in2)|(in2&!in1)) {
         safe = safz; 
      } else {
         safe = TMath::Min(saf1,saf2);
         safe = TMath::Max(safe, safz);
      }
      if (safe>safmin) return TGeoShape::Big();
      return safe;
   }      
   // normal case
   safz = fZ[iz]-point[2];
   if (safz>safmin) return TGeoShape::Big();
   if (safz<0) {
      saf1 = point[2]-fZ[iz+1];
      if (saf1>safmin) return TGeoShape::Big(); 
      if (saf1<0) {
         safz = TMath::Max(safz, saf1); // we are in between the 2 Z segments - we ignore safz
      } else {
         safz = saf1;
      }
   }         
   SetCurrentZ(point[2],iz);
   saf1 = fPoly->Safety(point, iseg);
   Double_t vert[12];
   Double_t norm[3];
   GetPlaneVertices(iz,iseg,vert);
   GetPlaneNormal(vert, norm);
   saf1 = saf1*TMath::Sqrt(1.-norm[2]*norm[2]);
   if (fPoly->Contains(point)) saf1 = -saf1;
   safe = TMath::Max(safz, saf1);
   safe = TMath::Abs(safe);
   if (safe>safmin) return TGeoShape::Big();
   return safe;
}

//_____________________________________________________________________________
Double_t TGeoXtru::Safety(Double_t *point, Bool_t in) const
{
// computes the closest distance from given point to this shape, according
// to option. The matching point on the shape is stored in spoint.
   //---> localize the Z segment
   Double_t safmin = TGeoShape::Big();
   Double_t safe;
   Double_t safz = TGeoShape::Big();
   TGeoXtru *xtru = (TGeoXtru*)this;
   Int_t iz;
   if (in) {
      safmin = TMath::Min(point[2]-fZ[0], fZ[fNz-1]-point[2]);
      for (iz=0; iz<fNz-1; iz++) {
         safe = xtru->SafetyToSector(point, iz, safmin);
         if (safe<safmin) safmin = safe;
      }
      return safmin;
   }
   iz = TMath::BinarySearch(fNz, fZ, point[2]);
   if (iz<0) {
      iz = 0;
      safz = fZ[0] - point[2];
   } else {
      if (iz==fNz-1) {
         iz = fNz-2;
         safz = point[2] - fZ[fNz-1];
      }
   }
   // loop segments from iz up
   Int_t i;
   for (i=iz; i<fNz-1; i++) {
      safe = xtru->SafetyToSector(point,i,safmin);
      if (safe<safmin) safmin=safe;
   }
   // loop segments from iz-1 down
   for (i=iz-1; i>0; i--) {            
      safe = xtru->SafetyToSector(point,i,safmin);
      if (safe<safmin) safmin=safe;
   }
   safe = TMath::Min(safmin, safz);
   return safe;
}

//_____________________________________________________________________________
void TGeoXtru::SavePrimitive(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() << endl;
   out << "   nz       = " << fNz << ";" << endl;
   out << "   nvert    = " << fNvert << ";" << endl;
   out << "   TGeoXtru *xtru = new TGeoXtru(nz);" << endl;
   out << "   xtru->SetName(\"" << GetName() << "\");" << endl;
   Int_t i;
   for (i=0; i<fNvert; i++) {
      out << "   xvert[" << i << "] = " << fX[i] << ";   yvert[" << i << "] = " << fY[i] << ";" << endl;
   }
   out << "   xtru->DefinePolygon(nvert,xvert,yvert);" << endl;
   for (i=0; i<fNz; i++) {
      out << "   zsect  = " << fZ[i] << ";" << endl; 
      out << "   x0     = " << fX0[i] << ";" << endl; 
      out << "   y0     = " << fY0[i] << ";" << endl; 
      out << "   scale0 = " << fScale[i] << ";" << endl; 
      out << "   xtru->DefineSection(" << i << ",zsect,x0,y0,scale0);" << endl;
   }
   out << "   TGeoShape *" << GetPointerName() << " = xtru;" << endl;
   TObject::SetBit(TGeoShape::kGeoSavePrimitive);
}         

//_____________________________________________________________________________
void TGeoXtru::SetCurrentZ(Double_t z, Int_t iz)
{
// Recompute current section vertices for a given Z position within range of section iz.
   Double_t x0, y0, scale, a, b;
   Int_t ind1, ind2;
   ind1 = iz;
   ind2 = iz+1;   
   Double_t invdz = 1./(fZ[ind2]-fZ[ind1]);
   a = (fX0[ind1]*fZ[ind2]-fX0[ind2]*fZ[ind1])*invdz;
   b = (fX0[ind2]-fX0[ind1])*invdz;
   x0 = a+b*z;
   a = (fY0[ind1]*fZ[ind2]-fY0[ind2]*fZ[ind1])*invdz;
   b = (fY0[ind2]-fY0[ind1])*invdz;
   y0 = a+b*z;
   a = (fScale[ind1]*fZ[ind2]-fScale[ind2]*fZ[ind1])*invdz;
   b = (fScale[ind2]-fScale[ind1])*invdz;
   scale = a+b*z;
   SetCurrentVertices(x0,y0,scale);
}
      
//_____________________________________________________________________________
void TGeoXtru::SetCurrentVertices(Double_t x0, Double_t y0, Double_t scale)      
{
// Set current vertex coordinates according X0, Y0 and SCALE.
   for (Int_t i=0; i<fNvert; i++) {
      fXc[i] = scale*fX[i] + x0;
      fYc[i] = scale*fY[i] + y0;
   }   
}

//_____________________________________________________________________________
void TGeoXtru::SetDimensions(Double_t *param)
{
// param[0] = nz  // number of z planes
//
// param[1] = z1  // Z position of first plane
// param[2] = x1  // X position of first plane
// param[3] = y1  // Y position of first plane
// param[4] = scale1  // scale factor for first plane
// ...
// param[4*(nz-1]+1] = zn
// param[4*(nz-1)+2] = xn
// param[4*(nz-1)+3] = yn
// param[4*(nz-1)+4] = scalen
   fNz = (Int_t)param[0];   
   if (fNz<2) {
      Error("SetDimensions","Cannot create TGeoXtru %s with less than 2 Z planes",GetName());
      SetShapeBit(TGeoShape::kGeoBad);
      return;
   }
   if (fZ) delete [] fZ;
   if (fScale) delete [] fScale;
   if (fX0) delete [] fX0;
   if (fY0) delete [] fY0;
   fZ = new Double_t[fNz];
   fScale = new Double_t[fNz];
   fX0 = new Double_t[fNz];
   fY0 = new Double_t[fNz];
   
   for (Int_t i=0; i<fNz; i++) 
      DefineSection(i, param[1+4*i], param[2+4*i], param[3+4*i], param[4+4*i]);
}   

//_____________________________________________________________________________
void TGeoXtru::SetPoints(Double_t *points) const
{
// create polycone mesh points
   Int_t i, j;
   Int_t indx = 0;
   TGeoXtru *xtru = (TGeoXtru*)this;
   if (points) {
      for (i = 0; i < fNz; i++) {
         xtru->SetCurrentVertices(fX0[i], fY0[i], fScale[i]);
         if (fPoly->IsClockwise()) {
            for (j = 0; j < fNvert; j++) {
               points[indx++] = fXc[j];
               points[indx++] = fYc[j];
               points[indx++] = fZ[i];
            }
         } else {
            for (j = 0; j < fNvert; j++) {
               points[indx++] = fXc[fNvert-1-j];
               points[indx++] = fYc[fNvert-1-j];
               points[indx++] = fZ[i];
            }
         }   
      }
   }
}

//_____________________________________________________________________________
void TGeoXtru::SetPoints(Float_t *points) const
{
// create polycone mesh points
   Int_t i, j;
   Int_t indx = 0;
   TGeoXtru *xtru = (TGeoXtru*)this;
   if (points) {
      for (i = 0; i < fNz; i++) {
         xtru->SetCurrentVertices(fX0[i], fY0[i], fScale[i]);
         if (fPoly->IsClockwise()) {
            for (j = 0; j < fNvert; j++) {
               points[indx++] = fXc[j];
               points[indx++] = fYc[j];
               points[indx++] = fZ[i];
            }
         } else {
            for (j = 0; j < fNvert; j++) {
               points[indx++] = fXc[fNvert-1-j];
               points[indx++] = fYc[fNvert-1-j];
               points[indx++] = fZ[i];
            }
         }   
      }
   }
}

//_____________________________________________________________________________
void TGeoXtru::GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t &npols) const
{
// Returns numbers of vertices, segments and polygons composing the shape mesh.
   Int_t nz = GetNz();
   Int_t nv = GetNvert();
   nvert = nz*nv;
   nsegs = nv*(2*nz-1);
   npols = nv*(nz-1)+2;
}

//_____________________________________________________________________________
Int_t TGeoXtru::GetNmeshVertices() const
{
// Return number of vertices of the mesh representation
   Int_t numPoints = fNz*fNvert;
   return numPoints;
}

//_____________________________________________________________________________
void TGeoXtru::Sizeof3D() const
{
///// fill size of this 3-D object
///   TVirtualGeoPainter *painter = gGeoManager->GetGeomPainter();
///   if (!painter) return;
///
///   Int_t numPoints = fNz*fNvert;
///   Int_t numSegs   = fNvert*(2*fNz-1);
///   Int_t numPolys  = fNvert*(fNz-1)+2;
///   painter->AddSize3D(numPoints, numSegs, numPolys);
}

//_____________________________________________________________________________
void TGeoXtru::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGeoVolume.
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGeoXtru::Class(), this);
      if (fPoly) fPoly->SetXY(fXc,fYc); // initialize with current coordinates   
   } else {
      R__b.WriteClassBuffer(TGeoXtru::Class(), this);
   }
}

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

   TGeoBBox::FillBuffer3D(buffer, reqSections, localFrame);

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