HistogramMap.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 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/StaticHistogram.h>
 
#include <fmt/format.h>
 
#include <map>
#include <mutex>
 
namespace Gaudi::Accumulators {
 
  namespace details {

    template <typename Key>
    struct FormatHistDefaultT {
      std::string text;
      FormatHistDefaultT( std::string_view t ) : text{ t } {}
      auto operator()( Key k ) { return fmt::format( fmt::runtime( text ), k ); }
    };

    template <typename Key, typename Histo>
    class HistogramMapInternal {
    public:
      template <typename OWNER, std::invocable<Key const&> FormatName, std::invocable<Key const&> FormatTitle>
      HistogramMapInternal( OWNER* owner, FormatName&& fname, FormatTitle&& ftitle,
                            typename Histo::AxisTupleType&& allAxis )
          : m_makeHisto{ [owner, fname, ftitle, allAxis, this]( Key const& k ) -> Histo& {
            return m_map
                .emplace( std::piecewise_construct, std::forward_as_tuple( k ),
                          std::forward_as_tuple( owner, fname( k ), ftitle( k ), allAxis ) )
                .first->second;
          } } {}

      template <typename OWNER>
      HistogramMapInternal( OWNER* owner, std::string_view name, std::string_view title,
                            typename Histo::AxisTupleType&& allAxis )
          : m_makeHisto{ [owner, name, title, allAxis, this]( Key const& k ) -> Histo& {
            return m_map
                .emplace( std::piecewise_construct, std::forward_as_tuple( k ),
                          std::forward_as_tuple( owner, FormatHistDefaultT<Key>( name )( k ),
                                                 FormatHistDefaultT<Key>( title )( k ), allAxis ) )
                .first->second;
          } } {}

      Histo& operator[]( Key const& k ) const {
        std::scoped_lock lock{ m_mapLock };
        auto             it = m_map.find( k );
        if ( it != m_map.end() ) return it->second;
        return m_makeHisto( k );
      }
 
    private:
      mutable std::map<Key, Histo>        m_map;
      mutable std::mutex                  m_mapLock{};
      std::function<Histo&( Key const& )> m_makeHisto;
      // operator[],
    };
  } // namespace details

  template <typename Key, typename Histo,
            typename Seq = std::make_integer_sequence<unsigned int, std::tuple_size_v<typename Histo::AxisTupleType>>>
  struct HistogramMap;
  template <typename Key, typename Histo, unsigned int... ND>
  struct HistogramMap<Key, Histo, std::integer_sequence<unsigned int, ND...>>
      : details::HistogramMapInternal<Key, Histo> {
    template <typename OWNER, typename FormatName, typename FormatTitle>
    HistogramMap( OWNER* owner, FormatName&& fname, FormatTitle&& ftitle, typename Histo::AxisTupleType&& allAxis )
        : details::HistogramMapInternal<Key, Histo>( 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>
    HistogramMap( OWNER* owner, FormatName&& fname, FormatTitle&& ftitle, AxisType<ND>... allAxis )
        : HistogramMap( owner, fname, ftitle, std::make_tuple( allAxis... ) ) {}
  };
 
} // namespace Gaudi::Accumulators