ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Attributes | List of all members
CounterGlobal Class Reference

Concrete implimentation of Counter to monitor global properties of the event. More...

#include <CounterGlobal.h>

Inheritance diagram for CounterGlobal:
Collaboration diagram for CounterGlobal:

Public Member Functions

 CounterGlobal ()=delete
 Forbid default constructor. More...
 
 CounterGlobal (const std::string &name, const MonitorBase *parent)
 Construct counter. More...
 
virtual ~CounterGlobal ()=default
 Default destructor. More...
 
CounterGlobal & operator= (const CounterGlobal &)=delete
 Forbid assignment. More...
 
 CounterGlobal (const CounterGlobal &)=delete
 Forbid copy. More...
 
virtual StatusCode newEvent (const CostData &data, size_t incrementWalltime, const float weight=1.) override
 Concrete implementation. 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...
 

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

Concrete implimentation of Counter to monitor global properties of the event.

Definition at line 14 of file CounterGlobal.h.

Constructor & Destructor Documentation

◆ CounterGlobal() [1/3]

CounterGlobal::CounterGlobal ( )
delete

Forbid default constructor.

◆ CounterGlobal() [2/3]

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

Construct counter.

Parameters
[in]nameCounter's name
[in]parentCounter's parent monitor, cached non-owning pointer.

Definition at line 9 of file CounterGlobal.cxx.

10  : CounterBase(name, parent)
11 {
12  regHistogram("AlgTime_perCall", "Algorithm CPU Time/Call;Time [ms];Events", VariableType::kPerCall, kLog, 0.01, 100000);
13  regHistogram("AlgTime_perEvent", "Algorithm CPU Time/Event;Time [ms];Events", VariableType::kPerEvent);
14  regHistogram("AlgCalls_perEvent", "Algorithm Calls/Event;Calls;Events", VariableType::kPerEvent, kLinear, -0.5, 4999.5, 500);
15  regHistogram("SteeringTime_perEvent", "Steering Time/Event;Time [ms];Events", VariableType::kPerEvent);
16  regHistogram("LbLength", "LBLength;Entry;LB Length [s]", VariableType::kPerEvent, kLinear, -0.5, 0.5, 1);
17 }

◆ ~CounterGlobal()

virtual CounterGlobal::~CounterGlobal ( )
virtualdefault

Default destructor.

◆ CounterGlobal() [3/3]

CounterGlobal::CounterGlobal ( const CounterGlobal &  )
delete

Forbid copy.

Member Function Documentation

◆ bookGetPointer()

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

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

Parameters
[in]histBare pointer to histogram. Ownership transferred to THistSvc.
[in]tDirHistogram 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.

233  {
234  std::string dir = getName();
235  if (tDir != "") {
236  dir += "/";
237  dir += tDir;
238  }
239  return getParent()->bookGetPointer(hist, dir);
240 }

◆ endEvent()

StatusCode CounterBase::endEvent ( float  weight = 1.0)
virtualinherited

Called by the framework.

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

Definition at line 225 of file CounterBase.cxx.

225  {
226  for (auto& nameVariablePair : m_variables) {
227  ATH_CHECK( nameVariablePair.second.endEvent() );
228  }
229  return StatusCode::SUCCESS;
230 }

◆ fill() [1/2]

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

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

Parameters
[in]nameVariable to increment
[in]valueThe payload value
[in]weightGlobal event weight

Definition at line 191 of file CounterBase.cxx.

191  {
192  auto it = m_variables.find(name);
193  if (it == m_variables.end()) {
194  return StatusCode::FAILURE;
195  }
196  ATH_CHECK( it->second.fill(value, weight) );
197  return StatusCode::SUCCESS;
198 }

◆ fill() [2/2]

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

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

Parameters
[in]nameVariable to increment
[in]xvalueThe payload x-axis value
[in]yvalueThe payload y-axis value
[in]weightGlobal event weight

Definition at line 200 of file CounterBase.cxx.

