Generic monitoring tool for athena components. More...

Namespaces
namespace	detail

Classes
class	CumulativeHistogramFiller1D
	Filler for 1D histograms filled in cummulative mode. More...
class	Group
	Group of local monitoring quantities and retain correlation when filling histograms More...
struct	HistogramDef
	the internal class used to keep parsed Filler properties More...
struct	HistogramException
	Represents error occurred during accessing histograms objects. More...
class	HistogramFactory
	Bridge between ROOT framework and monitoring code. More...
class	HistogramFiller
	Base class for all histogram fillers. More...
class	HistogramFiller1D
	Filler for plain 1D histograms. More...
class	HistogramFiller2DGeneric
	Generic filler for 2D histogram. More...
class	HistogramFiller2DProfile
	Filler for profile 2D histogram. More...
class	HistogramFillerEfficiency
	Filler for TEfficiency graphs. More...
class	HistogramFillerFactory
	Factory of the histogram fillers. More...
class	HistogramFillerRebinableAxis
	Mixin class for rebinning of histogram axis. More...
class	HistogramFillerTree
	Filler for TTrees. More...
class	IHistogramProvider
	Interface of the source of ROOT objects for HistogramFillers. More...
class	IMonitoredVariable
class	LiveHistogramProvider
	Provides latest-N-lumiblock histograms to be filled. More...
class	LumiblockHistogramProvider
	Implementation of IHistogramProvider for lumi block based histograms. More...
class	ObjectsCollection
	Monitoring of object collections (internal) More...
class	ObjectsRefCollection
	Monitoring of object collection references (internal) More...
class	OfflineHistogramProvider
	Implementation of IHistogramProvider for offline histograms. More...
class	Scalar
	Declare a monitored scalar variable. More...
class	ScopedTimer
	Helper class to create a scoped timer. More...
class	StaticHistogramProvider
	Default implementation of IHistogramProvider interface. More...
class	Timer
	A monitored timer. More...
class	ValuesCollection
	Internal class not to be used by end user. More...
class	ValuesRefCollection
	Internal class not to be used by end user. More...
class	VecHistogramFiller1D

Typedefs
typedef HistogramFiller2DGeneric< TH2 >	HistogramFiller2D
typedef HistogramFillerRebinableAxis< HistogramFiller2DProfile, Axis::X >	HistogramFiller2DProfileRebinable
	TProfile2D filler with rebinable x-axis.
typedef HistogramFiller2DGeneric< TProfile >	HistogramFillerProfile
	TProfile filler.
typedef HistogramFillerRebinableAxis< HistogramFillerProfile, Axis::X >	HistogramFillerProfileRebinable
	TProfile filler with rebinable x-axis.
typedef HistogramFillerRebinableAxis< HistogramFiller1D, Axis::X >	HistogramFillerRebinable1D
	Rebinable 1D histogram.
typedef HistogramFillerRebinableAxis< HistogramFiller2D, Axis::X >	HistogramFillerRebinable2DX
	Rebinable 2D histogram (x-axis only)
typedef HistogramFillerRebinableAxis< HistogramFiller2D, Axis::Y >	HistogramFillerRebinable2DY
	Rebinable 2D histogram (y-axis only)
typedef HistogramFillerRebinableAxis< HistogramFillerRebinable2DX, Axis::Y >	HistogramFillerRebinable2D
	Rebinable 2D histogram (both axes)

Enumerations
enum	Axis { X = 0 , Y , Z }
	Helper type for histogram axis selection. More...

Functions
template<class T>
ValuesCollection< T >	Collection (std::string name, const T &collection)
	Declare a monitored (double-convertible) collection.
template<class T>
ValuesCollection< T >	Collection (std::string name, T const &&collection)
template<class T>
ValuesRefCollection< T >	Collection (std::string name, const std::reference_wrapper< T > &collection)
	Declare a monitored (double-convertible) collection reference.
template<class T>
ValuesRefCollection< T >	Collection (std::string name, const std::reference_wrapper< T > &&collection)
template<class T>
ObjectsCollection< T, double >	Collection (std::string name, const T &collection, std::function< double(const typename ObjectsCollection< T, double >::const_value_type &)> accessor)
	Declare a monitored collection of objects via accessor function.
