ROOT logo
// @(#)root/geom:$Id$
// Author: Andrei Gheata   24/10/01
// TGeoPcon::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.             *
 *************************************************************************/

//_____________________________________________________________________________
// TGeoPcon - a polycone. It has at least 9 parameters :
//            - the lower phi limit;
//            - the range in phi;
//            - the number of z planes (at least two) where the inner/outer 
//              radii are changing;
//            - z coordinate, inner and outer radius for each z plane
//
//_____________________________________________________________________________
//Begin_Html
/*
<img src="gif/t_pcon.gif">
*/
//End_Html

//Begin_Html
/*
<img src="gif/t_pcondivPHI.gif">
*/
//End_Html

//Begin_Html
/*
<img src="gif/t_pcondivstepPHI.gif">
*/
//End_Html

//Begin_Html
/*
<img src="gif/t_pcondivstepZ.gif">
*/
//End_Html

#include "Riostream.h"

#include "TGeoManager.h"
#include "TGeoVolume.h"
#include "TVirtualGeoPainter.h"
#include "TGeoTube.h"
#include "TGeoCone.h"
#include "TGeoPcon.h"
#include "TVirtualPad.h"
#include "TBuffer3D.h"
#include "TBuffer3DTypes.h"
#include "TMath.h"

ClassImp(TGeoPcon)

//_____________________________________________________________________________
TGeoPcon::TGeoPcon()
         :TGeoBBox(0, 0, 0),
          fNz(0),
          fPhi1(0.),
          fDphi(0.),
          fRmin(NULL),
          fRmax(NULL),
          fZ(NULL),
          fFullPhi(kFALSE),
          fC1(0.),
          fS1(0.),
          fC2(0.),
          fS2(0.),
          fCm(0.),
          fSm(0.),
          fCdphi(0.)
{
// dummy ctor
   SetShapeBit(TGeoShape::kGeoPcon);
}   

//_____________________________________________________________________________
TGeoPcon::TGeoPcon(Double_t phi, Double_t dphi, Int_t nz)
         :TGeoBBox(0, 0, 0),
          fNz(nz),
          fPhi1(phi),
          fDphi(dphi),
          fRmin(NULL),
          fRmax(NULL),
          fZ(NULL),
          fFullPhi(kFALSE),
          fC1(0.),
          fS1(0.),
          fC2(0.),
          fS2(0.),
          fCm(0.),
          fSm(0.),
          fCdphi(0.)
{
// Default constructor
   SetShapeBit(TGeoShape::kGeoPcon);
   while (fPhi1<0) fPhi1+=360.;
   fRmin = new Double_t [nz];
   fRmax = new Double_t [nz];
   fZ    = new Double_t [nz];
   memset(fRmin, 0, nz*sizeof(Double_t));
   memset(fRmax, 0, nz*sizeof(Double_t));
   memset(fZ, 0, nz*sizeof(Double_t));
   if (TGeoShape::IsSameWithinTolerance(fDphi,360)) fFullPhi = kTRUE;
   Double_t phi1 = fPhi1;
   Double_t phi2 = phi1+fDphi;
   Double_t phim = 0.5*(phi1+phi2);
   fC1 = TMath::Cos(phi1*TMath::DegToRad());
   fS1 = TMath::Sin(phi1*TMath::DegToRad());
   fC2 = TMath::Cos(phi2*TMath::DegToRad());
   fS2 = TMath::Sin(phi2*TMath::DegToRad());
   fCm = TMath::Cos(phim*TMath::DegToRad());
   fSm = TMath::Sin(phim*TMath::DegToRad());
   fCdphi = TMath::Cos(0.5*fDphi*TMath::DegToRad());
}

//_____________________________________________________________________________
TGeoPcon::TGeoPcon(const char *name, Double_t phi, Double_t dphi, Int_t nz)
         :TGeoBBox(name, 0, 0, 0),
          fNz(nz),
          fPhi1(phi),
          fDphi(dphi),
          fRmin(NULL),
          fRmax(NULL),
          fZ(NULL),        
          fFullPhi(kFALSE),
          fC1(0.),
          fS1(0.),
          fC2(0.),
          fS2(0.),
          fCm(0.),
          fSm(0.),
          fCdphi(0.)
{
// Default constructor
   SetShapeBit(TGeoShape::kGeoPcon);
   while (fPhi1<0) fPhi1+=360.;
   fRmin = new Double_t [nz];
   fRmax = new Double_t [nz];
   fZ    = new Double_t [nz];
   memset(fRmin, 0, nz*sizeof(Double_t));
   memset(fRmax, 0, nz*sizeof(Double_t));
   memset(fZ, 0, nz*sizeof(Double_t));
   if (TGeoShape::IsSameWithinTolerance(fDphi,360)) fFullPhi = kTRUE;
   Double_t phi1 = fPhi1;
   Double_t phi2 = phi1+fDphi;
   Double_t phim = 0.5*(phi1+phi2);
   fC1 = TMath::Cos(phi1*TMath::DegToRad());
   fS1 = TMath::Sin(phi1*TMath::DegToRad());
   fC2 = TMath::Cos(phi2*TMath::DegToRad());
   fS2 = TMath::Sin(phi2*TMath::DegToRad());
   fCm = TMath::Cos(phim*TMath::DegToRad());
   fSm = TMath::Sin(phim*TMath::DegToRad());
   fCdphi = TMath::Cos(0.5*fDphi*TMath::DegToRad());
}

