ROOT logo
// @(#)root/geom:$Id$
// Author: Andrei Gheata   31/01/02
// TGeoPgon::Contains() 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.             *
 *************************************************************************/

//_____________________________________________________________________________
// TGeoPgon - a polygone. It has at least 10 parameters :
//            - the lower phi limit;
//            - the range in phi;
//            - the number of equal edges on each z plane;
//            - the number of z planes (at least two) where the inner/outer 
//              radii are changing;
//            - z coordinate, inner and outer radius of the inscribed cercle
//              (distance from center to edges) for each z plane
//
//_____________________________________________________________________________
//Begin_Html
/*
<img src="gif/t_pgon.gif">
*/
//End_Html
//Begin_Html
/*
<img src="gif/t_pgondivZ.gif">
*/
//End_Html

#include "Riostream.h"

#include "TGeoPgon.h"

#include "TGeoManager.h"
#include "TGeoVolume.h"
#include "TVirtualGeoPainter.h"
#include "TGeoTube.h"
#include "TVirtualPad.h"
#include "TBuffer3D.h"
#include "TBuffer3DTypes.h"
#include "TMath.h"
#include "TThread.h"
   
ClassImp(TGeoPgon)

//______________________________________________________________________________
TGeoPgon::ThreadData_t::ThreadData_t() :
   fIntBuffer(0), fDblBuffer(0)
{
   // Constructor.
}

//______________________________________________________________________________
TGeoPgon::ThreadData_t::~ThreadData_t()
{
   // Destructor.
   delete [] fIntBuffer;
   delete [] fDblBuffer;
}

//______________________________________________________________________________
TGeoPgon::ThreadData_t& TGeoPgon::GetThreadData() const
{
   Int_t tid = TGeoManager::ThreadId();
   return *fThreadData[tid];
}

//______________________________________________________________________________
void TGeoPgon::ClearThreadData() const
{
   TThread::Lock();
   std::vector<ThreadData_t*>::iterator i = fThreadData.begin();
   while (i != fThreadData.end())
   {
      delete *i;
      ++i;
   }
   fThreadData.clear();
   fThreadSize = 0;
   TThread::UnLock();
}

//______________________________________________________________________________
void TGeoPgon::CreateThreadData(Int_t nthreads)
{
// Create thread data for n threads max.
   if (fThreadSize) ClearThreadData();
   TThread::Lock();
   fThreadData.resize(nthreads);
   fThreadSize = nthreads;
   for (Int_t tid=0; tid<nthreads; tid++) {
      if (fThreadData[tid] == 0) {
         fThreadData[tid] = new ThreadData_t;
         fThreadData[tid]->fIntBuffer = new Int_t[fNedges+10];
         fThreadData[tid]->fDblBuffer = new Double_t[fNedges+10];
      }
   }   
   TThread::UnLock();
}

//_____________________________________________________________________________
TGeoPgon::TGeoPgon()
{
// dummy ctor
   SetShapeBit(TGeoShape::kGeoPgon);
   fNedges = 0;
   fThreadSize = 0;
}   

//_____________________________________________________________________________
TGeoPgon::TGeoPgon(Double_t phi, Double_t dphi, Int_t nedges, Int_t nz)
         :TGeoPcon(phi, dphi, nz) 
{
// Default constructor
   SetShapeBit(TGeoShape::kGeoPgon);
   fNedges = nedges;
   fThreadSize = 0;
   CreateThreadData(1);
}

//_____________________________________________________________________________
TGeoPgon::TGeoPgon(const char *name, Double_t phi, Double_t dphi, Int_t nedges, Int_t nz)
         :TGeoPcon(name, phi, dphi, nz) 
{
// Default constructor
   SetShapeBit(TGeoShape::kGeoPgon);
   fNedges = nedges;
   fThreadSize = 0;
   CreateThreadData(1);
}

//_____________________________________________________________________________
TGeoPgon::TGeoPgon(Double_t *param)
         :TGeoPcon() 
{
// Default constructor in GEANT3 style
// param[0] = phi1
// param[1] = dphi
// param[2] = nedges
// param[3] = nz
//
// param[4] = z1
// param[5] = Rmin1
// param[6] = Rmax1
// ...
   SetShapeBit(TGeoShape::kGeoPgon);
   SetDimensions(param);
   ComputeBBox();
   fThreadSize = 0;
   CreateThreadData(1);
}

//_____________________________________________________________________________
TGeoPgon::~TGeoPgon()
{
// destructor
   ClearThreadData();
}

//_____________________________________________________________________________
Double_t TGeoPgon::Capacity() const
{
// Computes capacity of the shape in [length^3]
   Int_t ipl;
   Double_t rmin1, rmax1, rmin2, rmax2, dphi, dz;
   Double_t capacity = 0.;
   dphi = fDphi/fNedges; // [deg]
   Double_t tphi2 = TMath::Tan(0.5*dphi*TMath::DegToRad());
   for (ipl=0; ipl<fNz-1; ipl++) {
      dz    = fZ[ipl+1]-fZ[ipl];
      if (dz < TGeoShape::Tolerance()) continue;
      rmin1 = fRmin[ipl];
      rmax1 = fRmax[ipl];
      rmin2 = fRmin[ipl+1];
      rmax2 = fRmax[ipl+1];
      capacity += fNedges*(tphi2/3.)*dz*(rmax1*rmax1+rmax1*rmax2+rmax2*rmax2 -
                                 rmin1*rmin1-rmin1*rmin2-rmin2*rmin2);
   }
   return capacity;   
}

//_____________________________________________________________________________
void TGeoPgon::ComputeBBox()
{
// compute bounding box for a polygone
   // Check if the sections are in increasing Z order
   for (Int_t isec=0; isec<fNz-1; isec++) {
      if (fZ[isec]>fZ[isec+1]) {
         InspectShape();
         Fatal("ComputeBBox", "Wrong section order");
      }   
   }
   // Check if the last sections are valid
   if (TMath::Abs(fZ[1]-fZ[0]) < TGeoShape::Tolerance() ||
       TMath::Abs(fZ[fNz-1]-fZ[fNz-2]) < TGeoShape::Tolerance()) {
      InspectShape();
      Fatal("ComputeBBox","Shape %s at index %d: Not allowed first two or last two sections at same Z",
             GetName(), gGeoManager->GetListOfShapes()->IndexOf(this));
   }          
   Double_t zmin = TMath::Min(fZ[0], fZ[fNz-1]);
   Double_t zmax = TMath::Max(fZ[0], fZ[fNz-1]);
   // find largest rmax an smallest rmin
   Double_t rmin, rmax;
   Double_t divphi = fDphi/fNedges;
   // find the radius of the outscribed circle
   rmin = fRmin[TMath::LocMin(fNz, fRmin)];   
   rmax = fRmax[TMath::LocMax(fNz, fRmax)];
   rmax = rmax/TMath::Cos(0.5*divphi*TMath::DegToRad());
   Double_t phi1 = fPhi1;
   Double_t phi2 = phi1 + fDphi;
   
   Double_t xc[4];
   Double_t yc[4];
   xc[0] = rmax*TMath::Cos(phi1*TMath::DegToRad());
   yc[0] = rmax*TMath::Sin(phi1*TMath::DegToRad());
   xc[1] = rmax*TMath::Cos(phi2*TMath::DegToRad());
   yc[1] = rmax*TMath::Sin(phi2*TMath::DegToRad());
   xc[2] = rmin*TMath::Cos(phi1*TMath::DegToRad());
   yc[2] = rmin*TMath::Sin(phi1*TMath::DegToRad());
   xc[3] = rmin*TMath::Cos(phi2*TMath::DegToRad());
   yc[3] = rmin*TMath::Sin(phi2*TMath::DegToRad());

   Double_t xmin = xc[TMath::LocMin(4, &xc[0])];
   Double_t xmax = xc[TMath::LocMax(4, &xc[0])]; 
   Double_t ymin = yc[TMath::LocMin(4, &yc[0])]; 
   Double_t ymax = yc[TMath::LocMax(4, &yc[0])];

   Double_t ddp = -phi1;
   if (ddp<0) ddp+= 360;
   if (ddp<=fDphi) xmax = rmax;
   ddp = 90-phi1;
   if (ddp<0) ddp+= 360;
   if (ddp<=fDphi) ymax = rmax;
   ddp = 180-phi1;
   if (ddp<0) ddp+= 360;
   if (ddp<=fDphi) xmin = -rmax;
   ddp = 270-phi1;
   if (ddp<0) ddp+= 360;
   if (ddp<=fDphi) ymin = -rmax;
   fOrigin[0] = 0.5*(xmax+xmin);
   fOrigin[1] = 0.5*(ymax+ymin);
   fOrigin[2] = 0.5*(zmax+zmin);
   fDX = 0.5*(xmax-xmin);
   fDY = 0.5*(ymax-ymin);
   fDZ = 0.5*(zmax-zmin);
   SetShapeBit(kGeoClosedShape);
}

