ATLAS Offline Software
Namespaces | Classes | Typedefs | Enumerations | Functions
Monitored Namespace Reference

Generic monitoring tool for athena components. More...

Namespaces

 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. More...
 
typedef HistogramFiller2DGeneric< TProfile > HistogramFillerProfile
 TProfile filler. More...
 
typedef HistogramFillerRebinableAxis< HistogramFillerProfile, Axis::X > HistogramFillerProfileRebinable
 TProfile filler with rebinable x-axis. More...
 
typedef HistogramFillerRebinableAxis< HistogramFiller1D, Axis::X > HistogramFillerRebinable1D
 Rebinable 1D histogram. More...
 
typedef HistogramFillerRebinableAxis< HistogramFiller2D, Axis::X > HistogramFillerRebinable2DX
 Rebinable 2D histogram (x-axis only) More...
 
typedef HistogramFillerRebinableAxis< HistogramFiller2D, Axis::Y > HistogramFillerRebinable2DY
 Rebinable 2D histogram (y-axis only) More...
 
typedef HistogramFillerRebinableAxis< HistogramFillerRebinable2DX, Axis::Y > HistogramFillerRebinable2D
 Rebinable 2D histogram (both axes) More...
 

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. More...
 
template<class T >
ValuesCollection< T > Collection (std::string name, T const &&collection)=delete
 
template<class T >
ValuesRefCollection< T > Collection (std::string name, const std::reference_wrapper< T > &collection)
 Declare a monitored (double-convertible) collection reference. More...
 
template<class T >
ValuesRefCollection< T > Collection (std::string name, const std::reference_wrapper< T > &&collection)=delete
 
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. More...
 
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. More...
 
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 (ToolHandleArray< GenericMonitoringTool > tools, const std::string &baseName, int nHist)
 Builds an array of indices (base case) More...
 
template<typename V , typename std::enable_if_t<!std::is_integral_v< V >> * = nullptr, typename... T>
std::vector< V > buildToolMap (ToolHandleArray< GenericMonitoringTool > tools, const std::string &baseName, int nHist, T... dimensions)
 Builds an N-dimensional array of indices (recursive) More...
 
template<typename V , typename std::enable_if_t< std::is_integral_v< V >> * = nullptr>
std::map< std::string, int > buildToolMap (ToolHandleArray< GenericMonitoringTool > tools, const std::string &baseName, const std::vector< std::string > &labels)
 Builds a map of indices (base case) More...
 
template<typename V , typename std::enable_if_t<!std::is_integral_v< V >> * = nullptr, typename... T>
std::map< std::string, V > buildToolMap (ToolHandleArray< GenericMonitoringTool > tools, const std::string &baseName, const std::vector< std::string > &labels, T... dimensions)
 Builds an N-dimensional map of indices (recursive) More...
 
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)
 

Detailed Description

Generic monitoring tool for athena components.

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

Namespace for the athenaMT monitoring infrastructure

Typedef Documentation

◆ HistogramFiller2D

typedef HistogramFiller2DGeneric<TH2> Monitored::HistogramFiller2D

Definition at line 80 of file HistogramFiller2D.h.

◆ HistogramFiller2DProfileRebinable

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

TProfile2D filler with rebinable x-axis.

Definition at line 58 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 72 of file HistogramFillerRebinable.h.

◆ HistogramFillerRebinable2D

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

Rebinable 2D histogram (both axes)

Definition at line 78 of file HistogramFillerRebinable.h.

◆ HistogramFillerRebinable2DX

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

Rebinable 2D histogram (x-axis only)

Definition at line 74 of file HistogramFillerRebinable.h.

◆ HistogramFillerRebinable2DY

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

Rebinable 2D histogram (y-axis only)

Definition at line 76 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};

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 ( ToolHandleArray< GenericMonitoringTool >  tools,
const std::string &  baseName,
const std::vector< std::string > &  labels 
)

Builds a map of indices (base case)

Definition at line 164 of file MonitoredGroup.h.

164  {
165  std::map<std::string,int> indexMap;
166  for ( const std::string& label : labels ) {
167  std::string groupName = baseName + "_" + label;
168  indexMap[label] = detail::findToolIndex(tools,groupName);
169  }
170  return indexMap;
171  }

