HistogramFiller.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef AthenaMonitoringKernel_HistogramFiller_h
#define AthenaMonitoringKernel_HistogramFiller_h
 
#include <boost/container/small_vector.hpp>
#include <functional>
#include <memory>
#include <mutex>
#include <vector>
 
#include "AthenaMonitoringKernel/HistogramDef.h"
#include "AthenaMonitoringKernel/IHistogramProvider.h"
#include "AthenaMonitoringKernel/IMonitoredVariable.h"
 
class TProfile;
class TProfile2D;
 
namespace Monitored {
 
  // Forward declare generic histogram filler (see HistogramFillerUtils.h)
  namespace detail {
    template<typename H, typename W, typename M, typename ...Ms>
    void doFill(H* hist, W weight, size_t i, const M& m1, const Ms&... m);
    template<typename W>
    void doFill(TProfile*, W, size_t, const double&, const char* const&);
    template<typename W>
    void doFill(TProfile*, W, size_t, const char* const&, const char* const&);
    template<typename W>
    void doFill(TProfile2D*, W, size_t, const double&, const double&, const char* const&);
    template<typename W>
    void doFill(TProfile2D*, W, size_t, const char* const&, const char* const&, const char* const&);
    template<typename W>
    void doFill(TProfile2D*, W, size_t, const char* const&, const double&, const char* const&);
    template<typename W>
    void doFill(TProfile2D*, W, size_t, const double&, const char* const&, const char* const&);
  }
 
  class HistogramFiller {
  public:
    HistogramFiller(const HistogramDef& histDef, std::shared_ptr<IHistogramProvider> histogramProvider)
      : m_histDef(new HistogramDef(histDef)),
        m_histogramProvider(std::move(histogramProvider)) {}
    HistogramFiller(const HistogramFiller& hf)
      : m_histDef(hf.m_histDef),
        m_histogramProvider(hf.m_histogramProvider) {}
 
    virtual ~HistogramFiller() {}
 
 
    struct VariablesPack {
      VariablesPack() = default;
      VariablesPack( const std::initializer_list<const Monitored::IMonitoredVariable*>&  v)
        : m_var( v ) {}
 
      const Monitored::IMonitoredVariable* operator[](std::size_t i) const {
        return m_var[i];
      }
 
      size_t size () const {
        return m_var.size();
      }
 
      inline void set( unsigned index, const IMonitoredVariable* ptr ) {
        if ( m_var.size() <= index ) {
          m_var.resize(index+1);
        }
        m_var[index] = ptr;
      }
 
      std::vector<std::string> names() const {
        std::vector<std::string> r;
        for ( const auto* v: m_var )
          if ( v != nullptr )
            r.push_back( v->name() );
        return r;
      }
 
      const Monitored::IMonitoredVariable* weight = nullptr; 
      const Monitored::IMonitoredVariable* cut = nullptr; 
 
    private:
      boost::container::small_vector<const Monitored::IMonitoredVariable*, 3> m_var;
    };
 
    virtual unsigned fill( const VariablesPack& ) const = 0;
 
    void touch() const {
      histogram<void>();
    }
 
 
    const std::vector<std::string>& histogramVariablesNames() const {
      return m_histDef->name;
    }
 
    const std::string& histogramWeightName() const {
      return m_histDef->weight;
    }
 
    const std::string& histogramCutMaskName() const {
      return m_histDef->cutMask;
    }
 
    const std::unique_lock<std::mutex> getLock() const {
      return std::unique_lock(m_lock);
    }
 
  protected:
    template <class H>
    H* histogram() const {
      return static_cast<H*>(m_histogramProvider->histogram());
    }
 
    template<class H, typename W, typename C, typename ...Ms>
    unsigned fill(W weight, C cut, const Ms&... m) const {
      auto hist = this->histogram<H>();
 
      size_t i = 0;
      for (; i < std::max({m.size()...}); ++i ) {
        if ( cut(i) ) {
          detail::doFill(hist, weight, i, m...);
        }
      }
      return i;
    }
 
    std::shared_ptr<HistogramDef> m_histDef;
    std::shared_ptr<IHistogramProvider> m_histogramProvider;
    mutable std::mutex m_lock;
 
  private:
    HistogramFiller& operator=(HistogramFiller const&) = delete;
  };
}
#endif /* AthenaMonitoringKernel_HistogramFiller_HistogramFiller_h */