template<class T>
ObjectsCollection< T, double >	Collection (std::string name, const T &&collection, std::function< double(const typename ObjectsCollection< T, double >::const_value_type &)> accessor)=delete
template<class T>
ObjectsCollection< T, std::string >	Collection (std::string name, const T &collection, std::function< std::string(const typename ObjectsCollection< T, std::string >::const_value_type &)> accessor)
template<class T>
ObjectsCollection< T, std::string >	Collection (std::string name, const T &&collection, std::function< std::string(const typename ObjectsCollection< T, std::string >::const_value_type &)> accessor)=delete
template<class T>
ObjectsRefCollection< T, double >	Collection (std::string name, const std::reference_wrapper< T > &collection, std::function< double(const typename ObjectsRefCollection< T, double >::const_value_type &)> accessor)
	Declare a monitored reference to a collection of objects via accessor function.
template<class T>
ObjectsRefCollection< T, double >	Collection (std::string name, const std::reference_wrapper< T > &&collection, std::function< double(const typename ObjectsRefCollection< T, double >::const_value_type &)> accessor)=delete
template<class T>
ObjectsRefCollection< T, std::string >	Collection (std::string name, const std::reference_wrapper< T > &collection, std::function< std::string(const typename ObjectsRefCollection< T, std::string >::const_value_type &)> accessor)
template<class T>
ObjectsRefCollection< T, std::string >	Collection (std::string name, const std::reference_wrapper< T > &&collection, std::function< std::string(const typename ObjectsRefCollection< T, std::string >::const_value_type &)> accessor)=delete
template<typename... T>
void	fill (const ToolHandle< GenericMonitoringTool > &tool, T &&... variables)
template<typename V, typename std::enable_if_t< std::is_integral_v< V > > * = nullptr>
std::vector< V >	buildToolMap (const ToolHandleArray< GenericMonitoringTool > &tools, const std::string &baseName, int nHist)
	Builds an array of indices (base case)
template<typename V, typename std::enable_if_t<!std::is_integral_v< V > > * = nullptr, typename... T>
std::vector< V >	buildToolMap (const ToolHandleArray< GenericMonitoringTool > &tools, const std::string &baseName, int nHist, T... dimensions)
	Builds an N-dimensional array of indices (recursive)
template<typename V, typename std::enable_if_t< std::is_integral_v< V > > * = nullptr>
std::map< std::string, int >	buildToolMap (const ToolHandleArray< GenericMonitoringTool > &tools, const std::string &baseName, const std::vector< std::string > &labels)
	Builds a map of indices (base case)
template<typename V, typename std::enable_if_t<!std::is_integral_v< V > > * = nullptr, typename... T>
std::map< std::string, V >	buildToolMap (const ToolHandleArray< GenericMonitoringTool > &tools, const std::string &baseName, const std::vector< std::string > &labels, T... dimensions)
	Builds an N-dimensional map of indices (recursive)
void	checkNamingConvention (std::string_view name)
std::ostream &	operator<< (std::ostream &os, const std::reference_wrapper< Monitored::IMonitoredVariable > &rmv)
template<typename T>
void	scalarFillerFunc (TBranch *branch, const IMonitoredVariable &var)
template<>
void	scalarFillerFunc< std::string > (TBranch *branch, const IMonitoredVariable &var)
template<typename T>
void	vectorFillerFunc (TBranch *branch, const IMonitoredVariable &var)
template<>
void	vectorFillerFunc< std::string > (TBranch *branch, const IMonitoredVariable &var)
template<>
void	scalarFillerFunc< std::string > (TBranch *branch, const IMonitoredVariable &var)
template<>
void	vectorFillerFunc< std::string > (TBranch *branch, const IMonitoredVariable &var)

Detailed Description

Generic monitoring tool for athena components.

Namespace for the athenaMT monitoring infrastructure.

The tool can be used standalone or attached to an algorithm, tool or service. The variables to be monitored need to be exposed via the Monitored framework. The histograms to be created are configured via the Histograms list property and the format is defined via Monitored::HistogramDef.

Configuration from python should be done using GenericMonitoringTool.defineHistogram. For the list of supported histogram types see Monitored::HistogramFillerFactory.

See also: athenaMT monitoring infrastructure

Typedef Documentation

◆ HistogramFiller2D

typedef HistogramFiller2DGeneric<TH2> Monitored::HistogramFiller2D

Definition at line 81 of file HistogramFiller2D.h.

◆ HistogramFiller2DProfileRebinable

typedef HistogramFillerRebinableAxis<HistogramFiller2DProfile, Axis::X> Monitored::HistogramFiller2DProfileRebinable

