StaticHistogram.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2024 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <Gaudi/Accumulators.h>
#include <Gaudi/MonitoringHub.h>
#include <GaudiKernel/HistoDef.h>
 
#include <array>
#include <cmath>
#include <fmt/format.h>
#include <nlohmann/json.hpp>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace {
  // Helper class creating a "subtuple" type from a tuple type by keeping only
  // the first N items.
  template <typename Tuple, typename Seq>
  struct SubTuple;
  template <typename Tuple, size_t... I>
  struct SubTuple<Tuple, std::index_sequence<I...>> {
    using type = decltype( std::make_tuple( std::get<I>( std::declval<Tuple>() )... ) );
  };
  template <typename Tuple, unsigned int N>
  using SubTuple_t = typename SubTuple<Tuple, std::make_index_sequence<N>>::type;
 
  template <typename T, unsigned int ND, typename = std::make_integer_sequence<unsigned int, ND>>
  struct make_tuple;
  template <typename T, unsigned int ND, unsigned int... S>
  struct make_tuple<T, ND, std::integer_sequence<unsigned int, S...>> {
    template <unsigned int>
    using typeMap = T;
    using type    = std::tuple<typeMap<S>...>;
  };
  template <typename T, unsigned int ND>
  using make_tuple_t = typename make_tuple<T, ND>::type;
 
  template <typename AxisTupleType>
  struct AxisToArithmetic;
  template <typename... Axis>
  struct AxisToArithmetic<std::tuple<Axis...>> {
    using type = std::tuple<typename Axis::ArithmeticType...>;
  };
  template <typename AxisTupleType>
  using AxisToArithmetic_t = typename AxisToArithmetic<AxisTupleType>::type;
  template <typename ProfArithmetic, typename AxisTupleType>
  using ProfileAxisToArithmetic_t = decltype( std::tuple_cat( std::declval<AxisToArithmetic_t<AxisTupleType>>(),
                                                              std::declval<std::tuple<ProfArithmetic>>() ) );
} // namespace
 
namespace Gaudi::Accumulators {
 
  namespace details {
    inline void requireValidTitle( std::string_view sv ) {
      if ( !sv.empty() && ( std::isspace( sv.back() ) || std::isspace( sv.front() ) ) ) {
        throw GaudiException(
            fmt::format( "Histogram title \'{}\' has whitespace at front or back -- please remove", sv ),
            "Gaudi::Accumulators", StatusCode::FAILURE );
      }
    }
  } // namespace details
 
  struct ExtractWeight {
    template <typename Arithmetic>
    constexpr decltype( auto ) operator()( const std::pair<unsigned long, Arithmetic>& v ) const noexcept {
      return v.second;
    }
  };
 
  struct WeightedProduct {
    template <typename Arithmetic>
    constexpr decltype( auto ) operator()( const std::pair<Arithmetic, Arithmetic>& v ) const noexcept {
      return v.first * v.second;
    }
  };
 
  struct WeightedSquare {
    template <typename Arithmetic>
    constexpr decltype( auto ) operator()( const std::pair<Arithmetic, Arithmetic>& v ) const noexcept {
      return v.first * v.first * v.second;
    }
  };
 
  template <typename Arithmetic, atomicity Atomicity>
  struct WeightedAdder {
    using RegularType              = std::pair<unsigned long, Arithmetic>;
    using AtomicType               = std::pair<std::atomic<unsigned long>, std::atomic<Arithmetic>>;
    using OutputType               = RegularType;
    static constexpr bool isAtomic = Atomicity == atomicity::full;
    using InternalType             = std::conditional_t<isAtomic, AtomicType, OutputType>;
    static constexpr OutputType getValue( const InternalType& v ) noexcept {
      if constexpr ( isAtomic ) {
        return { v.first.load( std::memory_order_relaxed ), v.second.load( std::memory_order_relaxed ) };
      } else {
        return v;
      }
    };
    static RegularType exchange( InternalType& v, RegularType newv ) noexcept {
      if constexpr ( isAtomic ) {
        return { v.first.exchange( newv.first ), v.second.exchange( newv.second ) };
      } else {
        return { std::exchange( v.first, newv.first ), std::exchange( v.second, newv.second ) };
      }
    }
    static constexpr OutputType DefaultValue() { return { 0, Arithmetic{} }; }
    static void                 merge( InternalType& a, RegularType b ) noexcept {
      if constexpr ( isAtomic ) {
        fetch_add( a.first, b.first );
        fetch_add( a.second, b.second );
      } else {
        a.first += b.first;
        a.second += b.second;
      }
    };
  };
 