//_____________________________________________________________________________   
void TGeoPgon::ComputeNormal(const Double_t *point, const Double_t *dir, Double_t *norm)
{
// Compute normal to closest surface from POINT. 
   memset(norm,0,3*sizeof(Double_t));
   Double_t phi1=0, phi2=0, c1=0, s1=0, c2=0, s2=0;
   Double_t dz, rmin1, rmin2;
   Bool_t is_seg  = (fDphi<360)?kTRUE:kFALSE;
   if (is_seg) {
      phi1 = fPhi1;
      if (phi1<0) phi1+=360;
      phi2 = phi1 + fDphi;
      phi1 *= TMath::DegToRad();
      phi2 *= TMath::DegToRad();
      c1 = TMath::Cos(phi1);
      s1 = TMath::Sin(phi1);
      c2 = TMath::Cos(phi2);
      s2 = TMath::Sin(phi2);
      if (TGeoShape::IsCloseToPhi(1E-5, point, c1,s1,c2,s2)) {
         TGeoShape::NormalPhi(point,dir,norm,c1,s1,c2,s2);
         return;
      }
   } // Phi done   

   Int_t ipl = TMath::BinarySearch(fNz, fZ, point[2]);
   if (ipl==(fNz-1) || ipl<0) {
      // point outside Z range
      norm[2] = TMath::Sign(1., dir[2]);
      return;
   }
   Int_t iplclose = ipl;
   if ((fZ[ipl+1]-point[2])<(point[2]-fZ[ipl])) iplclose++;
   dz = TMath::Abs(fZ[iplclose]-point[2]);

   Double_t divphi = fDphi/fNedges;
   Double_t phi = TMath::ATan2(point[1], point[0])*TMath::RadToDeg();
   while (phi<fPhi1) phi+=360.;
   Double_t ddp = phi-fPhi1;
   Int_t ipsec = Int_t(ddp/divphi);
   Double_t ph0 = (fPhi1+divphi*(ipsec+0.5))*TMath::DegToRad();
   // compute projected distance
   Double_t r, rsum, rpgon, ta, calf;
   r = TMath::Abs(point[0]*TMath::Cos(ph0)+point[1]*TMath::Sin(ph0));
   if (dz<1E-5) {
      if (iplclose==0 || iplclose==(fNz-1)) {
         norm[2] = TMath::Sign(1., dir[2]);
         return;
      }
      if (iplclose==ipl && TGeoShape::IsSameWithinTolerance(fZ[ipl],fZ[ipl-1])) {
         if (r<TMath::Max(fRmin[ipl],fRmin[ipl-1]) || r>TMath::Min(fRmax[ipl],fRmax[ipl-1])) {
            norm[2] = TMath::Sign(1., dir[2]);
            return;
         }
      } else {
         if (TGeoShape::IsSameWithinTolerance(fZ[iplclose],fZ[iplclose+1])) {
            if (r<TMath::Max(fRmin[iplclose],fRmin[iplclose+1]) || r>TMath::Min(fRmax[iplclose],fRmax[iplclose+1])) {
               norm[2] = TMath::Sign(1., dir[2]);
               return;
            }
         }
      }
   } //-> Z done

   dz = fZ[ipl+1]-fZ[ipl];
   rmin1 = fRmin[ipl];
   rmin2 = fRmin[ipl+1];
   rsum = rmin1+rmin2;
   Double_t safe = TGeoShape::Big();
   if (rsum>1E-10) {
      ta = (rmin2-rmin1)/dz;
      calf = 1./TMath::Sqrt(1+ta*ta);
      rpgon = rmin1 + (point[2]-fZ[ipl])*ta;
      safe = TMath::Abs(r-rpgon);
      norm[0] = calf*TMath::Cos(ph0);
      norm[1] = calf*TMath::Sin(ph0);
      norm[2] = -calf*ta;
   }
   ta = (fRmax[ipl+1]-fRmax[ipl])/dz;
   calf = 1./TMath::Sqrt(1+ta*ta);
   rpgon = fRmax[ipl] + (point[2]-fZ[ipl])*ta;
   if (safe>TMath::Abs(rpgon-r)) {
      norm[0] = calf*TMath::Cos(ph0);
      norm[1] = calf*TMath::Sin(ph0);
      norm[2] = -calf*ta;
   }   
   if (norm[0]*dir[0]+norm[1]*dir[1]+norm[2]*dir[2]<0) {
      norm[0] = -norm[0];
      norm[1] = -norm[1];
      norm[2] = -norm[2];
   }   
}

//_____________________________________________________________________________
Bool_t TGeoPgon::Contains(const Double_t *point) const
{
// test if point is inside this shape
   // check total z range
   if (point[2]<fZ[0]) return kFALSE;
   if (point[2]>fZ[fNz-1]) return kFALSE;
   Double_t divphi = fDphi/fNedges;
   // now check phi
   Double_t phi = TMath::ATan2(point[1], point[0])*TMath::RadToDeg();
   while (phi < fPhi1) phi += 360.0;
   Double_t ddp = phi-fPhi1;
   if (ddp>fDphi) return kFALSE;
   // now find phi division
   Int_t ipsec = TMath::Min(Int_t(ddp/divphi), fNedges-1);
   Double_t ph0 = (fPhi1+divphi*(ipsec+0.5))*TMath::DegToRad();
   // now check projected distance
   Double_t r = point[0]*TMath::Cos(ph0) + point[1]*TMath::Sin(ph0);
   // find in which Z section the point is in
   Int_t iz = TMath::BinarySearch(fNz, fZ, point[2]);
   if (iz==fNz-1) {
      if (r<fRmin[iz]) return kFALSE;
      if (r>fRmax[iz]) return kFALSE;
      return kTRUE;
   }  
   Double_t dz = fZ[iz+1]-fZ[iz];
   Double_t rmin, rmax;
   if (dz<1E-8) {
      // we are at a radius-changing plane 
      rmin = TMath::Min(fRmin[iz], fRmin[iz+1]);
      rmax = TMath::Max(fRmax[iz], fRmax[iz+1]);
      if (r<rmin) return kFALSE;
      if (r>rmax) return kFALSE;
      return kTRUE;
   }   
   // now compute rmin and rmax and test the value of r
   Double_t dzrat = (point[2]-fZ[iz])/dz;
   rmin = fRmin[iz]+dzrat*(fRmin[iz+1]-fRmin[iz]);
   // is the point inside the 'hole' at the center of the volume ?
   if (r < rmin) return kFALSE;
   rmax = fRmax[iz]+dzrat*(fRmax[iz+1]-fRmax[iz]);
   if (r > rmax) return kFALSE;
   
   return kTRUE;
}

//_____________________________________________________________________________
Double_t TGeoPgon::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 polygone
   // first find out in which Z section the point is in
   if (iact<3 && safe) {
      *safe = Safety(point, kTRUE);
      if (iact==0) return TGeoShape::Big();
      if (iact==1 && step<*safe) return TGeoShape::Big();
   }   
   // find current Z section
   Int_t ipl, ipsec;
   ipl = TMath::BinarySearch(fNz, fZ, point[2]);
   if (ipl==fNz-1) {
      if (dir[2]>=0) return 0.;
      ipl--;
   }   
   if (ipl<0) {
      // point out
      if (dir[2]<=0) return 0.;
      ipl++;
   }
   Double_t stepmax = step;
   if (!fThreadSize) ((TGeoPgon*)this)->CreateThreadData(1);
   ThreadData_t& td = GetThreadData();
   Double_t *sph = td.fDblBuffer;
   Int_t *iph = td.fIntBuffer;
   // locate current phi sector [0,fNedges-1]; -1 for dead region
   LocatePhi(point, ipsec);
   if (ipsec<0) {
   // Point on a phi boundary - entering or exiting ?
      Double_t phi1 = fPhi1*TMath::DegToRad();
      Double_t phi2 = (fPhi1+fDphi)*TMath::DegToRad();
      if ((point[0]*dir[1]-point[1]*dir[0])>0) {
         // phi1 next crossing
         if ((point[0]*TMath::Cos(phi1)+point[1]*TMath::Sin(phi1)) <
            (point[0]*TMath::Cos(phi2)+point[1]*TMath::Sin(phi2))) {
            // close to phimax 
            return 0.0;
         } else { 
            // close to phi1 - ignore it
            ipsec = 0;
         }
      } else {
         // phimax next crossing
         if ((point[0]*TMath::Cos(phi1)+point[1]*TMath::Sin(phi1)) >
            (point[0]*TMath::Cos(phi2)+point[1]*TMath::Sin(phi2))) {
            // close to phi1 
            return 0.0;
         } else {
            // close to phimax - ignore it
            ipsec = fNedges-1;
         }         
      }      
   }
   Int_t ipln = -1;
   if (TGeoShape::IsSameWithinTolerance(fZ[ipl],fZ[ipl+1])) {
      ipln = ipl;
   } else {   
      if (fNz>3 && ipl>=0 && ipl<fNz-3 && TGeoShape::IsSameWithinTolerance(fZ[ipl+1],fZ[ipl+2]) && TMath::Abs(point[2]-fZ[ipl+1])<1.E-8) {
         ipln = ipl+1;
      } else {
         if (ipl>1 && TGeoShape::IsSameWithinTolerance(fZ[ipl],fZ[ipl-1]) && TMath::Abs(point[2]-fZ[ipl])<1.E-8) ipln = ipl-1;
      }   
   }
   if (ipln>0) {
      // point between segments
      Double_t divphi = fDphi/fNedges;
      Double_t phi = (fPhi1 + (ipsec+0.5)*divphi)*TMath::DegToRad();
      Double_t cphi = TMath::Cos(phi);
      Double_t sphi = TMath::Sin(phi);
      Double_t rproj = point[0]*cphi+point[1]*sphi;
      if (dir[2]>0) {
         ipl = ipln+1;
         if (rproj>fRmin[ipln] && rproj<fRmin[ipln+1]) return 0.0;
         if (rproj<fRmax[ipln] && rproj>fRmax[ipln+1]) return 0.0;
      } else {
         ipl = ipln-1;
         if (rproj<fRmin[ipln] && rproj>fRmin[ipln+1]) return 0.0;
         if (rproj>fRmax[ipln] && rproj<fRmax[ipln+1]) return 0.0;
      }   
   }   
         
   Int_t icrossed;
   icrossed = GetPhiCrossList(point,dir,ipsec,sph,iph, stepmax);
   Double_t snext;
   if (TMath::Abs(dir[2])<TGeoShape::Tolerance()) {
      if (SliceCrossingInZ(point, dir, icrossed, iph, sph, snext, stepmax)) return snext;
      if (snext>TGeoShape::Tolerance()) return TGeoShape::Big();
      return 0.;
   }
   if (SliceCrossingIn(point, dir, ipl, icrossed, iph, sph, snext, stepmax)) return snext;
   if (snext>TGeoShape::Tolerance()) return TGeoShape::Big();
   return 0.;
}   

//_____________________________________________________________________________
void TGeoPgon::LocatePhi(const Double_t *point, Int_t &ipsec) const
{
// Locates index IPSEC of the phi sector containing POINT.
   Double_t phi = TMath::ATan2(point[1], point[0])*TMath::RadToDeg();
   while (phi<fPhi1) phi+=360.;
   ipsec = Int_t(fNedges*(phi-fPhi1)/fDphi); // [0, fNedges-1]
   if (ipsec>fNedges-1) ipsec = -1; // in gap
}                    