TProfile2D filler with rebinable x-axis.

Definition at line 62 of file HistogramFiller2DProfile.h.

◆ HistogramFillerProfile

typedef HistogramFiller2DGeneric<TProfile> Monitored::HistogramFillerProfile

TProfile filler.

Definition at line 17 of file HistogramFillerProfile.h.

◆ HistogramFillerProfileRebinable

typedef HistogramFillerRebinableAxis<HistogramFillerProfile, Axis::X> Monitored::HistogramFillerProfileRebinable

TProfile filler with rebinable x-axis.

Definition at line 19 of file HistogramFillerProfile.h.

◆ HistogramFillerRebinable1D

typedef HistogramFillerRebinableAxis<HistogramFiller1D, Axis::X> Monitored::HistogramFillerRebinable1D

Rebinable 1D histogram.

Definition at line 81 of file HistogramFillerRebinable.h.

◆ HistogramFillerRebinable2D

typedef HistogramFillerRebinableAxis<HistogramFillerRebinable2DX, Axis::Y> Monitored::HistogramFillerRebinable2D

Rebinable 2D histogram (both axes)

Definition at line 87 of file HistogramFillerRebinable.h.

◆ HistogramFillerRebinable2DX

typedef HistogramFillerRebinableAxis<HistogramFiller2D, Axis::X> Monitored::HistogramFillerRebinable2DX

Rebinable 2D histogram (x-axis only)

Definition at line 83 of file HistogramFillerRebinable.h.

◆ HistogramFillerRebinable2DY

typedef HistogramFillerRebinableAxis<HistogramFiller2D, Axis::Y> Monitored::HistogramFillerRebinable2DY

Rebinable 2D histogram (y-axis only)

Definition at line 85 of file HistogramFillerRebinable.h.

Enumeration Type Documentation

◆ Axis

enum Monitored::Axis

Helper type for histogram axis selection.

Enumerator
X
Y
Z

Definition at line 24 of file HistogramFillerUtils.h.

24{X = 0, Y, Z};

Monitored::X

@ X

Definition HistogramFillerUtils.h:24

Monitored::Y

@ Y

Definition HistogramFillerUtils.h:24

Monitored::Z

@ Z

Definition HistogramFillerUtils.h:24

Function Documentation

◆ buildToolMap() [1/4]

template<typename V, typename std::enable_if_t< std::is_integral_v< V > > * = nullptr>

std::map< std::string, int > Monitored::buildToolMap	(	const ToolHandleArray< GenericMonitoringTool > &	tools,
		const std::string &	baseName,
		const std::vector< std::string > &	labels )

Builds a map of indices (base case)

Definition at line 170 of file MonitoredGroup.h.

                                                                                                                                                          {
    std::map<std::string,int> indexMap;
    for ( const std::string& label : labels ) {
      std::string groupName = baseName + "_" + label;
      indexMap[label] = detail::findToolIndex(tools,groupName);
    }
    return indexMap;
  }

◆ buildToolMap() [2/4]

template<typename V, typename std::enable_if_t<!std::is_integral_v< V > > * = nullptr, typename... T>

std::map< std::string, V > Monitored::buildToolMap	(	const ToolHandleArray< GenericMonitoringTool > &	tools,
		const std::string &	baseName,
		const std::vector< std::string > &	labels,
		T...	dimensions )

Builds an N-dimensional map of indices (recursive)

Definition at line 181 of file MonitoredGroup.h.

                                                                                                                                                                         {
    std::map<std::string,V> indexMap;
    for ( const std::string& label : labels ) {
      std::string groupName = baseName + "_" + label;
      indexMap[label] = buildToolMap<typename V::mapped_type>(tools,groupName,dimensions...);
    }
    return indexMap;
  }

◆ buildToolMap() [3/4]

template<typename V, typename std::enable_if_t< std::is_integral_v< V > > * = nullptr>

std::vector< V > Monitored::buildToolMap	(	const ToolHandleArray< GenericMonitoringTool > &	tools,
		const std::string &	baseName,
		int	nHist )

Builds an array of indices (base case)

Definition at line 148 of file MonitoredGroup.h.

                                                                                                                        {
    std::vector<int> indexArray;
    for ( int iHist=0; iHist<nHist; iHist++ ) {
      std::string groupName = baseName + "_" + std::to_string(iHist);
      indexArray.push_back(detail::findToolIndex(tools,groupName));
    }
    return indexArray;
  }