200  {
201  auto it = m_variables.find(name);
202  if (it == m_variables.end()) {
203  return StatusCode::FAILURE;
204  }
205  ATH_CHECK( it->second.fill(xvalue, yvalue, weight) );
206  return StatusCode::SUCCESS;
207 }

◆ getName()

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

Getter for Counter's name.

Returns
Counter's name const string reference.

Definition at line 17 of file CounterBase.cxx.

17  {
18  return m_name;
19 }

◆ getParent()

const MonitorBase * CounterBase::getParent ( ) const
inherited

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.

22  {
23  return m_parent;
24 }

◆ getVariable()

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

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]nameVariable to return
Returns
Mutable reference to Variable

Definition at line 182 of file CounterBase.cxx.

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

◆ increment()

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

Convenience function.

Equivalent to fill(name, 1.0, weight);

Parameters
[in]nameVariable to increment
[in]weightGlobal event weight

Definition at line 220 of file CounterBase.cxx.

220  {
221  return fill(name, 1.0, weight);
222 }

◆ newEvent()

StatusCode CounterGlobal::newEvent ( const CostData &  data,
size_t  incrementWalltime,
const float  weight = 1. 
)
overridevirtual

Concrete implementation.

Monitors global properties in a single LB, or over all LB in a Range

Parameters
[in]dataAccess to event data
[in]incrementWalltimeIf 1, we should add the current events wall time to our internal histogram
[in]weightGlobal event weight

Implements CounterBase.

Definition at line 20 of file CounterGlobal.cxx.

20  {
21 
22  uint64_t lowTimestamp = std::numeric_limits<uint64_t>::max();
23  uint64_t highTimestamp = 0;
24  for (const xAOD::TrigComposite* tc : data.costCollection()) {
25  const uint32_t slot = tc->getDetail<uint32_t>("slot");
26  if (slot != data.onlineSlot()) {
27  continue; // When monitoring the master slot, this Counter ignores algs running in different slots
28  }
29 
30  const uint64_t start = tc->getDetail<uint64_t>("start"); // in mus
31  const uint64_t stop = tc->getDetail<uint64_t>("stop"); // in mus
32  const float cpuTime = timeToMilliSec(start, stop);
33  ATH_CHECK( fill("AlgTime_perCall", cpuTime, weight) );
34  ATH_CHECK( fill("AlgTime_perEvent", cpuTime, weight) );
35  ATH_CHECK( increment("AlgCalls_perEvent", weight) );
36  lowTimestamp = std::min(lowTimestamp, start);
37  highTimestamp = std::max(highTimestamp, stop);
38  }
39 
40  const float steeringTime = timeToMilliSec(lowTimestamp, highTimestamp);
41  ATH_CHECK( fill("SteeringTime_perEvent", steeringTime, weight) );
42 
43  if (incrementWalltime == 1) {
44  // Note: This accumulator doesn't use the standard weight.
45  // For P1 data taking it will be filled exactly once per LB
46  ATH_CHECK( fill("LbLength", 0.0, data.liveTime()) );
47  }
48 
49  return StatusCode::SUCCESS;
50 }

◆ operator=()

CounterGlobal& CounterGlobal::operator= ( const CounterGlobal &  )
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 
)
protectedinherited

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

Parameters
[in]nameThe name of the histogram (and corresponding Variable)
[in]titleROOT histogram title string in format "title;xaxis;yaxis"
[in]xaxisControls if the x-axis should use fixed-width or logarithmic bin boundaries.
[in]xminX-axis minimum bound.
[in]xmaxX-axis maximum bound.
[in]xbinsNumber of histogram bins.
[in]yaxisControls if the y-axis should use fixed-width or logarithmic bin boundaries.
[in]yminY-axis minimum bound.
[in]ymaxY-axis maximum bound.
[in]ybinsNumber of histogram bins.

Definition at line 109 of file CounterBase.cxx.

