Bin.h

Go to the documentation of this file.

// -*- C++ -*-
//
// This file is part of YODA -- Yet more Objects for Data Analysis
// Copyright (C) 2008-2023 The YODA collaboration (see AUTHORS for details)
//
#ifndef YODA_Bin_h
#define YODA_Bin_h
 
#include "YODA/Utils/BinUtils.h"
#include "YODA/Utils/Traits.h"
#include <iostream>
 
namespace YODA {
 
  template <typename T>
  struct ArithmeticWrapper {
    // {
    ArithmeticWrapper() : _storedNumber(0) {}
 
    ArithmeticWrapper(T num) : _storedNumber(num) {}
    // }
 
    // {
 
    ArithmeticWrapper<T>& operator+=(T&& rhs) {
      _storedNumber += std::forward<T>(rhs);
      return *this;
    }
    ArithmeticWrapper<T>& operator-=(T&& rhs) {
      _storedNumber -= std::forward<T>(rhs);
      return *this;
    }
    ArithmeticWrapper<T>& operator/=(T&& rhs) {
      _storedNumber /= std::forward<T>(rhs);
      return *this;
    }
    ArithmeticWrapper<T>& operator*=(T&& rhs) {
      _storedNumber *= std::forward<T>(rhs);
      return *this;
    }
 
    template<typename RetT = ArithmeticWrapper<T>>
    auto operator%=(T&& rhs)
    -> std::enable_if_t<std::is_integral<T>::value, RetT&> {
      _storedNumber %= std::forward<T>(rhs);
      return *this;
    }
    // }
 
    operator T() { return _storedNumber; }
 
    operator const T&() const { return _storedNumber; }
 
    T _storedNumber;
  };
 
  template <typename T, typename BinningT>
  class BinBase : public std::conditional_t<std::is_arithmetic<T>::value,
                                            ArithmeticWrapper<T>, T> {
  protected:
 
    // {
    using isArithmetic = std::conditional_t<std::is_arithmetic<T>::value,
                                            std::true_type, std::false_type>;
 
    using BaseT = std::conditional_t<isArithmetic::value,
                                     ArithmeticWrapper<T>, T>;
 
    template <size_t axisNum>
    using axisEdgeT = typename BinningT::template getAxisT<axisNum>::EdgeT;
 
    // }
 
  public:
    // {
 
    // For self-consistency, the user should
    // always pass the parent binning!
    BinBase() = delete;
 
    // Default copy constructor for STL vector
    BinBase(const BinBase& rhs) = default;
 
    // Default move constructor for STL vector
    BinBase(BinBase&& rhs) = default;
 
 
    BinBase(size_t binIndex, const BinningT& binning)
        : _binIndex(binIndex), _binning(&binning) { }
 
    BinBase(const T& storedVal, size_t binIndex, const BinningT& binning)
        : BaseT(storedVal), _binIndex(binIndex), _binning(&binning) { }
 
    BinBase(T&& storedVal, size_t binIndex, const BinningT& binning)
        : BaseT(std::move(storedVal)), _binIndex(binIndex), _binning(&binning) { }
 
    BinBase(const BinBase& other, const BinningT& binning)
        : BaseT(other), _binIndex(other._binIndex), _binning(&binning) { }
 
    BinBase& operator=(BaseT&& rhs) noexcept {
      //BaseT::operator=(std::forward<BaseT>(rhs));
      BaseT::operator=(std::move(rhs));
      return *this;
    }
 
    BinBase& operator=(const BaseT& rhs) noexcept {
      BaseT::operator=(rhs);
      return *this;
    }
 
    BinBase& operator=(const BinBase& rhs) noexcept {
      if (this != &rhs) {
        BaseT::operator=(rhs);
      }
      return *this;
    }
 
    BinBase& operator=(BinBase&& rhs) noexcept {
      if (this != &rhs) {
        BaseT::operator=(std::move(rhs));
      }
      return *this;
    }
 
    // @}
 
    // @{
 
    const T& raw() const noexcept {
      return *this;
    }
 
    size_t index() const noexcept {
      return _binIndex;
    }
 
    bool isMasked() const noexcept {
      return _binning->isMasked(_binIndex);
    }
 
    bool isVisible() const noexcept {
      return _binning->isVisible(_binIndex);
    }
 
    // @}
 
    // @{
 
    double dVol() const noexcept {
      return _binning->dVol(_binIndex);
    }
 
    template <size_t dimNum>
    enable_if_CAxisT<axisEdgeT<dimNum>> width() const noexcept {
      const auto& axis = _binning->template axis<dimNum>();
      size_t binIdx = _binning->globalToLocalIndices(_binIndex)[dimNum];
      return axis.width(binIdx);
    }
 
    template <size_t dimNum>
    enable_if_CAxisT<axisEdgeT<dimNum>> max() const noexcept {
      const auto& axis = _binning->template axis<dimNum>();
      size_t binIdx = _binning->globalToLocalIndices(_binIndex)[dimNum];
      return axis.max(binIdx);
    }
 
    template <size_t dimNum>
    enable_if_CAxisT<axisEdgeT<dimNum>> min() const noexcept {
      const auto& axis = _binning->template axis<dimNum>();
      size_t binIdx = _binning->globalToLocalIndices(_binIndex)[dimNum];
      return axis.min(binIdx);
    }
 
    template <size_t dimNum>
    enable_if_CAxisT<axisEdgeT<dimNum>> mid() const noexcept {
      const auto& axis = _binning->template axis<dimNum>();
      size_t binIdx = _binning->globalToLocalIndices(_binIndex)[dimNum];
      return axis.mid(binIdx);
    }
 
    template <size_t dimNum>
    enable_if_DAxisT<axisEdgeT<dimNum>> edge() const noexcept {
      const auto& axis = _binning->template axis<dimNum>();
      size_t binIdx = _binning->globalToLocalIndices(_binIndex)[dimNum];
      return axis.edge(binIdx);
    }
 
    // @}
 
  protected:
 
    const size_t _binIndex;
 
    const BinningT* _binning;
  };
 
 
  template <size_t N, typename T, typename BinningT>
  class Bin : public BinBase<T, BinningT> {
 