//_____________________________________________________________________________
Int_t TGeoPgon::GetPhiCrossList(const Double_t *point, const Double_t *dir, Int_t istart, Double_t *sphi, Int_t *iphi, Double_t stepmax) const
{
// Returns lists of PGON phi crossings for a ray starting from POINT.
   Double_t rxy, phi, cph, sph;
   Int_t icrossed = 0;
   if ((1.-TMath::Abs(dir[2]))<1E-8) {
      // ray is going parallel with Z
      iphi[0] = istart;
      sphi[0] = stepmax;
      return 1;
   }   
   Bool_t shootorig = (TMath::Abs(point[0]*dir[1]-point[1]*dir[0])<1E-8)?kTRUE:kFALSE;
   Double_t divphi = fDphi/fNedges;
   if (shootorig) {
      Double_t rdotn = point[0]*dir[0]+point[1]*dir[1];
      if (rdotn>0) {
         sphi[icrossed] = stepmax;
         iphi[icrossed++] = istart;
         return icrossed;
      }
      sphi[icrossed] = TMath::Sqrt((point[0]*point[0]+point[1]*point[1])/(1.-dir[2]*dir[2]));
      iphi[icrossed++] = istart;
      if (sphi[icrossed-1]>stepmax) {
         sphi[icrossed-1] = stepmax;
         return icrossed;
      }   
      phi = TMath::ATan2(dir[1], dir[0])*TMath::RadToDeg();   
      while (phi<fPhi1) phi+=360.;
      istart = Int_t((phi-fPhi1)/divphi);
      if (istart>fNedges-1) istart=-1;
      iphi[icrossed] = istart;
      sphi[icrossed] = stepmax;
      icrossed++;
      return icrossed;
   }   
   Int_t incsec = Int_t(TMath::Sign(1., point[0]*dir[1]-point[1]*dir[0]));
   Int_t ist;
   if (istart<0) ist=(incsec>0)?0:fNedges;
   else          ist=(incsec>0)?(istart+1):istart;
   Bool_t crossing = kTRUE;
   Bool_t gapdone = kFALSE;
   divphi *= TMath::DegToRad();
   Double_t phi1 = fPhi1*TMath::DegToRad();
   while (crossing) { 
      if (istart<0) gapdone = kTRUE;
      phi = phi1+ist*divphi;
      cph = TMath::Cos(phi);
      sph = TMath::Sin(phi);
      crossing = IsCrossingSemiplane(point,dir,cph,sph,sphi[icrossed],rxy);
      if (!crossing) sphi[icrossed] = stepmax;
      iphi[icrossed++] = istart;  
      if (crossing) {
         if (sphi[icrossed-1]>stepmax) {
            sphi[icrossed-1] = stepmax;
            return icrossed;
         }   
         if (istart<0) {
            istart = (incsec>0)?0:(fNedges-1);
         } else {
            istart += incsec;
            if (istart>fNedges-1) istart=(fDphi<360.)?(-1):0;
            else if (istart<0 && TGeoShape::IsSameWithinTolerance(fDphi,360)) istart=fNedges-1;
         }
         if (istart<0) {
            if (gapdone) return icrossed;
            ist=(incsec>0)?0:fNedges;
         } else  {
            ist=(incsec>0)?(istart+1):istart;
         }   
      }
   }      
   return icrossed;
}        

//_____________________________________________________________________________
Bool_t TGeoPgon::SliceCrossingInZ(const Double_t *point, const Double_t *dir, Int_t nphi, Int_t *iphi, Double_t *stepphi, Double_t &snext, Double_t stepmax) const
{
// Performs ray propagation between Z segments.
   snext = 0.;
   if (!nphi) return kFALSE;
   Int_t i;
   Double_t rmin, rmax;
   Double_t apg,bpg;
   Double_t pt[3];
   if (iphi[0]<0 && nphi==1) return kFALSE;
   // Get current Z segment
   Int_t ipl = TMath::BinarySearch(fNz, fZ, point[2]);
   if (ipl<0 || ipl==fNz-1) return kFALSE;
   if (TMath::Abs(point[2]-fZ[ipl])<TGeoShape::Tolerance()) {
      if (ipl<fNz-2 && TGeoShape::IsSameWithinTolerance(fZ[ipl],fZ[ipl+1])) {
         rmin = TMath::Min(fRmin[ipl], fRmin[ipl+1]);
         rmax = TMath::Max(fRmax[ipl], fRmax[ipl+1]);
      } else if (ipl>1 && TGeoShape::IsSameWithinTolerance(fZ[ipl],fZ[ipl-1])) {
         rmin = TMath::Min(fRmin[ipl], fRmin[ipl+1]);
         rmax = TMath::Max(fRmax[ipl], fRmax[ipl+1]);
      } else {
         rmin = fRmin[ipl];
         rmax = fRmax[ipl];
      }
   } else {
      rmin = Rpg(point[2], ipl, kTRUE, apg,bpg);        
      rmax = Rpg(point[2], ipl, kFALSE, apg,bpg);        
   }
   Int_t iphcrt;
   Double_t divphi = TMath::DegToRad()*fDphi/fNedges;
   Double_t rproj, ndot, dist;
   Double_t phi1 = fPhi1*TMath::DegToRad();
   Double_t cosph, sinph;
   Double_t snextphi = 0.;
   Double_t step = 0;
   Double_t phi;
   memcpy(pt,point,3*sizeof(Double_t));
   for (iphcrt=0; iphcrt<nphi; iphcrt++) {
      if (step>stepmax) {
         snext = step;
         return kFALSE;             
      }   
      if (iphi[iphcrt]<0) {
         snext = step;
         return kTRUE;
      }
      // check crossing
      snextphi = stepphi[iphcrt];
      phi = phi1+(iphi[iphcrt]+0.5)*divphi;
      cosph = TMath::Cos(phi);
      sinph = TMath::Sin(phi);
      rproj = pt[0]*cosph+pt[1]*sinph;
      dist = TGeoShape::Big();
      ndot = dir[0]*cosph+dir[1]*sinph;
      if (!TGeoShape::IsSameWithinTolerance(ndot,0)) {
         dist = (ndot>0)?((rmax-rproj)/ndot):((rmin-rproj)/ndot);
         if (dist<0) dist=0.;
      }
      if (dist < (snextphi-step)) {
         snext = step + dist;
         if (snext<stepmax) return kTRUE;
         return kFALSE;
      }            
      step = snextphi;
      for (i=0; i<3; i++) pt[i] = point[i]+step*dir[i];      
   }
   snext = step;
   return kFALSE;            
}
 
//_____________________________________________________________________________
Bool_t TGeoPgon::SliceCrossingZ(const Double_t *point, const Double_t *dir, Int_t nphi, Int_t *iphi, Double_t *stepphi, Double_t &snext, Double_t stepmax) const
{
// Performs ray propagation between Z segments.
   if (!nphi) return kFALSE;
   Int_t i;
   Double_t rmin, rmax;
   Double_t apg,bpg;
   Double_t pt[3];
   if (iphi[0]<0 && nphi==1) return kFALSE;
   // Get current Z segment
   Int_t ipl = TMath::BinarySearch(fNz, fZ, point[2]);
   if (ipl<0 || ipl==fNz-1) return kFALSE;
   if (TMath::Abs(point[2]-fZ[ipl])<TGeoShape::Tolerance()) {
      if (ipl<fNz-2 && TGeoShape::IsSameWithinTolerance(fZ[ipl],fZ[ipl+1])) {
         rmin = TMath::Min(fRmin[ipl], fRmin[ipl+1]);
         rmax = TMath::Max(fRmax[ipl], fRmax[ipl+1]);
      } else if (ipl>1 && TGeoShape::IsSameWithinTolerance(fZ[ipl],fZ[ipl-1])) {
         rmin = TMath::Min(fRmin[ipl], fRmin[ipl+1]);
         rmax = TMath::Max(fRmax[ipl], fRmax[ipl+1]);
      } else {
         rmin = fRmin[ipl];
         rmax = fRmax[ipl];
      }
   } else {
      rmin = Rpg(point[2], ipl, kTRUE, apg,bpg);        
      rmax = Rpg(point[2], ipl, kFALSE, apg,bpg);        
   }
   Int_t iphcrt;
   Double_t divphi = TMath::DegToRad()*fDphi/fNedges;
   Double_t rproj, ndot, dist;
   Double_t phi1 = fPhi1*TMath::DegToRad();
   Double_t cosph, sinph;
   Double_t snextphi = 0.;
   Double_t step = 0;
   Double_t phi;
   memcpy(pt,point,3*sizeof(Double_t));
   for (iphcrt=0; iphcrt<nphi; iphcrt++) {
      if (step>stepmax) return kFALSE;             
      snextphi = stepphi[iphcrt];
      if (iphi[iphcrt]<0) {
         if (iphcrt==nphi-1) return kFALSE;
         if (snextphi>stepmax) return kFALSE;
         for (i=0; i<3; i++) pt[i] = point[i]+snextphi*dir[i];
         phi = phi1+(iphi[iphcrt+1]+0.5)*divphi;
         cosph = TMath::Cos(phi);
         sinph = TMath::Sin(phi);
         rproj = pt[0]*cosph+pt[1]*sinph;
         if (rproj<rmin || rproj>rmax) {
            step = snextphi;
            continue;
         }   
         snext = snextphi;
         return kTRUE;
      }
      // check crossing
      phi = phi1+(iphi[iphcrt]+0.5)*divphi;
      cosph = TMath::Cos(phi);
      sinph = TMath::Sin(phi);
      rproj = pt[0]*cosph+pt[1]*sinph;
      dist = TGeoShape::Big();
      ndot = dir[0]*cosph+dir[1]*sinph;
      if (rproj<rmin) {
         dist = (ndot>0)?((rmin-rproj)/ndot):TGeoShape::Big();
      } else {
         dist = (ndot<0)?((rmax-rproj)/ndot):TGeoShape::Big();
      }    
      if (dist<1E10) {
         snext = step+dist;
         if (snext<stepmax) return kTRUE;
      }        
      step = snextphi;
      for (i=0; i<3; i++) pt[i] = point[i]+step*dir[i];      
   }
   return kFALSE;            
}  

