```// @(#)root/geom:\$Id\$
// Author: Mihaela Gheata   24/01/04

/*************************************************************************
*                                                                       *
* For the licensing terms see \$ROOTSYS/LICENSE.                         *
* For the list of contributors see \$ROOTSYS/README/CREDITS.             *
*************************************************************************/

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

#include "TGeoXtru.h"

#include "Riostream.h"
#include "TBuffer3D.h"
#include "TBuffer3DTypes.h"
#include "TClass.h"
#include "TMath.h"

#include "TVirtualGeoPainter.h"
#include "TGeoManager.h"
#include "TGeoVolume.h"
#include "TGeoPolygon.h"

ClassImp(TGeoXtru)

//______________________________________________________________________________
fSeg(0), fIz(0), fXc(0), fYc(0), fPoly(0)
{
// Constructor.
}

//______________________________________________________________________________
{
// Destructor.

delete [] fXc;
delete [] fYc;
delete fPoly;
}

//______________________________________________________________________________
{
/*
}
{
}
{

td.fXc = new Double_t [fNvert];
td.fYc = new Double_t [fNvert];
memcpy(td.fXc, fX, fNvert*sizeof(Double_t));
memcpy(td.fYc, fY, fNvert*sizeof(Double_t));
td.fPoly = new TGeoPolygon(fNvert);
td.fPoly->SetXY(td.fXc, td.fYc); // initialize with current coordinates
td.fPoly->FinishPolygon();
if (tid == 0 && td.fPoly->IsIllegalCheck()) {
Error("DefinePolygon", "Shape %s of type XTRU has an illegal polygon.", GetName());
}
}
*/
}

//______________________________________________________________________________
{
{
delete *i;
++i;
}
}

//______________________________________________________________________________
{
for (Int_t tid=0; tid<nthreads; tid++) {
td.fXc = new Double_t [fNvert];
td.fYc = new Double_t [fNvert];
memcpy(td.fXc, fX, fNvert*sizeof(Double_t));
memcpy(td.fYc, fY, fNvert*sizeof(Double_t));
td.fPoly = new TGeoPolygon(fNvert);
td.fPoly->SetXY(td.fXc, td.fYc); // initialize with current coordinates
td.fPoly->FinishPolygon();
if (tid == 0 && td.fPoly->IsIllegalCheck()) {
Error("DefinePolygon", "Shape %s of type XTRU has an illegal polygon.", GetName());
}
}
}
}

//______________________________________________________________________________
void TGeoXtru::SetIz(Int_t iz)
{
// Set current z-plane.

}
//______________________________________________________________________________
void TGeoXtru::SetSeg(Int_t iseg)
{
// Set current segment.

}

//_____________________________________________________________________________
TGeoXtru::TGeoXtru()
:TGeoBBox(),
fNvert(0),
fNz(0),
fZcurrent(0.),
fX(0),
fY(0),
fZ(0),
fScale(0),
fX0(0),
fY0(0),
{
// dummy ctor
SetShapeBit(TGeoShape::kGeoXtru);
}

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

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

//_____________________________________________________________________________
TGeoXtru::TGeoXtru(const TGeoXtru& xt) :
TGeoBBox(xt),
fNvert(0),
fNz(0),
fZcurrent(0),
fX(0),
fY(0),
fZ(0),
fScale(0),
fX0(0),
fY0(0),
{
//copy constructor
}

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

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

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

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

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

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

//_____________________________________________________________________________
Int_t TGeoXtru::DistancetoPrimitive(Int_t px, Int_t py)
{
// compute closest distance from point px,py to each corner
const Int_t numPoints = fNvert*fNz;
return ShapeDistancetoPrimitive(numPoints, px, py);
}

//_____________________________________________________________________________
void TGeoXtru::DrawPolygon(Option_t *option)
{
// Draw the section polygon.
if (td.fPoly) td.fPoly->Draw(option);
}

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

//_____________________________________________________________________________
Double_t TGeoXtru::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
// locate Z segment
if (iact<3 && safe) {
*safe = Safety(point, kTRUE);
if (iact==0) return TGeoShape::Big();
if (iact==1 && step<*safe) return TGeoShape::Big();
}
TGeoXtru *xtru = (TGeoXtru*)this;
Int_t iz = TMath::BinarySearch(fNz, fZ, point[2]);
if (iz < 0) {
if (dir[2]<=0) {
xtru->SetIz(-1);
return 0.;
}
iz = 0;
}
if (iz==fNz-1) {
if (dir[2]>=0) {
xtru->SetIz(-1);
return 0.;
}
iz--;
} else {
if (iz>0) {
if (TGeoShape::IsSameWithinTolerance(point[2],fZ[iz])) {
if (TGeoShape::IsSameWithinTolerance(fZ[iz],fZ[iz+1]) && dir[2]<0) iz++;
else if (TGeoShape::IsSameWithinTolerance(fZ[iz],fZ[iz-1]) && dir[2]>0) iz--;
}
}
}
Bool_t convex = td.fPoly->IsConvex();
//   Double_t stepmax = step;
//   if (stepmax>TGeoShape::Big()) stepmax = TGeoShape::Big();
Double_t snext = TGeoShape::Big();
Double_t dist, sz;
Double_t pt[3];
Int_t iv, ipl, inext;
// we treat the special case when dir[2]=0
if (TGeoShape::IsSameWithinTolerance(dir[2],0)) {
for (iv=0; iv<fNvert; iv++) {
xtru->SetIz(-1);
dist = DistToPlane(point,dir,iz,iv,TGeoShape::Big(),kTRUE);
if (dist<snext) {
snext = dist;
xtru->SetSeg(iv);
if (convex) return snext;
}
}
if (snext < 1.E10) return snext;
return TGeoShape::Tolerance();
}

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

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

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

return kTRUE;
}

//_____________________________________________________________________________
void TGeoXtru::DefineSection(Int_t snum, Double_t z, Double_t x0, Double_t y0, Double_t scale)
{
// defines z position of a section plane, rmin and rmax at this z.
if ((snum<0) || (snum>=fNz)) return;
fZ[snum]  = z;
fX0[snum] = x0;
fY0[snum] = y0;
fScale[snum] = scale;
if (snum) {
if (fZ[snum]<fZ[snum-1]) {
Warning("DefineSection", "In shape: %s, Z position of section "
"%i, z=%e, not in increasing order, %i, z=%e",
GetName(),snum,fZ[snum],snum-1,fZ[snum-1]);
return;
}
}
if (snum==(fNz-1)) {
ComputeBBox();
}
}

//_____________________________________________________________________________
Double_t TGeoXtru::GetZ(Int_t ipl) const
{
// Return the Z coordinate for segment ipl.
if (ipl<0 || ipl>(fNz-1)) {
Error("GetZ","In shape %s, ipl=%i out of range (0,%i)",GetName(),ipl,fNz-1);
return 0.;
}
return fZ[ipl];
}
//_____________________________________________________________________________
void TGeoXtru::GetPlaneNormal(const Double_t *vert, Double_t *norm) const
{
// Returns normal vector to the planar quadrilateral defined by vector VERT.
// The normal points outwards the xtru.
Double_t cross = 0.;
Double_t v1[3], v2[3];
v1[0] = vert[9]-vert[0];
v1[1] = vert[10]-vert[1];
v1[2] = vert[11]-vert[2];
v2[0] = vert[3]-vert[0];
v2[1] = vert[4]-vert[1];
v2[2] = vert[5]-vert[2];
norm[0] = v1[1]*v2[2]-v1[2]*v2[1];
cross += norm[0]*norm[0];
norm[1] = v1[2]*v2[0]-v1[0]*v2[2];
cross += norm[1]*norm[1];
norm[2] = v1[0]*v2[1]-v1[1]*v2[0];
cross += norm[2]*norm[2];
if (cross < TGeoShape::Tolerance()) return;
cross = 1./TMath::Sqrt(cross);
for (Int_t i=0; i<3; i++) norm[i] *= cross;
}

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

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

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

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

return buff;
}

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

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

indx = 0;

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

buff.fPols[indx++] = c;
buff.fPols[indx++] = nvert;
indx2 = (nz-1)*nvert;

for (j=0; j<nvert; j++) {
buff.fPols[indx++] = indx2+j;
}
}

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

// loop segments
Bool_t found = kFALSE;
Double_t vert[12];
Double_t norm[3];
//   printf("plane %d: safz=%f in=%d\n", iz, safz, in);
for (iseg=0; iseg<fNvert; iseg++) {
GetPlaneVertices(iz,iseg,vert);
GetPlaneNormal(vert, norm);
saf1 = (point[0]-vert[0])*norm[0]+(point[1]-vert[1])*norm[1]+(point[2]-vert[2])*norm[2];
if (in) saf1 = -saf1;
//      printf("segment %d: (%f,%f)-(%f,%f) norm=(%f,%f,%f): saf1=%f\n", iseg, vert[0],vert[1],vert[3],vert[4],norm[0],norm[1],norm[2],saf1);
if (saf1<-1.E-8) continue;
safe = TMath::Max(safz, saf1);
safe = TMath::Abs(safe);
if (safe>safmin) continue;
safmin = safe;
found = kTRUE;
}
if (found) return safmin;
return TGeoShape::Big();
}

//_____________________________________________________________________________
Double_t TGeoXtru::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 = TGeoShape::Big();
Double_t safe;
Double_t safz = TGeoShape::Big();
TGeoXtru *xtru = (TGeoXtru*)this;
Int_t iz;
if (in) {
safmin = TMath::Min(point[2]-fZ[0], fZ[fNz-1]-point[2]);
for (iz=0; iz<fNz-1; iz++) {
safe = xtru->SafetyToSector(point, iz, safmin, in);
if (safe<safmin) safmin = safe;
}
return safmin;
}
// Accurate safety is expensive, use the bounding box
if (!TGeoBBox::Contains(point)) return TGeoBBox::Safety(point,in);
iz = TMath::BinarySearch(fNz, fZ, point[2]);
if (iz<0) {
iz = 0;
safz = fZ[0] - point[2];
} else {
if (iz==fNz-1) {
iz = fNz-2;
safz = point[2] - fZ[fNz-1];
}
}
// loop segments from iz up
Int_t i;
for (i=iz; i<fNz-1; i++) {
safe = xtru->SafetyToSector(point,i,safmin, in);
if (safe<safmin) safmin=safe;
}
// loop segments from iz-1 down
for (i=iz-1; i>=0; i--) {
safe = xtru->SafetyToSector(point,i,safmin, in);
if (safe<safmin) safmin=safe;
}
safe = TMath::Min(safmin, safz);
return safe;
}

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

//_____________________________________________________________________________
void TGeoXtru::SetCurrentZ(Double_t z, Int_t iz)
{
// Recompute current section vertices for a given Z position within range of section iz.
Double_t x0, y0, scale, a, b;
Int_t ind1, ind2;
ind1 = iz;
ind2 = iz+1;
Double_t invdz = 1./(fZ[ind2]-fZ[ind1]);
a = (fX0[ind1]*fZ[ind2]-fX0[ind2]*fZ[ind1])*invdz;
b = (fX0[ind2]-fX0[ind1])*invdz;
x0 = a+b*z;
a = (fY0[ind1]*fZ[ind2]-fY0[ind2]*fZ[ind1])*invdz;
b = (fY0[ind2]-fY0[ind1])*invdz;
y0 = a+b*z;
a = (fScale[ind1]*fZ[ind2]-fScale[ind2]*fZ[ind1])*invdz;
b = (fScale[ind2]-fScale[ind1])*invdz;
scale = a+b*z;
SetCurrentVertices(x0,y0,scale);
}

//_____________________________________________________________________________
void TGeoXtru::SetCurrentVertices(Double_t x0, Double_t y0, Double_t scale)
{
// Set current vertex coordinates according X0, Y0 and SCALE.
for (Int_t i=0; i<fNvert; i++) {
td.fXc[i] = scale*fX[i] + x0;
td.fYc[i] = scale*fY[i] + y0;
}
}

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

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

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

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

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

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

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

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

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

if (reqSections & TBuffer3D::kRawSizes) {
Int_t nz = GetNz();
Int_t nvert = GetNvert();
Int_t nbPnts = nz*nvert;
Int_t nbSegs = nvert*(2*nz-1);
Int_t nbPols = nvert*(nz-1)+2;
if (buffer.SetRawSizes(nbPnts, 3*nbPnts, nbSegs, 3*nbSegs, nbPols, 6*(nbPols-2)+2*(2+nvert))) {
buffer.SetSectionsValid(TBuffer3D::kRawSizes);
}
}
// TODO: Push down to TGeoShape?
if ((reqSections & TBuffer3D::kRaw) && buffer.SectionsValid(TBuffer3D::kRawSizes)) {
SetPoints(buffer.fPnts);
if (!buffer.fLocalFrame) {
TransformPoints(buffer.fPnts, buffer.NbPnts());
}

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

return buffer;
}

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