HistDelta Class Reference

Class to keep track of delta histograms. More...

#include <HistDelta.h>

Public Types
enum	EDeltaType {   c_Disabled = 0 ,   c_Entries = 1 ,   c_Underflow = 2 ,   c_Events = 3 }
	enum definition for delta algo Disabled: nothing Entries: use nr histogram entries Underflow: use entries in histogram underflow bin Events: use nr processed events from framework (but: unreliable for normalization as the number of events for this specific histogram may differ) More...

Public Member Functions
	HistDelta (EDeltaType t=c_Disabled, int p=0, unsigned int a=0)
	Constructor.
	~HistDelta ()
	Destructor.
void	set (EDeltaType t, int p, unsigned int a)
	Parameter setter.
void	setNotUpdated (void)
	Set not-updated yet status.
void	update (const TH1 *hist)
	Check if update of delta histogram is necessary.
void	reset (void)
	Reset histogram and deltas, not the parameters.
TH1 *	getDelta (unsigned int n=0, bool onlyIfUpdated=true) const
	Get Delta Histogram.

Public Attributes
EDeltaType	m_type {c_Disabled}
	type of delta algo
int	m_parameter {0}
	parameter depending on algo, e.g.
unsigned int	m_amountDeltas {}
	amount of past histograms, at least 1
std::unique_ptr< TH1 >	m_lastHist {nullptr}
	Pointer to last histogram state for check.
int	m_lastValue {0}
	last value for comparison, depending on type
std::vector< std::unique_ptr< TH1 > >	m_deltaHists
	vector of histograms (max m_amountDeltas)
bool	m_updated {false}
	if any delta was updated in this event

Detailed Description

Class to keep track of delta histograms.

The class owns the histograms. It keeps track of necessary updates which are depending on underlying histogram changes and conditions like entries, undeflow entries, events, to determine the delta update. It can stored several delta histograms (time series).

Definition at line 27 of file HistDelta.h.

Member Enumeration Documentation

EDeltaType

enum EDeltaType

enum definition for delta algo Disabled: nothing Entries: use nr histogram entries Underflow: use entries in histogram underflow bin Events: use nr processed events from framework (but: unreliable for normalization as the number of events for this specific histogram may differ)

Definition at line 36 of file HistDelta.h.

{ c_Disabled = 0, c_Entries = 1, c_Underflow = 2, c_Events = 3};

Constructor & Destructor Documentation

HistDelta()

HistDelta ( EDeltaType t = c_Disabled, int p = 0, unsigned int a = 0 )

explicit

Constructor.

Parameters

t	type
p	parameter for type
a	amount of deletas in the past

Definition at line 15 of file HistDelta.cc.

                                                        : m_lastHist{nullptr}
{
  m_type = t;
  m_parameter = p;
  m_amountDeltas = a;
  m_lastValue = 0; // implied
}

~HistDelta()

~HistDelta

(

)

Destructor.

Definition at line 23 of file HistDelta.cc.

{
  m_lastHist = nullptr;
  m_deltaHists.clear();
}

Member Function Documentation

getDelta()

TH1 * getDelta	(	unsigned int	n = 0,
		bool	onlyIfUpdated = true ) const

Get Delta Histogram.

Parameters

n	number of delta into the past, 0 is most recent one
onlyIfUpdated	req only updated deltas, return nullptr otherwise

Returns

Found histogram or nullptr

Definition at line 106 of file HistDelta.cc.

{
  if (onlyIfUpdated && !m_updated) return nullptr;// not updated, but requested
  if (n >= m_deltaHists.size()) return nullptr;// request beyond the number of existing deltas
  return m_deltaHists.at(n).get();
}

reset()

void reset

(

void

)

Reset histogram and deltas, not the parameters.

Definition at line 99 of file HistDelta.cc.

{
  m_deltaHists.clear();
  if (m_lastHist) m_lastHist->Reset();
  m_lastValue = 0;
}

set()

void set	(	EDeltaType	t,
		int	p,
		unsigned int	a )

Parameter setter.

Parameters

t	type
p	parameter for type
a	amount of deltas in the past

Definition at line 29 of file HistDelta.cc.

{
  m_type = t;
  m_parameter = p;
  m_amountDeltas = a;
  m_lastHist = nullptr;
  m_lastValue = 0;
  m_deltaHists.clear();
}

setNotUpdated()

void setNotUpdated ( void )

inline

Set not-updated yet status.

Definition at line 66 of file HistDelta.h.

{m_updated = false;};

update()

void update

(

const TH1 *

hist

)

Check if update of delta histogram is necessary.

Parameters

hist	pointer to histogram

else { not (yet) enough data for update special case of initial sampling is not covered in this code -> leave it up to the user code e.g. if getDelta(0) returns a nullptr, the user code writer should decide if it is useful to use the basic histogram }

Definition at line 39 of file HistDelta.cc.

{
  m_updated = false;
  if (currentHist == nullptr) return; // this won't make sense
  gROOT->cd(); // make sure we dont accidentally write the histograms to an 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);
  }
}

Member Data Documentation

m_amountDeltas

unsigned int m_amountDeltas {}

amount of past histograms, at least 1

Definition at line 39 of file HistDelta.h.

{}; 

m_deltaHists

std::vector<std::unique_ptr<TH1> > m_deltaHists

vector of histograms (max m_amountDeltas)

Definition at line 42 of file HistDelta.h.

m_lastHist

std::unique_ptr<TH1> m_lastHist {nullptr}

Pointer to last histogram state for check.

Definition at line 40 of file HistDelta.h.

{nullptr};

m_lastValue

int m_lastValue {0}

last value for comparison, depending on type

Definition at line 41 of file HistDelta.h.

{0}; 

m_parameter

int m_parameter {0}

parameter depending on algo, e.g.

nr of entries or events

Definition at line 38 of file HistDelta.h.

{0}; 

m_type

EDeltaType m_type {c_Disabled}

type of delta algo

Definition at line 37 of file HistDelta.h.

{c_Disabled}; 

m_updated

bool m_updated {false}

if any delta was updated in this event

Definition at line 43 of file HistDelta.h.

{false};

---

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

• dqm/core/include/HistDelta.h
• dqm/core/src/HistDelta.cc