//_____________________________________________________________________________
Bool_t TGeoPgon::SliceCrossingIn(const Double_t *point, const Double_t *dir, Int_t ipl, Int_t nphi, Int_t *iphi, Double_t *stepphi, Double_t &snext, Double_t stepmax) const
{
// Check boundary crossing inside phi slices. Return distance snext to first crossing
// if smaller than stepmax.
// Protection in case point is in phi gap or close to phi boundaries and exiting
   snext = 0.;
   if (!nphi) return kFALSE;
   Int_t i;
   Int_t iphstart = 0;
   Double_t pt[3];
   if (iphi[0]<0) {
      if (stepphi[0]>TGeoShape::Tolerance()) return kFALSE;
      iphstart = 1;
   }   
   if (nphi>1 && iphi[1]<0 && stepphi[0]<TGeoShape::Tolerance()) {
      snext = stepphi[0];
      return kTRUE;
   }   
   // Get current Z segment
   Double_t snextphi = 0.;
   Double_t step = 0;
   Int_t incseg = (dir[2]>0)?1:-1; // dir[2] is never 0 here
   // Compute the projected radius from starting point
   Int_t iplstart = ipl;
   Int_t iphcrt = 0;
   Double_t apr=TGeoShape::Big(), bpr=0, db=0;
   Double_t rpg=0, rnew=0, znew=0;
   Double_t rpgin=0,rpgout=0,apgin=0,apgout=0,bpgin=0,bpgout=0;
   Double_t divphi = TMath::DegToRad()*fDphi/fNedges;
   Double_t phi1 = fPhi1*TMath::DegToRad();
   Double_t phi=0, dz=0;
   Double_t cosph=0, sinph=0;
   Double_t distz=0, distr=0, din=0, dout=0;
   Double_t invdir = 1./dir[2];
   memcpy(pt,point,3*sizeof(Double_t));
   for (iphcrt=iphstart; iphcrt<nphi; iphcrt++) {
      // check if step to current checked slice is too big
      if (step>stepmax) {
         snext = step;
         return kFALSE;
      }
      if (iphi[iphcrt]<0) {
         snext = snextphi;
         return kTRUE;
      }   
      snextphi = stepphi[iphcrt];
      phi = phi1+(iphi[iphcrt]+0.5)*divphi;
      cosph = TMath::Cos(phi);
      sinph = TMath::Sin(phi);
      Double_t rproj = Rproj(pt[2], pt, dir, cosph, sinph, apr, bpr);
      // compute distance to next Z plane
      while (ipl>=0 && ipl<fNz-1) {
         din = dout = TGeoShape::Big();
         // dist to last boundary of current segment according dir
         distz = (fZ[ipl+((1+incseg)>>1)]-pt[2])*invdir;
         // length of current segment
         dz = fZ[ipl+1] - fZ[ipl];
         if (dz < TGeoShape::Tolerance()) {
            rnew = apr+bpr*fZ[ipl];
            rpg = (rnew-fRmin[ipl])*(rnew-fRmin[ipl+1]);
            if (rpg<=0) din=distz;
            rpg = (rnew-fRmax[ipl])*(rnew-fRmax[ipl+1]);
            if (rpg<=0) dout=distz;
            distr = TMath::Min(din, dout);
         } else {
            rpgin = Rpg(pt[2], ipl, kTRUE, apgin, bpgin);
            db = bpgin-bpr;
            if (TMath::Abs(db) > TGeoShape::Tolerance()) {
               znew = (apr-apgin)/db;
               din = (znew-pt[2])*invdir;
            }
            rpgout = Rpg(pt[2], ipl, kFALSE, apgout, bpgout);
            db = bpgout-bpr;
            if (TMath::Abs(db) > TGeoShape::Tolerance()) {
               znew = (apr-apgout)/db;
               dout = (znew-pt[2])*invdir;
            }
            // protection for the first segment            
            Double_t dinp = (din>TMath::Abs(snext-TGeoShape::Tolerance()))?din:TGeoShape::Big();
            Double_t doutp = (dout>TMath::Abs(snext-TGeoShape::Tolerance()))?dout:TGeoShape::Big();
            distr = TMath::Min(dinp, doutp);
            if (iphcrt==iphstart && ipl==iplstart) {
               if (rproj<rpgin+1.E-8) {
                  Double_t ndotd = dir[0]*cosph+dir[1]*sinph+dir[2]*(fRmin[ipl]-fRmin[ipl+1])/dz;
                  if (ndotd<0) {
                     snext = (din<0)?step:(step+din);
                     return kTRUE;
                  } else {
                     // Ignore din
                     din = -TGeoShape::Big();
                  }     
                  distr = TMath::Max(din,dout);
                  if (distr<TGeoShape::Tolerance()) distr=TGeoShape::Big();
               } else if (rproj>rpgout-1.E-8) {
                  Double_t ndotd = dir[0]*cosph+dir[1]*sinph+dir[2]*(fRmax[ipl]-fRmax[ipl+1])/dz;
                  if (ndotd>0) {
                     snext = (dout<0)?step:(step+dout);
                     return kTRUE;
                  } else {
                     // Ignore dout
                     dout = -TGeoShape::Big();
                  }   
                  distr = TMath::Max(din,dout);    
                  if (distr<TGeoShape::Tolerance()) distr=TGeoShape::Big();
               }  
            }
         } 
         if (distr<snext-TGeoShape::Tolerance()) distr=TGeoShape::Big();
         if (snextphi < step+TMath::Min(distz,distr)) {
            for (i=0; i<3; i++) pt[i] = point[i] + snextphi*dir[i];
            step = snextphi;
            snext = 0.0;
            break;
         }   
         if (distr<=distz+TGeoShape::Tolerance()) {
            step += distr;
            snext = step;
            return (step>stepmax)?kFALSE:kTRUE;
         }
         // we have crossed a Z boundary
         snext = distz;
         if ((ipl+incseg<0) || (ipl+incseg>fNz-2)) {
            // it was the last boundary
            step += distz;
            snext = step;
            return (step>stepmax)?kFALSE:kTRUE;
         } 
         ipl += incseg;
      }   // end loop Z
   }   // end loop phi
   snext = TGeoShape::Big();
   return kFALSE;
}   
               
//_____________________________________________________________________________
Bool_t TGeoPgon::SliceCrossing(const Double_t *point, const Double_t *dir, Int_t nphi, Int_t *iphi, Double_t *stepphi, Double_t &snext, Double_t stepmax) const
{
// Check boundary crossing inside phi slices. Return distance snext to first crossing
// if smaller than stepmax.
   if (!nphi) return kFALSE;
   Int_t i;
   Double_t pt[3];
   if (iphi[0]<0 && nphi==1) return kFALSE;
         
   Double_t snextphi = 0.;
   Double_t step = 0;
   // Get current Z segment
   Int_t incseg = (dir[2]>0)?1:-1; // dir[2] is never 0 here
   Int_t ipl = TMath::BinarySearch(fNz, fZ, point[2]);
   if (ipl<0) {
      ipl = 0; // this should never happen
      if (incseg<0) return kFALSE;
   } else {
      if (ipl==fNz-1) {
         ipl = fNz-2;  // nor this
         if (incseg>0) return kFALSE;
      } else {
         if (TMath::Abs(point[2]-fZ[ipl])<TGeoShape::Tolerance()) {
         // we are at the sector edge, but never inside the pgon
            if ((ipl+incseg)<0 || (ipl+incseg)>fNz-1) return kFALSE;
            if (TGeoShape::IsSameWithinTolerance(fZ[ipl],fZ[ipl+incseg])) ipl += incseg;
            // move to next clean segment if downwards
            if (incseg<0) {
               if (TGeoShape::IsSameWithinTolerance(fZ[ipl],fZ[ipl+1])) ipl--;
            }   
         }
      }
   }         
   // Compute the projected radius from starting point
   Int_t iphcrt;
   Double_t apg,bpg;
   Double_t rpgin;
   Double_t rpgout;
   Double_t divphi = TMath::DegToRad()*fDphi/fNedges;
   Double_t phi1 = fPhi1*TMath::DegToRad();
   Double_t phi;
   Double_t cosph, sinph;
   Double_t rproj;
   memcpy(pt,point,3*sizeof(Double_t));
   for (iphcrt=0; iphcrt<nphi; iphcrt++) {
      // check if step to current checked slice is too big
      if (step>stepmax) return kFALSE;
      // jump over the dead sector
      snextphi = stepphi[iphcrt];
      if (iphi[iphcrt]<0) {
         if (iphcrt==nphi-1) return kFALSE;
         if (snextphi>stepmax) return kFALSE;
         for (i=0; i<3; i++) pt[i] = point[i]+snextphi*dir[i];
         // we have a new z, so check again iz
         if (incseg>0) {
            // loop z planes
            while (pt[2]>fZ[ipl+1]) {
               ipl++;
               if (ipl>fNz-2) return kFALSE;
            }
         } else {
            while (pt[2]<fZ[ipl]) {
               ipl--;
               if (ipl<0) return kFALSE;
            }
         }      
         // check if we have a crossing when entering new sector
         rpgin = Rpg(pt[2],ipl,kTRUE,apg,bpg);
         rpgout = Rpg(pt[2],ipl,kFALSE,apg,bpg);
         phi = phi1+(iphi[iphcrt+1]+0.5)*divphi;
         cosph = TMath::Cos(phi);
         sinph = TMath::Sin(phi);
         
         rproj = pt[0]*cosph+pt[1]*sinph;
         if (rproj<rpgin || rproj>rpgout) {
            step = snextphi;
            continue;
         }   
         snext = snextphi;
         return kTRUE;
      } 
      if (IsCrossingSlice(point, dir, iphi[iphcrt], step, ipl, snext, TMath::Min(snextphi, stepmax)))
         return kTRUE;
      step = snextphi;   
   }                  
   return kFALSE;
}
//_____________________________________________________________________________
Bool_t TGeoPgon::IsCrossingSlice(const Double_t *point, const Double_t *dir, Int_t iphi, Double_t sstart, Int_t &ipl, Double_t &snext, Double_t stepmax) const
{
// Check crossing of a given pgon slice, from a starting point inside the slice
   if (ipl<0 || ipl>fNz-2) return kFALSE;
   if (sstart>stepmax) return kFALSE;
   Double_t pt[3];
   memcpy(pt, point, 3*sizeof(Double_t));
   if (sstart>0) for (Int_t i=0; i<3; i++) pt[i] += sstart*dir[i];
   stepmax -= sstart;
   Double_t step;
   Int_t incseg = (dir[2]>0)?1:-1;
   Double_t invdir = 1./dir[2];
   Double_t divphi = TMath::DegToRad()*fDphi/fNedges;
   Double_t phi = fPhi1*TMath::DegToRad() + (iphi+0.5)*divphi;
   Double_t cphi = TMath::Cos(phi);
   Double_t sphi = TMath::Sin(phi);
   Double_t apr = TGeoShape::Big();
   Double_t bpr = 0.;
   Rproj(pt[2], point, dir, cphi, sphi, apr, bpr);
   Double_t dz;
   // loop segments
   Int_t icrtseg = ipl;
   Int_t isegstart = ipl;
   Int_t iseglast = (incseg>0)?(fNz-1):-1;
   Double_t din,dout,rdot,rnew,rpg,apg,bpg,db,znew;
   
   for (ipl=isegstart; ipl!=iseglast; ipl+=incseg) {
      step = (fZ[ipl+1-((1+incseg)>>1)]-pt[2])*invdir;
      if (step>0) {
         if (step>stepmax) {
            ipl = icrtseg;
            return kFALSE;
         }
         icrtseg = ipl;
      }      
      din = dout = TGeoShape::Big();
      dz = fZ[ipl+1]-fZ[ipl];
      
//      rdot = (rproj-fRmin[ipl])*dz - (pt[2]-fZ[ipl])*(fRmin[ipl+1]-fRmin[ipl]);
      if (TGeoShape::IsSameWithinTolerance(dz,0)) rdot = dir[2]*TMath::Sign(1.,fRmin[ipl]-fRmin[ipl+1]);
      else rdot = dir[0]*cphi+dir[1]*sphi+dir[2]*(fRmin[ipl]-fRmin[ipl+1])/dz;
      if (rdot>0) {
         // inner surface visible ->check crossing
//         printf("   inner visible\n");
         if (TGeoShape::IsSameWithinTolerance(dz,0)) {
            rnew = apr+bpr*fZ[ipl];
            rpg = (rnew-fRmin[ipl])*(rnew-fRmin[ipl+1]);
            if (rpg<=0) din=(fZ[ipl]-pt[2])*invdir;
         } else {
            rpg = Rpg(pt[2], ipl, kTRUE, apg, bpg);
            db = bpg-bpr;
            if (!TGeoShape::IsSameWithinTolerance(db,0)) {
               znew = (apr-apg)/db;
               if (znew>fZ[ipl] && znew<fZ[ipl+1]) {
                  din=(znew-pt[2])*invdir;
                  if (din<0) din=TGeoShape::Big();
               }   
            }
         }
      }
//      printf("   din=%f\n", din);
//      rdot = (rproj-fRmax[ipl])*dz - (pt[2]-fZ[ipl])*(fRmax[ipl+1]-fRmax[ipl]);        
      if (TGeoShape::IsSameWithinTolerance(dz,0)) rdot = dir[2]*TMath::Sign(1.,fRmax[ipl]-fRmax[ipl+1]);
      else rdot = dir[0]*cphi+dir[1]*sphi+dir[2]*(fRmax[ipl]-fRmax[ipl+1])/dz;
      if (rdot<0) {
//         printf("   outer visible\n");
         // outer surface visible ->check crossing
         if (TGeoShape::IsSameWithinTolerance(dz,0)) {
            rnew = apr+bpr*fZ[ipl];
            rpg = (rnew-fRmax[ipl])*(rnew-fRmax[ipl+1]);
            if (rpg<=0) dout=(fZ[ipl]-pt[2])*invdir;
         } else {
            rpg = Rpg(pt[2], ipl, kFALSE, apg, bpg);
            db = bpg-bpr;
            if (!TGeoShape::IsSameWithinTolerance(db,0)) {
               znew = (apr-apg)/db;
               if (znew>fZ[ipl] && znew<fZ[ipl+1]) dout=(znew-pt[2])*invdir;
               if (dout<0) dout=TGeoShape::Big();
            }
         }
      }
//      printf("   dout=%f\n", dout);
      step = TMath::Min(din, dout);
      if (step<1E10) {
         // there is a crossing within this segment
         if (step>stepmax) {
            ipl = icrtseg;
            return kFALSE;
         }   
         snext = sstart+step;
         return kTRUE;
      }   
   }
   ipl = icrtseg;
   return kFALSE;
}           