//_____________________________________________________________________________
TGeoPcon::TGeoPcon(Double_t *param)
         :TGeoBBox(0, 0, 0),
          fNz(0),
          fPhi1(0.),
          fDphi(0.),
          fRmin(0),
          fRmax(0),
          fZ(0),
          fFullPhi(kFALSE),
          fC1(0.),
          fS1(0.),
          fC2(0.),
          fS2(0.),
          fCm(0.),
          fSm(0.),
          fCdphi(0.)
{
// Default constructor in GEANT3 style
// param[0] = phi1
// param[1] = dphi
// param[2] = nz
//
// param[3] = z1
// param[4] = Rmin1
// param[5] = Rmax1
// ...
   SetShapeBit(TGeoShape::kGeoPcon);
   SetDimensions(param);
   ComputeBBox();
}

//_____________________________________________________________________________
TGeoPcon::TGeoPcon(const TGeoPcon& pc) : 
  TGeoBBox(pc),
  fNz(0),
  fPhi1(0.),
  fDphi(0.),
  fRmin(0),
  fRmax(0),
  fZ(0),
  fFullPhi(kFALSE),
  fC1(0.),
  fS1(0.),
  fC2(0.),
  fS2(0.),
  fCm(0.),
  fSm(0.),
  fCdphi(0.)
{ 
   //copy constructor
}

//_____________________________________________________________________________
TGeoPcon& TGeoPcon::operator=(const TGeoPcon& pc) 
{
   //assignment operator
   if(this!=&pc) {
      TGeoBBox::operator=(pc);
      fNz=0;
      fPhi1=0.;
      fDphi=0.;
      fRmin=0;
      fRmax=0;
      fZ=0;
      fFullPhi=kFALSE;
      fC1=0;
      fS1=0;
      fC2=0;
      fS2=0;
      fCm=0;
      fSm=0;
      fCdphi=0;
   } 
   return *this;
}

//_____________________________________________________________________________
TGeoPcon::~TGeoPcon()
{
// destructor
   if (fRmin) {delete[] fRmin; fRmin = 0;}
   if (fRmax) {delete[] fRmax; fRmax = 0;}
   if (fZ)    {delete[] fZ; fZ = 0;}
}