◆ buildToolMap() [4/4]

template<typename V, typename std::enable_if_t<!std::is_integral_v< V > > * = nullptr, typename... T>

std::vector< V > Monitored::buildToolMap	(	const ToolHandleArray< GenericMonitoringTool > &	tools,
		const std::string &	baseName,
		int	nHist,
		T...	dimensions )

Builds an N-dimensional array of indices (recursive)

Definition at line 159 of file MonitoredGroup.h.

                                                                                                                                         {
    std::vector<V> indexArray;
    for ( int iHist=0; iHist<nHist; iHist++ ) {
      std::string groupName = baseName + "_" + std::to_string(iHist);
      indexArray.push_back(buildToolMap<typename V::value_type>(tools,groupName,dimensions...));
    }
    return indexArray;
  }

◆ checkNamingConvention()

void Monitored::checkNamingConvention ( std::string_view name )

Definition at line 10 of file MonitoredTimer.cxx.

                                                    {
    // Enforce some naming convention for timers
    if ( name.substr(0,5) != "TIME_") {
      std::string error("Name of Timer \"");
      error+= name;
      error+=  "\" needs to start with \"TIME_\"";
      throw std::runtime_error(error);
    }
  }

◆ Collection() [1/12]

template<class T>

ValuesRefCollection< T > Monitored::Collection	(	std::string	name,
		const std::reference_wrapper< T > &&	collection )

delete

◆ Collection() [2/12]

template<class T>

ObjectsRefCollection< T, double > Monitored::Collection	(	std::string	name,
		const std::reference_wrapper< T > &&	collection,
		std::function< double(const typename ObjectsRefCollection< T, double >::const_value_type &)>	accessor )

delete

◆ Collection() [3/12]

template<class T>

ObjectsRefCollection< T, std::string > Monitored::Collection	(	std::string	name,
		const std::reference_wrapper< T > &&	collection,
		std::function< std::string(const typename ObjectsRefCollection< T, std::string >::const_value_type &)>	accessor )

delete

◆ Collection() [4/12]

template<class T>

ValuesRefCollection< T > Monitored::Collection	(	std::string	name,
		const std::reference_wrapper< T > &	collection )

Declare a monitored (double-convertible) collection reference.

Template Parameters

T	Type of collection

Parameters

name	Name of monitored quantity
collection	std::reference_wrapper to collection to be monitored (e.g. STL container or array)

Examples:

Various types of collections can be monitored. STL containers:

    std::vector<float> eta( {0.2, 0.1} );
    std::vector<double> phi( {-1, 1} ) ;
    auto vectorT   = Monitored::Collection( "Eta", eta );
    auto setT      = Monitored::Collection( "Phi", phi );
    auto group = Monitored::Group( monTool, vectorT, setT );

or more generally, any iterable container:

See also: Monitored::Scalar; Monitored::Group

Definition at line 61 of file MonitoredCollection.h.

                                                                                                                  {
    return ValuesRefCollection<T>(std::move(name), collection);
  }

◆ Collection() [5/12]

template<class T>

ObjectsRefCollection< T, double > Monitored::Collection	(	std::string	name,
		const std::reference_wrapper< T > &	collection,
		std::function< double(const typename ObjectsRefCollection< T, double >::const_value_type &)>	accessor )

Declare a monitored reference to a collection of objects via accessor function.

Template Parameters

T	Type of collection

Parameters

name	Name of monitored quantity
collection	std::reference_wrapper to collection to be monitored (e.g. STL container or array)
accessor	Function taking an element and returning a double

Examples:

Collection of objects can be monitored provided via an accessor function:

    std::vector<Track> tracks;
    auto eta = Monitored::Collection( "Eta", tracks, &Track::eta );
    auto phi = Monitored::Collection( "Phi", tracks, []( const Track& t ) { return t.phi(); } );
 
    auto group = Monitored::Group( monTool, eta, phi ); // this is binding to histograms
 
    tracks.emplace_back( 0.1, 0.9 );
    tracks.emplace_back( 1.3, 1. );

