HistogramFillerUtils.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef AthenaMonitoringKernel_HistogramFillerUtils_h
#define AthenaMonitoringKernel_HistogramFillerUtils_h
 
#include <algorithm>
#include <utility>
 
#include "AthenaMonitoringKernel/IMonitoredVariable.h"
#include "AthenaMonitoringKernel/OHLockedHist.h"
#include "HistogramFactory.h"
#include "CxxUtils/AthUnlikelyMacros.h"
 
#include "TH1.h"
#include "TProfile.h"
#include "THashList.h"
#include "TProfile2D.h"
 
namespace Monitored {

  enum Axis {X = 0, Y, Z};
 
  namespace detail {
 
    auto noWeight = [](size_t){ return 1.0; }; 
    auto noCut = [](size_t){ return true; };   

    constexpr std::array axis_name{"X", "Y", "Z"};
    constexpr std::array axis_bit{TH1::kXaxis, TH1::kYaxis, TH1::kZaxis};

    template<Axis AXIS, typename H>
    constexpr auto getAxis(H* hist) {
      if constexpr (AXIS==Axis::X) return hist->GetXaxis();
      else if constexpr (AXIS==Axis::Y) return hist->GetYaxis();
      else return hist->GetZaxis();
    }

    template<Axis AXIS, typename H>
    double getFillValue(const H* hist, const IMonitoredVariable* var, size_t i) {
      if ( var->hasStringRepresentation() ) {
        const TAxis* axis = getAxis<AXIS>(hist);
        const int binNumber = axis->FindFixBin( var->getString(i).c_str() );
        return axis->GetBinCenter(binNumber);
      } else {
        return var->get(i);
      }
    }

    bool shouldRebinHistogram(const TAxis* axis, const double value) {
      return axis ? axis->GetXmax() <= value : false;
    }

    template<Axis AXIS, typename H>
    void rebinHistogram(H* hist, const double value) {
      hist->SetCanExtend(axis_bit[AXIS]);
      TAxis* a = getAxis<AXIS>(hist);
 
      // Rebinning requires to take OH lock in online (no-op offline)
      oh_scoped_lock_histogram lock;
      // Rebinning requires a lock on the global ROOT directory state
      std::scoped_lock<std::mutex> dirLock(HistogramFactory::globalROOTMutex());
      do {
        // need to unset cleanup bit of parent histogram during this operation
        // since it gets copied to a hidden temporary (probably unintentionally)
        bool curcleanup = hist->TestBit(TObject::kMustCleanup);
        hist->ResetBit(TObject::kMustCleanup);
        hist->LabelsInflate(axis_name[AXIS]);
        hist->SetBit(TObject::kMustCleanup, curcleanup);
      } while (shouldRebinHistogram(a, value));
    }

    template<typename T>
    bool fillWillRebinHistogram(const TAxis* axis, T value) {
      if (not axis) return false;
      const int bin = axis->FindFixBin(value);
      // if under/overflow
      if ( bin==0 or bin==axis->GetNbins()+1 ) {
        return true;
      }
      return false;
    }

    template<>
    bool fillWillRebinHistogram(const TAxis* axis, const char* value) {
      // valid bin found
      if ( not axis or axis->FindFixBin(value)>0 ) return false;
 
      // If there are no labels yet at least one unlabeled bin is available
      const THashList* labels = axis->GetLabels();
      if ( not labels ) return false;
 
      return true;
    }

    template<typename H, typename T, T... a, typename ...Vs>
    bool fillWillRebinHistogram(H* hist, std::integer_sequence<T, a...>, const Vs&... v) {
      // First check if axis is extensible, then if value would be outside of range
      return (... || (getAxis<static_cast<Axis>(a)>(hist)->CanExtend() and
                      detail::fillWillRebinHistogram(getAxis<static_cast<Axis>(a)>(hist), v)));
    }

    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 magic: Recursively convert all M to double or string
      if constexpr(std::is_same_v<M, Monitored::IMonitoredVariable>) {
        // For >=2D: If one variable has a single entry, do repeated fills with that value
        const size_t j = m1.size()==1 ? 0 : i;
        if (not m1.hasStringRepresentation())
          doFill(hist, weight, i, m..., m1.get(j));
        else
          doFill(hist, weight, i, m..., m1.getString(j).c_str());
      } else {
        // In case re-binning occurs need to take the OH lock for online (no-op offline)
        if ( ATH_UNLIKELY(fillWillRebinHistogram(hist, std::index_sequence_for<M, Ms...>{},
                                                 m1, m...)) ){
          oh_scoped_lock_histogram lock;
          // Rebinning requires a lock on the global ROOT directory state
          std::scoped_lock<std::mutex> dirLock(HistogramFactory::globalROOTMutex());
          hist->Fill(m1, m..., weight(i));
        }
        else hist->Fill(m1, m..., weight(i));
      }
    }
 
    // TProfile does not support string as y-value.
    // (this terminates the above pack expansion)
    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&) {}
  }
}
 
#endif