//_____________________________________________________________________________
Double_t TGeoPcon::Capacity() const
{
// Computes capacity of the shape in [length^3]
   Int_t ipl;
   Double_t rmin1, rmax1, rmin2, rmax2, phi1, phi2, dz;
   Double_t capacity = 0.;
   phi1 = fPhi1;
   phi2 = fPhi1 + fDphi;
   for (ipl=0; ipl<fNz-1; ipl++) {
      dz    = 0.5*(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 += TGeoConeSeg::Capacity(dz,rmin1,rmax1,rmin2,rmax2,phi1,phi2);
   }
   return capacity;   
}

//_____________________________________________________________________________   
void TGeoPcon::ComputeBBox()
{
// compute bounding box of the pcon
   // Check if the sections are in increasing Z order
   for (Int_t isec=0; isec<fNz-1; isec++) {
      if (TMath::Abs(fZ[isec]-fZ[isec+1]) < TGeoShape::Tolerance()) fZ[isec+1]=fZ[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;
   rmin = fRmin[TMath::LocMin(fNz, fRmin)];
   rmax = fRmax[TMath::LocMax(fNz, fRmax)];
   
   Double_t xc[4];
   Double_t yc[4];
   xc[0] = rmax*fC1;
   yc[0] = rmax*fS1;
   xc[1] = rmax*fC2;
   yc[1] = rmax*fS2;
   xc[2] = rmin*fC1;
   yc[2] = rmin*fS1;
   xc[3] = rmin*fC2;
   yc[3] = rmin*fS2;

   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 = -fPhi1;
   if (ddp<0) ddp+= 360;
   if (ddp<=fDphi) xmax = rmax;
   ddp = 90-fPhi1;
   if (ddp<0) ddp+= 360;
   if (ddp<=fDphi) ymax = rmax;
   ddp = 180-fPhi1;
   if (ddp<0) ddp+= 360;
   if (ddp<=fDphi) xmin = -rmax;
   ddp = 270-fPhi1;
   if (ddp<0) ddp+= 360;
   if (ddp<=fDphi) ymin = -rmax;
   fOrigin[0] = (xmax+xmin)/2;
   fOrigin[1] = (ymax+ymin)/2;
   fOrigin[2] = (zmax+zmin)/2;
   fDX = (xmax-xmin)/2;
   fDY = (ymax-ymin)/2;
   fDZ = (zmax-zmin)/2;
   SetShapeBit(kGeoClosedShape);
}   

//_____________________________________________________________________________   
void TGeoPcon::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 r;
   Double_t ptnew[3];
   Double_t dz, rmin1, rmax1, rmin2, rmax2;
   Bool_t is_tube;
   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]);
   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])) {
         r = TMath::Sqrt(point[0]*point[0]+point[1]*point[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])) {
            r = TMath::Sqrt(point[0]*point[0]+point[1]*point[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
   memcpy(ptnew, point, 3*sizeof(Double_t));
   dz = 0.5*(fZ[ipl+1]-fZ[ipl]);
   if (TGeoShape::IsSameWithinTolerance(dz,0.)) {
      norm[2] = TMath::Sign(1., dir[2]);
      return;
   }         
   ptnew[2] -= 0.5*(fZ[ipl]+fZ[ipl+1]);
   rmin1 = fRmin[ipl];
   rmax1 = fRmax[ipl];
   rmin2 = fRmin[ipl+1];
   rmax2 = fRmax[ipl+1];
   is_tube = (TGeoShape::IsSameWithinTolerance(rmin1,rmin2) && TGeoShape::IsSameWithinTolerance(rmax1,rmax2))?kTRUE:kFALSE;
   if (!fFullPhi) {
      if (is_tube) TGeoTubeSeg::ComputeNormalS(ptnew,dir,norm,rmin1,rmax1,dz,fC1,fS1,fC2,fS2);
      else         TGeoConeSeg::ComputeNormalS(ptnew,dir,norm,dz,rmin1,rmax1,rmin2,rmax2,fC1,fS1,fC2,fS2);
   } else {
      if (is_tube) TGeoTube::ComputeNormalS(ptnew,dir,norm,rmin1,rmax1,dz);
      else         TGeoCone::ComputeNormalS(ptnew,dir,norm,dz,rmin1,rmax1,rmin2,rmax2);
   }
}

//_____________________________________________________________________________
Bool_t TGeoPcon::Contains(const Double_t *point) const
{
// test if point is inside this shape
   // check total z range
   if ((point[2]<fZ[0]) || (point[2]>fZ[fNz-1])) return kFALSE;
   // check R squared
   Double_t r2 = point[0]*point[0]+point[1]*point[1];
   
   Int_t izl = 0;
   Int_t izh = fNz-1;
   Int_t izt = (fNz-1)/2;
   while ((izh-izl)>1) {
      if (point[2] > fZ[izt]) izl = izt;     
      else izh = izt;
      izt = (izl+izh)>>1;
   }
   // the point is in the section bounded by izl and izh Z planes
   
   // compute Rmin and Rmax and test the value of R squared
   Double_t rmin, rmax;  
   if (TGeoShape::IsSameWithinTolerance(fZ[izl],fZ[izh]) && TGeoShape::IsSameWithinTolerance(point[2],fZ[izl])) {
      rmin = TMath::Min(fRmin[izl], fRmin[izh]);
      rmax = TMath::Max(fRmax[izl], fRmax[izh]);
   } else {
      Double_t dz = fZ[izh] - fZ[izl];
      Double_t dz1 = point[2] - fZ[izl];
      rmin = (fRmin[izl]*(dz-dz1)+fRmin[izh]*dz1)/dz;
      rmax = (fRmax[izl]*(dz-dz1)+fRmax[izh]*dz1)/dz;
   }
   if ((r2<rmin*rmin) || (r2>rmax*rmax)) return kFALSE;
   // now check phi 
   if (TGeoShape::IsSameWithinTolerance(fDphi,360)) return kTRUE;
   if (r2<1E-10) return kTRUE;
   Double_t phi = TMath::ATan2(point[1], point[0]) * TMath::RadToDeg();
   if (phi < 0) phi+=360.0;
   Double_t ddp = phi-fPhi1;
   if (ddp<0) ddp+=360.;
   if (ddp<=fDphi) return kTRUE;
   return kFALSE;
}

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

//_____________________________________________________________________________
Double_t TGeoPcon::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 polycone
   if (iact<3 && safe) {
      *safe = Safety(point, kTRUE);
      if (iact==0) return TGeoShape::Big();
      if ((iact==1) && (*safe>step)) return TGeoShape::Big();
   }
   Double_t snxt = TGeoShape::Big();
   Double_t sstep = 1E-6;
   Double_t point_new[3];
   // determine which z segment contains the point
   Int_t ipl = TMath::BinarySearch(fNz, fZ, point[2]+TMath::Sign(1.E-10,dir[2]));
   if (ipl<0) ipl=0;
   if (ipl==(fNz-1)) ipl--;
   Double_t dz = 0.5*(fZ[ipl+1]-fZ[ipl]);
   Bool_t special_case = kFALSE;
   if (dz<1e-9) {
      // radius changing segment, make sure track is not in the XY plane
      if (TGeoShape::IsSameWithinTolerance(dir[2], 0)) {
         special_case = kTRUE;
      } else {
         //check if a close point is still contained
         point_new[0] = point[0]+sstep*dir[0];
         point_new[1] = point[1]+sstep*dir[1];
         point_new[2] = point[2]+sstep*dir[2];
         if (!Contains(point_new)) return 0.;
         return (DistFromInside(point_new,dir,iact,step,safe)+sstep);
      }   
   }   
   // determine if the current segment is a tube or a cone
   Bool_t intub = kTRUE;
   if (!TGeoShape::IsSameWithinTolerance(fRmin[ipl],fRmin[ipl+1])) intub=kFALSE;
   else if (!TGeoShape::IsSameWithinTolerance(fRmax[ipl],fRmax[ipl+1])) intub=kFALSE;
   // determine phi segmentation
   memcpy(point_new, point, 2*sizeof(Double_t));
   // new point in reference system of the current segment
   point_new[2] = point[2]-0.5*(fZ[ipl]+fZ[ipl+1]);
   
   if (special_case) {
      if (!fFullPhi) snxt = TGeoTubeSeg::DistFromInsideS(point_new, dir, 
               TMath::Min(fRmin[ipl],fRmin[ipl+1]), TMath::Max(fRmax[ipl],fRmax[ipl+1]),
               dz, fC1,fS1,fC2,fS2,fCm,fSm,fCdphi);
      else       snxt = TGeoTube::DistFromInsideS(point_new, dir, 
               TMath::Min(fRmin[ipl],fRmin[ipl+1]), TMath::Max(fRmax[ipl],fRmax[ipl+1]),dz);
      return snxt;
   }   
   if (intub) {
      if (!fFullPhi) snxt=TGeoTubeSeg::DistFromInsideS(point_new, dir, fRmin[ipl], fRmax[ipl],dz, fC1,fS1,fC2,fS2,fCm,fSm,fCdphi); 
      else snxt=TGeoTube::DistFromInsideS(point_new, dir, fRmin[ipl], fRmax[ipl],dz);
   } else {
      if (!fFullPhi) snxt=TGeoConeSeg::DistFromInsideS(point_new,dir,dz,fRmin[ipl],fRmax[ipl],fRmin[ipl+1],fRmax[ipl+1],fC1,fS1,fC2,fS2,fCm,fSm,fCdphi);
      else snxt=TGeoCone::DistFromInsideS(point_new,dir,dz,fRmin[ipl],fRmax[ipl],fRmin[ipl+1], fRmax[ipl+1]);
   }                              

   for (Int_t i=0; i<3; i++) point_new[i]=point[i]+(snxt+1E-6)*dir[i];
   if (!Contains(&point_new[0])) return snxt;
   
   snxt += DistFromInside(&point_new[0], dir, 3) + 1E-6;
   return snxt;
}

//_____________________________________________________________________________
Double_t TGeoPcon::DistToSegZ(const Double_t *point, const Double_t *dir, Int_t &iz) const
{
// compute distance to a pcon Z slice. Segment iz must be valid
   Double_t zmin=fZ[iz];
   Double_t zmax=fZ[iz+1];
   if (TGeoShape::IsSameWithinTolerance(zmin,zmax)) {
      if (TGeoShape::IsSameWithinTolerance(dir[2],0)) return TGeoShape::Big();
      Int_t istep=(dir[2]>0)?1:-1;
      iz+=istep;
      if (iz<0 || iz>(fNz-2)) return TGeoShape::Big();
      return DistToSegZ(point,dir,iz);
   }
   Double_t dz=0.5*(zmax-zmin);
   Double_t local[3];
   memcpy(&local[0], point, 3*sizeof(Double_t));
   local[2]=point[2]-0.5*(zmin+zmax);
   Double_t snxt;
   Double_t rmin1=fRmin[iz];
   Double_t rmax1=fRmax[iz];
   Double_t rmin2=fRmin[iz+1];
   Double_t rmax2=fRmax[iz+1];

   if (TGeoShape::IsSameWithinTolerance(rmin1,rmin2) && TGeoShape::IsSameWithinTolerance(rmax1,rmax2)) {
      if (fFullPhi) snxt=TGeoTube::DistFromOutsideS(local, dir, rmin1, rmax1, dz);
      else snxt=TGeoTubeSeg::DistFromOutsideS(local,dir,rmin1,rmax1,dz,fC1,fS1,fC2,fS2,fCm,fSm,fCdphi);
   } else {  
      if (fFullPhi) snxt=TGeoCone::DistFromOutsideS(local,dir,dz,rmin1, rmax1,rmin2,rmax2);
      else snxt=TGeoConeSeg::DistFromOutsideS(local,dir,dz,rmin1,rmax1,rmin2,rmax2,fC1,fS1,fC2,fS2,fCm,fSm,fCdphi);
   }
   if (snxt<1E20) return snxt;
   // check next segment
   if (TGeoShape::IsSameWithinTolerance(dir[2],0)) return TGeoShape::Big();
   Int_t istep=(dir[2]>0)?1:-1;
   iz+=istep;
   if (iz<0 || iz>(fNz-2)) return TGeoShape::Big();
   return DistToSegZ(point,dir,iz);
}      

//_____________________________________________________________________________
Double_t TGeoPcon::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 tube
   if ((iact<3) && safe) {
      *safe = Safety(point, kFALSE);
      if ((iact==1) && (*safe>step)) return TGeoShape::Big();
      if (iact==0) return TGeoShape::Big();
   }
   // check if ray intersect outscribed cylinder
   if ((point[2]<fZ[0]) && (dir[2]<=0)) return TGeoShape::Big();
   if ((point[2]>fZ[fNz-1]) && (dir[2]>=0)) return TGeoShape::Big();
// Check if the bounding box is crossed within the requested distance
   Double_t sdist = TGeoBBox::DistFromOutside(point,dir, fDX, fDY, fDZ, fOrigin, step);
   if (sdist>=step) return TGeoShape::Big();

   Double_t r2 = point[0]*point[0]+point[1]*point[1];
   Double_t radmax=0;
   radmax=fRmax[TMath::LocMax(fNz, fRmax)];
   if (r2>(radmax*radmax)) {
      Double_t rpr=-point[0]*dir[0]-point[1]*dir[1];
      Double_t nxy=dir[0]*dir[0]+dir[1]*dir[1];
      if (rpr<TMath::Sqrt((r2-radmax*radmax)*nxy)) return TGeoShape::Big();
   }

   // find in which Z segment we are
   Int_t ipl = TMath::BinarySearch(fNz, fZ, point[2]);
   Int_t ifirst = ipl;
   if (ifirst<0) {
      ifirst=0;
   } else if (ifirst>=(fNz-1)) ifirst=fNz-2;
   // find if point is in the phi gap
   Double_t phi=0;
   if (!fFullPhi) {
      phi=TMath::ATan2(point[1], point[0]);
      if (phi<0) phi+=2.*TMath::Pi();
   } 

   // compute distance to boundary
   return DistToSegZ(point,dir,ifirst);
}