//_____________________________________________________________________________
Double_t TGeoPgon::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 polygone
   if (iact<3 && safe) {
      *safe = Safety(point, kFALSE);
      if (iact==0) return TGeoShape::Big();               // just safety computed
      if (iact==1 && step<*safe) return TGeoShape::Big(); // safety mode
   }   
// 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();
   // Protection for points on last Z sections
   if (dir[2]<=0 && TMath::Abs(point[2]-fZ[0])<TGeoShape::Tolerance()) return TGeoShape::Big();
   if (dir[2]>=0 && TMath::Abs(point[2]-fZ[fNz-1])<TGeoShape::Tolerance()) return TGeoShape::Big();
   // copy the current point
   Double_t pt[3];
   memcpy(pt,point,3*sizeof(Double_t));
   // find current Z section
   Int_t ipl;
   Int_t i, ipsec;
   ipl = TMath::BinarySearch(fNz, fZ, pt[2]);

   Double_t divphi=fDphi/fNedges;
   // check if ray may intersect outer cylinder
   Double_t snext = 0.;
   Double_t stepmax = step;
   Double_t rpr, snewcross;
   Double_t r2 = pt[0]*pt[0]+pt[1]*pt[1];
   Double_t radmax = fRmax[TMath::LocMax(fNz, fRmax)];
   radmax = radmax/TMath::Cos(0.5*divphi*TMath::DegToRad());
   radmax += 1E-8;
   if (r2>(radmax*radmax) || pt[2]<fZ[0] || pt[2]>fZ[fNz-1]) {
      pt[2] -= 0.5*(fZ[0]+fZ[fNz-1]);
      snext = TGeoTube::DistFromOutsideS(pt,dir,0.,radmax,0.5*(fZ[fNz-1]-fZ[0]));
      if (snext>1E10) return TGeoShape::Big();
      if (snext>stepmax) return TGeoShape::Big();
      stepmax -= snext;
      pt[2] = point[2];
      for (i=0; i<3; i++) pt[i] += snext*dir[i];
      Bool_t checkz = (ipl<0 && TMath::Abs(pt[2]-fZ[0])<1E-8)?kTRUE:kFALSE;
      if (!checkz) checkz = (ipl==fNz-1 && TMath::Abs(pt[2]-fZ[fNz-1])<1E-8)?kTRUE:kFALSE;
      if (checkz) {
         Double_t rmin,rmax;
         if (ipl<0) {
            rmin = fRmin[0];
            rmax = fRmax[0];
         } else {
            rmin = fRmin[fNz-1];
            rmax = fRmax[fNz-1];
         }      
         Double_t phi = TMath::ATan2(pt[1], pt[0])*TMath::RadToDeg();
         while (phi < fPhi1) phi += 360.0;
         Double_t ddp = phi-fPhi1;
         if (ddp<=fDphi) {
            ipsec = Int_t(ddp/divphi);
            Double_t ph0 = (fPhi1+divphi*(ipsec+0.5))*TMath::DegToRad();
            rpr = pt[0]*TMath::Cos(ph0) + pt[1]*TMath::Sin(ph0);
            if (rpr>=rmin && rpr<=rmax) return snext;
         }   
      }   
   }   
   if (!fThreadSize) ((TGeoPgon*)this)->CreateThreadData(1);
   ThreadData_t& td = GetThreadData();
   Double_t *sph = td.fDblBuffer;
   Int_t *iph = td.fIntBuffer;
   Int_t icrossed;
   // locate current phi sector [0,fNedges-1]; -1 for dead region
   // if ray is perpendicular to Z, solve this particular case
   if (TMath::Abs(dir[2])<TGeoShape::Tolerance()) {
      LocatePhi(pt, ipsec);
      icrossed = GetPhiCrossList(pt,dir,ipsec,sph,iph, stepmax);
      if (SliceCrossingZ(pt, dir, icrossed, iph, sph, snewcross, stepmax)) return (snext+snewcross);
      return TGeoShape::Big();
   }
   // Locate phi and get the phi crossing list
   divphi *= TMath::DegToRad();
   Bool_t inphi = kTRUE;
   Double_t ph = TMath::ATan2(pt[1], pt[0])*TMath::RadToDeg();
   while (ph<fPhi1) ph+=360.;
   ipsec = Int_t(fNedges*(ph-fPhi1)/fDphi); // [0, fNedges-1]
   if (ipsec>fNedges-1) ipsec = -1; // in gap
   Double_t phim = fPhi1+0.5*fDphi;
   Double_t ddp = TMath::Abs(ph-phim);
   if (fDphi<360.0) {
      inphi = (ddp<0.5*fDphi+TGeoShape::Tolerance())?kTRUE:kFALSE;
   } 
   ipl = TMath::BinarySearch(fNz, fZ, pt[2]);
   if (ipl<0) ipl=0;
   if (ipl==fNz-1) ipl--;
   Bool_t inz = kTRUE;
   if (pt[2]>fZ[fNz-1]+TGeoShape::Tolerance()) inz=kFALSE;  
   if (pt[2]<fZ[0]-TGeoShape::Tolerance()) inz=kFALSE;  
   Bool_t onphi = kFALSE;
   if (inphi && inz) {
      Bool_t done = kFALSE;
      Double_t dz = fZ[ipl+1]-fZ[ipl];
      Double_t phi = fPhi1*TMath::DegToRad() + (ipsec+0.5)*divphi;
      Double_t cphi = TMath::Cos(phi);
      Double_t sphi = TMath::Sin(phi);
      Double_t rproj = pt[0]*cphi+pt[1]*sphi;
      if (TGeoShape::IsSameWithinTolerance(dz,0)) {
         if (rproj<fRmin[ipl] && rproj>fRmin[ipl+1] && dir[2]>0) return 0.0;
         if (rproj>fRmin[ipl] && rproj<fRmin[ipl+1] && dir[2]<0) return 0.0;
         if (rproj>fRmax[ipl] && rproj<fRmax[ipl+1] && dir[2]>0) return 0.0;
         if (rproj<fRmax[ipl] && rproj>fRmax[ipl+1] && dir[2]<0) return 0.0;
         done = kTRUE;
      }
      if (!done) {
         Double_t apgout,bpgout;
         Double_t rpgout = Rpg(pt[2], ipl, kFALSE, apgout, bpgout);
         if (rproj<rpgout+1.E-8) {
            Double_t apgin,bpgin;
            Double_t rpgin = Rpg(pt[2], ipl, kTRUE, apgin, bpgin);
            if (rproj>rpgin-1.E-8) {
               Double_t safrmin = rproj-rpgin;
               Double_t safrmax = rpgout-rproj;
               Double_t safz = TMath::Min(pt[2]-fZ[ipl],fZ[ipl+1]-pt[2]);
               Double_t safphi = TGeoShape::Big();
               if (fDphi<360) {
                  safphi=rproj*TMath::Sin((ddp-0.5*fDphi)*TMath::DegToRad());
                  safphi = TMath::Abs(safphi);
               }   
//               printf("inside pgon: safrmin=%f, safrmax=%f, safphi=%f, safz=%f\n",safrmin,safrmax,safphi,safz);
               Double_t dzinv = 1./dz;
               if (safrmin<safz && safrmin<safrmax && safrmin<safphi) {
                  // on inner boundary
                  Double_t ndotd = dir[0]*cphi+dir[1]*sphi+dir[2]*(fRmin[ipl]-fRmin[ipl+1])*dzinv;
//                  printf("   - inner ndotd=%f (>0 ->0)\n",ndotd);
                  if (ndotd>0) return snext;
                  done = kTRUE;
               }   
               if (!done && safrmax<safz && safrmax<safphi) {
                  Double_t ndotd = dir[0]*cphi+dir[1]*sphi+dir[2]*(fRmax[ipl]-fRmax[ipl+1])*dzinv;
//                  printf("   - outer ndotd=%f (<0 ->0)\n",ndotd);
                  if (ndotd<0) return snext;
                  done = kTRUE;
               }
               if (!done && safz<safphi) {
                  done = kTRUE;
                  Int_t iplc = ipl;
                  if (TMath::Abs(pt[2]-fZ[ipl]) > TMath::Abs(fZ[ipl+1]-pt[2])) iplc++;   
                  if (iplc==0 || iplc==fNz-1) {                                    
                     if (pt[2]*dir[2]<0) return snext;
                     return TGeoShape::Big();
                  } else {
                     if (TGeoShape::IsSameWithinTolerance(fZ[iplc],fZ[iplc+1])) {
                        if (dir[2]>0) {
                           if (rproj<fRmin[iplc] && rproj>fRmin[iplc+1]) return snext;
                           if (rproj>fRmax[iplc] && rproj<fRmax[iplc+1]) return snext;
                        } else {
                           if (rproj>fRmin[iplc] && rproj<fRmin[iplc+1]) return snext;
                           if (rproj<fRmax[iplc] && rproj>fRmax[iplc+1]) return snext;
                        }   
                     } else if (TGeoShape::IsSameWithinTolerance(fZ[iplc],fZ[iplc-1])) {
                        if (dir[2]>0) {
                           if (rproj<fRmin[iplc-1] && rproj>fRmin[iplc]) return snext;
                           if (rproj>fRmax[iplc-1] && rproj<fRmax[iplc]) return snext;
                        } else {
                           if (rproj>fRmin[iplc-1] && rproj<fRmin[iplc]) return snext;
                           if (rproj<fRmax[iplc-1] && rproj>fRmax[iplc]) return snext;
                        }                        
                     }
                  }   
               }
               if (!done) {
                  // point on phi boundary
                  onphi = kTRUE;
               }
            }               
         }
      }     
   }
   icrossed = GetPhiCrossList(pt,dir,ipsec,sph,iph, stepmax);
   if (onphi) {
      if (!icrossed) return snext;
      if (iph[0]<0 && sph[0]<TGeoShape::Tolerance()) return (snext+sph[0]);
      if (iph[0]>=0 && sph[0]>1.E-8) return snext;
   }
   // Fire-up slice crossing algorithm
   if (SliceCrossing(pt, dir, icrossed, iph, sph, snewcross, stepmax)) {
      snext += snewcross;
      return snext;
   }   
   return TGeoShape::Big();   
}          