120 {
121  std::string hisSvcName = getParent()->getParent()->getName() + "_" + getParent()->getName() + "_" + getName() + "_" + name;
122  std::unique_ptr<TH2F> hist;
123 
124  if (xmax <= xmin || ymax <= ymin || xbins == 0 || ybins == 0) {
125  throw std::runtime_error("CounterBase::regHistogram: Cannot have max <= min or bins == 0");
126  }
127 
128  if (xaxis == kLinear && yaxis == kLinear) {
129  hist = std::make_unique<TH2F>(hisSvcName.c_str(), title.c_str(), xbins, xmin, xmax, ybins, ymin, ymax);
130  } else if (xaxis == kLog || yaxis == kLog) {
131  if ( (xaxis == kLog && xmin <= 0) || (yaxis == kLog && ymin <= 0) ) {
132  throw std::runtime_error("CounterBase::regHistogram: Cannot have min <= 0 with log binning");
133  }
134  std::unique_ptr<double[]> xlogbins = std::make_unique<double[]>(xbins+1);
135  std::unique_ptr<double[]> ylogbins = std::make_unique<double[]>(ybins+1);
136  if (xaxis == kLog){
137  const double xlogmin = log10(xmin);
138  const double xlogmax = log10(xmax);
139  const double dlogx = (xlogmax-xlogmin)/((double)xbins);
140  for (size_t i = 0; i <= xbins; ++i) {
141  const double xlog = xlogmin + i*dlogx;
142  xlogbins[i] = exp( log(10) * xlog );
143  }
144  } else {
145  const double dx = (xmax-xmin)/((double)xbins);
146  for (size_t i = 0; i <= xbins; ++i) {
147  xlogbins[i] = xmin + i*dx;
148  }
149  }
150 
151  if (yaxis == kLog){
152  const double ylogmin = log10(ymin);
153  const double ylogmax = log10(ymax);
154  const double dlogy = (ylogmax-ylogmin)/((double)ybins);
155  for (size_t i = 0; i <= ybins; ++i) {
156  const double ylog = ylogmin + i*dlogy;
157  ylogbins[i] = exp( log(10) * ylog );
158  }
159  } else {
160  const double dy = (ymax-ymin)/((double)ybins);
161  for (size_t i = 0; i <= ybins; ++i) {
162  ylogbins[i] = ymin + i*dy;
163  }
164  }
165 
166  hist = std::make_unique<TH2F>(hisSvcName.c_str(), title.c_str(), xbins, xlogbins.get(), ybins, ylogbins.get());
167  } else {
168  throw std::runtime_error("CounterBase::regHistogram: Unknown logarithm flag");
169  }
170 
171  m_variables.emplace(std::piecewise_construct,
172  std::forward_as_tuple(name),
173  std::forward_as_tuple(name, bookGetPointer(hist.release()), type)
174  );
175  // Histogram is now owned by THistSvc. A cache of the ptr is kept in the Variable
176 }

◆ 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 
)
protectedinherited

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

Parameters
[in]nameThe name of the histogram (and corresponding Variable)
[in]titleROOT histogram title string in format "title;xaxis;yaxis"
[in]xaxisControls if the x-axis should use fixed-width or logarithmic bin boundaries.
[in]minX-axis minimum bound.
[in]maxX-axis maximum bound.
[in]binsNumber of histogram bins.

Definition at line 27 of file CounterBase.cxx.

34 {
35  std::string hisSvcName = getParent()->getParent()->getName() + "_" + getParent()->getName() + "_" + getName() + "_" + name;
36  std::unique_ptr<TH1F> hist;
37 
38  if (max <= min || bins == 0) {
39  throw std::runtime_error("CounterBase::regHistogram: Cannot have max <= min or bins == 0");
40  }
41 
42  if (xaxis == kLinear) {
43  hist = std::make_unique<TH1F>(hisSvcName.c_str(), title.c_str(), bins, min, max);
44  } else if (xaxis == kLog) {
45  if (min <= 0) {
46  throw std::runtime_error("CounterBase::regHistogram: Cannot have min <= 0 with log binning");
47  }
48  std::unique_ptr<double[]> xbins = std::make_unique<double[]>(bins+1);
49  const double xlogmin = log10(min);
50  const double xlogmax = log10(max);
51  const double dlogx = (xlogmax-xlogmin)/((double)bins);
52  for (size_t i = 0; i <= bins; ++i) {
53  const double xlog = xlogmin + i*dlogx;
54  xbins[i] = exp( log(10) * xlog );
55  }
56  hist = std::make_unique<TH1F>(hisSvcName.c_str(), title.c_str(), bins, xbins.get());
57  } else {
58  throw std::runtime_error("CounterBase::regHistogram: Unknown logarithm flag");
59  }
60 
61  m_variables.emplace(std::piecewise_construct,
62  std::forward_as_tuple(name),
63  std::forward_as_tuple(name, bookGetPointer(hist.release()), type)
64  );
65  // Histogram is now owned by THistSvc. A cache of the ptr is kept in the Variable
66 }

