Monitored::LiveHistogramProvider Class Reference

Provides latest-N-lumiblock histograms to be filled. More...

#include <LiveHistogramProvider.h>

Inheritance diagram for Monitored::LiveHistogramProvider:

Collaboration diagram for Monitored::LiveHistogramProvider:

Public Member Functions
	LiveHistogramProvider (GenericMonitoringTool *const gmTool, std::shared_ptr< HistogramFactory > factory, const HistogramDef &histDef)
	Constructor.
TNamed *	histogram () override
	Getter of ROOT histogram.
void	updateHistDef ()
	Updates HistogramDef xmin, xmax and xbins members.
void	copyDataToNewHistogram (TH1 *hOld, TH1 *hNew)
	Copies bin contents from an old to a new histogram.
void	copyDataToNewHistogram (TProfile *hOld, TProfile *hNew)

Private Attributes
GenericMonitoringTool *const	m_gmTool
std::shared_ptr< HistogramFactory >	m_factory
std::shared_ptr< HistogramDef >	m_histDef
TNamed *	m_currentHistogram = nullptr
int	m_currentLumiBlock = 0

Detailed Description

Provides latest-N-lumiblock histograms to be filled.

Provides histograms which shows only information from the last N lumiblocks. The highest encountered lumiblock is calculated, and only data from Max-N to N is shown. Note: kLBNLive must be defined in histogram definition options.

Definition at line 24 of file LiveHistogramProvider.h.

Constructor & Destructor Documentation

LiveHistogramProvider()

Monitored::LiveHistogramProvider::LiveHistogramProvider ( GenericMonitoringTool *const gmTool, std::shared_ptr< HistogramFactory > factory, const HistogramDef & histDef )

inline

Constructor.

Parameters

gmTool	Source of the lumi block info.
factory	ROOT object factory.
def	Definition of the histogram.

Definition at line 34 of file LiveHistogramProvider.h.

      : IHistogramProvider()
      , m_gmTool(gmTool)
      , m_factory(std::move(factory))
      , m_histDef(new HistogramDef(histDef))
      {}

Member Function Documentation

copyDataToNewHistogram() [1/2]

void Monitored::LiveHistogramProvider::copyDataToNewHistogram ( TH1 * hOld, TH1 * hNew )

inline

Copies bin contents from an old to a new histogram.

Definition at line 127 of file LiveHistogramProvider.h.

                                                      {
      int offset = hNew->GetXaxis()->GetXmax() - hOld->GetXaxis()->GetXmax();
      int nNewEntries(0);
      bool sumw2Filled = (hOld->GetSumw2N()>0);
 
      // Loop through the old histogram bins
      for (int oldBin=0; oldBin < hOld->GetNcells(); oldBin++) {
        // Convert global bin number into x-y-z bin number
        int oldBinX, oldBinY, oldBinZ;
        hOld->GetBinXYZ(oldBin, oldBinX, oldBinY, oldBinZ);
        if ((oldBinX-offset < 1) || hOld->IsBinUnderflow(oldBin, 1) || hOld->IsBinOverflow(oldBin, 1)) {
          // Overflow bins are ignored since their meaning has changed.
          continue;
        } else {
          // Get the global bin coordinate of this (x, y, z) bin coordinates.
          int newBin = hNew->GetBin(oldBinX-offset, oldBinY, oldBinZ);
      if (hOld->GetBinContent(oldBin)) hNew->SetBinContent(newBin, hOld->GetBinContent(oldBin));
      if (sumw2Filled) {
        hNew->SetBinError(newBin, hOld->GetBinError(oldBin));
        nNewEntries+=(*hOld->GetSumw2())[oldBin]; // works correctly only for weight=1
      }
        }
      }
      // Update the total number of entries member.
      if (sumw2Filled) hNew->SetEntries(nNewEntries);
      else hNew->SetEntries(hOld->GetEntries()); // a choice since there is no way to get it right.
    }  

copyDataToNewHistogram() [2/2]

void Monitored::LiveHistogramProvider::copyDataToNewHistogram ( TProfile * hOld, TProfile * hNew )

inline

Definition at line 155 of file LiveHistogramProvider.h.

                                                                {
      int offset = hNew->GetXaxis()->GetXmax() - hOld->GetXaxis()->GetXmax();
      int nNewEntries(0);
      bool sumw2Filled = (hOld->GetSumw2N()>0);
      
      // Loop through the old histogram bins
      for (int oldBin=0; oldBin < hOld->GetNcells(); oldBin++) {
    // Convert global bin number into x-y-z bin number
    int oldBinX, oldBinY, oldBinZ;
    hOld->GetBinXYZ(oldBin, oldBinX, oldBinY, oldBinZ);
    if ((oldBinX-offset < 1) || hOld->IsBinUnderflow(oldBin, 1) || hOld->IsBinOverflow(oldBin, 1)) {
      // Overflow bins are ignored since their meaning has changed.
      continue;
    } else {
      // Get the global bin coordinate of this (x, y, z) bin coordinates.
      int newBin = hNew->GetBin(oldBinX-offset, oldBinY, oldBinZ);
      int oldBinEntries = hOld->GetBinEntries(oldBin);
      if (oldBinEntries>0) {
        nNewEntries += oldBinEntries;
        hNew->SetBinEntries(newBin, oldBinEntries);
        (*hNew)[newBin] = (*hOld)[oldBin];
        (*hNew->GetSumw2())[newBin] = (*hOld->GetSumw2())[oldBin];
      }
    }
      }
      // Update the total number of entries member.
      if (sumw2Filled) hNew->SetEntries(nNewEntries);
      else hNew->SetEntries(hOld->GetEntries()); // a choice since there is no way to get it right.
    } 