  template <atomicity Atomicity, typename Arithmetic>
  struct WeightedCountAccumulator
      : GenericAccumulator<std::pair<Arithmetic, Arithmetic>, std::pair<unsigned long, Arithmetic>, Atomicity, Identity,
                           ExtractWeight, WeightedAdder<Arithmetic, Atomicity>> {
    using Base = GenericAccumulator<std::pair<Arithmetic, Arithmetic>, std::pair<unsigned long, Arithmetic>, Atomicity,
                                    Identity, ExtractWeight, WeightedAdder<Arithmetic, Atomicity>>;
    using Base::Base;
    using Base::operator+=;
    WeightedCountAccumulator operator+=( const Arithmetic weight ) {
      *this += { 1ul, weight };
      return *this;
    }
    unsigned long nEntries() const { return this->rawValue().first; }
    Arithmetic    sumOfWeights() const { return this->rawValue().second; }
  };
 
  template <atomicity Atomicity, typename Arithmetic>
  struct WeightedSumAccumulator
      : GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity, WeightedProduct> {
    using GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity,
                             WeightedProduct>::GenericAccumulator;
    Arithmetic sum() const { return this->value(); }
  };
 
  template <atomicity Atomicity, typename Arithmetic = double>
  struct WeightedSquareAccumulator
      : GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity, WeightedSquare> {
    using GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity,
                             WeightedSquare>::GenericAccumulator;
    Arithmetic sum2() const { return this->value(); };
  };
 
  template <atomicity Atomicity, typename Arithmetic>
  using WeightedAveragingAccumulator =
      AveragingAccumulatorBase<Atomicity, Arithmetic, WeightedCountAccumulator, WeightedSumAccumulator>;
 
  template <atomicity Atomicity, typename Arithmetic>
  using WeightedSigmaAccumulator =
      SigmaAccumulatorBase<Atomicity, Arithmetic, WeightedAveragingAccumulator, WeightedSquareAccumulator>;
 
  template <typename Arithmetic>
  class Axis {
  public:
    using ArithmeticType = Arithmetic;
    Axis( unsigned int nBins = 0, Arithmetic minValue = Arithmetic{}, Arithmetic maxValue = Arithmetic{},
          std::string title = {}, std::vector<std::string> labels = {} )
        : m_title( std::move( title ) )
        , nBins( nBins )
        , m_minValue( minValue )
        , m_maxValue( maxValue )
        , m_labels( std::move( labels ) ) {
      details::requireValidTitle( m_title );
      recomputeRatio();
      for ( const auto& s : m_labels ) details::requireValidTitle( s );
    };
    explicit Axis( Gaudi::Histo1DDef const& def )
        : Axis( (unsigned int)def.bins(), def.lowEdge(), def.highEdge(), def.title() ){};
 
    unsigned int index( Arithmetic value ) const {
      // In case we use integer as Arithmetic type, we cannot use ratio for computing indices,
      // as ratios < 1.0 will simply be 0, so we have to pay the division in such a case
      int idx;
      if constexpr ( std::is_integral_v<Arithmetic> ) {
        idx = ( ( value - m_minValue ) * nBins / ( m_maxValue - m_minValue ) ) + 1;
      } else {
        idx = std::floor( ( value - m_minValue ) * m_ratio ) + 1;
      }
      return idx < 0 ? 0 : ( (unsigned int)idx > numBins() ? numBins() + 1 : (unsigned int)idx );
    }
 
    friend std::ostream& operator<<( std::ostream& o, Axis const& axis ) {
      // Note that we print python code here, as the generic toStream implementation uses this
      // operator to generate python code.
      o << "(" << axis.numBins() << ", " << axis.minValue() << ", " << axis.maxValue() << ", "
        << "\"" << axis.m_title << "\", (";
      for ( auto const& label : axis.m_labels ) { o << "\"" << label << "\", "; }
      return o << "))";
    }
 
    bool inAcceptance( Arithmetic value ) const { return value >= m_minValue && value <= m_maxValue; }
 
