library: libRooFit #include "RooIntegrator1D.h"

# RooIntegrator1D

class description - source file - inheritance tree (.pdf)

## class RooIntegrator1D : public RooAbsIntegrator

| Inheritance Chart:

`TObject`

<-

`RooAbsIntegrator`

<-

`RooIntegrator1D`

<-

`RooIntegrator2D` |

        protected:

           Double_t addMidpoints(Int_t n)
           Double_t addTrapezoids(Int_t n)
               void extrapolate(Int_t n)
             Bool_t initialize()
          Double_t* xvec(Double_t& xx)

        public:

                                    RooIntegrator1D()
                                    RooIntegrator1D(const RooAbsFunc& function, RooIntegrator1D::SummationRule rule = Trapezoid, Int_t maxSteps = 0, Double_t eps = 0)
                                    RooIntegrator1D(const RooAbsFunc& function, Double_t xmin, Double_t xmax, RooIntegrator1D::SummationRule rule = Trapezoid, Int_t maxSteps = 0, Double_t eps = 0)
                                    RooIntegrator1D(const RooAbsFunc& function, const RooNumIntConfig& config)
                                    RooIntegrator1D(const RooAbsFunc& function, Double_t xmin, Double_t xmax, const RooNumIntConfig& config)
                                    RooIntegrator1D(const RooIntegrator1D&)
                            virtual ~RooIntegrator1D()
                     virtual Bool_t canIntegrate1D() const
                     virtual Bool_t canIntegrate2D() const
                     virtual Bool_t canIntegrateND() const
                     virtual Bool_t canIntegrateOpenEnded() const
                     virtual Bool_t checkLimits() const
                     static TClass* Class()
          virtual RooAbsIntegrator* clone(const RooAbsFunc& function, const RooNumIntConfig& config) const
                   virtual Double_t integral(const Double_t* yvec = 0)
                    virtual TClass* IsA() const
                     virtual Bool_t setLimits(Double_t xmin, Double_t xmax)
                     virtual Bool_t setUseIntegrandLimits(Bool_t flag)
                       virtual void ShowMembers(TMemberInspector& insp, char* parent)
                       virtual void Streamer(TBuffer& b)
                               void StreamerNVirtual(TBuffer& b)

### Data Members

        protected:

                                  Bool_t _useIntegrandLimits
          RooIntegrator1D::SummationRule _rule
                                   Int_t _maxSteps
                                   Int_t _minStepsZero
                                   Int_t _fixSteps
                                Double_t _epsAbs
                                Double_t _epsRel
                                  Bool_t _doExtrap
                                Double_t _xmin                ! do not persist
                                Double_t _xmax                ! do not persist
                                Double_t _range               ! do not persist
                                Double_t _extrapValue         ! do not persist
                                Double_t _extrapError         ! do not persist
                               Double_t* _h                   ! do not persist
                               Double_t* _s                   ! do not persist
                               Double_t* _c                   ! do not persist
                               Double_t* _d                   ! do not persist
                                Double_t _savedResult         ! do not persist
                               Double_t* _x                   ! do not persist

        public:

          static const RooIntegrator1D::SummationRule Trapezoid
          static const RooIntegrator1D::SummationRule Midpoint
                  static const enum RooIntegrator1D:: _nPoints

## Class Description

RooIntegrator1D()

RooIntegrator1D(const RooAbsFunc& function, SummationRule rule, Int_t maxSteps, Double_t eps) : RooAbsIntegrator(function), _rule(rule), _maxSteps(maxSteps), _minStepsZero(999), _fixSteps(0), _epsAbs(eps), _epsRel(eps), _doExtrap(kTRUE)

     Use this form of the constructor to integrate over the function's default range.

RooIntegrator1D(const RooAbsFunc& function, Double_t xmin, Double_t xmax, SummationRule rule, Int_t maxSteps, Double_t eps) : RooAbsIntegrator(function), _rule(rule), _maxSteps(maxSteps), _minStepsZero(999), _fixSteps(0), _epsAbs(eps), _epsRel(eps), _doExtrap(kTRUE)

     Use this form of the constructor to override the function's default range.

RooIntegrator1D(const RooAbsFunc& function, const RooNumIntConfig& config) : RooAbsIntegrator(function,config.printEvalCounter()), _epsAbs(config.epsAbs()), _epsRel(config.epsRel())

     Use this form of the constructor to integrate over the function's default range.

RooIntegrator1D(const RooAbsFunc& function, Double_t xmin, Double_t xmax, const RooNumIntConfig& config) : RooAbsIntegrator(function,config.printEvalCounter()), _epsAbs(config.epsAbs()), _epsRel(config.epsRel())

     Use this form of the constructor to override the function's default range.

RooAbsIntegrator* clone(const RooAbsFunc& function, const RooNumIntConfig& config) const

Bool_t initialize()

     apply defaults if necessary

~RooIntegrator1D()

     Release integrator workspace

Bool_t setLimits(Double_t xmin, Double_t xmax)

     Change our integration limits. Return kTRUE if the new limits are
     ok, or otherwise kFALSE. Always returns kFALSE and does nothing
     if this object was constructed to always use our integrand's limits.

Bool_t checkLimits() const

     Check that our integration range is finite and otherwise return kFALSE.
     Update the limits from the integrand if requested.

Double_t integral(const Double_t *yvec)

Double_t addMidpoints(Int_t n)

     Calculate the n-th stage of refinement of the Second Euler-Maclaurin
     summation rule which has the useful property of not evaluating the
     integrand at either of its endpoints but requires more function
     evaluations than the trapezoidal rule. This rule can be used with
     a suitable change of variables to estimate improper integrals.

Double_t addTrapezoids(Int_t n)

     Calculate the n-th stage of refinement of the extended trapezoidal
     summation rule. This is the most efficient rule for a well behaved
     integrand that can be evaluated over its entire range, including the
     endpoints.

void extrapolate(Int_t n)

### Inline Functions

                     Bool_t setUseIntegrandLimits(Bool_t flag)
                     Bool_t canIntegrate1D() const
                     Bool_t canIntegrate2D() const
                     Bool_t canIntegrateND() const
                     Bool_t canIntegrateOpenEnded() const
                  Double_t* xvec(Double_t& xx)
                    TClass* Class()
                    TClass* IsA() const
                       void ShowMembers(TMemberInspector& insp, char* parent)
                       void Streamer(TBuffer& b)
                       void StreamerNVirtual(TBuffer& b)
            RooIntegrator1D RooIntegrator1D(const RooIntegrator1D&)

Last update: Tue Jun 28 18:13:15 2005
Copyright (c) 2000-2005, Regents of the University of California *