  protected:
 
    using BaseT = BinBase<T, BinningT>;
 
  public:
 
    using BaseT::BaseT;
    using BaseT::operator=;
 
    // For self-consistency, the user should
    // always pass the parent binning!
    Bin() = delete;
 
    /* This would have been a nice idea, except we cannot guarantee
      that the content type even has the concept of a value.
    double value(const bool divbyvol = false) const noexcept {
      const double scale = divbyvol? BaseT::dVol() : 1.0;
      if constexpr (hasFillDim<T>::value) {
        if constexpr (T::FillDim::value > N) {
          return BaseT::mean(T::FillDim::value) / scale;// profiles
        }
        return BaseT::sumW() / scale; // histograms
      }
      return BaseT::value() / scale; // other
    }
 
    double valueErr(const bool divbyvol = false) const noexcept {
      const double scale = divbyvol? BaseT::dVol() : 1.0;
      if constexpr (hasFillDim<T>::value) {
        if constexpr (T::FillDim::value > N) { // profiles
          return BaseT::stdErr(T::FillDim::value) / scale;
        }
        return BaseT::errW() / scale; // histograms
      }
      return BaseT::valueErr() / scale; // other
    }
 
    double relErr() const noexcept {
      return value()? valueErr() / value() : std::numeric_limits<double>::quiet_NaN();
    }
 
    double density() const noexcept {
      return value() / BaseT::dVol();
    }
 
    double densityErr() const noexcept {
      return valueErr() / BaseT::dVol();
    }*/
 
  };
 
 
  template<typename T, typename BinningT>
  class Bin<1, T, BinningT>
               : public BinBase<T, BinningT>,
                 public XBinMixin<Bin<1, T, BinningT>,
                                  typename BinningT::template getEdgeT<0>> {
  protected:
 
    using BaseT = BinBase<T, BinningT>;
 
    template <size_t axisNum>
    using axisEdgeT = typename BinningT::template getAxisT<axisNum>::EdgeT;
 
  public:
 
    using BaseT::BaseT;
    using BaseT::operator=;
 
    // For self-consistency, the user should
    // always pass the parent binning!
    Bin() = delete;
 
    double dLen() const noexcept { return BaseT::dVol(); }
 
  };
 
 
  template<typename T, typename BinningT>
  class Bin<2, T, BinningT>
               : public BinBase<T, BinningT>,
                 public XBinMixin<Bin<2, T, BinningT>,
                                  typename BinningT::template getEdgeT<0>>,
                 public YBinMixin<Bin<2, T, BinningT>,
                                  typename BinningT::template getEdgeT<1>> {
 
  protected:
 
    using BaseT = BinBase<T, BinningT>;
 
    template <size_t axisNum>
    using axisEdgeT = typename BinningT::template getAxisT<axisNum>::EdgeT;
 
  public:
 
    using BaseT::BaseT;
    using BaseT::operator=;
 
    // For self-consistency, the user should
    // always pass the parent binning!
    Bin() = delete;
 
    double dArea() const noexcept { return BaseT::dVol(); }
 
  };
 
 
  template<typename T, typename BinningT>
  class Bin<3, T, BinningT>
               : public BinBase<T, BinningT>,
                 public XBinMixin<Bin<3, T, BinningT>,
                                  typename BinningT::template getEdgeT<0>>,
                 public YBinMixin<Bin<3, T, BinningT>,
                                  typename BinningT::template getEdgeT<1>>,
                 public ZBinMixin<Bin<3, T, BinningT>,
                                  typename BinningT::template getEdgeT<2>> {
 
  protected:
 
    using BaseT = BinBase<T, BinningT>;
 
    template <size_t axisNum>
    using axisEdgeT = typename BinningT::template getAxisT<axisNum>::EdgeT;
 
  public:
 
    using BaseT::BaseT;
    using BaseT::operator=;
 
    // For self-consistency, the user should
    // always pass the parent binning!
    Bin() = delete;
 
  };
 
}
 
#endif