A collection of strings can be used to fill labelled histograms:

    auto countID = Monitored::Scalar<std::string>( "DetID", "SCT" );
    std::vector<std::string> caloLabels( { "LAr", "LAr", "Tile" } );
    auto countCalo = Monitored::Collection<std::vector<std::string>>( "DetCalo", caloLabels );
    auto x = Monitored::Scalar("x", 1.2 );
    std::vector<double> yvalues({0.2, 2.1, 1.3});
    auto y = Monitored::Collection("y", yvalues );
    
    {
      // this will fill: (SCT,LAr) (SCT,LAr) (SCT,Tile)
      Monitored::Group(monTool, countID, countCalo);
    }
    {
      // this will fill: (LAr,0.2) (LAr,2.1) (Tile,1.3)
      Monitored::Group(monTool, countCalo, y);
    }
    {
      // this will fill: (LAr,1.2) (LAr,1.2) (Tile,1.2)
      Monitored::Group(monTool, countCalo, x);
    }

Use of accessor functions work the same way as for Monitored::Scalar:

    struct StringInObject {
      int layer;
      std::string name;
      const std::string& getName() const { return name; }
    };
    std::vector<StringInObject> testData({{0, "PIX"}, {1, "PIX"}, {3, "SCT"}, {1, "PIX"}});
    auto name = Monitored::Collection("DetID", testData,  [](const StringInObject& s)->const std::string &{ return s.getName(); }); // lambda as accessor
 
    auto ignored1 = Monitored::Collection("ignored", testData,  &StringInObject::getName  ); // access via member function
    auto ignored2 = Monitored::Collection("ignored", testData,  [](const StringInObject& s){ return s.getName().c_str(); }  ); // accessor returning const char* is supported
    Monitored::Group(monTool, name);

See also: Monitored::Scalar; Monitored::Group

Definition at line 137 of file MonitoredCollection.h.

                                                                                                              {
    return ObjectsRefCollection<T, double>(std::move(name), collection, std::move(accessor));
  }

◆ Collection() [6/12]

template<class T>

ObjectsRefCollection< T, std::string > Monitored::Collection	(	std::string	name,
		const std::reference_wrapper< T > &	collection,
		std::function< std::string(const typename ObjectsRefCollection< T, std::string >::const_value_type &)>	accessor )

Definition at line 149 of file MonitoredCollection.h.

                                                                                                              {
    return ObjectsRefCollection<T, std::string>(std::move(name), collection, std::move(accessor));
  }

◆ Collection() [7/12]

template<class T>

ObjectsCollection< T, double > Monitored::Collection	(	std::string	name,
		const T &&	collection,
		std::function< double(const typename ObjectsCollection< T, double >::const_value_type &)>	accessor )

delete

◆ Collection() [8/12]

template<class T>

ObjectsCollection< T, std::string > Monitored::Collection	(	std::string	name,
		const T &&	collection,
		std::function< std::string(const typename ObjectsCollection< T, std::string >::const_value_type &)>	accessor )

delete

◆ Collection() [9/12]

template<class T>

ValuesCollection< T > Monitored::Collection	(	std::string	name,
		const T &	collection )

Declare a monitored (double-convertible) collection.

Template Parameters

T	Type of collection

Parameters

name	Name of monitored quantity
collection	Collection to be monitored (e.g. STL container or array)

Examples:

Various types of collections can be monitored. STL containers:

    std::vector<float> eta( {0.2, 0.1} );
    std::vector<double> phi( {-1, 1} ) ;
    auto vectorT   = Monitored::Collection( "Eta", eta );
    auto setT      = Monitored::Collection( "Phi", phi );
    auto group = Monitored::Group( monTool, vectorT, setT );

or more generally, any iterable container:

See also: Monitored::Scalar; Monitored::Group

Definition at line 38 of file MonitoredCollection.h.

                                                                                         {
    return ValuesCollection<T>(std::move(name), collection);
  }

◆ Collection() [10/12]

template<class T>

ObjectsCollection< T, double > Monitored::Collection	(	std::string	name,
		const T &	collection,
		std::function< double(const typename ObjectsCollection< T, double >::const_value_type &)>	accessor )

Declare a monitored collection of objects via accessor function.

Template Parameters

T	Type of collection

Parameters

name	Name of monitored quantity
collection	Collection to be monitored (e.g. STL container or array)
accessor	Function taking an element and returning a double

Examples:

Collection of objects can be monitored provided via an accessor function:

    std::vector<Track> tracks;
    auto eta = Monitored::Collection( "Eta", tracks, &Track::eta );
    auto phi = Monitored::Collection( "Phi", tracks, []( const Track& t ) { return t.phi(); } );
 
    auto group = Monitored::Group( monTool, eta, phi ); // this is binding to histograms
 
    tracks.emplace_back( 0.1, 0.9 );
    tracks.emplace_back( 1.3, 1. );

