Forward declare. More...

#include <CounterBase.h>

Inheritance diagram for CounterBase:

Collaboration diagram for CounterBase:

Public Member Functions
	CounterBase ()=delete
	Forbid default constructor. More...

	CounterBase (const std::string &name, const MonitorBase *parent)
	Construct counter. More...

virtual	~CounterBase ()=default
	Default destructor. More...

CounterBase &	operator= (const CounterBase &)=delete
	Forbid assignment. More...

	CounterBase (const CounterBase &)=delete
	Forbid copy. More...

const std::string &	getName () const
	Getter for Counter's name. More...

const MonitorBase *	getParent () const
	Return cached non-owning const ptr to this Counter's parent Monitor. More...

bool	variableExists (const std::string &name) const
	Check if a variable of a given name exists. More...

Variable &	getVariable (const std::string &name)
	Returns a mutable reference to a named Variable. More...

StatusCode	fill (const std::string &name, float value, float weight=1.0)
	Fill (for per-Call) or accumulate in a buffer (for per-Event) a quantity histogrammed by a named Variable. More...

StatusCode	fill (const std::string &name, float xvalue, float yvalue, float weight)
	Fill (for per-Call) or accumulate in a buffer (for per-Event) a quantity histogrammed by a named Variable. More...

StatusCode	increment (const std::string &name, float weight=1.0)
	Convenience function. More...

StatusCode	setDenominator (const std::string &name, float value)
	Optional for per-Event Variables. More...

virtual StatusCode	endEvent (float weight=1.0)
	Called by the framework. More...

virtual StatusCode	newEvent (const CostData &data, size_t index, float weight=1.0)=0
	Pure virtual interface called by Monitor to instruct this Counter to perform its analysis. More...

Protected Member Functions
void	regHistogram (const std::string &name, const std::string &title, const VariableType type=VariableType::kPerCall, const LogType xaxis=kLog, const float min=0.1, const float max=1000000., const size_t bins=70)
	Book a histogram for this Counter, to be filled in per-event monitoring. More...

void	regTProfile (const std::string &name, const std::string &title, const VariableType type=VariableType::kPerCall, const LogType xaxis=kLog, const float min=0.1, const float max=1000000., const size_t bins=70)
	Book a TProfile for this Counter, to be filled in per-event monitoring. More...

void	regHistogram (const std::string &name, const std::string &title, const VariableType type, const LogType xaxis, const float xmin, const float xmax, const size_t xbins, const LogType yaxis, const float ymin, const float ymax, const size_t ybins)
	Book a 2D histogram for this Counter, to be filled in per-event monitoring. More...

TH1 *	bookGetPointer (TH1 *hist, const std::string &tDir="") const
	Appends Counter name (to histogram path) and forwards histogram book request to parent Monitor. More...

float	timeToMilliSec (const uint64_t start, const uint64_t stop) const
	Helper function. More...

Private Attributes
const std::string	m_name
	Counter's name. More...

const MonitorBase *	m_parent
	Counter's parent Monitor. More...

std::unordered_map< std::string, Variable >	m_variables
	Store of Counter's Variables. More...

Detailed Description

Forward declare.

Base class for all "Counter" objects, with common histogram management functionality.

A Counter object represents a logical object which has monitored properties. A counter might represent an Algorithm, a Chain, a Lumi block, a ROS, etc. Each specialisation will have its own set of histograms.

Definition at line 25 of file CounterBase.h.

Constructor & Destructor Documentation

◆ CounterBase() [1/3]

CounterBase::CounterBase ( )

delete

Forbid default constructor.

◆ CounterBase() [2/3]

CounterBase::CounterBase	(	const std::string &	name,
		const MonitorBase *	parent
	)

Construct counter.

Parameters

[in]	name	Counter's name
[in]	parent	Counter's parent monitor, cached non-owning pointer.

Definition at line 12 of file CounterBase.cxx.

13 : m_name(name), m_parent(parent) {

14 }

◆ ~CounterBase()

virtual CounterBase::~CounterBase ( )

virtualdefault

Default destructor.

