TGeoTube

 Default constructor

 Default constructor specifying minimum and maximum radius

 Default constructor specifying minimum and maximum radius

 Default constructor specifying minimum and maximum radius
 param[0] = Rmin
 param[1] = Rmax
 param[2] = dz

 destructor

 Computes capacity of the shape in [length^3]

 Computes capacity of the shape in [length^3]

 compute bounding box of the tube

 Compute normal to closest surface from POINT.

{
 Compute normal to closest surface from POINT.
norm[2] = 0;
Double_t phi = TMath::ATan2(point[1], point[0]);
norm[0] = TMath::Cos(phi);
norm[1] = TMath::Sin(phi);
if (norm[0]*dir[0]+norm[1]*dir[1]<0) {
norm[0] = -norm[0];
norm[1] = -norm[1];
}
}

_____________________________________________________________________________
Bool_t TGeoTube::Contains(Double_t *point) const
{
 test if point is inside this tube
if (TMath::Abs(point[2]) > fDz) return kFALSE;
Double_t r2 = point[0]*point[0]+point[1]*point[1];
if ((r2<fRmin*fRmin) || (r2>fRmax*fRmax)) return kFALSE;
return kTRUE;
}

_____________________________________________________________________________
Int_t TGeoTube::DistancetoPrimitive(Int_t px, Int_t py)
{
 compute closest distance from point px,py to each corner
Int_t n = gGeoManager->GetNsegments();
Int_t numPoints = 4*n;
if (!HasRmin()) numPoints = 2*(n+1);
return ShapeDistancetoPrimitive(numPoints, px, py);
}

_____________________________________________________________________________
Double_t TGeoTube::DistFromInsideS(Double_t *point, Double_t *dir, Double_t rmin, Double_t rmax, Double_t dz)
{
 Compute distance from inside point to surface of the tube (static)
 Boundary safe algorithm.
 compute distance to surface
 Do Z
Double_t sz = TGeoShape::Big();
if (dir[2]) {
sz = (TMath::Sign(dz, dir[2])-point[2])/dir[2];
if (sz<=0) return 0.0;
}
 Do R
Double_t nsq=dir[0]*dir[0]+dir[1]*dir[1];
if (TMath::Abs(nsq)<TGeoShape::Tolerance()) return sz;
Double_t rsq=point[0]*point[0]+point[1]*point[1];
Double_t rdotn=point[0]*dir[0]+point[1]*dir[1];
Double_t b,d;
Double_t sr = TGeoShape::Big();
 inner cylinder
if (rmin>0) {
 Protection in case point is actually outside the tube
if (rsq <= rmin*rmin+TGeoShape::Tolerance()) {
if (rdotn<0) return 0.0;
} else {
if (rdotn<0) {
DistToTube(rsq,nsq,rdotn,rmin,b,d);
if (d>0) {
sr=-b-d;
if (sr>0) return TMath::Min(sz,sr);
}
}
}
}
 outer cylinder
if (rsq >= rmax*rmax-TGeoShape::Tolerance()) {
if (rdotn>=0) return 0.0;
}
DistToTube(rsq,nsq,rdotn,rmax,b,d);
if (d>0) {
sr=-b+d;
if (sr>0) return TMath::Min(sz,sr);
}
return 0.;
}

_____________________________________________________________________________
Double_t TGeoTube::DistFromInside(Double_t *point, Double_t *dir, Int_t iact, Double_t step, Double_t *safe) const
{
 Compute distance from inside point to surface of the tube
 Boundary safe algorithm.
if (iact<3 && safe) {
*safe = Safety(point, kTRUE);
if (iact==0) return TGeoShape::Big();
if ((iact==1) && (*safe>step)) return TGeoShape::Big();
}
 compute distance to surface
return DistFromInsideS(point, dir, fRmin, fRmax, fDz);
}