    // accessors
    unsigned int numBins() const { return nBins; };
    void         setNumBins( unsigned int n ) {
      nBins = n;
      recomputeRatio();
    }
    Arithmetic minValue() const { return m_minValue; };
    void       setMinValue( Arithmetic v ) {
      m_minValue = v;
      recomputeRatio();
    }
    Arithmetic maxValue() const { return m_maxValue; };
    void       setMaxValue( Arithmetic v ) {
      m_maxValue = v;
      recomputeRatio();
    }
    std::string const&             title() const { return m_title; }
    void                           setTitle( std::string const& t ) { m_title = t; };
    std::vector<std::string> const labels() const { return m_labels; }
 
  private:
    std::string m_title;
 
  public:
    unsigned int nBins;
 
  private:
    Arithmetic m_minValue, m_maxValue;
    Arithmetic m_ratio;
    std::vector<std::string> m_labels;
 
    void recomputeRatio() {
      m_ratio = ( m_maxValue == m_minValue ) ? Arithmetic{} : nBins / ( m_maxValue - m_minValue );
    }
  };
 
  template <typename Arithmetic>
  void to_json( nlohmann::json& j, const Axis<Arithmetic>& axis ) {
    j = nlohmann::json{ { "nBins", axis.numBins() },
                        { "minValue", axis.minValue() },
                        { "maxValue", axis.maxValue() },
                        { "title", axis.title() } };
    if ( !axis.labels().empty() ) { j["labels"] = axis.labels(); }
  }
 
  template <typename Arithmetic, unsigned int NIndex>
  struct HistoInputType : HistoInputType<make_tuple_t<Arithmetic, NIndex>, NIndex> {
    using HistoInputType<make_tuple_t<Arithmetic, NIndex>, NIndex>::HistoInputType;
  };
  template <unsigned int NIndex, typename... Elements>
  struct HistoInputType<std::tuple<Elements...>, NIndex> : std::tuple<Elements...> {
    using InternalType = std::tuple<Elements...>;
    using ValueType    = HistoInputType<SubTuple_t<InternalType, NIndex>, NIndex>;
    using std::tuple<Elements...>::tuple;
    template <class... AxisType, typename = typename std::enable_if_t<( sizeof...( AxisType ) == NIndex )>>
    unsigned int computeIndex( std::tuple<AxisType...> const& axis ) const {
      return computeIndexInternal<0, std::tuple<AxisType...>>( axis );
    }
    template <class... AxisType, typename = typename std::enable_if_t<( sizeof...( AxisType ) == NIndex )>>
    static unsigned int computeTotNBins( std::tuple<AxisType...> const& axis ) {
      return computeTotNBinsInternal<0, std::tuple<AxisType...>>( axis );
    }
    auto forInternalCounter() const { return 1ul; }
    template <class... AxisType, typename = typename std::enable_if_t<( sizeof...( AxisType ) == NIndex )>>
    bool inAcceptance( std::tuple<AxisType...> const& axis ) const {
      return inAcceptanceInternal<0, std::tuple<AxisType...>>( axis );
    }
 
  private:
    template <int N, class Tuple>
    unsigned int computeIndexInternal( Tuple const& allAxis ) const {
      // compute global index. Bins are stored in a column first manner
      auto const&  axis       = std::get<N>( allAxis );
      unsigned int localIndex = axis.index( std::get<N>( *this ) );
      if constexpr ( N + 1 == NIndex )
        return localIndex;
      else
        return localIndex + ( axis.numBins() + 2 ) * computeIndexInternal<N + 1, Tuple>( allAxis );
    }
    template <int N, class Tuple>
    static unsigned int computeTotNBinsInternal( Tuple const& allAxis ) {
      auto const&  axis       = std::get<N>( allAxis );
      unsigned int localNBins = axis.numBins() + 2;
      if constexpr ( N + 1 == NIndex )
        return localNBins;
      else
        return localNBins * computeTotNBinsInternal<N + 1, Tuple>( allAxis );
    }
    template <int N, class Tuple>
    bool inAcceptanceInternal( Tuple const& allAxis ) const {
      auto const& axis        = std::get<N>( allAxis );
      bool        localAnswer = axis.inAcceptance( std::get<N>( *this ) );
      if constexpr ( N + 1 == NIndex )
        return localAnswer;
      else
        return localAnswer || inAcceptanceInternal<N + 1, Tuple>( allAxis );
    }
  };
 
