NumericalDefiniteIntegral.h

Go to the documentation of this file.

#ifndef GAUDIMATH_NUMERICALDEFINITEINTEGRAL_H
#define GAUDIMATH_NUMERICALDEFINITEINTEGRAL_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <string>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/StatusCode.h"
// ============================================================================
// GaudiMath
// ============================================================================
#include "GaudiMath/Integration.h"
// ============================================================================
// CLHEP
// ============================================================================
#include "CLHEP/GenericFunctions/AbsFunction.hh"
// ============================================================================
#include "gsl/gsl_integration.h"

#if defined(__clang__) || defined(__CLING__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winconsistent-missing-override"
#elif defined(__GNUC__) && __GNUC__ >= 5
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsuggest-override"
#endif

namespace Genfun
{
  namespace GaudiMathImplementation
  {
    class GAUDI_API NumericalDefiniteIntegral : public AbsFunction
    {
    public:
      struct _Workspace { gsl_integration_workspace* ws ; };
      struct _Function  ;
    public:

      typedef std::vector<double>   Points ;

    public:

      FUNCTION_OBJECT_DEF( NumericalDefiniteIntegral )

    public:

      NumericalDefiniteIntegral
      ( const AbsFunction&                        function            ,
        const size_t                              index               ,
        const double                              a                   ,
        const double                              b                   ,
        const GaudiMath::Integration::Type        type     =
        GaudiMath::Integration::Adaptive                              ,
        const GaudiMath::Integration::KronrodRule rule     =
        GaudiMath::Integration::Default                               ,
        const double                              epsabs   = 1.e-10   ,
        const double                              epsrel   = 1.e-7    ,
        const size_t                              size     = 1000     );


      NumericalDefiniteIntegral
      ( const AbsFunction&                  function           ,
        const size_t                        index              ,
        const double                        a                  ,
        const double                        b                  ,
        const Points&                       points             ,
        const double                        epsabs    = 1e-9   ,
        const double                        epsrel    = 1.e-6  ,
        const size_t                        size      = 1000   ) ;


      NumericalDefiniteIntegral
      ( const AbsFunction&                      function           ,
        const size_t                            index              ,
        const double                            a                  ,
        const GaudiMath::Integration::Inf       b         =
        GaudiMath::Integration::Infinity                           ,
        const double                            epsabs    = 1e-9   ,
        const double                            epsrel    = 1.e-6  ,
        const size_t                            size      = 1000   ) ;

      NumericalDefiniteIntegral
      ( const AbsFunction&                      function           ,
        const size_t                            index              ,
        const GaudiMath::Integration::Inf       a                  ,
        const double                            b                  ,
        const double                            epsabs    = 1e-9   ,
        const double                            epsrel    = 1.e-6  ,
        const size_t                            size      = 1000   ) ;

      NumericalDefiniteIntegral
      ( const AbsFunction&                      function           ,
        const size_t                            index              ,
        // FIXME: The next two arguments should be "double" but are "float" to resolve the
        // ambiguity with the first constructor when providing
        // '(const Genfun::AbsFunction, const unsigned int, const double, const double)'
        const float                             epsabs    = 1e-9   ,
        const float                             epsrel    = 1.e-6  ,
        const size_t                            size      = 1000   ) ;

      NumericalDefiniteIntegral ( const NumericalDefiniteIntegral& ) ;

      ~NumericalDefiniteIntegral() override = default;

    public:

      unsigned int dimensionality() const override { return m_DIM ; }

      double operator() ( double          argument ) const override ;
      double operator() ( const Argument& argument ) const override ;

      bool hasAnalyticDerivative() const override { return true ;}

      Genfun::Derivative partial ( unsigned int index ) const override;

    public:

      const AbsFunction& function () const { return *m_function ; }
      double             a        () const { return         m_a ; }
      double             b        () const { return         m_b ; }
      const Points&      points   () const { return    m_points ; }
      double             epsabs   () const { return    m_epsabs ; }
      double             epsrel   () const { return    m_epsrel ; }

      double             result   () const { return    m_result ; }
      double             error    () const { return     m_error ; }

      // maximal number of bisection integvals for adaptive algorithms
      size_t             size     () const { return      m_size ; }

      GaudiMath::Integration::Type
      type     () const { return      m_type ; }
      GaudiMath::Integration::Category
      category () const { return  m_category ; }
      GaudiMath::Integration::KronrodRule
      rule     () const { return      m_rule ; }

    protected:

      // adaptive integration on infinite intervals
      double                     QAGI ( _Function* fun ) const ;
      // adaptive integration  with known singular points
      double                     QAGP ( _Function* fun ) const ;
      // non-adaptive integration
      double                     QNG  ( _Function* fun ) const ;
      // adaptive integration
      double                     QAG  ( _Function* fun ) const ;
      // adaptive integral with singularities
      double                     QAGS ( _Function* fun ) const ;

      // allocate the integration workspace
      _Workspace*                allocate                () const ;
      // the integration workspace
      _Workspace*                ws                      () const
      { return m_ws.get() ; };

      // throw the exception
      StatusCode Exception
      ( const std::string& message ,
        const StatusCode&  sc = StatusCode::FAILURE ) const ;

    private:

      // defautl constructor is disabled
      NumericalDefiniteIntegral();
      // assignement is disabled
      NumericalDefiniteIntegral& operator=( const NumericalDefiniteIntegral& );

    public:
      struct gsl_ws_deleter {
          void operator()(_Workspace *p) const {
            if (p) gsl_integration_workspace_free ( p->ws ) ;
            delete p;
          }
      };
    private:

      std::unique_ptr<const AbsFunction>  m_function ;
      size_t                              m_DIM = 0  ;
      size_t                              m_index    ;

      double                              m_a  = -std::numeric_limits<double>::infinity();
      double                              m_b  = std::numeric_limits<double>::infinity();

      GaudiMath::Integration::Type        m_type     ;
      GaudiMath::Integration::Category    m_category ;
      GaudiMath::Integration::KronrodRule m_rule     ;

      Points                              m_points   ;

      double                              m_epsabs   ;
      double                              m_epsrel   ;

      mutable double                      m_result = -std::numeric_limits<double>::infinity();
      mutable double                      m_error  = std::numeric_limits<double>::infinity();

      size_t                              m_size     ;
      mutable std::unique_ptr<_Workspace,gsl_ws_deleter> m_ws;

      mutable  Argument                   m_argument ;
      mutable  Argument                   m_argF     ;

    };
    FUNCTION_OBJECT_IMP( NumericalDefiniteIntegral )

  } // end of namespace GaudiMathImplementation
} // end of namespace Genfun

#if defined(__clang__) || defined(__CLING__)
#pragma clang diagnostic pop
#elif defined(__GNUC__) && __GNUC__ >= 5
#pragma GCC diagnostic pop
#endif

// ============================================================================
// The END
// ============================================================================
#endif // GAUDIMATH_NUMERICALDEFINITEINTEGRAL_H
// ============================================================================