◆ 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 ( 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 175 of file MonitoredGroup.h.

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

◆ buildToolMap() [3/4]

template<typename V , typename std::enable_if_t< std::is_integral_v< V >> * = nullptr>
std::vector<V> Monitored::buildToolMap ( ToolHandleArray< GenericMonitoringTool >  tools,
const std::string &  baseName,
int  nHist 
)

Builds an array of indices (base case)

Definition at line 142 of file MonitoredGroup.h.

142  {
143  std::vector<int> indexArray;
144  for ( int iHist=0; iHist<nHist; iHist++ ) {
145  std::string groupName = baseName + "_" + std::to_string(iHist);
146  indexArray.push_back(detail::findToolIndex(tools,groupName));
147  }
148  return indexArray;
149  }

◆ buildToolMap() [4/4]

template<typename V , typename std::enable_if_t<!std::is_integral_v< V >> * = nullptr, typename... T>
std::vector<V> Monitored::buildToolMap ( ToolHandleArray< GenericMonitoringTool >  tools,
const std::string &  baseName,
int  nHist,
T...  dimensions 
)

Builds an N-dimensional array of indices (recursive)

Definition at line 153 of file MonitoredGroup.h.

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

◆ checkNamingConvention()

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

Definition at line 10 of file MonitoredTimer.cxx.

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

◆ 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
TType of collection
Parameters
nameName of monitored quantity
collectionstd::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.

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

◆ 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
TType of collection
Parameters
nameName of monitored quantity
collectionstd::reference_wrapper to collection to be monitored (e.g. STL container or array)
accessorFunction 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){ 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.

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

◆ 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.

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

◆ 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
TType of collection
Parameters
nameName of monitored quantity
collectionCollection 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.

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

◆ 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
TType of collection
Parameters
nameName of monitored quantity
collectionCollection to be monitored (e.g. STL container or array)
accessorFunction 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){ 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.

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

◆ 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.

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

◆ 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 122 of file MonitoredGroup.h.

122  {
123  if (!tool.empty()) {
124  tool->invokeFillers({std::forward<T>(variables)...});
125  }
126  }

◆ operator<<()

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

Definition at line 122 of file GenericMonitoringTool.cxx.

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

◆ scalarFillerFunc()

template<typename T >
void Monitored::scalarFillerFunc ( TBranch *  branch,
const IMonitoredVariable &  var 
)

Definition at line 161 of file HistogramFillerTree.h.

161  {
162  if (ATH_UNLIKELY(var.size() == 0)) {
163  MsgStream log(Athena::getMessageSvc(), "HistogramFillerTree");
164  log << MSG::WARNING << "Tree " << branch->GetTree()->GetName() << ": Empty value passed to scalar branch fill for"
165  << branch->GetName() << endmsg;
166  return;
167  }
168  T tofill = var.get(0);
169  T* ptr = &tofill;
170  branch->SetAddress(ptr);
171  branch->Fill();
172  }

◆ scalarFillerFunc< std::string >()

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

Definition at line 176 of file HistogramFillerTree.h.

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

◆ vectorFillerFunc()

template<typename T >
void Monitored::vectorFillerFunc ( TBranch *  branch,
const IMonitoredVariable &  var 
)

Definition at line 190 of file HistogramFillerTree.h.

190  {
191  std::vector<T> tofill;
192  tofill.reserve(var.size());
193  for (size_t i = 0; i < var.size(); i++) {
194  tofill.push_back(var.get(i));
195  }
196  std::vector<T>* tofillptr = &tofill;
197  branch->SetAddress(&tofillptr);
198  branch->Fill();
199  }

◆ vectorFillerFunc< std::string >()

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

Definition at line 203 of file HistogramFillerTree.h.

203  {
204  std::vector<std::string> tofill;
205  tofill.reserve(var.size());
206  for (size_t i = 0; i < var.size(); i++) {
207  tofill.push_back(var.getString(i));
208  }
209  auto* tofillptr = &tofill;
210  branch->SetAddress(&tofillptr);
211  branch->Fill();
212  }
beamspotnt.var
var
Definition: bin/beamspotnt.py:1394
test_pyathena.eta
eta
Definition: test_pyathena.py:10
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
checkCoolLatestUpdate.variables
variables
Definition: checkCoolLatestUpdate.py:13
Monitored::Z
@ Z
Definition: HistogramFillerUtils.h:24
PlotCalibFromCool.label
label
Definition: PlotCalibFromCool.py:78
RunTileMonitoring.groupName
groupName
Definition: RunTileMonitoring.py:158
ATH_UNLIKELY
#define ATH_UNLIKELY(x)
Definition: AthUnlikelyMacros.h:17
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
x
#define x
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
dumpTruth.getName
getName
Definition: dumpTruth.py:34
Monitored::X
@ X
Definition: HistogramFillerUtils.h:24
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
xAOD::phi
setEt phi
Definition: TrigEMCluster_v1.cxx:29
beamspotnt.labels
list labels
Definition: bin/beamspotnt.py:1447
lumiFormat.i
int i
Definition: lumiFormat.py:85
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
Monitored::Y
@ Y
Definition: HistogramFillerUtils.h:24
tools
Definition: DataQuality/ZLumiScripts/python/tools/__init__.py:1
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:453
xAOD::JetAttributeAccessor::accessor
const AccessorWrapper< T > * accessor(xAOD::JetAttribute::AttributeID id)
Returns an attribute accessor corresponding to an AttributeID.
Definition: JetAccessorMap.h:26
RTTAlgmain.branch
branch
Definition: RTTAlgmain.py:61
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
Monitored::detail::findToolIndex
int findToolIndex(const ToolHandleArray< GenericMonitoringTool > &toolArray, const std::string &name)
Finds the index of an element in a tool handle array by its string name.
Definition: MonitoredGroup.h:132
y
#define y
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
Track::eta
double eta() const
Definition: MonitoredAlg.cxx:28
Track
Definition: TriggerChamberClusterOnTrackCreator.h:21
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
get_generator_info.error
error
Definition: get_generator_info.py:40
error
Definition: IImpactPoint3dEstimator.h:70
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
Generated on Thu Nov 7 2024 22:18:42 for ATLAS Offline Software by   doxygen 1.8.18