◆ CounterBase() [3/3]

CounterBase::CounterBase ( const CounterBase & )

delete

Forbid copy.

Member Function Documentation

◆ bookGetPointer()

TH1 * CounterBase::bookGetPointer	(	TH1 *	hist,
		const std::string &	tDir = `""`
	)		const

protected

Appends Counter name (to histogram path) and forwards histogram book request to parent Monitor.

Parameters

[in]	hist	Bare pointer to histogram. Ownership transferred to THistSvc.
[in]	tDir	Histogram name & directory.

Returns: Cached pointer to histogram. Used to fill histogram without having to perform THishSvc lookup.

Definition at line 233 of file CounterBase.cxx.

                                                                        {
   std::string dir = getName();
   if (tDir != "") {
     dir += "/";
     dir += tDir;
   }
   return getParent()->bookGetPointer(hist, dir);
 }

◆ endEvent()

StatusCode CounterBase::endEvent ( float weight = 1.0 )

virtual

Called by the framework.

Causes per-Event Variables to fill their histograms with their accumulated data.

Definition at line 225 of file CounterBase.cxx.

                                       {
   for (auto& nameVariablePair : m_variables) {
     ATH_CHECK( nameVariablePair.second.endEvent() );
   }
   return StatusCode::SUCCESS;
 }

◆ fill() [1/2]

StatusCode CounterBase::fill	(	const std::string &	name,
		float	value,
		float	weight = `1.0`
	)

Fill (for per-Call) or accumulate in a buffer (for per-Event) a quantity histogrammed by a named Variable.

Parameters

[in]	name	Variable to increment
[in]	value	The payload value
[in]	weight	Global event weight

Definition at line 191 of file CounterBase.cxx.

                                                                              {
   auto it = m_variables.find(name);
   if (it == m_variables.end()) {
     return StatusCode::FAILURE;
   }
   ATH_CHECK( it->second.fill(value, weight) );
   return StatusCode::SUCCESS;
 }

◆ fill() [2/2]

StatusCode CounterBase::fill	(	const std::string &	name,
		float	xvalue,
		float	yvalue,
		float	weight
	)

Fill (for per-Call) or accumulate in a buffer (for per-Event) a quantity histogrammed by a named Variable.

Parameters

[in]	name	Variable to increment
[in]	xvalue	The payload x-axis value
[in]	yvalue	The payload y-axis value
[in]	weight	Global event weight

Definition at line 200 of file CounterBase.cxx.

                                                                                              {
   auto it = m_variables.find(name);
   if (it == m_variables.end()) {
     return StatusCode::FAILURE;
   }
   ATH_CHECK( it->second.fill(xvalue, yvalue, weight) );
   return StatusCode::SUCCESS;
 }

◆ getName()

const std::string & CounterBase::getName ( ) const

Getter for Counter's name.

Returns: Counter's name const string reference.

Definition at line 17 of file CounterBase.cxx.

                                             {
   return m_name;
 }

◆ getParent()

const MonitorBase * CounterBase::getParent ( ) const

Return cached non-owning const ptr to this Counter's parent Monitor.

Returns: Cached pointer parent Monitor.

Definition at line 22 of file CounterBase.cxx.

                                                 {
   return m_parent;
 }

◆ getVariable()

Variable & CounterBase::getVariable ( const std::string & name )

Returns a mutable reference to a named Variable.

Throws if no such Variable exists. Used when more complicated logic is needed on a Variable than simply using the fill() method.

Parameters

[in] name Variable to return

Returns: Mutable reference to Variable

Definition at line 182 of file CounterBase.cxx.

                                                         {
   auto it = m_variables.find(name);
   if (it == m_variables.end()) {
     throw std::runtime_error( "CounterBase::getVariable: No varialbe with name " + name );
   }
   return (it->second);
 }

◆ increment()

StatusCode CounterBase::increment	(	const std::string &	name,
		float	weight = `1.0`
	)

Convenience function.

Equivalent to fill(name, 1.0, weight);

Parameters

[in]	name	Variable to increment
[in]	weight	Global event weight