//_____________________________________________________________________________
void TGeoPcon::DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax)
{
// Defines z position of a section plane, rmin and rmax at this z. Sections
// should be defined in increasing or decreasing Z order and the last section 
// HAS to be snum = fNz-1
   if ((snum<0) || (snum>=fNz)) return;
   fZ[snum]    = z;
   fRmin[snum] = rmin;
   fRmax[snum] = rmax;
   if (rmin>rmax) 
      Warning("DefineSection", "Shape %s: invalid rmin=%g rmax=%g", GetName(), rmin, rmax);
   if (snum==(fNz-1)) {
      // Reorder sections in increasing Z order
      if (fZ[0] > fZ[snum]) {
         Int_t iz = 0;
         Int_t izi = fNz-1;
         Double_t temp;
         while (iz<izi) {
            temp = fZ[iz];
            fZ[iz] = fZ[izi];
            fZ[izi] = temp;
            temp = fRmin[iz];
            fRmin[iz] = fRmin[izi];
            fRmin[izi] = temp;
            temp = fRmax[iz];
            fRmax[iz] = fRmax[izi];
            fRmax[izi] = temp;
            iz++;
            izi--;
         }   
      }      
      ComputeBBox();
   }   
}

//_____________________________________________________________________________
Int_t TGeoPcon::GetNsegments() const
{
// Returns number of segments on each mesh circle segment.
   return gGeoManager->GetNsegments();
}