//_____________________________________________________________________________
Int_t TGeoPgon::DistancetoPrimitive(Int_t px, Int_t py)
{
// compute closest distance from point px,py to each corner
   Int_t n = fNedges+1;
   const Int_t numPoints = 2*n*fNz;
   return ShapeDistancetoPrimitive(numPoints, px, py);
}

//_____________________________________________________________________________
TGeoVolume *TGeoPgon::Divide(TGeoVolume *voldiv, const char *divname, Int_t iaxis, Int_t ndiv, 
                             Double_t start, Double_t step) 
{
//--- Divide this polygone shape belonging to volume "voldiv" into ndiv volumes
// called divname, from start position with the given step. Returns pointer
// to created division cell volume in case of Z divisions. Phi divisions are
// allowed only if nedges%ndiv=0 and create polygone "segments" with nedges/ndiv edges.
// Z divisions can be performed if the divided range is in between two consecutive Z planes.
// In case a wrong division axis is supplied, returns pointer to volume that was divided.

//   printf("Dividing %s : nz=%d nedges=%d phi1=%g dphi=%g (ndiv=%d iaxis=%d start=%g step=%g)\n",
//          voldiv->GetName(), fNz, fNedges, fPhi1, fDphi, ndiv, iaxis, start, step);
   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
   Int_t nedges = fNedges;
   Double_t zmin = start;
   Double_t zmax = start+ndiv*step;            
   Int_t isect = -1;
   Int_t is, id, ipl;
   switch (iaxis) {
      case 1:  //---                R division
         Error("Divide", "makes no sense dividing a pgon on radius");
         return 0;
      case 2:  //---                Phi division
         if (fNedges%ndiv) {
            Error("Divide", "ndiv should divide number of pgon edges");
            return 0;
         }
         nedges = fNedges/ndiv;
         finder = new TGeoPatternCylPhi(voldiv, ndiv, start, start+ndiv*step);
         vmulti = gGeoManager->MakeVolumeMulti(divname, voldiv->GetMedium());
         voldiv->SetFinder(finder);
         finder->SetDivIndex(voldiv->GetNdaughters());            
         shape = new TGeoPgon(-step/2, step, nedges, fNz);
         vol = new TGeoVolume(divname, shape, voldiv->GetMedium());
         vmulti->AddVolume(vol);
         for (is=0; is<fNz; is++)
            ((TGeoPgon*)shape)->DefineSection(is, fZ[is], fRmin[is], fRmax[is]); 
         opt = "Phi";
         for (id=0; id<ndiv; id++) {
            voldiv->AddNodeOffset(vol, id, start+id*step+step/2, opt.Data());
            ((TGeoNodeOffset*)voldiv->GetNodes()->At(voldiv->GetNdaughters()-1))->SetFinder(finder);
         }
         return vmulti;
      case 3: // ---                Z division
         // find start plane
         for (ipl=0; ipl<fNz-1; ipl++) {
            if (start<fZ[ipl]) continue;
            else {
               if ((start+ndiv*step)>fZ[ipl+1]) continue;
            }
            isect = ipl;
            zmin = fZ[isect];
            zmax = fZ[isect+1];
            break;
         }
         if (isect<0) {
            Error("Divide", "cannot divide pcon on Z if divided region is not between 2 consecutive planes");
            return 0;
         }
         finder = new TGeoPatternZ(voldiv, ndiv, start, start+ndiv*step);
         vmulti = gGeoManager->MakeVolumeMulti(divname, voldiv->GetMedium());
         voldiv->SetFinder(finder);
         finder->SetDivIndex(voldiv->GetNdaughters());
         opt = "Z";
         for (id=0; id<ndiv; id++) {
            Double_t z1 = start+id*step;
            Double_t z2 = start+(id+1)*step;
            Double_t rmin1 = (fRmin[isect]*(zmax-z1)-fRmin[isect+1]*(zmin-z1))/(zmax-zmin);
            Double_t rmax1 = (fRmax[isect]*(zmax-z1)-fRmax[isect+1]*(zmin-z1))/(zmax-zmin);
            Double_t rmin2 = (fRmin[isect]*(zmax-z2)-fRmin[isect+1]*(zmin-z2))/(zmax-zmin);
            Double_t rmax2 = (fRmax[isect]*(zmax-z2)-fRmax[isect+1]*(zmin-z2))/(zmax-zmin);
            shape = new TGeoPgon(fPhi1, fDphi, nedges, 2); 
            ((TGeoPgon*)shape)->DefineSection(0, -step/2, rmin1, rmax1); 
            ((TGeoPgon*)shape)->DefineSection(1,  step/2, rmin2, rmax2); 
            vol = new TGeoVolume(divname, shape, voldiv->GetMedium());
            vmulti->AddVolume(vol);
            voldiv->AddNodeOffset(vol, id, start+id*step+step/2, opt.Data());
            ((TGeoNodeOffset*)voldiv->GetNodes()->At(voldiv->GetNdaughters()-1))->SetFinder(finder);
         }
         return vmulti;
      default:
         Error("Divide", "Wrong axis type for division");
         return 0;            
   }
}

//_____________________________________________________________________________
void TGeoPgon::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] = fRmin[0];           // Rmin
   param[1] = fRmax[0];           // Rmax
   for (Int_t i=1; i<fNz; i++) {
      if (fRmin[i] < param[0]) param[0] = fRmin[i];
      if (fRmax[i] > param[1]) param[1] = fRmax[i];
   }
   Double_t divphi = fDphi/fNedges;
   param[1] /= TMath::Cos(0.5*divphi*TMath::DegToRad());
   param[0] *= param[0];
   param[1] *= param[1];
   if (TGeoShape::IsSameWithinTolerance(fDphi,360)) {
      param[2] = 0.;
      param[3] = 360.;
      return;
   }   
   param[2] = (fPhi1<0)?(fPhi1+360.):fPhi1;     // Phi1
   param[3] = param[2]+fDphi;                   // Phi2
}   

//_____________________________________________________________________________
void TGeoPgon::InspectShape() const
{
// Inspect the PGON parameters.
   printf("*** Shape %s: TGeoPgon ***\n", GetName());
   printf("    Nedges = %i\n", fNedges);
   TGeoPcon::InspectShape();
}

//_____________________________________________________________________________
TBuffer3D *TGeoPgon::MakeBuffer3D() const
{
   // Creates a TBuffer3D describing *this* shape.
   // Coordinates are in local reference frame.

   const Int_t n = GetNsegments()+1;
   Int_t nz = GetNz();
   if (nz < 2) return 0;
   Int_t nbPnts = nz*2*n;
   if (nbPnts <= 0) return 0;
   Double_t dphi = GetDphi();
   Bool_t specialCase = kFALSE;
   if (TGeoShape::IsSameWithinTolerance(dphi,360)) specialCase = kTRUE;
   Int_t nbSegs = 4*(nz*n-1+(specialCase == kTRUE));
   Int_t nbPols = 2*(nz*n-1+(specialCase == kTRUE));

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

   return buff;
}