◆ 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 
)
protectedinherited

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

Parameters
[in]nameThe name of the histogram (and corresponding Variable)
[in]titleROOT histogram title string in format "title;xaxis;yaxis"
[in]xaxisControls if the x-axis should use fixed-width or logarithmic bin boundaries.
[in]minX-axis minimum bound.
[in]maxX-axis maximum bound.
[in]binsNumber of histogram bins.

Definition at line 68 of file CounterBase.cxx.

75 {
76  std::string hisSvcName = getParent()->getParent()->getName() + "_" + getParent()->getName() + "_" + getName() + "_" + name;
77  std::unique_ptr<TProfile> hist;
78 
79  if (max <= min || bins == 0) {
80  throw std::runtime_error("CounterBase::regTProfile: Cannot have max <= min or bins == 0");
81  }
82 
83  if (xaxis == kLinear) {
84  hist = std::make_unique<TProfile>(hisSvcName.c_str(), title.c_str(), bins, min, max);
85  } else if (xaxis == kLog) {
86  if (min <= 0) {
87  throw std::runtime_error("CounterBase::regTProfile: Cannot have min <= 0 with log binning");
88  }
89  std::unique_ptr<double[]> xbins = std::make_unique<double[]>(bins+1);
90  const double xlogmin = log10(min);
91  const double xlogmax = log10(max);
92  const double dlogx = (xlogmax-xlogmin)/((double)bins);
93  for (size_t i = 0; i <= bins; ++i) {
94  const double xlog = xlogmin + i*dlogx;
95  xbins[i] = exp( log(10) * xlog );
96  }
97  hist = std::make_unique<TProfile>(hisSvcName.c_str(), title.c_str(), bins, xbins.get());
98  } else {
99  throw std::runtime_error("CounterBase::regTProfile: Unknown logarithm flag");
100  }
101 
102  m_variables.emplace(std::piecewise_construct,
103  std::forward_as_tuple(name),
104  std::forward_as_tuple(name, bookGetPointer(hist.release()), type)
105  );
106  // Histogram is now owned by THistSvc. A cache of the ptr is kept in the Variable
107 }

◆ setDenominator()

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

Optional for per-Event Variables.

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

Parameters
[in]nameVariable to set the denominator for.
[in]valueThe denominator

Definition at line 210 of file CounterBase.cxx.

210  {
211  auto it = m_variables.find(name);
212  if (it == m_variables.end()) {
213  return StatusCode::FAILURE;
214  }
215  it->second.setDenominator(value);
216  return StatusCode::SUCCESS;
217 }

◆ timeToMilliSec()

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

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.

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

◆ variableExists()

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

Check if a variable of a given name exists.

Parameters
[in]nameName of Variable.
Returns
True if variable already exists.

Definition at line 178 of file CounterBase.cxx.

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

Member Data Documentation

◆ m_name

const std::string CounterBase::m_name
privateinherited

Counter's name.

Definition at line 203 of file CounterBase.h.

◆ m_parent