//_____________________________________________________________________________
TGeoVolume *TGeoPcon::Divide(TGeoVolume *voldiv, const char *divname, Int_t iaxis, Int_t ndiv, 
                             Double_t start, Double_t step) 
{
//--- Divide this polycone 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. 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.
   TGeoShape *shape;           //--- shape to be created
   TGeoVolume *vol;            //--- division volume to be created
   TGeoVolumeMulti *vmulti;    //--- generic divided volume
   TGeoPatternFinder *finder;  //--- finder to be attached 
   TString opt = "";           //--- option to be attached
   Double_t 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", "Shape %s: cannot divide a pcon on radius", GetName());
         return 0;
      case 2:  //---               Phi division
         finder = new TGeoPatternCylPhi(voldiv, ndiv, start, start+ndiv*step);
         vmulti = gGeoManager->MakeVolumeMulti(divname, voldiv->GetMedium());
         voldiv->SetFinder(finder);
         finder->SetDivIndex(voldiv->GetNdaughters());            
         shape = new TGeoPcon(-step/2, step, fNz);
         for (is=0; is<fNz; is++)
            ((TGeoPcon*)shape)->DefineSection(is, fZ[is], fRmin[is], fRmax[is]); 
            vol = new TGeoVolume(divname, shape, voldiv->GetMedium());
            vmulti->AddVolume(vol);
            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", "Shape %s: cannot divide pcon on Z if divided region is not between 2 planes", GetName());
            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);
            Bool_t is_tube = (TGeoShape::IsSameWithinTolerance(fRmin[isect],fRmin[isect+1]) && TGeoShape::IsSameWithinTolerance(fRmax[isect],fRmax[isect+1]))?kTRUE:kFALSE;
            Bool_t is_seg = (fDphi<360)?kTRUE:kFALSE;
            if (is_seg) {
               if (is_tube) shape=new TGeoTubeSeg(fRmin[isect],fRmax[isect],step/2, fPhi1, fPhi1+fDphi);
               else shape=new TGeoConeSeg(step/2, rmin1, rmax1, rmin2, rmax2, fPhi1, fPhi1+fDphi);
            } else {
               if (is_tube) shape=new TGeoTube(fRmin[isect],fRmax[isect],step/2);
               else shape = new TGeoCone(step/2,rmin1,rmax1,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", "Shape %s: Wrong axis %d for division",GetName(), iaxis);
         return 0;            
   }
}

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

