TGeoHype

class TGeoHype : public TGeoTube

    public:

                          TGeoHype()
                          TGeoHype(Double_t rin, Double_t stin, Double_t rout, Double_t stout, Double_t dz)
                          TGeoHype(const char* name, Double_t rin, Double_t stin, Double_t rout, Double_t stout, Double_t dz)
                          TGeoHype(Double_t* params)
                          TGeoHype(const TGeoHype&)
                  virtual ~TGeoHype()
           static TClass* Class()
             virtual void ComputeBBox()
             virtual void ComputeNormal(Double_t* point, Double_t* dir, Double_t* norm)
           virtual Bool_t Contains(Double_t* point) const
            virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
         virtual Double_t DistFromInside(Double_t* point, Double_t* dir, Int_t iact = 1, Double_t step = TGeoShape::Big(), Double_t* safe = 0) const
         virtual Double_t DistFromOutside(Double_t* point, Double_t* dir, Int_t iact = 1, Double_t step = TGeoShape::Big(), Double_t* safe = 0) const
                    Int_t DistToHype(Double_t* point, Double_t* dir, Double_t* s, Bool_t inner) const
      virtual TGeoVolume* Divide(TGeoVolume* voldiv, const char* divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step)
         virtual Double_t GetAxisRange(Int_t iaxis, Double_t& xlo, Double_t& xhi) const
             virtual void GetBoundingCylinder(Double_t* param) const
            virtual Int_t GetByteCount() const
       virtual TGeoShape* GetMakeRuntimeShape(TGeoShape* mother, TGeoMatrix* mat) const
            virtual Int_t GetNmeshVertices() const
                 Double_t GetStIn() const
                 Double_t GetStOut() const
                   Bool_t HasInner() const
             virtual void InspectShape() const
          virtual TClass* IsA() const
           virtual Bool_t IsCylType() const
       virtual TBuffer3D* MakeBuffer3D() const
                TGeoHype& operator=(const TGeoHype&)
             virtual void Paint(Option_t* option)
                 Double_t RadiusHypeSq(Double_t z, Bool_t inner) const
         virtual Double_t Safety(Double_t* point, Bool_t in = kTRUE) const
                 Double_t SafetyToHype(Double_t* point, Bool_t inner, Bool_t in) const
             virtual void SetDimensions(Double_t* param)
                     void SetHypeDimensions(Double_t rin, Double_t stin, Double_t rout, Double_t stout, Double_t dz)
             virtual void SetPoints(Double_t* buff) const
             virtual void SetPoints(Float_t* buff) const
             virtual void SetSegsAndPols(TBuffer3D* buff) const
             virtual void ShowMembers(TMemberInspector& insp, char* parent)
             virtual void Sizeof3D() const
             virtual void Streamer(TBuffer& b)
                     void StreamerNVirtual(TBuffer& b)
                 Double_t ZHypeSq(Double_t r, Bool_t inner) const

Data Members

    private:

      Double_t fTin     Tangent of stereo angle for inner surface
      Double_t fTout    Tangent of stereo angle for outer surface
      Double_t fTinsq   Squared tangent of stereo angle for inner surface
      Double_t fToutsq  Squared tangent of stereo angle for outer surface

    protected:

      Double_t fStIn   Stereo angle for inner surface
      Double_t fStOut  Stereo angle for inner surface

Class Description

 TGeoHype - Hyperboloid class defined by 5 parameters. Bounded by:
            - Two z planes at z=+/-dz
            - Inner and outer lateral surfaces. These represent the surfaces
              described by the revolution of 2 hyperbolas about the Z axis:
               r^2 - (t*z)^2 = a^2

            r = distance between hyperbola and Z axis at coordinate z
            t = tangent of the stereo angle (angle made by hyperbola
                asimptotic lines and Z axis). t=0 means cylindrical surface.
            a = distance between hyperbola and Z axis at z=0

          The inner hyperbolic surface is described by:
              r^2 - (tin*z)^2 = rin^2
           - absence of the inner surface (filled hyperboloid can be forced
             by rin=0 and sin=0
          The outer hyperbolic surface is described by:
              r^2 - (tout*z)^2 = rout^2
  TGeoHype parameters: dz[cm], rin[cm], sin[deg], rout[cm], sout[deg].
    MANDATORY conditions:
           - rin < rout
           - rout > 0
           - rin^2 + (tin*dz)^2 > rout^2 + (tout*dz)^2
    SUPPORTED CASES:
           - rin = 0, tin != 0     => inner surface conical
           - tin=0 AND/OR tout=0   => corresponding surface(s) cyllindrical
             e.g. tin=0 AND tout=0 => shape becomes a tube with: rmin,rmax,dz

_____________________________________________________________________________

 Default constructor

 Constructor specifying hyperboloid parameters.

 Constructor specifying parameters and name.

 Default constructor specifying a list of parameters
 param[0] = dz
 param[1] = rin
 param[2] = stin
 param[3] = rout
 param[4] = stout

 destructor

 Compute bounding box of the hyperboloid

 Compute normal to closest surface from POINT.

 test if point is inside this tube

 compute closest distance from point px,py to each corner

 Compute distance from inside point to surface of the hyperboloid.

 compute distance from outside point to surface of the hyperboloid.

 Compute distance from an arbitrary point to inner/outer surface of hyperboloid.
 Returns number of positive solutions. S[2] contains the solutions.

 Cannot divide hyperboloids.

 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

 in case shape has some negative parameters, these has to be computed
 in order to fit the mother

 print shape parameters

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

 Paint this shape according to option

 Fill TBuffer3D structure for segments and polygons.

 Compute r^2 = x^2 + y^2 at a given z coordinate, for either inner or outer hyperbolas.

 Compute z^2 at a given  r^2, for either inner or outer hyperbolas.

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

 Compute an underestimate of the closest distance from a point to inner or
 outer infinite hyperbolas.

 param[0] = dz
 param[1] = rin
 param[2] = stin
 param[3] = rout
 param[4] = stout

 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);

Inline Functions

              Int_t GetByteCount() const
           Double_t GetStIn() const
           Double_t GetStOut() const
             Bool_t HasInner() const
             Bool_t IsCylType() const
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)
               void StreamerNVirtual(TBuffer& b)
           TGeoHype TGeoHype(const TGeoHype&)
          TGeoHype& operator=(const TGeoHype&)