  template <typename ArithmeticTuple, unsigned int NIndex, typename WArithmetic>
  struct WeightedHistoInputType : std::pair<HistoInputType<ArithmeticTuple, NIndex>, WArithmetic> {
    using ValueType = typename HistoInputType<ArithmeticTuple, NIndex>::ValueType;
    using std::pair<HistoInputType<ArithmeticTuple, NIndex>, WArithmetic>::pair;
    template <class... AxisType, typename = typename std::enable_if_t<( sizeof...( AxisType ) == NIndex )>>
    unsigned int computeIndex( std::tuple<AxisType...> const& axis ) const {
      return this->first.computeIndex( axis );
    }
    template <class... AxisType, typename = typename std::enable_if_t<( sizeof...( AxisType ) == NIndex )>>
    static unsigned int computeTotNBins( std::tuple<AxisType...> const& axis ) {
      return HistoInputType<ArithmeticTuple, NIndex>::computeTotNBins( axis );
    }
    auto forInternalCounter() const { return std::pair( this->first.forInternalCounter(), this->second ); }
    template <class... AxisType, typename = typename std::enable_if_t<( sizeof...( AxisType ) == NIndex )>>
    bool inAcceptance( std::tuple<AxisType...> const& axis ) const {
      return this->first.inAcceptance( axis );
    }
  };
 
  template <atomicity Atomicity, typename InputType, typename Arithmetic,
            template <atomicity Ato, typename Arith> typename BaseAccumulatorT, typename AxisTupleType>
  class HistogramingAccumulatorInternal {
    template <atomicity, typename, typename, template <atomicity, typename> typename, typename>
    friend class HistogramingAccumulatorInternal;
 
  public:
    using ND                      = std::integral_constant<unsigned int, std::tuple_size_v<AxisTupleType>>;
    using BaseAccumulator         = BaseAccumulatorT<Atomicity, Arithmetic>;
    using AxisTupleArithmeticType = typename InputType::ValueType;
    HistogramingAccumulatorInternal( AxisTupleType axis )
        : m_axis{ axis }
        , m_totNBins{ InputType::computeTotNBins( m_axis ) }
        , m_value( new BaseAccumulator[m_totNBins] ) {
      reset();
    }
    template <atomicity ato>
    HistogramingAccumulatorInternal(
        construct_empty_t,
        const HistogramingAccumulatorInternal<ato, InputType, Arithmetic, BaseAccumulatorT, AxisTupleType>& other )
        : m_axis( other.m_axis ), m_totNBins{ other.m_totNBins }, m_value( new BaseAccumulator[m_totNBins] ) {
      reset();
    }
    [[deprecated( "Use `++h1[x]`, `++h2[{x,y}]`, etc. instead." )]] HistogramingAccumulatorInternal&
    operator+=( InputType v ) {
      accumulator( v.computeIndex( m_axis ) ) += v.forInternalCounter();
      return *this;
    }
    void reset() {
      for ( unsigned int index = 0; index < m_totNBins; index++ ) accumulator( index ).reset();
    }
    template <atomicity ato>
    void mergeAndReset(
        HistogramingAccumulatorInternal<ato, InputType, Arithmetic, BaseAccumulatorT, AxisTupleType>& other ) {
      assert( m_totNBins == other.m_totNBins );
      for ( unsigned int index = 0; index < m_totNBins; index++ ) {
        accumulator( index ).mergeAndReset( other.accumulator( index ) );
      }
    }
    [[nodiscard]] auto operator[]( typename InputType::ValueType v ) {
      return Buffer<BaseAccumulatorT, Atomicity, Arithmetic>{ accumulator( v.computeIndex( m_axis ) ) };
    }
 
    template <unsigned int N>
    auto& axis() const {
      return std::get<N>( m_axis );
    }
    auto& axis() const { return m_axis; }
    auto  binValue( unsigned int i ) const { return accumulator( i ).value(); }
    auto  nEntries( unsigned int i ) const { return accumulator( i ).nEntries(); }
    auto  totNBins() const { return m_totNBins; }
 
    // FIXME These methods are there for backwrad compatibility with previous implementation
    // where all Axis had to be of type Axis<...> and were stored in an array
    // Newer code should call axis<N>().foo for whatever foo is defined in that axis type
    auto nBins( unsigned int i ) const { return _getAxis( i, std::integral_constant<size_t, 0>() ).numBins(); }
    auto minValue( unsigned int i ) const { return _getAxis( i, std::integral_constant<size_t, 0>() ).minValue(); }
    auto maxValue( unsigned int i ) const { return _getAxis( i, std::integral_constant<size_t, 0>() ).maxValue(); }
 