//_____________________________________________________________________________
Double_t TGeoPcon::GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const
{
// Get range of shape for a given axis.
   xlo = 0;
   xhi = 0;
   Double_t dx = 0;
   switch (iaxis) {
      case 2:
         xlo = fPhi1;
         xhi = fPhi1 + fDphi;
         dx = fDphi;
         return dx;
      case 3:
         xlo = fZ[0];
         xhi = fZ[fNz-1];
         dx = xhi-xlo;
         return dx;
   }
   return dx;
}         
            
//_____________________________________________________________________________
void TGeoPcon::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];
   }
   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
}   

//_____________________________________________________________________________
Double_t TGeoPcon::GetRmin(Int_t ipl) const
{
// Returns Rmin for Z segment IPL.
   if (ipl<0 || ipl>(fNz-1)) {
      Error("GetRmin","ipl=%i out of range (0,%i) in shape %s",ipl,fNz-1,GetName());
      return 0.;
   }
   return fRmin[ipl];
}      

//_____________________________________________________________________________
Double_t TGeoPcon::GetRmax(Int_t ipl) const
{
// Returns Rmax for Z segment IPL.
   if (ipl<0 || ipl>(fNz-1)) {
      Error("GetRmax","ipl=%i out of range (0,%i) in shape %s",ipl,fNz-1,GetName());
      return 0.;
   }
   return fRmax[ipl];
}      

//_____________________________________________________________________________
Double_t TGeoPcon::GetZ(Int_t ipl) const
{
// Returns Z for segment IPL.
   if (ipl<0 || ipl>(fNz-1)) {
      Error("GetZ","ipl=%i out of range (0,%i) in shape %s",ipl,fNz-1,GetName());
      return 0.;
   }
   return fZ[ipl];
}      