Definition at line 220 of file CounterBase.cxx.

                                                                      {
   return fill(name, 1.0, weight);
 }

◆ newEvent()

virtual StatusCode CounterBase::newEvent	(	const CostData &	data,
		size_t	index,
		float	weight = `1.0`
	)

pure virtual

Pure virtual interface called by Monitor to instruct this Counter to perform its analysis.

Parameters

[in]	data	Access to event data
[in]	index	Index within appropriate event data container which is to be analysed by this Counter
[in]	weight	Global event weight

Implemented in CounterThread, CounterROS, CounterChain, CounterAlgorithm, CounterSequence, and CounterGlobal.

◆ operator=()

CounterBase& CounterBase::operator= ( const CounterBase & )

delete

Forbid assignment.

◆ regHistogram() [1/2]

void CounterBase::regHistogram	(	const std::string &	name,
		const std::string &	title,
		const VariableType	type,
		const LogType	xaxis,
		const float	xmin,
		const float	xmax,
		const size_t	xbins,
		const LogType	yaxis,
		const float	ymin,
		const float	ymax,
		const size_t	ybins
	)

protected

Book a 2D histogram for this Counter, to be filled in per-event monitoring.

Parameters

[in]	name	The name of the histogram (and corresponding Variable)
[in]	title	ROOT histogram title string in format "title;xaxis;yaxis"
[in]	xaxis	Controls if the x-axis should use fixed-width or logarithmic bin boundaries.
[in]	xmin	X-axis minimum bound.
[in]	xmax	X-axis maximum bound.
[in]	xbins	Number of histogram bins.
[in]	yaxis	Controls if the y-axis should use fixed-width or logarithmic bin boundaries.
[in]	ymin	Y-axis minimum bound.
[in]	ymax	Y-axis maximum bound.
[in]	ybins	Number of histogram bins.

Definition at line 109 of file CounterBase.cxx.

 {
   std::string hisSvcName = getParent()->getParent()->getName() + "_" + getParent()->getName() + "_" + getName() + "_" + name;
   std::unique_ptr<TH2F> hist;
  
   if (xmax <= xmin || ymax <= ymin || xbins == 0 || ybins == 0) {
     throw std::runtime_error("CounterBase::regHistogram: Cannot have max <= min or bins == 0");
   }
  
   if (xaxis == kLinear && yaxis == kLinear) {
     hist = std::make_unique<TH2F>(hisSvcName.c_str(), title.c_str(), xbins, xmin, xmax, ybins, ymin, ymax);
   } else if (xaxis == kLog || yaxis == kLog) {
     if ( (xaxis == kLog && xmin <= 0) || (yaxis == kLog && ymin <= 0) ) {
       throw std::runtime_error("CounterBase::regHistogram: Cannot have min <= 0 with log binning");
     }
     std::unique_ptr<double[]> xlogbins = std::make_unique<double[]>(xbins+1);
     std::unique_ptr<double[]> ylogbins = std::make_unique<double[]>(ybins+1);
     if (xaxis == kLog){
       const double xlogmin = log10(xmin);
       const double xlogmax = log10(xmax);
       const double dlogx   = (xlogmax-xlogmin)/((double)xbins);
       for (size_t i = 0; i <= xbins; ++i) { 
         const double xlog = xlogmin + i*dlogx;
         xlogbins[i] = exp( log(10) * xlog ); 
       }
     } else {
       const double dx = (xmax-xmin)/((double)xbins);
       for (size_t i = 0; i <= xbins; ++i) {
         xlogbins[i] = xmin + i*dx; 
       }
     }
  
     if (yaxis == kLog){
       const double ylogmin = log10(ymin);
       const double ylogmax = log10(ymax);
       const double dlogy   = (ylogmax-ylogmin)/((double)ybins);
       for (size_t i = 0; i <= ybins; ++i) { 
         const double ylog = ylogmin + i*dlogy;
         ylogbins[i] = exp( log(10) * ylog ); 
       }
     } else {
       const double dy = (ymax-ymin)/((double)ybins);
       for (size_t i = 0; i <= ybins; ++i) {
         ylogbins[i] = ymin + i*dy; 
       }
     }
  
     hist = std::make_unique<TH2F>(hisSvcName.c_str(), title.c_str(), xbins, xlogbins.get(), ybins, ylogbins.get());
   } else {
     throw std::runtime_error("CounterBase::regHistogram: Unknown logarithm flag");
   }
  
   m_variables.emplace(std::piecewise_construct,
     std::forward_as_tuple(name),
     std::forward_as_tuple(name, bookGetPointer(hist.release()), type)
   );
   // Histogram is now owned by THistSvc. A cache of the ptr is kept in the Variable
 }