  private:
    BaseAccumulator& accumulator( unsigned int index ) const {
      assert( index < m_totNBins );
      return m_value[index];
    }
 
    // FIXME Only used for backward compatibility. should be dropped at some stage
    // Can only work if all axis have same type, which is no more the case
    std::tuple_element_t<0, AxisTupleType> const& _getAxis( size_t i,
                                                            typename std::tuple_size<AxisTupleType>::type ) const {
      throw std::logic_error(
          fmt::format( "Retrieving axis {} in Histogram of dimension {}", i, std::tuple_size_v<AxisTupleType> ) );
    }
    template <size_t N, typename = std::enable_if_t<std::tuple_size_v<AxisTupleType> != N>>
    auto& _getAxis( size_t i, std::integral_constant<size_t, N> ) const {
      if ( i == N ) return std::get<N>( m_axis );
      return _getAxis( i, std::integral_constant<size_t, N + 1>() );
    }
 
    AxisTupleType m_axis;
    unsigned int m_totNBins;
    std::unique_ptr<BaseAccumulator[]> m_value;
  };
 
  template <atomicity Atomicity, typename Arithmetic, typename ND, typename AxisTupleType>
  using HistogramingAccumulator =
      HistogramingAccumulatorInternal<Atomicity, HistoInputType<AxisToArithmetic_t<AxisTupleType>, ND::value>,
                                      unsigned long, IntegralAccumulator, AxisTupleType>;
 
  template <atomicity Atomicity, typename Arithmetic, typename ND, typename AxisTupleType>
  using WeightedHistogramingAccumulator =
      HistogramingAccumulatorInternal<Atomicity,
                                      WeightedHistoInputType<AxisToArithmetic_t<AxisTupleType>, ND::value, Arithmetic>,
                                      Arithmetic, WeightedCountAccumulator, AxisTupleType>;
 
  template <atomicity Atomicity, typename Arithmetic, typename ND, typename AxisTupleType>
  using ProfileHistogramingAccumulator =
      HistogramingAccumulatorInternal<Atomicity,
                                      HistoInputType<ProfileAxisToArithmetic_t<Arithmetic, AxisTupleType>, ND::value>,
                                      Arithmetic, SigmaAccumulator, AxisTupleType>;
 
  template <atomicity Atomicity, typename Arithmetic, typename ND, typename AxisTupleType>
  using WeightedProfileHistogramingAccumulator = HistogramingAccumulatorInternal<
      Atomicity, WeightedHistoInputType<ProfileAxisToArithmetic_t<Arithmetic, AxisTupleType>, ND::value, Arithmetic>,
      Arithmetic, WeightedSigmaAccumulator, AxisTupleType>;
 