A collection of strings can be used to fill labelled histograms:

    auto countID = Monitored::Scalar<std::string>( "DetID", "SCT" );
    std::vector<std::string> caloLabels( { "LAr", "LAr", "Tile" } );
    auto countCalo = Monitored::Collection<std::vector<std::string>>( "DetCalo", caloLabels );
    auto x = Monitored::Scalar("x", 1.2 );
    std::vector<double> yvalues({0.2, 2.1, 1.3});
    auto y = Monitored::Collection("y", yvalues );
    
    {
      // this will fill: (SCT,LAr) (SCT,LAr) (SCT,Tile)
      Monitored::Group(monTool, countID, countCalo);
    }
    {
      // this will fill: (LAr,0.2) (LAr,2.1) (Tile,1.3)
      Monitored::Group(monTool, countCalo, y);
    }
    {
      // this will fill: (LAr,1.2) (LAr,1.2) (Tile,1.2)
      Monitored::Group(monTool, countCalo, x);
    }

Use of accessor functions work the same way as for Monitored::Scalar:

    struct StringInObject {
      int layer;
      std::string name;
      const std::string& getName() const { return name; }
    };
    std::vector<StringInObject> testData({{0, "PIX"}, {1, "PIX"}, {3, "SCT"}, {1, "PIX"}});
    auto name = Monitored::Collection("DetID", testData,  [](const StringInObject& s)->const std::string &{ return s.getName(); }); // lambda as accessor
 
    auto ignored1 = Monitored::Collection("ignored", testData,  &StringInObject::getName  ); // access via member function
    auto ignored2 = Monitored::Collection("ignored", testData,  [](const StringInObject& s){ return s.getName().c_str(); }  ); // accessor returning const char* is supported
    Monitored::Group(monTool, name);

See also: Monitored::Scalar; Monitored::Group

Definition at line 91 of file MonitoredCollection.h.

                                                                                                         {
    return ObjectsCollection<T, double>(std::move(name), collection, std::move(accessor));
  }

◆ Collection() [11/12]

template<class T>

ObjectsCollection< T, std::string > Monitored::Collection	(	std::string	name,
		const T &	collection,
		std::function< std::string(const typename ObjectsCollection< T, std::string >::const_value_type &)>	accessor )

Definition at line 104 of file MonitoredCollection.h.

                                                                                                           {
    return ObjectsCollection<T, std::string>(std::move(name), collection, std::move(accessor));
  }

◆ Collection() [12/12]

template<class T>

ValuesCollection< T > Monitored::Collection	(	std::string	name,
		T const &&	collection )

delete

◆ fill()

template<typename... T>

void Monitored::fill	(	const ToolHandle< GenericMonitoringTool > &	tool,
		T &&...	variables )

Definition at line 128 of file MonitoredGroup.h.

                                                                             {
    if (!tool.empty()) {
      tool->invokeFillers({std::forward<T>(variables)...});
    }
  }

◆ operator<<()

std::ostream & Monitored::operator<<	(	std::ostream &	os,
		const std::reference_wrapper< Monitored::IMonitoredVariable > &	rmv )

Definition at line 121 of file GenericMonitoringTool.cxx.

                                                                                                            {
        std::string s = rmv.get().name();
        return os << s;
    }

◆ scalarFillerFunc()

template<typename T>

void Monitored::scalarFillerFunc	(	TBranch *	branch,
		const IMonitoredVariable &	var )

Definition at line 163 of file HistogramFillerTree.h.

                                                                        {
    if (ATH_UNLIKELY(var.size() == 0)) {
      MsgStream log(Athena::getMessageSvc(), "HistogramFillerTree"); 
      log << MSG::WARNING << "Tree " << branch->GetTree()->GetName() << ": Empty value passed to scalar branch fill for" 
                          << branch->GetName() << endmsg;
      return; 
    }
    T tofill = var.get(0);
    T* ptr = &tofill;
    branch->SetAddress(ptr);
    branch->Fill();
  }

◆ scalarFillerFunc< std::string >() [1/2]

template<>

void Monitored::scalarFillerFunc< std::string >	(	TBranch *	branch,
		const IMonitoredVariable &	var )

