HistDelta.cc

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#include <dqm/core/HistDelta.h>
#include <dqm/core/DQMHistAnalysis.h>
#include <string>
#include <TROOT.h>
 
using namespace Belle2;
 
HistDelta::HistDelta(EDeltaType t, int p, unsigned int a) : m_lastHist{nullptr}
{
  m_type = t;
  m_parameter = p;
  m_amountDeltas = a;
  m_lastValue = 0; // implied
}
 
HistDelta::~HistDelta()
{
  m_lastHist = nullptr;
  m_deltaHists.clear();
}
 
void HistDelta::set(EDeltaType t, int p, unsigned int a)
{
  m_type = t;
  m_parameter = p;
  m_amountDeltas = a;
  m_lastHist = nullptr;
  m_lastValue = 0;
  m_deltaHists.clear();
}
 
void HistDelta::update(const TH1* currentHist)
{
  m_updated = false;
  if (currentHist == nullptr) return; // this won't make sense
  gROOT->cd(); // make sure we dont accidentally write the histograms to a open file
  // cover first update after start
  if (m_lastHist == nullptr) {
    m_lastHist = std::unique_ptr<TH1>(static_cast<TH1*>(currentHist->Clone()));
    m_lastHist->SetName(TString(currentHist->GetName()) + "_last");
    m_lastHist->Reset();
    m_updated = true;
  }
  // now check if need to update m_deltaHists
  bool need_update = false;
  switch (m_type) {
    case c_Entries:
      // default case, look at the entries in the histogram
      need_update = currentHist->GetEntries() - m_lastHist->GetEntries() >= m_parameter;
      break;
    case c_Underflow:
      // here we misuse underflow as event counter in some histograms, e.g. PXD
      need_update = currentHist->GetBinContent(0) - m_lastHist->GetBinContent(0) >= m_parameter;
      break;
    case c_Events:
      // use event processed counter
      need_update = DQMHistAnalysisModule::getEventProcessed() - m_lastValue >= m_parameter;
      if (need_update) m_lastValue = DQMHistAnalysisModule::getEventProcessed(); // update last value
      break;
    default:
      // any unsupported types map to case 0(Disabled), and will disable delta for this hist
      [[fallthrough]];
    case c_Disabled:
      break;
  }
 
  if (need_update) {
    m_updated = true;
    auto delta = static_cast<TH1*>(currentHist->Clone());
    delta->SetName(TString(delta->GetName()) + "_delta");
    delta->Add(m_lastHist.get(), -1.);
 
    // we use this as a fifo, but cannot use queue as we need the random access
    // maybe use deque?
    m_deltaHists.emplace(m_deltaHists.begin(), delta);
    if (m_deltaHists.size() > m_amountDeltas) {
      // remove (and delete) last element
      m_deltaHists.erase(m_deltaHists.begin() + m_deltaHists.size() - 1);
    }
    m_lastHist->Reset();
    m_lastHist->Add(currentHist);
  }
}
 
void HistDelta::reset(void)
{
  m_deltaHists.clear();
  if (m_lastHist) m_lastHist->Reset();
  m_lastValue = 0;
}
 
TH1* HistDelta::getDelta(unsigned int n, bool onlyIfUpdated) const
{
  if (onlyIfUpdated && !m_updated) return nullptr;// not updated, but requested
  if (n >= m_deltaHists.size()) return nullptr;
  return m_deltaHists.at(n).get();
}