  template <unsigned int ND, atomicity Atomicity, typename Arithmetic, const char* Type,
            template <atomicity, typename, typename, typename> typename Accumulator, typename AxisTupleType>
  class HistogramingCounterBase;
  template <unsigned int ND, atomicity Atomicity, typename Arithmetic, const char* Type,
            template <atomicity, typename, typename, typename> typename Accumulator, typename... AxisTypes>
  class HistogramingCounterBase<ND, Atomicity, Arithmetic, Type, Accumulator, std::tuple<AxisTypes...>>
      : public BufferableCounter<Atomicity, Accumulator, Arithmetic, std::integral_constant<unsigned int, ND>,
                                 std::tuple<AxisTypes...>> {
  public:
    using AxisTupleType    = std::tuple<AxisTypes...>;
    using NumberDimensions = std::integral_constant<unsigned int, ND>;
    using Parent           = BufferableCounter<Atomicity, Accumulator, Arithmetic, NumberDimensions, AxisTupleType>;
    using AccumulatorType  = Accumulator<Atomicity, Arithmetic, NumberDimensions, AxisTupleType>;
    using AxisTupleArithmeticType = typename AccumulatorType::AxisTupleArithmeticType;
    using AxisArithmeticType = typename std::tuple_element<0, AxisTupleType>::type::ArithmeticType;
    inline static const std::string typeString{ std::string{ Type } + ':' + typeid( Arithmetic ).name() };
    template <typename OWNER>
    HistogramingCounterBase( OWNER* owner, std::string const& name, std::string const& title, AxisTupleType axis )
        : Parent( owner, name, *this, axis ), m_title( title ) {
      details::requireValidTitle( m_title );
    }
    template <typename OWNER>
    HistogramingCounterBase( OWNER* owner, std::string const& name, std::string const& title, AxisTypes... allAxis )
        : HistogramingCounterBase( owner, name, title, std::make_tuple( allAxis... ) ) {}
    using Parent::print;
    template <typename stream>
    stream& printImpl( stream& o, bool /*tableFormat*/ ) const {
      o << ND << "D Histogram with config ";
      std::apply( [&o]( auto&&... args ) { ( ( o << args << "\n" ), ... ); }, this->axis() );
      return o;
    }
    std::ostream& print( std::ostream& o, bool tableFormat = false ) const override {
      return printImpl( o, tableFormat );
    }
    MsgStream&   print( MsgStream& o, bool tableFormat = false ) const override { return printImpl( o, tableFormat ); }
    friend void  reset( HistogramingCounterBase& c ) { c.reset(); }
    friend void  mergeAndReset( HistogramingCounterBase& h, HistogramingCounterBase& o ) { h.mergeAndReset( o ); }
    friend void  to_json( nlohmann::json& j, HistogramingCounterBase const& h ) { h.to_json( j ); }
    virtual void to_json( nlohmann::json& j ) const {
      // get all bin values and compute total nbEntries
      std::vector<typename AccumulatorType::BaseAccumulator::OutputType> bins;
      bins.reserve( this->totNBins() );
      unsigned long totNEntries{ 0 };
      for ( unsigned int i = 0; i < this->totNBins(); i++ ) {
        bins.push_back( this->binValue( i ) );
        totNEntries += this->nEntries( i );
      }
      // build json
      j = { { "type", std::string( Type ) + ":" + typeid( Arithmetic ).name() },
            { "title", m_title },
            { "dimension", ND },
            { "empty", totNEntries == 0 },
            { "nEntries", totNEntries },
            { "axis", this->axis() },
            { "bins", bins } };
    }
    std::string const& title() const { return m_title; }
 
  protected:
    std::string const m_title;
  };
 
  namespace naming {
    inline constexpr char histogramString[]                = "histogram:Histogram";
    inline constexpr char weightedHistogramString[]        = "histogram:WeightedHistogram";
    inline constexpr char profilehistogramString[]         = "histogram:ProfileHistogram";
    inline constexpr char weightedProfilehistogramString[] = "histogram:WeightedProfileHistogram";
  } // namespace naming
 
  template <unsigned int ND, atomicity Atomicity = atomicity::full, typename Arithmetic = double,
            typename AxisTupleType = make_tuple_t<Axis<Arithmetic>, ND>>
  using StaticHistogram = HistogramingCounterBase<ND, Atomicity, Arithmetic, naming::histogramString,
                                                  HistogramingAccumulator, AxisTupleType>;
 
  template <unsigned int ND, atomicity Atomicity = atomicity::full, typename Arithmetic = double,
            typename AxisTupleType = make_tuple_t<Axis<Arithmetic>, ND>>
  using StaticWeightedHistogram = HistogramingCounterBase<ND, Atomicity, Arithmetic, naming::weightedHistogramString,
                                                          WeightedHistogramingAccumulator, AxisTupleType>;
 
  template <unsigned int ND, atomicity Atomicity = atomicity::full, typename Arithmetic = double,
            typename AxisTupleType = make_tuple_t<Axis<Arithmetic>, ND>>
  using StaticProfileHistogram = HistogramingCounterBase<ND, Atomicity, Arithmetic, naming::profilehistogramString,
                                                         ProfileHistogramingAccumulator, AxisTupleType>;
 
  template <unsigned int ND, atomicity Atomicity = atomicity::full, typename Arithmetic = double,
            typename AxisTupleType = make_tuple_t<Axis<Arithmetic>, ND>>
  using StaticWeightedProfileHistogram =
      HistogramingCounterBase<ND, Atomicity, Arithmetic, naming::weightedProfilehistogramString,
                              WeightedProfileHistogramingAccumulator, AxisTupleType>;
 
} // namespace Gaudi::Accumulators