HistogramArray.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/Histogram.h>
 
#include <fmt/format.h>
 
#include <boost/container/static_vector.hpp>
 
#include <array>
#include <utility>
 
namespace Gaudi::Accumulators {
 
  namespace details {
 
    struct FormatHistDefault {
      std::string_view text;
      FormatHistDefault( std::string_view t ) : text{ t } {}
      auto operator()( size_t n ) { return fmt::format( fmt::runtime( text ), n ); }
    };
 
    template <typename Histo, std::size_t N, typename = void>
    struct HistogramArrayInternal;
 
    template <typename Histo, std::size_t N>
    struct HistogramArrayInternal<Histo, N, std::enable_if_t<( N < 30 )>> : std::array<Histo, N> {
      template <typename OWNER, typename FormatName, typename FormatTitle, std::size_t... Ns,
                typename = typename std::enable_if_t<std::is_invocable_v<FormatName, int>>,
                typename = typename std::enable_if_t<std::is_invocable_v<FormatTitle, int>>>
      HistogramArrayInternal( OWNER* owner, FormatName&& fname, FormatTitle&& ftitle,
                              std::integer_sequence<std::size_t, Ns...>, typename Histo::AxisTupleType&& allAxis )
          : std::array<Histo, N>{ Histo{ owner, fname( Ns ), ftitle( Ns ), allAxis }... } {}
      template <typename OWNER, std::size_t... Ns>
      HistogramArrayInternal( OWNER* owner, std::string_view name, std::string_view title,
                              std::integer_sequence<std::size_t, Ns...>, typename Histo::AxisTupleType&& allAxis )
          : std::array<Histo, N>{
                Histo{ owner, FormatHistDefault{ name }( Ns ), FormatHistDefault{ title }( Ns ), allAxis }... } {}
    };
 
    template <typename Histo, std::size_t N>
    struct HistogramArrayInternal<Histo, N, std::enable_if_t<( N >= 30 )>> : boost::container::static_vector<Histo, N> {
      template <typename OWNER, typename FormatName, typename FormatTitle,
                typename = typename std::enable_if_t<std::is_invocable_v<FormatName, int>>,
                typename = typename std::enable_if_t<std::is_invocable_v<FormatTitle, int>>>
      HistogramArrayInternal( OWNER* owner, FormatName&& fname, FormatTitle&& ftitle,
                              typename Histo::AxisTupleType&& allAxis ) {
        for ( std::size_t i = 0; i < N; i++ ) { this->emplace_back( owner, fname( i ), ftitle( i ), allAxis ); }
      }
      template <typename OWNER>
      HistogramArrayInternal( OWNER* owner, std::string_view name, std::string_view title,
                              typename Histo::AxisTupleType&& allAxis ) {
        for ( std::size_t i = 0; i < N; i++ ) {
          this->emplace_back( owner, FormatHistDefault{ name }( i ), FormatHistDefault{ title }( i ), allAxis );
        }
      }
    };
  } // namespace details
 
  template <typename Histo, std::size_t N,
            typename Seq = std::make_integer_sequence<unsigned int, std::tuple_size_v<typename Histo::AxisTupleType>>>
  struct HistogramArray;
  template <typename Histo, std::size_t N, unsigned int... ND>
  struct HistogramArray<Histo, N, std::integer_sequence<unsigned int, ND...>>
      : details::HistogramArrayInternal<Histo, N> {
    template <typename OWNER, typename FormatName, typename FormatTitle, std::size_t M = N,
              typename std::enable_if_t<( M < 30 ), int> = 0>
    HistogramArray( OWNER* owner, FormatName&& fname, FormatTitle&& ftitle, typename Histo::AxisTupleType&& allAxis )
        : details::HistogramArrayInternal<Histo, N>( owner, fname, ftitle, std::make_integer_sequence<std::size_t, N>{},
                                                     std::forward<typename Histo::AxisTupleType>( allAxis ) ) {}
 
    template <typename OWNER, typename FormatName, typename FormatTitle, std::size_t M = N,
              typename std::enable_if_t<( M >= 30 ), int> = 0>
    HistogramArray( OWNER* owner, FormatName&& fname, FormatTitle&& ftitle, typename Histo::AxisTupleType&& allAxis )
        : details::HistogramArrayInternal<Histo, N>( owner, fname, ftitle,
                                                     std::forward<typename Histo::AxisTupleType>( allAxis ) ) {}
 
    template <unsigned int I>
    using AxisType = std::tuple_element_t<I, typename Histo::AxisTupleType>;
 
    template <typename OWNER, typename FormatName, typename FormatTitle>
    HistogramArray( OWNER* owner, FormatName&& fname, FormatTitle&& ftitle, AxisType<ND>... allAxis )
        : HistogramArray( owner, fname, ftitle, std::make_tuple( allAxis... ) ) {}
  };
 
} // namespace Gaudi::Accumulators