TGeoParaboloid

class TGeoParaboloid : public TGeoBBox

    public:

                               TGeoParaboloid()
                               TGeoParaboloid(Double_t rlo, Double_t rhi, Double_t dz)
                               TGeoParaboloid(const char* name, Double_t rlo, Double_t rhi, Double_t dz)
                               TGeoParaboloid(Double_t* params)
                               TGeoParaboloid(const TGeoParaboloid&)
                       virtual ~TGeoParaboloid()
                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
                      Double_t DistToParaboloid(Double_t* point, Double_t* dir) const
           virtual TGeoVolume* Divide(TGeoVolume* voldiv, const char* divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step)
                  virtual void GetBoundingCylinder(Double_t* param) const
      virtual const TBuffer3D& GetBuffer3D(Int_t reqSections, Bool_t localFrame) const
                      Double_t GetDz() const
            virtual TGeoShape* GetMakeRuntimeShape(TGeoShape* mother, TGeoMatrix* mat) const
                 virtual Int_t GetNmeshVertices() const
                      Double_t GetRhi() const
                      Double_t GetRlo() const
                  virtual void InspectShape() const
               virtual TClass* IsA() const
                virtual Bool_t IsCylType() const
            virtual TBuffer3D* MakeBuffer3D() const
               TGeoParaboloid& operator=(const TGeoParaboloid&)
              virtual Double_t Safety(Double_t* point, Bool_t in = kTRUE) const
                  virtual void SavePrimitive(ofstream& out, Option_t* option)
                  virtual void SetDimensions(Double_t* param)
                          void SetParaboloidDimensions(Double_t rlo, Double_t rhi, Double_t dz)
                  virtual void SetPoints(Double_t* points) const
                  virtual void SetPoints(Float_t* points) 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)

Data Members

    private:

      Double_t fRlo  radius at z=-dz
      Double_t fRhi  radius at z=+dz
      Double_t fDz   range on Z axis [-dz, dz]
      Double_t fA    quadratic coeff.
      Double_t fB    Z value of parabola at x=y=0

Class Description

 Dummy constructor

 Default constructor specifying X and Y semiaxis length

 Default constructor specifying X and Y semiaxis length

 Default constructor specifying minimum and maximum radius
 param[0] =  rlo
 param[1] =  rhi
 param[2] = dz

 destructor

 compute bounding box of the tube

 Compute normal to closest surface from POINT.

 test if point is inside the elliptical tube

 compute closest distance from point px,py to each vertex

 Compute distance from a point to the parabola given by:
  z = a*rsq + b;   rsq = x*x+y*y

 compute distance from inside point to surface of the paraboloid

 compute distance from outside point to surface of the paraboloid and safe distance

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

 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.

 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.

 Create paraboloid mesh points.
 Npoints = n*(n+1) + 2
   ifirst = 0
   ipoint(i,j) = 1+i*n+j;                              i=[0,n]  j=[0,n-1]
   ilast = 1+n*(n+1)
 Nsegments = n*(2*n+3)
   lower: (0, j+1);                                    j=[0,n-1]
   circle(i): (n*i+1+j, n*i+1+(j+1)%n);                i=[0,n]  j=[0,n-1]
   generator(i): (n*i+1+j, n*(i+1)+1+j);               i,j=[0,n-1]
   upper: (n*n+1+j, (n+1)*n+1)                           j=[0,n-1]
 Npolygons = n*(n+2)
   lower: (n+j, (j+1)%n, j)                              j=[0,n-1]
   lateral(i): ((2*i+1)*n+j, 2*(i+1)*n+j, (2*i+3)*n+j, 2*(i+1)*n+(j+1)%n)
                                                      i,j = [0,n-1]
   upper: ((2n+1)*n+j, 2*n*(n+1)+(j+1)%n, 2*n*(n+1)+j)   j=[0,n-1]

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

/   Int_t n = gGeoManager->GetNsegments();
/   TVirtualGeoPainter *painter = gGeoManager->GetGeomPainter();
/   if (painter) painter->AddSize3D(n*(n+1)+2, n*(2*n+3), n*(n+2));

Inline Functions

               Double_t GetRlo() const
               Double_t GetRhi() const
               Double_t GetDz() const
                 Bool_t IsCylType() const
                TClass* Class()
                TClass* IsA() const
                   void ShowMembers(TMemberInspector& insp, char* parent)
                   void Streamer(TBuffer& b)
                   void StreamerNVirtual(TBuffer& b)
         TGeoParaboloid TGeoParaboloid(const TGeoParaboloid&)
        TGeoParaboloid& operator=(const TGeoParaboloid&)