//_____________________________________________________________________________
void TGeoPcon::InspectShape() const
{
// print shape parameters
   printf("*** Shape %s: TGeoPcon ***\n", GetName());
   printf("    Nz    = %i\n", fNz);
   printf("    phi1  = %11.5f\n", fPhi1);
   printf("    dphi  = %11.5f\n", fDphi);
   for (Int_t ipl=0; ipl<fNz; ipl++)
      printf("     plane %i: z=%11.5f Rmin=%11.5f Rmax=%11.5f\n", ipl, fZ[ipl], fRmin[ipl], fRmax[ipl]);
   printf(" Bounding box:\n");
   TGeoBBox::InspectShape();
}

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

   const Int_t n = gGeoManager->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 TGeoPcon::SetSegsAndPols(TBuffer3D &buff) const
{
// Fill TBuffer3D structure for segments and polygons.
   Int_t i, j;
   const Int_t n = gGeoManager->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 cilindres, number of segments: 2*(nz-1)*n
   for (i = 0; i < (nz-1); i++) {
      //inside cilinder
      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 cilinder
      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
   for (j = 0; j < n-1; j++) {
      buff.fPols[indx++] = c+3;
      buff.fPols[indx++] = 4;
      buff.fPols[indx++] = 2*nz*m+j;
      buff.fPols[indx++] = m+j;
      buff.fPols[indx++] = 2*nz*m+j+1;
      buff.fPols[indx++] = j;
   }
   for (j = 0; j < n-1; j++) {
      buff.fPols[indx++] = c+3;
      buff.fPols[indx++] = 4;
      buff.fPols[indx++] = 2*nz*m+n+j;
      buff.fPols[indx++] = (nz*2-2)*m+j;
      buff.fPols[indx++] = 2*nz*m+n+j+1;
      buff.fPols[indx++] = (nz*2-2)*m+m+j;
   }
   if (specialCase) {
      buff.fPols[indx++] = c+3;
      buff.fPols[indx++] = 4;
      buff.fPols[indx++] = 2*nz*m+j;
      buff.fPols[indx++] = m+j;
      buff.fPols[indx++] = 2*nz*m;
      buff.fPols[indx++] = j;
 
      buff.fPols[indx++] = c+3;
      buff.fPols[indx++] = 4;
      buff.fPols[indx++] = 2*nz*m+n+j;
      buff.fPols[indx++] = (nz*2-2)*m+m+j;
      buff.fPols[indx++] = 2*nz*m+n;
      buff.fPols[indx++] = (nz*2-2)*m+j;
   }

   //inside & outside, number of polygons: (nz-1)*2*(n-1)
   for (k = 0; k < (nz-1); k++) {
      for (j = 0; j < n-1; j++) {
         buff.fPols[indx++] = c;
         buff.fPols[indx++] = 4;
         buff.fPols[indx++] = 2*k*m+j;
         buff.fPols[indx++] = nz*2*m+(2*k+2)*n+j+1;
         buff.fPols[indx++] = (2*k+2)*m+j;
         buff.fPols[indx++] = nz*2*m+(2*k+2)*n+j;
      }
      for (j = 0; j < n-1; j++) {
         buff.fPols[indx++] = c+1;
         buff.fPols[indx++] = 4;
         buff.fPols[indx++] = (2*k+1)*m+j;
         buff.fPols[indx++] = nz*2*m+(2*k+3)*n+j;
         buff.fPols[indx++] = (2*k+3)*m+j;
         buff.fPols[indx++] = nz*2*m+(2*k+3)*n+j+1;
      }
      if (specialCase) {
         buff.fPols[indx++] = c;
         buff.fPols[indx++] = 4;
         buff.fPols[indx++] = 2*k*m+j;
         buff.fPols[indx++] = nz*2*m+(2*k+2)*n;
         buff.fPols[indx++] = (2*k+2)*m+j;
         buff.fPols[indx++] = nz*2*m+(2*k+2)*n+j;
 
         buff.fPols[indx++] = c+1;
         buff.fPols[indx++] = 4;
         buff.fPols[indx++] = (2*k+1)*m+j;
         buff.fPols[indx++] = nz*2*m+(2*k+3)*n+j;
         buff.fPols[indx++] = (2*k+3)*m+j;
         buff.fPols[indx++] = nz*2*m+(2*k+3)*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;
         buff.fPols[indx++] = indx2+(2*k+3)*n+n-1;
         buff.fPols[indx++] = indx2+2*nz*n+2*k+1;
         buff.fPols[indx++] = indx2+2*(k+1)*n+n-1;
      }
      buff.fPols[indx-8] = indx2+n;
      buff.fPols[indx-2] = indx2+2*n-1;
   }
}   

//_____________________________________________________________________________
Double_t TGeoPcon::SafetyToSegment(const Double_t *point, Int_t ipl, Bool_t in, Double_t safmin) const
{
// Compute safety from POINT to segment between planes ipl, ipl+1 within safmin.

   Double_t safe = TGeoShape::Big();
   if (ipl<0 || ipl>fNz-2) return (safmin+1.); // error in input plane
// Get info about segment.
   Double_t dz = 0.5*(fZ[ipl+1]-fZ[ipl]);
   if (dz<1E-9) return 1E9; // radius-changing segment
   Double_t ptnew[3];
   memcpy(ptnew, point, 3*sizeof(Double_t));
   ptnew[2] -= 0.5*(fZ[ipl]+fZ[ipl+1]);
   safe = TMath::Abs(ptnew[2])-dz;
   if (safe>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];
   Bool_t   is_tube = (TGeoShape::IsSameWithinTolerance(rmin1,rmin2) && TGeoShape::IsSameWithinTolerance(rmax1,rmax2))?kTRUE:kFALSE;
   if (!fFullPhi) {
      if (is_tube) safe = TGeoTubeSeg::SafetyS(ptnew,in,rmin1,rmax1, dz,fPhi1,fPhi1+fDphi,0);
      else         safe = TGeoConeSeg::SafetyS(ptnew,in,dz,rmin1,rmax1,rmin2,rmax2,fPhi1,fPhi1+fDphi,0);
   } else {
      if (is_tube) safe = TGeoTube::SafetyS(ptnew,in,rmin1,rmax1,dz,0);
      else         safe = TGeoCone::SafetyS(ptnew,in,dz,rmin1,rmax1,rmin2,rmax2,0);
   }
   if (safe<0) safe=0;
   return safe;   
}

//_____________________________________________________________________________
Double_t TGeoPcon::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.
   //---> localize the Z segment
   
   Double_t safmin, saftmp;
   Double_t dz;
   Int_t ipl, iplane;

   if (in) {
   //---> point is inside pcon
      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
      if (ipl>0 && TGeoShape::IsSameWithinTolerance(fZ[ipl-1],fZ[ipl]) && TGeoShape::IsSameWithinTolerance(point[2],fZ[ipl-1])) ipl--;
      dz = 0.5*(fZ[ipl+1]-fZ[ipl]);
      if (dz<1E-8) {
         // Point on a segment-changing plane
         safmin = TMath::Min(point[2]-fZ[ipl-1],fZ[ipl+2]-point[2]);
         saftmp = TGeoShape::Big();
         if (fDphi<360) saftmp = TGeoShape::SafetyPhi(point,in,fPhi1,fPhi1+fDphi);
         if (saftmp<safmin) safmin = saftmp;
         Double_t radius = TMath::Sqrt(point[0]*point[0]+point[1]*point[1]);
         if (fRmin[ipl]>0) safmin = TMath::Min(safmin, radius-fRmin[ipl]);
         if (fRmin[ipl+1]>0) safmin = TMath::Min(safmin, radius-fRmin[ipl+1]);
         safmin = TMath::Min(safmin, fRmax[ipl]-radius);
         safmin = TMath::Min(safmin, fRmax[ipl+1]-radius);
         if (safmin<0) safmin = 0;
         return safmin;
      }   
      // Check safety for current segment
      safmin = SafetyToSegment(point, ipl);
      if (safmin>1E10) {
         //  something went wrong - point is not inside current segment
         return 0.;
      }
      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,kFALSE,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,kFALSE,safmin));
         if (saftmp<safmin) safmin=saftmp;
         iplane--;
      }   
      return safmin;
   }   
   //---> point is outside pcon
   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+2<fNz)) {
      ipl++;
      dz = 0.5*(fZ[ipl+1]-fZ[ipl]);
   }   
   // Check safety for current segment
   safmin = SafetyToSegment(point, ipl, kFALSE);
   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,kFALSE,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,kFALSE,safmin));
      if (saftmp<safmin) safmin=saftmp;
      iplane--;
   }   
   return safmin;
}