const MonitorBase* CounterBase::m_parent
privateinherited

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
privateinherited

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:
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
ymin
double ymin
Definition: listroot.cxx:63
CounterBase::regHistogram
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.
Definition: CounterBase.cxx:27
max
#define max(a, b)
Definition: cfImp.cxx:41
MonitorBase::bookGetPointer
TH1 * bookGetPointer(TH1 *hist, const std::string &tDir="") const
Appends Monitor name (to histogram path) and forwards histogram book request to parent Range.
Definition: Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.cxx:37
python.App.bins
bins
Definition: App.py:410
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
CounterBase::fill
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 Vari...
Definition: CounterBase.cxx:191
plotmaker.hist
hist
Definition: plotmaker.py:148
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:14
kPerEvent
@ kPerEvent
Variable should buffer fill calls in an accumulator and fill the underlying histogram once at the end...
Definition: Trigger/TrigCost/TrigCostAnalysis/src/Variable.h:19
skel.it
it
Definition: skel.GENtoEVGEN.py:423
PixelAthClusterMonAlgCfg.ybins
ybins
Definition: PixelAthClusterMonAlgCfg.py:163
athena.value
value
Definition: athena.py:122
PixelModuleFeMask_create_db.stop
int stop
Definition: PixelModuleFeMask_create_db.py:76
CounterBase::CounterBase
CounterBase()=delete
Forbid default constructor.
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
CounterBase::getName
const std::string & getName() const
Getter for Counter's name.
Definition: CounterBase.cxx:17
MonitoredRange::getName
const std::string & getName() const
Getter for Range's name.
Definition: MonitoredRange.cxx:24
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:200
MonitorBase::getParent
const MonitoredRange * getParent() const
Return cached non-owning const ptr to this Monitor's parent Range.
Definition: Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.cxx:24
kLog
@ kLog
Logarithmic x-binning.
Definition: Trigger/TrigCost/TrigCostAnalysis/src/Variable.h:28
lumiFormat.i
int i
Definition: lumiFormat.py:92
CounterBase::bookGetPointer
TH1 * bookGetPointer(TH1 *hist, const std::string &tDir="") const
Appends Counter name (to histogram path) and forwards histogram book request to parent Monitor.
Definition: CounterBase.cxx:233
xmin
double xmin
Definition: listroot.cxx:60
MonitorBase::getName
const std::string & getName() const
Getter for Monitor's name.
Definition: Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.cxx:19
covarianceTool.title
title
Definition: covarianceTool.py:542
test_pyathena.parent
parent
Definition: test_pyathena.py:15
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:52
CounterBase::m_parent
const MonitorBase * m_parent
Counter's parent Monitor.
Definition: CounterBase.h:204
beamspotman.dir
string dir
Definition: beamspotman.py:623
min
#define min(a, b)
Definition: cfImp.cxx:40
kPerCall
@ kPerCall
Variable should fill underlying histogram on each fill.
Definition: Trigger/TrigCost/TrigCostAnalysis/src/Variable.h:18
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
CounterBase::getParent
const MonitorBase * getParent() const
Return cached non-owning const ptr to this Counter's parent Monitor.
Definition: CounterBase.cxx:22
kLinear
@ kLinear
Linear x-binning.
Definition: Trigger/TrigCost/TrigCostAnalysis/src/Variable.h:27
LArCellBinning.xbins
int xbins
Definition: LArCellBinning.py:163
makeTRTBarrelCans.dy
tuple dy
Definition: makeTRTBarrelCans.py:21
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
CounterBase::increment
StatusCode increment(const std::string &name, float weight=1.0)
Convenience function.
Definition: CounterBase.cxx:220
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
makeTRTBarrelCans.dx
tuple dx
Definition: makeTRTBarrelCans.py:20
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
xmax
double xmax
Definition: listroot.cxx:61
CounterBase::m_variables
std::unordered_map< std::string, Variable > m_variables
Store of Counter's Variables.
Definition: CounterBase.h:205
CounterBase::timeToMilliSec
float timeToMilliSec(const uint64_t start, const uint64_t stop) const
Helper function.
Definition: CounterBase.cxx:243
CounterBase::m_name
const std::string m_name
Counter's name.
Definition: CounterBase.h:203
ymax
double ymax
Definition: listroot.cxx:64
Generated on Mon Jul 8 2024 21:41:58 for ATLAS Offline Software by   doxygen 1.8.18