Definition at line 178 of file HistogramFillerTree.h.

                                                                                   {
    if (ATH_UNLIKELY(var.size() == 0)) { 
      MsgStream log(Athena::getMessageSvc(), "HistogramFillerTree"); 
      log << MSG::WARNING << "Tree " << branch->GetTree()->GetName() << ": Empty value passed to scalar branch fill for" 
                          << branch->GetName() << endmsg;
      return; 
    }
    std::string tofill{var.getString(0)};
    branch->SetObject(&tofill);
    //*static_cast<std::string*>(branch->GetObject()) = tofill;
    branch->Fill();
  }

◆ scalarFillerFunc< std::string >() [2/2]

template<>

void Monitored::scalarFillerFunc< std::string >	(	TBranch *	branch,
		const IMonitoredVariable &	var )

Definition at line 178 of file HistogramFillerTree.h.

                                                                                   {
    if (ATH_UNLIKELY(var.size() == 0)) { 
      MsgStream log(Athena::getMessageSvc(), "HistogramFillerTree"); 
      log << MSG::WARNING << "Tree " << branch->GetTree()->GetName() << ": Empty value passed to scalar branch fill for" 
                          << branch->GetName() << endmsg;
      return; 
    }
    std::string tofill{var.getString(0)};
    branch->SetObject(&tofill);
    //*static_cast<std::string*>(branch->GetObject()) = tofill;
    branch->Fill();
  }

◆ vectorFillerFunc()

template<typename T>

void Monitored::vectorFillerFunc	(	TBranch *	branch,
		const IMonitoredVariable &	var )

Definition at line 192 of file HistogramFillerTree.h.

                                                                        {
    std::vector<T> tofill;
    tofill.reserve(var.size());
    for (size_t i = 0; i < var.size(); i++) {
      tofill.push_back(var.get(i));
    }
    std::vector<T>* tofillptr = &tofill;
    branch->SetAddress(&tofillptr);
    branch->Fill();
  }

◆ vectorFillerFunc< std::string >() [1/2]

template<>

void Monitored::vectorFillerFunc< std::string >	(	TBranch *	branch,
		const IMonitoredVariable &	var )

Definition at line 205 of file HistogramFillerTree.h.

                                                                                   {
    std::vector<std::string> tofill;
    tofill.reserve(var.size());
    for (size_t i = 0; i < var.size(); i++) {
      tofill.push_back(var.getString(i));
    }
    auto* tofillptr = &tofill;
    branch->SetAddress(&tofillptr);
    branch->Fill();
  }

◆ vectorFillerFunc< std::string >() [2/2]

template<>

void Monitored::vectorFillerFunc< std::string >	(	TBranch *	branch,
		const IMonitoredVariable &	var )

Definition at line 205 of file HistogramFillerTree.h.

                                                                                   {
    std::vector<std::string> tofill;
    tofill.reserve(var.size());
    for (size_t i = 0; i < var.size(); i++) {
      tofill.push_back(var.getString(i));
    }
    auto* tofillptr = &tofill;
    branch->SetAddress(&tofillptr);
    branch->Fill();
  }

Namespaces

Classes

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

◆ HistogramFiller2D

◆ HistogramFiller2DProfileRebinable

◆ HistogramFillerProfile

◆ HistogramFillerProfileRebinable

◆ HistogramFillerRebinable1D

◆ HistogramFillerRebinable2D

◆ HistogramFillerRebinable2DX

◆ HistogramFillerRebinable2DY

Enumeration Type Documentation

◆ Axis

Function Documentation

◆ buildToolMap() [1/4]

◆ buildToolMap() [2/4]

◆ buildToolMap() [3/4]

◆ buildToolMap() [4/4]

◆ checkNamingConvention()

◆ Collection() [1/12]

◆ Collection() [2/12]

◆ Collection() [3/12]

◆ Collection() [4/12]

Examples:

◆ Collection() [5/12]

Examples:

◆ Collection() [6/12]

◆ Collection() [7/12]

◆ Collection() [8/12]

◆ Collection() [9/12]

Examples:

◆ Collection() [10/12]

Examples:

◆ Collection() [11/12]

◆ Collection() [12/12]

◆ fill()

◆ operator<<()

◆ scalarFillerFunc()

◆ scalarFillerFunc< std::string >() [1/2]

◆ scalarFillerFunc< std::string >() [2/2]

◆ vectorFillerFunc()

◆ vectorFillerFunc< std::string >() [1/2]

◆ vectorFillerFunc< std::string >() [2/2]