//_____________________________________________________________________________
void TGeoPgon::SetSegsAndPols(TBuffer3D &buff) const
{
// Fill TBuffer3D structure for segments and polygons.
   Int_t i, j;
   const Int_t n = GetNsegments()+1;
   Int_t nz = GetNz();
   if (nz < 2) return;
   Int_t nbPnts = nz*2*n;
   if (nbPnts <= 0) return;
   Double_t dphi = GetDphi();
   Bool_t specialCase = kFALSE;
   if (TGeoShape::IsSameWithinTolerance(dphi,360)) specialCase = kTRUE;
   Int_t c = GetBasicColor();

   Int_t indx, indx2, k;
   indx = indx2 = 0;

   //inside & outside circles, number of segments: 2*nz*(n-1)
   //             special case number of segments: 2*nz*n
   for (i = 0; i < nz*2; i++) {
      indx2 = i*n;
      for (j = 1; j < n; j++) {
         buff.fSegs[indx++] = c;
         buff.fSegs[indx++] = indx2+j-1;
         buff.fSegs[indx++] = indx2+j;
      }
      if (specialCase) {
         buff.fSegs[indx++] = c;
         buff.fSegs[indx++] = indx2+j-1;
         buff.fSegs[indx++] = indx2;
      }
   }

   //bottom & top lines, number of segments: 2*n
   for (i = 0; i < 2; i++) {
      indx2 = i*(nz-1)*2*n;
      for (j = 0; j < n; j++) {
         buff.fSegs[indx++] = c;
         buff.fSegs[indx++] = indx2+j;
         buff.fSegs[indx++] = indx2+n+j;
      }
   }

   //inside & outside cylinders, number of segments: 2*(nz-1)*n
   for (i = 0; i < (nz-1); i++) {
      //inside cylinder
      indx2 = i*n*2;
      for (j = 0; j < n; j++) {
         buff.fSegs[indx++] = c+2;
         buff.fSegs[indx++] = indx2+j;
         buff.fSegs[indx++] = indx2+n*2+j;
      }
      //outside cylinder
      indx2 = i*n*2+n;
      for (j = 0; j < n; j++) {
         buff.fSegs[indx++] = c+3;
         buff.fSegs[indx++] = indx2+j;
         buff.fSegs[indx++] = indx2+n*2+j;
      }
   }

   //left & right sections, number of segments: 2*(nz-2)
   //          special case number of segments: 0
   if (!specialCase) {
      for (i = 1; i < (nz-1); i++) {
         for (j = 0; j < 2; j++) {
            buff.fSegs[indx++] = c;
            buff.fSegs[indx++] =  2*i    * n + j*(n-1);
            buff.fSegs[indx++] = (2*i+1) * n + j*(n-1);
         }
      }
   }

   Int_t m = n - 1 + (specialCase == kTRUE);
   indx = 0;

   //bottom & top, number of polygons: 2*(n-1)
   // special case number of polygons: 2*n
   i = 0;
   for (j = 0; j < n-1; j++) {
      buff.fPols[indx++] = c+3;
      buff.fPols[indx++] = 4;
      buff.fPols[indx++] = 2*nz*m+i*n+j;
      buff.fPols[indx++] = i*(nz*2-2)*m+m+j;
      buff.fPols[indx++] = 2*nz*m+i*n+j+1;
      buff.fPols[indx++] = i*(nz*2-2)*m+j;
   }
   if (specialCase) {
      buff.fPols[indx++] = c+3;
      buff.fPols[indx++] = 4;
      buff.fPols[indx++] = 2*nz*m+i*n+j;
      buff.fPols[indx++] = i*(nz*2-2)*m+m+j;
      buff.fPols[indx++] = 2*nz*m+i*n;
      buff.fPols[indx++] = i*(nz*2-2)*m+j;
   }
   i = 1;
   for (j = 0; j < n-1; j++) {
      buff.fPols[indx++] = c+3;
      buff.fPols[indx++] = 4;
      buff.fPols[indx++] = i*(nz*2-2)*m+j;
      buff.fPols[indx++] = 2*nz*m+i*n+j+1;
      buff.fPols[indx++] = i*(nz*2-2)*m+m+j;
      buff.fPols[indx++] = 2*nz*m+i*n+j;
   }
   if (specialCase) {
      buff.fPols[indx++] = c+3;
      buff.fPols[indx++] = 4;
      buff.fPols[indx++] = i*(nz*2-2)*m+j;
      buff.fPols[indx++] = 2*nz*m+i*n;
      buff.fPols[indx++] = i*(nz*2-2)*m+m+j;
      buff.fPols[indx++] = 2*nz*m+i*n+j;
   }

   //inside & outside, number of polygons: (nz-1)*2*(n-1)
   for (k = 0; k < (nz-1); k++) {
      i = 0;
         for (j = 0; j < n-1; j++) {
            buff.fPols[indx++] = c+i;
            buff.fPols[indx++] = 4;
            buff.fPols[indx++] = nz*2*m+(2*k+i*1+2)*n+j+1;
            buff.fPols[indx++] = (2*k+i*1+2)*m+j;
            buff.fPols[indx++] = nz*2*m+(2*k+i*1+2)*n+j;
            buff.fPols[indx++] = (2*k+i*1)*m+j;
         }
         if (specialCase) {
            buff.fPols[indx++] = c+i;
            buff.fPols[indx++] = 4;
            buff.fPols[indx++] = nz*2*m+(2*k+i*1+2)*n;
            buff.fPols[indx++] = (2*k+i*1+2)*m+j;
            buff.fPols[indx++] = nz*2*m+(2*k+i*1+2)*n+j;
            buff.fPols[indx++] = (2*k+i*1)*m+j;
         }
      i = 1;
         for (j = 0; j < n-1; j++) {
            buff.fPols[indx++] = c+i;
            buff.fPols[indx++] = 4;
            buff.fPols[indx++] = (2*k+i*1)*m+j;
            buff.fPols[indx++] = nz*2*m+(2*k+i*1+2)*n+j;
            buff.fPols[indx++] = (2*k+i*1+2)*m+j;
            buff.fPols[indx++] = nz*2*m+(2*k+i*1+2)*n+j+1;
         }
         if (specialCase) {
            buff.fPols[indx++] = c+i;
            buff.fPols[indx++] = 4;
            buff.fPols[indx++] = (2*k+i*1)*m+j;
            buff.fPols[indx++] = nz*2*m+(2*k+i*1+2)*n+j;
            buff.fPols[indx++] = (2*k+i*1+2)*m+j;
            buff.fPols[indx++] = nz*2*m+(2*k+i*1+2)*n;
         }
   }

   //left & right sections, number of polygons: 2*(nz-1)
   //          special case number of polygons: 0
   if (!specialCase) {
      indx2 = nz*2*(n-1);
      for (k = 0; k < (nz-1); k++) {
         buff.fPols[indx++] = c+2;
         buff.fPols[indx++] = 4;
         buff.fPols[indx++] = k==0 ? indx2 : indx2+2*nz*n+2*(k-1);
         buff.fPols[indx++] = indx2+2*(k+1)*n;
         buff.fPols[indx++] = indx2+2*nz*n+2*k;
         buff.fPols[indx++] = indx2+(2*k+3)*n;
            
         buff.fPols[indx++] = c+2;
         buff.fPols[indx++] = 4;
         buff.fPols[indx++] = k==0 ? indx2+n-1 : indx2+2*nz*n+2*(k-1)+1;//a
         buff.fPols[indx++] = indx2+(2*k+3)*n+n-1;//d
         buff.fPols[indx++] = indx2+2*nz*n+2*k+1;//c
         buff.fPols[indx++] = indx2+2*(k+1)*n+n-1;//b
      }
      buff.fPols[indx-8] = indx2+n;
      buff.fPols[indx-2] = indx2+2*n-1;
   }
}

//_____________________________________________________________________________
Double_t TGeoPgon::Rpg(Double_t z, Int_t ipl, Bool_t inner, Double_t &a, Double_t &b) const
{
// Computes projected pgon radius (inner or outer) corresponding to a given Z
// value. Fills corresponding coefficients of:
//   Rpg(z) = a + b*z
// Note: ipl must be in range [0,fNz-2]
   Double_t rpg;
   if (ipl<0 || ipl>fNz-2) {
      Fatal("Rpg", "Plane index parameter ipl=%i out of range\n", ipl);
      return 0;
   }   
   Double_t dz = fZ[ipl+1] - fZ[ipl];
   if (dz<TGeoShape::Tolerance()) {
      // radius-changing region
      rpg = (inner)?TMath::Min(fRmin[ipl],fRmin[ipl+1]):TMath::Max(fRmax[ipl],fRmax[ipl+1]);
      a = rpg;
      b = 0.;
      return rpg;
   }   
   Double_t r1=0, r2=0;
   if (inner) {
      r1 = fRmin[ipl];
      r2 = fRmin[ipl+1];
   } else {
      r1 = fRmax[ipl];
      r2 = fRmax[ipl+1];
   }
   Double_t dzinv = 1./dz;
   a = (r1*fZ[ipl+1]-r2*fZ[ipl])*dzinv;
   b = (r2-r1)*dzinv;
   return (a+b*z);
}         

//_____________________________________________________________________________
Double_t TGeoPgon::Rproj(Double_t z, const Double_t *point, const Double_t *dir, Double_t cphi, Double_t sphi, Double_t &a, Double_t &b) const
{
// Computes projected distance at a given Z for a given ray inside a given sector 
// and fills coefficients:
//   Rproj = a + b*z
   if (TMath::Abs(dir[2])<TGeoShape::Tolerance()) {
      a =  b = TGeoShape::Big();
      return TGeoShape::Big();
   }
   Double_t invdirz = 1./dir[2];
   a = ((point[0]*dir[2]-point[2]*dir[0])*cphi+(point[1]*dir[2]-point[2]*dir[1])*sphi)*invdirz;
   b = (dir[0]*cphi+dir[1]*sphi)*invdirz;
   return (a+b*z);   
}   