//_____________________________________________________________________________
void TGeoPcon::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 << "   nz    = " << fNz << ";" << std::endl;
   out << "   TGeoPcon *pcon = new TGeoPcon(\"" << GetName() << "\",phi1,dphi,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 << "   pcon->DefineSection(" << i << ", z,rmin,rmax);" << std::endl;
   }
   out << "   TGeoShape *" << GetPointerName() << " = pcon;" << std::endl;
   TObject::SetBit(TGeoShape::kGeoSavePrimitive);
}
         
//_____________________________________________________________________________
void TGeoPcon::SetDimensions(Double_t *param)
{
// Set polycone dimensions starting from an array.
   fPhi1    = param[0];
   while (fPhi1<0) fPhi1 += 360.;
   fDphi    = param[1];
   fNz      = (Int_t)param[2];
   if (fNz<2) {
      Error("SetDimensions","Pcon %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));
   if (TGeoShape::IsSameWithinTolerance(fDphi,360)) fFullPhi = kTRUE;
   Double_t phi1 = fPhi1;
   Double_t phi2 = phi1+fDphi;
   Double_t phim = 0.5*(phi1+phi2);
   fC1 = TMath::Cos(phi1*TMath::DegToRad());
   fS1 = TMath::Sin(phi1*TMath::DegToRad());
   fC2 = TMath::Cos(phi2*TMath::DegToRad());
   fS2 = TMath::Sin(phi2*TMath::DegToRad());
   fCm = TMath::Cos(phim*TMath::DegToRad());
   fSm = TMath::Sin(phim*TMath::DegToRad());
   fCdphi = TMath::Cos(0.5*fDphi*TMath::DegToRad());

   for (Int_t i=0; i<fNz; i++) 
      DefineSection(i, param[3+3*i], param[4+3*i], param[5+3*i]);
}   

//_____________________________________________________________________________
void TGeoPcon::SetPoints(Double_t *points) const
{
// create polycone mesh points
   Double_t phi, dphi;
   Int_t n = gGeoManager->GetNsegments() + 1;
   dphi = fDphi/(n-1);
   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++] = fRmin[i] * TMath::Cos(phi);
            points[indx++] = fRmin[i] * TMath::Sin(phi);
            points[indx++] = fZ[i];
         }
         for (j = 0; j < n; j++) {
            phi = (fPhi1+j*dphi)*TMath::DegToRad();
            points[indx++] = fRmax[i] * TMath::Cos(phi);
            points[indx++] = fRmax[i] * TMath::Sin(phi);
            points[indx++] = fZ[i];
         }
      }
   }
}

//_____________________________________________________________________________
void TGeoPcon::SetPoints(Float_t *points) const
{
// create polycone mesh points
   Double_t phi, dphi;
   Int_t n = gGeoManager->GetNsegments() + 1;
   dphi = fDphi/(n-1);
   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++] = fRmin[i] * TMath::Cos(phi);
            points[indx++] = fRmin[i] * TMath::Sin(phi);
            points[indx++] = fZ[i];
         }
         for (j = 0; j < n; j++) {
            phi = (fPhi1+j*dphi)*TMath::DegToRad();
            points[indx++] = fRmax[i] * TMath::Cos(phi);
            points[indx++] = fRmax[i] * TMath::Sin(phi);
            points[indx++] = fZ[i];
         }
      }
   }
}
//_____________________________________________________________________________
Int_t TGeoPcon::GetNmeshVertices() const
{
// Return number of vertices of the mesh representation
   Int_t n = gGeoManager->GetNsegments()+1;
   Int_t numPoints = fNz*2*n;
   return numPoints;
}   

//_____________________________________________________________________________
void TGeoPcon::Sizeof3D() const
{
///// fill size of this 3-D object
///   TVirtualGeoPainter *painter = gGeoManager->GetGeomer();
///   if (!painter) return;
///    Int_t n;
   ///
///    n = gGeoManager->GetNsegments()+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);
}

//_____________________________________________________________________________
void TGeoPcon::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 = gGeoManager->GetNsegments()+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));
}

//_____________________________________________________________________________
const TBuffer3D & TGeoPcon::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 = gGeoManager->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 TGeoPcon::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGeoPcon.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGeoPcon::Class(),this);
      if (TGeoShape::IsSameWithinTolerance(fDphi,360)) fFullPhi = kTRUE;
      Double_t phi1 = fPhi1;
      Double_t phi2 = phi1+fDphi;
      Double_t phim = 0.5*(phi1+phi2);
      fC1 = TMath::Cos(phi1*TMath::DegToRad());
      fS1 = TMath::Sin(phi1*TMath::DegToRad());
      fC2 = TMath::Cos(phi2*TMath::DegToRad());
      fS2 = TMath::Sin(phi2*TMath::DegToRad());
      fCm = TMath::Cos(phim*TMath::DegToRad());
      fSm = TMath::Sin(phim*TMath::DegToRad());
      fCdphi = TMath::Cos(0.5*fDphi*TMath::DegToRad());
   } else {
      R__b.WriteClassBuffer(TGeoPcon::Class(),this);
   }
}

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