root/Math/IntegratorMultiDim.h

0001 // @(#)root/mathcore:$Id$
0002 // Authors: M. Slawinska   08/2007
0003
0004 /**********************************************************************
0005  *                                                                    *
0006  * Copyright (c) 2007 , LCG ROOT MathLib Team                         *
0007  *                                                                    *
0008  *                                                                    *
0009  **********************************************************************/
0010
0011 // Header source file for class IntegratorMultiDim
0012
0013
0014 #ifndef ROOT_Math_IntegratorMultiDim
0015 #define ROOT_Math_IntegratorMultiDim
0016
0017
0018 #include "Math/IFunctionfwd.h"
0019
0020 #include "Math/AllIntegrationTypes.h"
0021
0022 #include "Math/IntegratorOptions.h"
0023
0024 #include "Math/VirtualIntegrator.h"
0025
0026 #include "Math/WrappedFunction.h"
0027
0028 #include <memory>
0029 #include <string>
0030
0031 namespace ROOT {
0032 namespace Math {
0033
0034 //___________________________________________________________________________________________
0035 /**
0036    User class for performing multidimensional integration
0037
0038    By default uses adaptive multi-dimensional integration using the algorithm from Genz Mallik
0039    implemented in the class ROOT::Math::AdaptiveIntegratorMultiDim otherwise it can uses via the
0040    plug-in manager the MC integration class (ROOT::Math::GSLMCIntegration) from MathMore.
0041
0042    @ingroup Integration
0043
0044
0045  */
0046
0047 class IntegratorMultiDim {
0048
0049 public:
0050
0051    typedef IntegrationMultiDim::Type Type;   // for the enumerations defining the types
0052
0053
0054     /** Generic constructor of multi dimensional Integrator. By default uses the Adaptive integration method
0055
0056        @param type   integration type (adaptive, MC methods, etc..)
0057        @param absTol desired absolute Error
0058        @param relTol desired relative Error
0059        @param ncall  number of function calls (apply only to MC integration methods)
0060
0061        In case no parameter  values are passed the default ones used in IntegratorMultiDimOptions are used
0062     */
0063    explicit
0064    IntegratorMultiDim(IntegrationMultiDim::Type type = IntegrationMultiDim::kDEFAULT, double absTol = -1, double relTol = -1, unsigned int ncall = 0) :
0065       fIntegrator(nullptr)
0066    {
0067        fIntegrator = CreateIntegrator(type, absTol, relTol, ncall);
0068    }
0069
0070     /** Generic Constructor of multi dimensional Integrator passing a function. By default uses the adaptive integration method
0071
0072        @param f      integration function (multi-dim interface)
0073        @param type   integration type (adaptive, MC methods, etc..)
0074        @param absTol desired absolute Error
0075        @param relTol desired relative Error
0076        @param ncall  number of function calls (apply only to MC integration methods)
0077     */
0078    explicit
0079    IntegratorMultiDim(const IMultiGenFunction &f, IntegrationMultiDim::Type type = IntegrationMultiDim::kDEFAULT, double absTol = -1, double relTol = -1, unsigned int ncall = 0) :
0080       fIntegrator(nullptr)
0081    {
0082       fIntegrator = CreateIntegrator(type, absTol, relTol, ncall);
0083       SetFunction(f);
0084    }
0085
0086    // remove template constructor since is ambiguous
0087
0088     /** Template Constructor of multi dimensional Integrator passing a generic function. By default uses the adaptive integration method
0089
0090        @param f      integration function (generic function implementing operator()(const double *)
0091        @param dim    function dimension
0092        @param type   integration type (adaptive, MC methods, etc..)
0093        @param absTol desired absolute Error
0094        @param relTol desired relative Error
0095        @param ncall  number of function calls (apply only to MC integration methods)
0096     */
0097 // this is ambiguous
0098 //    template<class Function>
0099 //    IntegratorMultiDim(Function & f, unsigned int dim, IntegrationMultiDim::Type type = IntegrationMultiDim::kADAPTIVE, double absTol = 1.E-9, double relTol = 1E-6, unsigned int ncall = 100000) {
0100 //       fIntegrator = CreateIntegrator(type, absTol, relTol, ncall);
0101 //       SetFunction(f, dim);
0102 //    }
0103
0104    /// destructor
0105    virtual ~IntegratorMultiDim() {
0106       if (fIntegrator) delete fIntegrator;
0107    }
0108
0109
0110    // disable copy constructor and assignment operator
0111
0112 private:
0113    IntegratorMultiDim(const IntegratorMultiDim &) : fIntegrator(nullptr), fFunc(nullptr) {}
0114    IntegratorMultiDim & operator=(const IntegratorMultiDim &) { return *this; }
0115
0116 public:
0117
0118
0119    /**
0120       evaluate the integral with the previously given function between xmin[] and xmax[]
0121    */
0122    double Integral(const double* xmin, const double * xmax) {
0123       return !fIntegrator ? 0 : fIntegrator->Integral(xmin,xmax);
0124    }
0125
0126    /// evaluate the integral passing a new function
0127    double Integral(const IMultiGenFunction &f, const double* xmin, const double * xmax) {
0128       SetFunction(f);
0129       return Integral(xmin,xmax);
0130    }
0131
0132    /// evaluate the integral passing a new generic function
0133    template<class Function>
0134    double Integral(Function & f , unsigned int dim, const double* xmin, const double * xmax) {
0135       SetFunction<Function>(f,dim);
0136       return Integral(xmin, xmax);
0137    }
0138
0139
0140    /**
0141        set integration function using a generic function implementing the operator()(double *x)
0142        The dimension of the function is in this case required
0143    */
0144    template <class Function>
0145    void SetFunction(Function & f, unsigned int dim) {
0146       fFunc.reset(new  WrappedMultiFunction<Function &> (f, dim) );
0147       fIntegrator->SetFunction(*fFunc);
0148    }
0149
0150    // set the function without cloning it
0151    void SetFunction(const IMultiGenFunction &f) {
0152       if (fIntegrator)  fIntegrator->SetFunction(f);
0153    }
0154
0155    /// return result of last integration
0156    double Result() const { return !fIntegrator ? 0 : fIntegrator->Result(); }
0157
0158    /// return integration error
0159    double Error() const { return !fIntegrator ? 0 : fIntegrator->Error(); }
0160
0161    ///  return the Error Status of the last Integral calculation
0162    int Status() const { return !fIntegrator ? -1 : fIntegrator->Status(); }
0163
0164    // return number of function evaluations in calculating the integral
0165    //unsigned int NEval() const { return fNEval; }
0166
0167    /// set the relative tolerance
0168    void SetRelTolerance(double relTol) { if (fIntegrator) fIntegrator->SetRelTolerance(relTol); }
0169
0170    /// set absolute tolerance
0171    void SetAbsTolerance(double absTol)  { if (fIntegrator) fIntegrator->SetAbsTolerance(absTol); }
0172
0173    /// set the options
0174    void SetOptions(const ROOT::Math::IntegratorMultiDimOptions & opt) { if (fIntegrator) fIntegrator->SetOptions(opt); }
0175
0176    /// retrieve the options
0177    ROOT::Math::IntegratorMultiDimOptions Options() const { return fIntegrator ? fIntegrator->Options() : IntegratorMultiDimOptions(); }
0178
0179    /// return a pointer to integrator object
0180    VirtualIntegratorMultiDim * GetIntegrator() { return fIntegrator; }
0181
0182    /// return name of integrator
0183    std::string Name() const { return fIntegrator ? Options().Integrator() : std::string(""); }
0184
0185    /// static function to get the enumeration from a string
0186    static IntegrationMultiDim::Type GetType(const char * name);
0187
0188    /// static function to get a string from the enumeration
0189    static std::string GetName(IntegrationMultiDim::Type);
0190
0191 protected:
0192
0193    VirtualIntegratorMultiDim * CreateIntegrator(IntegrationMultiDim::Type type , double absTol, double relTol, unsigned int ncall);
0194
0195  private:
0196
0197    VirtualIntegratorMultiDim * fIntegrator;     ///< pointer to multi-dimensional integrator base class
0198    std::unique_ptr<IMultiGenFunction> fFunc;    ///< pointer to owned function
0199
0200
0201 };
0202
0203 }//namespace Math
0204 }//namespace ROOT
0205
0206 #endif /* ROOT_Math_IntegratorMultiDim */