_____________________________________________________________________________
Double_t TGeoTube::DistFromOutsideS(Double_t *point, Double_t *dir, Double_t rmin, Double_t rmax, Double_t dz)
{
 Static method to compute distance from outside point to a tube with given parameters
 Boundary safe algorithm.
 check Z planes
Double_t xi,yi,zi;
Double_t rmaxsq = rmax*rmax;
Double_t rminsq = rmin*rmin;
zi = dz - TMath::Abs(point[2]);
Double_t s = TGeoShape::Big();
Bool_t in = kFALSE;
Bool_t inz = (zi<0)?kFALSE:kTRUE;
if (!inz) {
if (point[2]*dir[2]>=0) return TGeoShape::Big();
s  = -zi/TMath::Abs(dir[2]);
xi = point[0]+s*dir[0];
yi = point[1]+s*dir[1];
Double_t r2=xi*xi+yi*yi;
if ((rminsq<=r2) && (r2<=rmaxsq)) return s;
}

Double_t rsq = point[0]*point[0]+point[1]*point[1];
 check outer cyl. surface
Double_t nsq=dir[0]*dir[0]+dir[1]*dir[1];
Double_t rdotn=point[0]*dir[0]+point[1]*dir[1];
Double_t b,d;
Bool_t inrmax = kFALSE;
Bool_t inrmin = kFALSE;
if (rsq<=rmaxsq+TGeoShape::Tolerance()) inrmax = kTRUE;
if (rsq>=rminsq-TGeoShape::Tolerance()) inrmin = kTRUE;
in = inz & inrmin & inrmax;
 If inside, we are most likely on a boundary within machine precision.
if (in) {
Bool_t checkout = kFALSE;
Double_t r = TMath::Sqrt(rsq);
if (zi<rmax-r) {
if ((rmin==0) || (zi<r-rmin)) {
if (point[2]*dir[2]<0) return 0.0;
return TGeoShape::Big();
}
}
if ((rmaxsq-rsq) < (rsq-rminsq)) checkout = kTRUE;
if (checkout) {
if (rdotn>=0) return TGeoShape::Big();
return 0.0;
}
if (rmin==0) return 0.0;
if (rdotn>=0) return 0.0;
 Ray exiting rmin -> check (+) solution for inner tube
if (TMath::Abs(nsq)<TGeoShape::Tolerance()) return TGeoShape::Big();
DistToTube(rsq, nsq, rdotn, rmin, b, d);
if (d>0) {
s=-b+d;
if (s>0) {
zi=point[2]+s*dir[2];
if (TMath::Abs(zi)<=dz) return s;
}
}
return TGeoShape::Big();
}
 Check outer cylinder (only r>rmax has to be considered)
if (TMath::Abs(nsq)<TGeoShape::Tolerance()) return TGeoShape::Big();
if (!inrmax) {
DistToTube(rsq, nsq, rdotn, rmax, b, d);
if (d>0) {
s=-b-d;
if (s>0) {
zi=point[2]+s*dir[2];
if (TMath::Abs(zi)<=dz) return s;
}
}
}
 check inner cylinder
if (rmin>0) {
DistToTube(rsq, nsq, rdotn, rmin, b, d);
if (d>0) {
s=-b+d;
if (s>0) {
zi=point[2]+s*dir[2];
if (TMath::Abs(zi)<=dz) return s;
}
}
}
return TGeoShape::Big();
}

_____________________________________________________________________________
Double_t TGeoTube::DistFromOutside(Double_t *point, Double_t *dir, Int_t iact, Double_t step, Double_t *safe) const
{
 Compute distance from outside point to surface of the tube and safe distance
 Boundary safe algorithm.
 fist localize point w.r.t tube
if (iact<3 && safe) {
*safe = Safety(point, kFALSE);
if (iact==0) return TGeoShape::Big();
if ((iact==1) && (step<=*safe)) return TGeoShape::Big();
}
 find distance to shape
return DistFromOutsideS(point, dir, fRmin, fRmax, fDz);
}

_____________________________________________________________________________
void TGeoTube::DistToTube(Double_t rsq, Double_t nsq, Double_t rdotn, Double_t radius, Double_t &b, Double_t &delta)
{
 Static method computing the distance to a tube with given radius, starting from
 POINT along DIR director cosines. The distance is computed as :
    RSQ   = point[0]*point[0]+point[1]*point[1]
    NSQ   = dir[0]*dir[0]+dir[1]*dir[1]  ---> should NOT be 0 !!!
    RDOTN = point[0]*dir[0]+point[1]*dir[1]
 The distance can be computed as :
    D = -B +/- DELTA
 where DELTA.GT.0 and D.GT.0

Double_t t1 = 1./nsq;
Double_t t3=rsq-(radius*radius);
b          = t1*rdotn;
Double_t c =t1*t3;
delta = b*b-c;
if (delta>0) {
delta=TMath::Sqrt(delta);
} else {
delta = -1;
}
}

_____________________________________________________________________________
TGeoVolume *TGeoTube::Divide(TGeoVolume *voldiv, const char *divname, Int_t iaxis, Int_t ndiv,
Double_t start, Double_t step)
{
--- Divide this tube 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. For radial division
 creates all volumes with different shapes and returns pointer to volume that
 was divided. In case a wrong division axis is supplied, returns pointer to
 volume that was divided.

 Returns name of axis IAXIS.

 Get range of shape for a given axis.

--- Fill vector param[4] with the bounding cylinder parameters. The order
 is the following : Rmin, Rmax, Phi1, Phi2, dZ

 print shape parameters

 Creates a TBuffer3D describing *this* shape.
 Coordinates are in local reference frame.

 Fill TBuffer3D structure for segments and polygons.

 computes the closest distance from given point to this shape, according
 to option. The matching point on the shape is stored in spoint.

 computes the closest distance from given point to this shape, according
 to option. The matching point on the shape is stored in spoint.

 Save a primitive as a C++ statement(s) on output stream "out".

 Set tube dimensions.

 Set tube dimensions starting from a list.

 create tube mesh points

 create tube mesh points

 Return number of vertices of the mesh representation

/// fill size of this 3-D object
/    TVirtualGeoPainter *painter = gGeoManager->GetGeomPainter();
/    if (!painter) return;
/    Int_t n = gGeoManager->GetNsegments();
/    Int_t numPoints = n*4;
/    Int_t numSegs   = n*8;
/    Int_t numPolys  = n*4;
/    painter->AddSize3D(numPoints, numSegs, numPolys);

 Fills a static 3D buffer and returns a reference.

 constructors