integrate.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2015-2020,2022
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_INTEGRATE_H_
#define SRC_INCLUDE_SMASH_INTEGRATE_H_
 
#include <cuba.h>
 
#include <algorithm>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
 
#include "gsl/gsl_integration.h"
#include "gsl/gsl_monte_plain.h"
#include "gsl/gsl_monte_vegas.h"
 
#include "fpenvironment.h"
#include "random.h"
 
namespace smash {
 
struct GslWorkspaceDeleter {
  constexpr GslWorkspaceDeleter() = default;
 
  void operator()(gsl_integration_cquad_workspace *ptr) const {
    if (ptr == nullptr) {
      return;
    }
    gsl_integration_cquad_workspace_free(ptr);
  }
};
 
class Result : public std::pair<double, double> {
  using Base = std::pair<double, double>;
 
 public:
  using Base::pair;
 
  operator double() const { return Base::first; }
 
  double value() const { return Base::first; }
 
  double error() const { return Base::second; }
 
  void check_error(const std::string &integration_name,
                   double relative_tolerance = 5e-4,
                   double absolute_tolerance = 1e-9) const {
    const double allowed_error =
        std::max(absolute_tolerance, value() * relative_tolerance);
    if (error() > allowed_error) {
      std::stringstream error_msg;
      error_msg << integration_name << " resulted in I = " << value() << " ± "
                << error()
                << ", but the required precision is either absolute error < "
                << absolute_tolerance << " or relative error < "
                << relative_tolerance << std::endl;
      throw std::runtime_error(error_msg.str());
    }
  }
};
 
class Integrator {
 public:
  explicit Integrator(size_t workspace_size = 1000)
      : workspace_(gsl_integration_cquad_workspace_alloc(workspace_size)) {}
 
  template <typename F>
  Result operator()(double a, double b, F &&fun) {
    Result result;
    const gsl_function gslfun{
        /* important! The lambda cannot use captures, otherwise the
         * conversion to a function pointer type is impossible. */
        [](double x, void *type_erased) -> double {
          auto &&f = *static_cast<F *>(type_erased);
          return f(x);
        },
        &fun};
    // We disable float traps when calling GSL code we cannot control.
    DisableFloatTraps guard;
    const int error_code = gsl_integration_cquad(
        &gslfun, a, b, accuracy_absolute_, accuracy_relative_, workspace_.get(),
        &result.first, &result.second,
        nullptr /* Don't store the number of evaluations */);
    if (error_code) {
      std::stringstream err;
      err << "GSL 1D deterministic integration: " << gsl_strerror(error_code);
      throw std::runtime_error(err.str());
    }
    result.check_error("GSL 1D deterministic integration", accuracy_relative_,
                       accuracy_absolute_);
    return result;
  }
 
  void set_precision(double absolute, double relative) {
    accuracy_absolute_ = absolute;
    accuracy_relative_ = relative;
  }
 
 private:
  std::unique_ptr<gsl_integration_cquad_workspace, GslWorkspaceDeleter>
      workspace_;
 
  double accuracy_absolute_ = 1.0e-9;
 
  double accuracy_relative_ = 5.0e-4;
};
 
template <typename F>
struct Integrand2d {
  double min1;
  double diff1;
  double min2;
  double diff2;
  F f;
};
 
class Integrator2d {
 public:
  explicit Integrator2d(int num_calls = 1e6, double epsrel = 5e-4,
                        double epsabs = 1e-9)
      : maxeval_(num_calls), epsrel_(epsrel), epsabs_(epsabs) {}
 
  template <typename F>
  Result operator()(double min1, double max1, double min2, double max2, F fun) {
    Result result = {0., 0.};
 
    if (max1 < min1 || max2 < min2) {
      /* Tolerance chosen large enough for floating-point arithmetic error in
       * chained decays, consider increasing if insufficient. */
      bool tolerable = (max1 - min1 > -1.e-15) && (max2 - min2 > -1.e-15);
      if (tolerable) {
        return result;
      }
      std::stringstream err;
      err << "Integrator2d got wrong integration limits: [" << min1 << ", "
          << max1 << "], [" << min2 << ", " << max2 << "]";
      throw std::invalid_argument(err.str());
    }
 
    Integrand2d<F> f_with_limits = {min1, max1 - min1, min2, max2 - min2, fun};
 
    const integrand_t cuhre_fun{[](const int * /* ndim */, const cubareal xx[],
                                   const int * /* ncomp */, cubareal ff[],
                                   void *userdata) -> int {
      auto i = static_cast<Integrand2d<F> *>(userdata);
      /* We have to transform the integrand to the unit cube.
       * This is what Cuba expects. */
      ff[0] = (i->f)(i->min1 + i->diff1 * xx[0], i->min2 + i->diff2 * xx[1]) *
              i->diff1 * i->diff2;
      return 0;
    }};
 
    const int ndim = 2;
    const int ncomp = 1;
    void *userdata = &f_with_limits;
    const int nvec = 1;
    const int flags = 0;  // Use the defaults.
    const int mineval = 0;
    const int maxeval = maxeval_;
    const int key = -1;  // Use the default.
    const char *statefile = nullptr;
    void *spin = nullptr;
 
    Cuhre(ndim, ncomp, cuhre_fun, userdata, nvec, epsrel_, epsabs_, flags,
          mineval, maxeval, key, statefile, spin, &nregions_, &neval_, &fail_,
          &result.first, &result.second, &prob_);
 
    if (fail_) {
      std::stringstream err;
      err << "After " << neval_ << " evaluations "
          << "Cuhre integration from Cuba reports error code " << fail_;
      throw std::runtime_error(err.str());
    }
    result.check_error("Cuba integration ", epsrel_, epsabs_);
 
    return result;
  }
 
 private:
  int maxeval_;
  double epsrel_;
  double epsabs_;
  int nregions_;
  int neval_;
  int fail_;
  double prob_;
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_INTEGRATE_H_