//_____________________________________________________________________________
Double_t TGeoPgon::SafetyToSegment(const Double_t *point, Int_t ipl, Int_t iphi, Bool_t in, Double_t safphi, Double_t safmin) const
{
// Compute safety from POINT to segment between planes ipl, ipl+1 within safmin.
   Double_t saf[3];
   Double_t safe;
   Int_t i;
   Double_t r,rpgon, ta, calf;
   if (ipl<0 || ipl>fNz-2) return (safmin+1.); // error in input plane
// Get info about segment.
   Double_t dz = fZ[ipl+1]-fZ[ipl];
   if (dz<1E-9) return 1E9; // skip radius-changing segment
   Double_t znew = point[2] - 0.5*(fZ[ipl]+fZ[ipl+1]);
   saf[0] = 0.5*dz - TMath::Abs(znew);
   if (-saf[0]>safmin) return TGeoShape::Big(); // means: stop checking further segments
   Double_t rmin1 = fRmin[ipl];
   Double_t rmax1 = fRmax[ipl];
   Double_t rmin2 = fRmin[ipl+1];
   Double_t rmax2 = fRmax[ipl+1];
   Double_t divphi = fDphi/fNedges;
   if (iphi<0) {
      Double_t f = 1./TMath::Cos(0.5*divphi*TMath::DegToRad());
      rmax1 *= f;
      rmax2 *= f;
      r = TMath::Sqrt(point[0]*point[0]+point[1]*point[1]);
      Double_t ro1 = 0.5*(rmin1+rmin2);
      Double_t tg1 = (rmin2-rmin1)/dz;
      Double_t cr1 = 1./TMath::Sqrt(1.+tg1*tg1);
      Double_t ro2 = 0.5*(rmax1+rmax2);
      Double_t tg2 = (rmax2-rmax1)/dz;
      Double_t cr2 = 1./TMath::Sqrt(1.+tg2*tg2);
      Double_t rin = tg1*znew+ro1;
      Double_t rout = tg2*znew+ro2;
      saf[1] = (ro1>0)?((r-rin)*cr1):TGeoShape::Big();
      saf[2] = (rout-r)*cr2;
      for (i=0; i<3; i++) saf[i]=-saf[i];
      safe = saf[TMath::LocMax(3,saf)];
      safe = TMath::Max(safe, safphi);
      if (safe<0) safe = 0;
      return safe;
   }
   Double_t ph0 = (fPhi1+divphi*(iphi+0.5))*TMath::DegToRad();
   r = point[0]*TMath::Cos(ph0)+point[1]*TMath::Sin(ph0);
   if (rmin1+rmin2>1E-10) {
      ta = (rmin2-rmin1)/dz;
      calf = 1./TMath::Sqrt(1+ta*ta);
      rpgon = rmin1 + (point[2]-fZ[ipl])*ta;
      saf[1] = (r-rpgon)*calf;
   } else {
      saf[1] = TGeoShape::Big();
   }   
   ta = (rmax2-rmax1)/dz;
   calf = 1./TMath::Sqrt(1+ta*ta);
   rpgon = rmax1 + (point[2]-fZ[ipl])*ta;
   saf[2] = (rpgon-r)*calf;
   if (in) {
      safe = saf[TMath::LocMin(3,saf)];
      safe = TMath::Min(safe, safphi);
   } else {          
      for (i=0; i<3; i++) saf[i]=-saf[i];
      safe = saf[TMath::LocMax(3,saf)];
      safe = TMath::Max(safe, safphi);
   }
   if (safe<0) safe=0;
   return safe;
}      

//_____________________________________________________________________________
Double_t TGeoPgon::Safety(const 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.
   Double_t safmin, saftmp, safphi;
   Double_t dz;
   Int_t ipl, iplane, iphi;
   LocatePhi(point, iphi);
   safphi = TGeoShape::SafetyPhi(point,in,fPhi1, fPhi1+fDphi);
   if (in) {
   //---> point is inside pgon
      ipl = TMath::BinarySearch(fNz, fZ, point[2]);
      if (ipl==(fNz-1)) return 0;   // point on last Z boundary
      if (ipl<0) return 0;          // point on first Z boundary
      dz = 0.5*(fZ[ipl+1]-fZ[ipl]);
      if (dz<1E-8) return 0;
      // Check safety for current segment
      safmin = SafetyToSegment(point, ipl, iphi, in, safphi);
      if (safmin>1E10) {
         //  something went wrong - point is not inside current segment
         return TGeoShape::Big();
      }
      if (safmin<1E-6) return TMath::Abs(safmin); // point on radius-changing plane
      // check increasing iplanes
      iplane = ipl+1;
      saftmp = 0.;
      while ((iplane<fNz-1) && saftmp<1E10) {
         saftmp = TMath::Abs(SafetyToSegment(point,iplane,iphi,kFALSE,safphi,safmin));
         if (saftmp<safmin) safmin=saftmp;
         iplane++;
      }   
      // now decreasing nplanes
      iplane = ipl-1;
      saftmp = 0.;
      while ((iplane>=0) && saftmp<1E10) {
         saftmp = TMath::Abs(SafetyToSegment(point,iplane,iphi,kFALSE,safphi,safmin));
         if (saftmp<safmin) safmin=saftmp;
         iplane--;
      }   
      return safmin;
   }   
   //---> point is outside pgon
   ipl = TMath::BinarySearch(fNz, fZ, point[2]);
   if (ipl<0) ipl=0;
   else if (ipl==fNz-1) ipl=fNz-2;
   dz = 0.5*(fZ[ipl+1]-fZ[ipl]);
   if (dz<1E-8) {
      ipl++;
      if (ipl>fNz-2) return 0.;  // invalid last section
      dz = 0.5*(fZ[ipl+1]-fZ[ipl]);
   }   
   // Check safety for current segment
   safmin = SafetyToSegment(point, ipl,iphi,kFALSE,safphi);
   if (safmin<1E-6) return TMath::Abs(safmin); // point on radius-changing plane
   saftmp = 0.;
   // check increasing iplanes
   iplane = ipl+1;
   saftmp = 0.;
   while ((iplane<fNz-1) && saftmp<1E10) {
      saftmp = TMath::Abs(SafetyToSegment(point,iplane,iphi,kFALSE,safphi,safmin));
      if (saftmp<safmin) safmin=saftmp;
      iplane++;
   }   
   // now decreasing nplanes
   iplane = ipl-1;
   saftmp = 0.;
   while ((iplane>=0) && saftmp<1E10) {
      saftmp = TMath::Abs(SafetyToSegment(point,iplane,iphi, kFALSE,safphi,safmin));
      if (saftmp<safmin) safmin=saftmp;
      iplane--;
   }   
   return safmin;
}

//_____________________________________________________________________________
void TGeoPgon::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 << "   phi1    = " << fPhi1 << ";" << std::endl;
   out << "   dphi    = " << fDphi << ";" << std::endl;
   out << "   nedges = " << fNedges << ";" << std::endl;
   out << "   nz      = " << fNz << ";" << std::endl;
   out << "   TGeoPgon *pgon = new TGeoPgon(\"" << GetName() << "\",phi1,dphi,nedges,nz);" << std::endl;
   for (Int_t i=0; i<fNz; i++) {
      out << "      z     = " << fZ[i] << ";" << std::endl;
      out << "      rmin  = " << fRmin[i] << ";" << std::endl;
      out << "      rmax  = " << fRmax[i] << ";" << std::endl;
      out << "   pgon->DefineSection(" << i << ", z,rmin,rmax);" << std::endl;
   }
   out << "   TGeoShape *" << GetPointerName() << " = pgon;" << std::endl;
   TObject::SetBit(TGeoShape::kGeoSavePrimitive);
}

//_____________________________________________________________________________
void TGeoPgon::SetDimensions(Double_t *param)
{
// Set PGON dimensions starting from an array.
   fPhi1    = param[0];
   fDphi    = param[1];
   fNedges  = (Int_t)param[2];
   fNz      = (Int_t)param[3];
   if (fNz<2) {
      Error("SetDimensions","Pgon %s: Number of Z sections must be > 2", GetName());
      return;
   } 
   if (fRmin) delete [] fRmin;  
   if (fRmax) delete [] fRmax;  
   if (fZ) delete [] fZ;  
   fRmin = new Double_t [fNz];
   fRmax = new Double_t [fNz];
   fZ    = new Double_t [fNz];
   memset(fRmin, 0, fNz*sizeof(Double_t));
   memset(fRmax, 0, fNz*sizeof(Double_t));
   memset(fZ, 0, fNz*sizeof(Double_t));
   for (Int_t i=0; i<fNz; i++) 
      DefineSection(i, param[4+3*i], param[5+3*i], param[6+3*i]);
}   

//_____________________________________________________________________________
void TGeoPgon::SetPoints(Double_t *points) const
{
// create polygone mesh points
   Double_t phi, dphi;
   Int_t n = fNedges + 1;
   dphi = fDphi/(n-1);
   Double_t factor = 1./TMath::Cos(TMath::DegToRad()*dphi/2);
   Int_t i, j;
   Int_t indx = 0;

   if (points) {
      for (i = 0; i < fNz; i++) {
         for (j = 0; j < n; j++) {
            phi = (fPhi1+j*dphi)*TMath::DegToRad();
            points[indx++] = factor * fRmin[i] * TMath::Cos(phi);
            points[indx++] = factor * fRmin[i] * TMath::Sin(phi);
            points[indx++] = fZ[i];
         }
         for (j = 0; j < n; j++) {
            phi = (fPhi1+j*dphi)*TMath::DegToRad();
            points[indx++] = factor * fRmax[i] * TMath::Cos(phi);
            points[indx++] = factor * fRmax[i] * TMath::Sin(phi);
            points[indx++] = fZ[i];
         }
      }
   }
}

//_____________________________________________________________________________
void TGeoPgon::SetPoints(Float_t *points) const
{
// create polygone mesh points
   Double_t phi, dphi;
   Int_t n = fNedges + 1;
   dphi = fDphi/(n-1);
   Double_t factor = 1./TMath::Cos(TMath::DegToRad()*dphi/2);
   Int_t i, j;
   Int_t indx = 0;

   if (points) {
      for (i = 0; i < fNz; i++) {
         for (j = 0; j < n; j++) {
            phi = (fPhi1+j*dphi)*TMath::DegToRad();
            points[indx++] = factor * fRmin[i] * TMath::Cos(phi);
            points[indx++] = factor * fRmin[i] * TMath::Sin(phi);
            points[indx++] = fZ[i];
         }
         for (j = 0; j < n; j++) {
            phi = (fPhi1+j*dphi)*TMath::DegToRad();
            points[indx++] = factor * fRmax[i] * TMath::Cos(phi);
            points[indx++] = factor * fRmax[i] * TMath::Sin(phi);
            points[indx++] = fZ[i];
         }
      }
   }
}

//_____________________________________________________________________________
void TGeoPgon::GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t &npols) const
{
// Returns numbers of vertices, segments and polygons composing the shape mesh.
   Int_t n = fNedges+1;
   Int_t nz = GetNz();
   nvert = nz*2*n;
   Bool_t specialCase = (TGeoShape::IsSameWithinTolerance(GetDphi(),360));
   nsegs = 4*(nz*n-1+(specialCase == kTRUE));
   npols = 2*(nz*n-1+(specialCase == kTRUE));
}

//_____________________________________________________________________________
Int_t TGeoPgon::GetNmeshVertices() const
{
// Return number of vertices of the mesh representation
   Int_t n = fNedges+1;
   Int_t numPoints = fNz*2*n;
   return numPoints;
}   

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

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