◆ regHistogram() [2/2]

void CounterBase::regHistogram	(	const std::string &	name,
		const std::string &	title,
		const VariableType	type = `VariableType::kPerCall`,
		const LogType	xaxis = `kLog`,
		const float	min = `0.1`,
		const float	max = `1000000.`,
		const size_t	bins = `70`
	)

protected

Book a histogram for this Counter, to be filled in per-event monitoring.

Parameters

[in]	name	The name of the histogram (and corresponding Variable)
[in]	title	ROOT histogram title string in format "title;xaxis;yaxis"
[in]	xaxis	Controls if the x-axis should use fixed-width or logarithmic bin boundaries.
[in]	min	X-axis minimum bound.
[in]	max	X-axis maximum bound.
[in]	bins	Number of histogram bins.

Definition at line 27 of file CounterBase.cxx.

 {
   std::string hisSvcName = getParent()->getParent()->getName() + "_" + getParent()->getName() + "_" + getName() + "_" + name;
   std::unique_ptr<TH1F> hist;
  
   if (max <= min || bins == 0) {
     throw std::runtime_error("CounterBase::regHistogram: Cannot have max <= min or bins == 0");
   }
  
   if (xaxis == kLinear) {
     hist = std::make_unique<TH1F>(hisSvcName.c_str(), title.c_str(), bins, min, max);
   } else if (xaxis == kLog) {
     if (min <= 0) {
       throw std::runtime_error("CounterBase::regHistogram: Cannot have min <= 0 with log binning");
     }
     std::unique_ptr<double[]> xbins = std::make_unique<double[]>(bins+1);
     const double xlogmin = log10(min);
     const double xlogmax = log10(max);
     const double dlogx   = (xlogmax-xlogmin)/((double)bins);
     for (size_t i = 0; i <= bins; ++i) { 
       const double xlog = xlogmin + i*dlogx;
       xbins[i] = exp( log(10) * xlog ); 
     }
     hist = std::make_unique<TH1F>(hisSvcName.c_str(), title.c_str(), bins, xbins.get());
   } else {
     throw std::runtime_error("CounterBase::regHistogram: Unknown logarithm flag");
   }
  
   m_variables.emplace(std::piecewise_construct,
     std::forward_as_tuple(name),
     std::forward_as_tuple(name, bookGetPointer(hist.release()), type)
   );
   // Histogram is now owned by THistSvc. A cache of the ptr is kept in the Variable
 }

◆ regTProfile()

void CounterBase::regTProfile	(	const std::string &	name,
		const std::string &	title,
		const VariableType	type = `VariableType::kPerCall`,
		const LogType	xaxis = `kLog`,
		const float	min = `0.1`,
		const float	max = `1000000.`,
		const size_t	bins = `70`
	)

protected

Book a TProfile for this Counter, to be filled in per-event monitoring.

Parameters

[in]	name	The name of the histogram (and corresponding Variable)
[in]	title	ROOT histogram title string in format "title;xaxis;yaxis"
[in]	xaxis	Controls if the x-axis should use fixed-width or logarithmic bin boundaries.
[in]	min	X-axis minimum bound.
[in]	max	X-axis maximum bound.
[in]	bins	Number of histogram bins.