histogram()

TNamed * Monitored::LiveHistogramProvider::histogram ( )

inlineoverridevirtual

Getter of ROOT histogram.

Each time the method is called, factory produces ROOT object based on the current lumi block. Note: ROOT objects are cached at the factory. Nevertheless, it is recommended to call this method as rarely as possible.

Returns

ROOT object

Implements Monitored::IHistogramProvider.

Definition at line 53 of file LiveHistogramProvider.h.

                                 {
      // Get the LB for this event.
      const int lumiBlock = m_gmTool->lumiBlock();
 
      if (lumiBlock > m_currentLumiBlock) {
        // Update the variable keeping track of the highest LB.
        m_currentLumiBlock = std::max((float) lumiBlock, m_histDef->xmax);
 
        if (!m_currentHistogram) {
          // The histogram does not exist yet and must be created.
          updateHistDef();
          m_currentHistogram = m_factory->create(*m_histDef);
        } else {
          // The histogram exists and needs to be rolled
          if (m_histDef->type=="TEfficiency") {
            // Roll a TEfficiency (same process as the codeblock immediately above)
            TH1* totalClone = static_cast<TEfficiency*>(m_currentHistogram)->GetCopyTotalHisto();
            TH1* passedClone = static_cast<TEfficiency*>(m_currentHistogram)->GetCopyPassedHisto();
            m_factory->remove(*m_histDef);
            updateHistDef();
            TEfficiency* eNew = static_cast<TEfficiency*> (m_factory->create(*m_histDef));
            TH1* totalNew = eNew->GetCopyTotalHisto();
            TH1* passedNew = eNew->GetCopyPassedHisto();
            copyDataToNewHistogram(totalClone, totalNew);
            copyDataToNewHistogram(passedClone, passedNew);
            eNew->SetTotalHistogram(*totalNew, "");
            eNew->SetPassedHistogram(*passedNew, "");
            m_currentHistogram = eNew;
            delete totalClone;
            delete totalNew;
            delete passedClone;
            delete passedNew;
      } else if (m_histDef->type=="TProfile") {
        // Store the data and deregister the old histogram.
            TProfile* hClone = static_cast<TProfile*> (m_currentHistogram->Clone());
            m_factory->remove(*m_histDef);
            // Update the bin ranges and register the new histogram.
            updateHistDef();
            TProfile* hNew = static_cast<TProfile*> (m_factory->create(*m_histDef));
            // Fill it with the old histogram's data and update pointer.
            copyDataToNewHistogram(hClone, hNew);
            m_currentHistogram = hNew;
            // Free the memory used by the clone
            delete hClone;
          } else {
            // Store the data and deregister the old histogram.
            TH1* hClone = (TH1*) m_currentHistogram->Clone();
            m_factory->remove(*m_histDef);
            // Update the bin ranges and register the new histogram.
            updateHistDef();
            TH1* hNew = (TH1*) m_factory->create(*m_histDef);
            // Fill it with the old histogram's data and update pointer.
            copyDataToNewHistogram(hClone, hNew);
            m_currentHistogram = hNew;
            // Free the memory used by the clone
            delete hClone;
          }
        }
      }
      return m_currentHistogram;
    }

updateHistDef()

void Monitored::LiveHistogramProvider::updateHistDef ( )

inline

Updates HistogramDef xmin, xmax and xbins members.

Definition at line 118 of file LiveHistogramProvider.h.

                         {
        m_histDef->xmax = std::max(m_currentLumiBlock + 0.5f, m_histDef->xmax);
        m_histDef->xmin = std::max(m_currentLumiBlock + 0.5f - m_histDef->kLive, 0.5f);
        m_histDef->xbins = m_histDef->xmax - m_histDef->xmin;
    }

Member Data Documentation

m_currentHistogram

TNamed* Monitored::LiveHistogramProvider::m_currentHistogram = nullptr

private

Definition at line 189 of file LiveHistogramProvider.h.

m_currentLumiBlock

int Monitored::LiveHistogramProvider::m_currentLumiBlock = 0

private

Definition at line 190 of file LiveHistogramProvider.h.

m_factory

std::shared_ptr<HistogramFactory> Monitored::LiveHistogramProvider::m_factory

private

Definition at line 187 of file LiveHistogramProvider.h.

m_gmTool

GenericMonitoringTool* const Monitored::LiveHistogramProvider::m_gmTool

private

Definition at line 186 of file LiveHistogramProvider.h.

m_histDef

std::shared_ptr<HistogramDef> Monitored::LiveHistogramProvider::m_histDef

private

Definition at line 188 of file LiveHistogramProvider.h.

---

The documentation for this class was generated from the following file:

• LiveHistogramProvider.h