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

Concrete implimentation of Counter to monitor all properties of a given Algorithm class. The new event logic is the same as in CounterAlgorithm, only histogram definition differs. More...

#include <CounterAlgorithmClass.h>

Inheritance diagram for CounterAlgorithmClass:
Collaboration diagram for CounterAlgorithmClass:

Public Member Functions

 CounterAlgorithmClass ()=delete
 Forbid default constructor. More...
 
 CounterAlgorithmClass (const std::string &name, const MonitorBase *parent)
 Construct counter. More...
 
virtual ~CounterAlgorithmClass ()=default
 Default destructor. More...
 
CounterAlgorithmClassoperator= (const CounterAlgorithmClass &)=delete
 Forbid assignment. More...
 
 CounterAlgorithmClass (const CounterAlgorithmClass &)=delete
 Forbid copy. More...
 
virtual StatusCode newEvent (const CostData &data, size_t index, const float weight=1.) override
 Concrete implimentation. More...
 
const std::string & getName () const
 Getter for Counter's name. More...
 
const MonitorBasegetParent () 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...
 
VariablegetVariable (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 MonitorBasem_parent
 Counter's parent Monitor. More...
 
std::unordered_map< std::string, Variablem_variables
 Store of Counter's Variables. More...
 

Detailed Description

Concrete implimentation of Counter to monitor all properties of a given Algorithm class. The new event logic is the same as in CounterAlgorithm, only histogram definition differs.

Definition at line 15 of file CounterAlgorithmClass.h.

Constructor & Destructor Documentation

◆ CounterAlgorithmClass() [1/3]

CounterAlgorithmClass::CounterAlgorithmClass ( )
delete

Forbid default constructor.

◆ CounterAlgorithmClass() [2/3]

CounterAlgorithmClass::CounterAlgorithmClass ( 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 7 of file CounterAlgorithmClass.cxx.

9 {
10  regHistogram("Time_perCall", "CPU Time/Call;Time [ms];Calls", VariableType::kPerCall, kLog, 0.01, 100000);
11  regHistogram("FirstTime_perEvent", "First Call CPU Time;Time [ms];Events", VariableType::kPerCall, kLog, 0.01, 100000);
12  regHistogram("Time_perEvent", "CPU Time/Event;Time [ms];Events", VariableType::kPerEvent);
13  regHistogram("Time_perEventFractional", "CPU Time/Event CPU Time;Fractional Time;Events", VariableType::kPerEvent, kLinear, 0., 1.);
14  regHistogram("AlgCalls_perEvent", "Calls/Event;Calls;Events", VariableType::kPerEvent, kLinear, -0.5, 1499.5, 1500);
15  regHistogram("InEventView_perCall", "In Event View;Yes or No;Calls", VariableType::kPerCall, kLinear, -0.5, 1.5, 2);
16  regHistogram("RoIID_perCall", "RoI ID;RoI ID;Calls", VariableType::kPerCall, kLinear, -1.5, 20.5, 22);
17  regHistogram("Request_perEvent", "Number of requests/Event;Number of requests;Events", VariableType::kPerEvent, LogType::kLinear, -0.5, 299.5, 300);
18  regHistogram("NetworkRequest_perEvent", "Number of network requests/Event;Number of requests;Events", VariableType::kPerEvent, LogType::kLinear, -0.5, 299.5, 300);
19  regHistogram("CachedROBSize_perEvent", "Total ROB Size/Event;ROB size;Events", VariableType::kPerEvent, LogType::kLinear, 0, 1024, 50);
20  regHistogram("NetworkROBSize_perEvent", "Total ROB Size/Event;ROB size;Events", VariableType::kPerEvent, LogType::kLinear, 0, 1024, 50);
21  regHistogram("RequestTime_perEvent", "ROB Elapsed Time/Event;Elapsed Time [ms];Events", VariableType::kPerEvent);
22 }

◆ ~CounterAlgorithmClass()

virtual CounterAlgorithmClass::~CounterAlgorithmClass ( )
virtualdefault

Default destructor.

◆ CounterAlgorithmClass() [3/3]

CounterAlgorithmClass::CounterAlgorithmClass ( const CounterAlgorithmClass )
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 CounterAlgorithm::newEvent ( const CostData data,
size_t  index,
const float  weight = 1. 
)
overridevirtualinherited

Concrete implimentation.

Monitores algorithm at specified index. Expected to match this instances name().

Parameters
[in]dataAccess to event data
[in]indexIndex within appropriate event data container which is to be analysed by this Counter
[in]weightGlobal event weight

Implements CounterBase.

Definition at line 30 of file CounterAlgorithm.cxx.

30  {
31  const xAOD::TrigComposite* alg = data.costCollection().at(index);
32 
33  const uint64_t start = alg->getDetail<uint64_t>("start"); // in mus
34  const uint64_t stop = alg->getDetail<uint64_t>("stop"); // in mus
35  const float cpuTime = timeToMilliSec(start, stop);
36 
37  ATH_CHECK( fill("Time_perCall", cpuTime, weight) );
38 
39  ATH_CHECK( fill("Time_perEvent", cpuTime, weight) );
40 
41  Variable& firstTime_perEvent = getVariable("FirstTime_perEvent");
42  if (firstTime_perEvent.getCalls() == 0) {
43  ATH_CHECK( firstTime_perEvent.fill(cpuTime, weight) );
44  }
45 
46  ATH_CHECK( setDenominator("Time_perEventFractional", data.algTotalTimeMilliSec()) );
47  ATH_CHECK( fill("Time_perEventFractional", cpuTime, weight) );
48 
49  ATH_CHECK( increment("AlgCalls_perEvent", weight) );
50 
51  const bool globalScope = (TrigConf::HLTUtils::hash2string( alg->getDetail<TrigConf::HLTHash>("store"), "STORE").find("StoreGateSvc") != std::string::npos);
52  ATH_CHECK( fill("InEventView_perCall", (globalScope ? 0.0 : 1.0), weight) );
53 
54  ATH_CHECK( fill("RoIID_perCall", alg->getDetail<int32_t>("roi"), weight) );
55 
56  // Monitor data requests per algorithm
57  if (data.algToRequestMap().count(index)) {
58  for (size_t requestIdx : data.algToRequestMap().at(index)) {
59  const xAOD::TrigComposite* request = data.rosCollection().at(requestIdx);
60  const std::vector<unsigned> robs_history = request->getDetail<std::vector<unsigned>>("robs_history");
61  const std::vector<uint32_t> robs_size = request->getDetail<std::vector<uint32_t>>("robs_size");
62 
63  bool networkRequestIncremented = false;
64  for (size_t i = 0; i < robs_size.size(); ++i) {
65  // ROB request was fetched over the network
66  if (robs_history[i] == robmonitor::RETRIEVED) {
67  // size is stored in words, should be in kilobytes
68  ATH_CHECK( fill("NetworkROBSize_perEvent", robs_size[i] / 500., weight) );
69  networkRequestIncremented = true;
70  }
71  // ROB request was cached
72  else if (robs_history[i] == robmonitor::HLT_CACHED || robs_history[i] == robmonitor::DCM_CACHED) {
73  ATH_CHECK( fill("CachedROBSize_perEvent", robs_size[i] / 500., weight) );
74  }
75  }
76 
77  ATH_CHECK( increment("Request_perEvent", weight) );
78 
79  if (networkRequestIncremented) {
80  ATH_CHECK( increment("NetworkRequest_perEvent", weight) );
81  }
82 
83  const float rosTime = timeToMilliSec(request->getDetail<uint64_t>("start"), request->getDetail<uint64_t>("stop"));
84  ATH_CHECK( fill("RequestTime_perEvent", rosTime, weight) );
85  }
86  }
87 
88  return StatusCode::SUCCESS;
89 }

◆ operator=()

CounterAlgorithmClass& CounterAlgorithmClass::operator= ( const CounterAlgorithmClass )
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:
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
ymin
double ymin
Definition: listroot.cxx:63
CounterBase::setDenominator
StatusCode setDenominator(const std::string &name, float value)
Optional for per-Event Variables.
Definition: CounterBase.cxx:210
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
SGout2dot.alg
alg
Definition: SGout2dot.py:243
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
index
Definition: index.py:1
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
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
TrigConf::HLTHash
uint32_t HLTHash
Definition: TrigConfHLTUtils/TrigConfHLTUtils/HLTUtils.h:19
plotmaker.hist
hist
Definition: plotmaker.py:148
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:14
robmonitor::DCM_CACHED
@ DCM_CACHED
Definition: ROBDataMonitor.h:28
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:396
PixelAthClusterMonAlgCfg.ybins
ybins
Definition: PixelAthClusterMonAlgCfg.py:169
athena.value
value
Definition: athena.py:124
PixelModuleFeMask_create_db.stop
int stop
Definition: PixelModuleFeMask_create_db.py:76
Variable::getCalls
size_t getCalls() const
Getter for how many times fill() has already been called on this Variable in this event.
Definition: Variable.cxx:29
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
CounterAlgorithm::CounterAlgorithm
CounterAlgorithm()=delete
Forbid default constructor.
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:189
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:85
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
plotting.yearwise_luminosity_vs_mu.bins
bins
Definition: yearwise_luminosity_vs_mu.py:30
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
kPerCall
@ kPerCall
Variable should fill underlying histogram on each fill.
Definition: Trigger/TrigCost/TrigCostAnalysis/src/Variable.h:18
CounterBase::getVariable
Variable & getVariable(const std::string &name)
Returns a mutable reference to a named Variable.
Definition: CounterBase.cxx:182
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
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
TrigConf::HLTUtils::hash2string
static const std::string hash2string(HLTHash, const std::string &category="TE")
hash function translating identifiers into names (via internal dictionary)
Variable
Wrapper around a histogram which allows for some additional filling patterns and data manipulation.
Definition: Trigger/TrigCost/TrigCostAnalysis/src/Variable.h:39
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
robmonitor::RETRIEVED
@ RETRIEVED
Definition: ROBDataMonitor.h:26
robmonitor::HLT_CACHED
@ HLT_CACHED
Definition: ROBDataMonitor.h:27
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
xAOD::TrigComposite_v1::getDetail
bool getDetail(const std::string &name, TYPE &value) const
Get an TYPE detail from the object.
CounterBase::timeToMilliSec
float timeToMilliSec(const uint64_t start, const uint64_t stop) const
Helper function.
Definition: CounterBase.cxx:243
Variable::fill
StatusCode fill(float value, float weight=1.0)
Fill histogram (per-Call Variable), or add value to internal accumulator (per-Event Variable) to be f...
Definition: Variable.cxx:49
CounterBase::m_name
const std::string m_name
Counter's name.
Definition: CounterBase.h:203
ymax
double ymax
Definition: listroot.cxx:64