Definition at line 68 of file CounterBase.cxx.

 {
   std::string hisSvcName = getParent()->getParent()->getName() + "_" + getParent()->getName() + "_" + getName() + "_" + name;
   std::unique_ptr<TProfile> hist;
  
   if (max <= min || bins == 0) {
     throw std::runtime_error("CounterBase::regTProfile: Cannot have max <= min or bins == 0");
   }
  
   if (xaxis == kLinear) {
     hist = std::make_unique<TProfile>(hisSvcName.c_str(), title.c_str(), bins, min, max);
   } else if (xaxis == kLog) {
     if (min <= 0) {
       throw std::runtime_error("CounterBase::regTProfile: Cannot have min <= 0 with log binning");
     }
     std::unique_ptr<double[]> xbins = std::make_unique<double[]>(bins+1);
     const double xlogmin = log10(min);
     const double xlogmax = log10(max);
     const double dlogx   = (xlogmax-xlogmin)/((double)bins);
     for (size_t i = 0; i <= bins; ++i) { 
       const double xlog = xlogmin + i*dlogx;
       xbins[i] = exp( log(10) * xlog ); 
     }
     hist = std::make_unique<TProfile>(hisSvcName.c_str(), title.c_str(), bins, xbins.get());
   } else {
     throw std::runtime_error("CounterBase::regTProfile: Unknown logarithm flag");
   }
  
   m_variables.emplace(std::piecewise_construct,
     std::forward_as_tuple(name),
     std::forward_as_tuple(name, bookGetPointer(hist.release()), type)
   );
   // Histogram is now owned by THistSvc. A cache of the ptr is kept in the Variable
 }

◆ setDenominator()

StatusCode CounterBase::setDenominator	(	const std::string &	name,
		float	value
	)

Optional for per-Event Variables.

Sets a denominator to divide the value through by before filling.

Parameters

[in]	name	Variable to set the denominator for.
[in]	value	The denominator

Definition at line 210 of file CounterBase.cxx.

                                                                          {
   auto it = m_variables.find(name);
   if (it == m_variables.end()) {
     return StatusCode::FAILURE;
   }
   it->second.setDenominator(value);
   return StatusCode::SUCCESS;
 }

◆ timeToMilliSec()

float CounterBase::timeToMilliSec	(	const uint64_t	start,
		const uint64_t	stop
	)		const

protected

Helper function.

Compute the time difference in discreet microseconds and covert to fractional milliseconds.

Returns: Time difference in milliseconds, floating point.

Definition at line 243 of file CounterBase.cxx.

                                                                                  {
   if (stop < start) {
     throw std::runtime_error("Asked for a stop time " + std::to_string(stop) + " which is before the start time " + std::to_string(start));
   }
   const uint64_t difference = stop - start;
   return (difference * 1e-3); // micro to ms
 }

◆ variableExists()

bool CounterBase::variableExists ( const std::string & name ) const

Check if a variable of a given name exists.

Parameters

[in] name Name of Variable.

Returns: True if variable already exists.

Definition at line 178 of file CounterBase.cxx.

                                                             {
   return (m_variables.count(name) == 1);
 }

Member Data Documentation

◆ m_name

const std::string CounterBase::m_name

private

Counter's name.

Definition at line 203 of file CounterBase.h.

◆ m_parent

const MonitorBase* CounterBase::m_parent

private

Counter's parent Monitor.

Cached non-owning const pointer.

Definition at line 204 of file CounterBase.h.

◆ m_variables

std::unordered_map< std::string, Variable > CounterBase::m_variables

private

Store of Counter's Variables.

These wrap a histogram pointer. Keyed by name.

Definition at line 205 of file CounterBase.h.

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

Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CounterBase() [1/3]

◆ CounterBase() [2/3]

◆ ~CounterBase()

◆ CounterBase() [3/3]

Member Function Documentation

◆ bookGetPointer()

◆ endEvent()

◆ fill() [1/2]

◆ fill() [2/2]

◆ getName()

◆ getParent()

◆ getVariable()

◆ increment()

◆ newEvent()

◆ operator=()

◆ regHistogram() [1/2]

◆ regHistogram() [2/2]

◆ regTProfile()

◆ setDenominator()

◆ timeToMilliSec()

◆ variableExists()

Member Data Documentation

◆ m_name

◆ m_parent

◆ m_variables