Base.h

Go to the documentation of this file.

#pragma once

// -- std includes
#include <array>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>

namespace marlinmt {
  namespace book {
    namespace types {
  
      // TODO: check for minimal amount of copies 
      template<typename Precision_t>
      class AxisConfig {
      public:

        AxisConfig( const std::string_view& title,
                    std::size_t bins,
                    Precision_t min,
                    Precision_t max) 
          : _title(title), _bins{bins}, _min{min}, _max{max}{}


        AxisConfig( std::size_t bins,
                    Precision_t min,
                    Precision_t max) 
          : AxisConfig( "", bins, min, max ){}

        template<typename Itr>
        AxisConfig( const std::string_view& title,
                    Itr begin, Itr end) 

          : _title(title),
            _bins{(end - begin) - 1},
            _iregularBorder(begin, end),
            _min{_iregularBorder.front()},
            _max{_iregularBorder.back()}
        {}

        template<typename Itr>
        explicit AxisConfig( Itr begin, Itr end ) 
          : AxisConfig<Itr>( "", begin, end ){}

        template<typename Container>
        AxisConfig(
            const std::string_view& title,
            const Container& container)
          : AxisConfig(title, container.begin(), container.end()) {}

        [[nodiscard]]
        std::string_view title() const { return _title; }

        [[nodiscard]]
        std::size_t bins() const { return _bins; }

        [[nodiscard]]
        Precision_t min() const { return _min; }

        [[nodiscard]]
        Precision_t max() const { return _max; }

        [[nodiscard]]
        bool isRegular() const { return !_iregularBorder.has_value(); }

        const std::vector<Precision_t>& iregularBorder() const {
          return _iregularBorder.value_or(std::vector<Precision_t>{});
        }
      private:
        std::string _title;
        std::size_t _bins;
        Precision_t _min;
        Precision_t _max;
        std::optional<std::vector<Precision_t>> _iregularBorder{std::nullopt};
      };


      template<typename P, typename W, std::size_t D>
      struct HistConfig {
        using Weight_t = W;
        using Precision_t = P;
        using Impl_t = void*;
        using ConcurrentFiller_t = void*;
        using ConcurrentManager_t = void*;
        static constexpr std::size_t Dimension = static_cast<std::size_t>(D);
      };

      template<typename>
      class HistT;

      template<typename Config>
      HistT<Config>& add(HistT<Config>& to, const HistT<Config>& from);

      template<typename Config>
      void add(
          const std::shared_ptr<HistT<Config>>& to,
          const std::shared_ptr<HistT<Config>>& from);

      template<typename>
      class HistConcurrentFiller;

      template<typename>
      class HistConcurrentFillManager;

      template<typename Config>
      class HistT {
        typename Config::Impl_t& impl() { return _impl; }
        [[nodiscard]]
        const typename Config::Impl_t& impl() const { return _impl; }
        friend HistT<Config>& add<Config>(HistT<Config>&,const HistT<Config>&);
        friend void add<Config>(const std::shared_ptr<HistT<Config>>&,const std::shared_ptr<HistT<Config>>&);
        friend class HistConcurrentFillManager<Config>;

      public:
        using Weight_t = typename Config::Weight_t;
        using Precision_t = typename Config::Precision_t;
        static constexpr std::size_t Dimension = Config::Dimension;
        using Point_t = std::array<Precision_t, Dimension>;
        using AxisConfig_t = AxisConfig<Precision_t>;

        explicit HistT(const AxisConfig_t& axis) : HistT("",axis) {}

        HistT(const AxisConfig_t& axisA,
              const AxisConfig_t& axisB) : HistT("",axisA, axisB) {}

        HistT(const AxisConfig_t& axisA,
              const AxisConfig_t& axisB,
              const AxisConfig_t& axisC) : HistT("",axisA, axisB, axisC) {}

        HistT( const std::string_view& title, const AxisConfig_t& axis);

        HistT(
            const std::string_view& title,
            const AxisConfig_t& axisA,
            const AxisConfig_t& axisB);

        HistT( const std::string_view& title,
               const AxisConfig_t& axisA,
               const AxisConfig_t& axisB,
               const AxisConfig_t& axisC);

        void Fill(const Point_t& point, const Weight_t& weight);

        // TODO: used generic iterator
        void FillN(const Point_t *pFirst, const Point_t *pLast,
                  const Weight_t *wFirst, const Weight_t *wLast);


        void FillN(const Point_t *first, const Point_t *last);

        [[nodiscard]]
        const typename Config::Impl_t& get() const { return _impl; }

        constexpr bool hasImpl() {
          return !std::is_same_v<Config::Impl_t, void*>;
        }

      private:
          typename Config::Impl_t _impl{};
      };

      template<typename Config>
      class HistConcurrentFillManager {
        friend class HistConcurrentFiller<Config>;
        typename Config::ConcurrentManager_t& impl() { return _impl; }
      public:
        explicit  HistConcurrentFillManager(HistT<Config>& hist);
      private:
        typename Config::ConcurrentManager_t _impl;
      };

      template<typename Config>
      class HistConcurrentFiller {
      public:
        using Type = HistT<Config>;
        using Point_t = typename Type::Point_t;
        using Weight_t = typename Type::Weight_t;

        explicit HistConcurrentFiller(HistConcurrentFillManager<Config>& manager);

        void Fill(const Point_t& p, const Weight_t& w);

        void FillN(const Point_t *pFirst, const Point_t *pLast,
                  const Weight_t *wFirst, const Weight_t *wLast);

        void FillN(const Point_t *first, const Point_t *last);

        void Flush();
      
      private:
        typename Config::ConcurrentFiller_t _impl;
      };

      template<typename Config>
      auto toRoot6(const HistT<Config>& hist, const std::string_view& name);


    } // end namespace types

    namespace details {
      template<typename I, typename O>
      constexpr O safe_cast(const I& input) {
        static_assert((true == std::is_integral_v<I>) == std::is_integral_v<O>
            , "safe_cast only available for integral types!");
        if ( 
            static_cast<O>(input) >= std::numeric_limits<O>::min()
            && static_cast<O>(input) <= std::numeric_limits<O>::max()) {
          return static_cast<O>(input);
        }
        throw std::domain_error("Input number is outside of target type domain!");
      }
      
    } // end namespace details
    
    // -- MarlinBook forward declarations
    class BookStore ;
    template < typename T >
    class Handle ;
    template < typename T >
    class BaseHandle ;

  } // end namespace book
} // end namespace marlinmt