ATLAS Offline Software
Classes | Public Member Functions | Private Member Functions | Private Attributes | List of all members
TrigSignatureMoni Class Reference

#include <TrigSignatureMoni.h>

Inheritance diagram for TrigSignatureMoni:
Collaboration diagram for TrigSignatureMoni:

Classes

class  RateHistogram
 

Public Member Functions

 TrigSignatureMoni (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual StatusCode initialize () override
 
virtual StatusCode start () override
 
virtual StatusCode execute (const EventContext &context) const override
 
virtual StatusCode stop () override
 
virtual void handle (const Incident &incident) override
 

Private Member Functions

int nBinsX (SG::ReadHandle< TrigConf::HLTMenu > &) const
 
int nBinsX () const
 
int nChains (SG::ReadHandle< TrigConf::HLTMenu > &) const
 
int nBCIDs () const
 
int nSequenceBins () const
 
int nSteps () const
 
int nBaseSteps () const
 
StatusCode initHist (LockedHandle< TH2 > &, SG::ReadHandle< TrigConf::HLTMenu > &, bool=true)
 
StatusCode initSeqHist (LockedHandle< TH2 > &, std::set< std::string > &)
 
StatusCode fillDecisionCount (const std::vector< TrigCompositeUtils::DecisionID > &, int) const
 
StatusCode fillPassEvents (const TrigCompositeUtils::DecisionIDContainer &, int) const
 
StatusCode fillRate (const TrigCompositeUtils::DecisionIDContainer &, int) const
 
StatusCode fillHistogram (const TrigCompositeUtils::DecisionIDContainer &, int, LockedHandle< TH2 > &) const
 
StatusCode fillSequences (const std::set< std::string > &) const
 
StatusCode fillStreamsAndGroups (const std::map< std::string, TrigCompositeUtils::DecisionIDContainer > &, const TrigCompositeUtils::DecisionIDContainer &) const
 

Private Attributes

SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > m_l1DecisionsKey { this, "L1Decisions", "HLTSeedingSummary", "Chains activated after the L1" }
 
SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > m_finalDecisionKey { this, "FinalDecisionKey", "HLTNav_Summary", "Final stage of all decisions" }
 
SG::ReadHandleKey< TrigConf::HLTMenu > m_HLTMenuKey { this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu", "HLT Menu" }
 
SG::ReadHandleKey< TrigConf::L1Menu > m_L1MenuKey { this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu" }
 
ServiceHandle< IIncidentSvc > m_incidentSvc { this, "IncidentSvc", "IncidentSvc", "Incident service"}
 
ServiceHandle< ITHistSvc > m_histSvc { this, "THistSvc", "THistSvc/THistSvc", "Histogramming svc" }
 
Gaudi::Property< std::string > m_bookingPath { this, "HistPath", "/EXPERT/HLTFramework", "Booking path for the histogram"}
 
Gaudi::Property< unsigned int > m_duration {this, "RateIntegrationDuration", 10, "Integration time for the rate histogram in seconds"}
 
Gaudi::Property< unsigned int > m_intervals {this, "RateIntegrationIntervals", 6, "Number of the rate histogram publications"}
 
ToolHandleArray< DecisionCollectorTool > m_decisionCollectorTools { this, "DecisionCollectorTools", {}, "Tools that collect decisions (yes/no) for steps" }
 
ToolHandleArray< DecisionCollectorTool > m_featureCollectorTools { this, "FeatureCollectorTools", {}, "Tools that collect decision counts for specific features for steps" }
 
LockedHandle< TH2 > m_passHistogram ATLAS_THREAD_SAFE
 
LockedHandle< TH2 > m_countHistogram ATLAS_THREAD_SAFE
 
RateHistogram m_rateHistogram
 
RateHistogram m_sequenceHistogram
 
std::map< unsigned int, int > m_chainIDToBinMap
 Chain id to histogram bin map. More...
 
std::map< std::string, int > m_nameToBinMap
 Sequence/group/bunchgroup name to bin map. More...
 
std::map< std::string, int > m_sequenceToBinMap
 Sequence to bin map for sequence histogram. More...
 
std::map< unsigned int, std::set< std::string > > m_chainIDToBunchMap
 Chain ID to bunchgroup name map. More...
 
std::map< std::string, TrigCompositeUtils::DecisionIDContainer > m_groupToChainMap
 Group name to chain objects map. More...
 
std::map< std::string, TrigCompositeUtils::DecisionIDContainer > m_streamToChainMap
 Stream name to chain objects map, excluding express. More...
 
std::map< std::string, TrigCompositeUtils::DecisionIDContainer > m_expressChainMap
 Stream name to chain objects map, including only express. More...
 

Detailed Description

Definition at line 36 of file TrigSignatureMoni.h.

Constructor & Destructor Documentation

◆ TrigSignatureMoni()

TrigSignatureMoni::TrigSignatureMoni ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 14 of file TrigSignatureMoni.cxx.

15  : base_class(name, pSvcLocator)
16 {}

Member Function Documentation

◆ execute()

StatusCode TrigSignatureMoni::execute ( const EventContext &  context) const
overridevirtual

Definition at line 299 of file TrigSignatureMoni.cxx.

299  {
300 
301  SG::ReadHandle<TrigCompositeUtils::DecisionContainer> l1Decisions = SG::makeHandle(m_l1DecisionsKey, context);
302 
303  const TrigCompositeUtils::Decision* l1SeededChains = nullptr; // Activated by L1
304  const TrigCompositeUtils::Decision* unprescaledChains = nullptr; // Activated and passed prescale check
305  for (const TrigCompositeUtils::Decision* d : *l1Decisions) {
306  if (d->name() == "l1seeded") {
307  l1SeededChains = d;
308  } else if (d->name() == "unprescaled") {
309  unprescaledChains = d;
310  }
311  }
312 
313  if (l1SeededChains == nullptr || unprescaledChains == nullptr) {
314  ATH_MSG_ERROR("Unable to read in the summary from the HLTSeeding.");
315  return StatusCode::FAILURE;
316  }
317 
318  auto fillL1 = [&](int index) -> StatusCode {
319  TrigCompositeUtils::DecisionIDContainer ids;
320  TrigCompositeUtils::decisionIDs(l1Decisions->at(index), ids);
321  ATH_MSG_DEBUG( "L1 " << index << " N positive decisions " << ids.size() );
322  ATH_CHECK(fillPassEvents(ids, index + 1));
323  ATH_CHECK(fillRate(ids, index + 1));
324  if (!ids.empty()){
325  m_passHistogram->Fill(1, double(index + 1));
326  m_rateHistogram.fill(1, double(index + 1));
327  }
328  return StatusCode::SUCCESS;
329  };
330 
331  // Fill histograms with L1 decisions in and after prescale
332  ATH_CHECK(fillL1(0));
333  ATH_CHECK(fillL1(1));
334 
335  // Fill HLT steps
336  int step = 0;
337  for ( auto& ctool: m_decisionCollectorTools ) {
338  std::vector<TrigCompositeUtils::DecisionID> stepSum;
339  std::set<std::string> stepSequences;
340  ctool->getDecisions( stepSum );
341  ctool->getSequencesPerEvent( stepSequences );
342  ATH_MSG_DEBUG( " Step " << step << " decisions (for decisions): " << stepSum.size() );
343  TrigCompositeUtils::DecisionIDContainer stepUniqueSum( stepSum.begin(), stepSum.end() );
344  ATH_CHECK( fillPassEvents( stepUniqueSum, 3+step ) );
345  ATH_CHECK( fillSequences( stepSequences ) );
346  ++step;
347  }
348 
349  step = 0;
350  for ( auto& ctool: m_featureCollectorTools ) {
351  std::vector<TrigCompositeUtils::DecisionID> stepSum;
352  std::set<std::string> stepSequences;
353  ctool->getDecisions( stepSum );
354  ATH_MSG_DEBUG( " Step " << step << " decisions (for features): " << stepSum.size() );
355  TrigCompositeUtils::DecisionIDContainer stepUniqueSum( stepSum.begin(), stepSum.end() );
356  ATH_CHECK( fillDecisionCount( stepSum, 3+step ) );
357  ++step;
358  }
359 
360  // Collect the final decisions
361  SG::ReadHandle<TrigCompositeUtils::DecisionContainer> finalDecisionsHandle = SG::makeHandle( m_finalDecisionKey, context );
362  ATH_CHECK( finalDecisionsHandle.isValid() );
363  TrigCompositeUtils::DecisionIDContainer finalIDs;
364  const TrigCompositeUtils::Decision* decisionObject = TrigCompositeUtils::getTerminusNode(*finalDecisionsHandle);
365  if (!decisionObject) {
366  ATH_MSG_WARNING("Unable to locate trigger navigation terminus node. Cannot tell which chains passed the event.");
367  } else {
368  TrigCompositeUtils::decisionIDs(decisionObject, finalIDs);
369  }
370 
371  // Collect the express stream decisions
372  TrigCompositeUtils::DecisionIDContainer expressFinalIDs;
373  const TrigCompositeUtils::Decision* expressDecisionObject = TrigCompositeUtils::getExpressTerminusNode(*finalDecisionsHandle);
374  if (!expressDecisionObject) {
375  ATH_MSG_WARNING("Unable to locate trigger navigation express terminus node. Cannot tell which chains passed the express stream in this event.");
376  } else {
377  TrigCompositeUtils::decisionIDs(expressDecisionObject, expressFinalIDs);
378  }
379 
380  // Fill the histograms with output counts/rate
381  const int countOutputRow {nSteps()-1};
382  const int rateOutputRow {nBaseSteps()-1};
383  ATH_CHECK( fillStreamsAndGroups(m_streamToChainMap, finalIDs));
384  ATH_CHECK( fillStreamsAndGroups(m_groupToChainMap, finalIDs));
385  ATH_CHECK( fillPassEvents(finalIDs, countOutputRow));
386  ATH_CHECK( fillRate(finalIDs, rateOutputRow));
387 
388  // Fill the histograms with express counts/rate
389  const int countExpressRow {nSteps()};
390  const int rateExpressRow {nBaseSteps()};
391  ATH_CHECK( fillStreamsAndGroups(m_expressChainMap, expressFinalIDs));
392  ATH_CHECK( fillPassEvents(expressFinalIDs, countExpressRow));
393  ATH_CHECK( fillRate(expressFinalIDs, rateExpressRow));
394 
395  // Fill the "All" column in counts/rate histograms
396  if (!finalIDs.empty()) {
397  m_passHistogram->Fill(1, double(countOutputRow));
398  m_rateHistogram.fill(1, double(rateOutputRow));
399  }
400  if (!expressFinalIDs.empty()) {
401  m_passHistogram->Fill(1, double(countExpressRow));
402  m_rateHistogram.fill(1, double(rateExpressRow));
403  }
404 
405  return StatusCode::SUCCESS;
406 }

◆ fillDecisionCount()

StatusCode TrigSignatureMoni::fillDecisionCount ( const std::vector< TrigCompositeUtils::DecisionID > &  dc,
int  row 
) const
private

Definition at line 237 of file TrigSignatureMoni.cxx.

237  {
238  for (TrigCompositeUtils::DecisionID id : dc) {
239  TrigCompositeUtils::DecisionID chain = id;
240  if (TrigCompositeUtils::isLegId(HLT::Identifier(id)) ) chain = TrigCompositeUtils::getIDFromLeg(id);
241  auto id2bin = m_chainIDToBinMap.find( chain );
242  if ( id2bin == m_chainIDToBinMap.end()) {
243  ATH_MSG_WARNING("HLT chain " << HLT::Identifier(chain) << " not configured to be monitored");
244  } else {
245  m_countHistogram->Fill(id2bin->second, double(row));
246  }
247  }
248 
249  return StatusCode::SUCCESS;
250 
251 }

◆ fillHistogram()

StatusCode TrigSignatureMoni::fillHistogram ( const TrigCompositeUtils::DecisionIDContainer &  dc,
int  row,
LockedHandle< TH2 > &  histogram 
) const
private

Definition at line 217 of file TrigSignatureMoni.cxx.

217  {
218  for (TrigCompositeUtils::DecisionID id : dc) {
219  auto id2bin = m_chainIDToBinMap.find( id );
220  if ( id2bin == m_chainIDToBinMap.end() && HLT::Identifier(id).name().find("leg") != 0 ) {
221  ATH_MSG_WARNING( "HLT chain " << HLT::Identifier(id) << " not configured to be monitored" );
222  } else {
223  histogram->Fill( id2bin->second, double(row) );
224  }
225  }
226  return StatusCode::SUCCESS;
227 }

◆ fillPassEvents()

StatusCode TrigSignatureMoni::fillPassEvents ( const TrigCompositeUtils::DecisionIDContainer &  dc,
int  row 
) const
private

Definition at line 233 of file TrigSignatureMoni.cxx.

233  {
234  return fillHistogram(dc, row, m_passHistogram);
235 }

◆ fillRate()

StatusCode TrigSignatureMoni::fillRate ( const TrigCompositeUtils::DecisionIDContainer &  dc,
int  row 
) const
private

Definition at line 229 of file TrigSignatureMoni.cxx.

229  {
230  return fillHistogram(dc, row, m_rateHistogram.getBuffer());
231 }

◆ fillSequences()

StatusCode TrigSignatureMoni::fillSequences ( const std::set< std::string > &  sequences) const
private

Definition at line 253 of file TrigSignatureMoni.cxx.

253  {
254  for (const std::string& seq : sequences) {
255  m_sequenceHistogram.fill(m_sequenceToBinMap.at(seq), 1);
256  }
257 
258  return StatusCode::SUCCESS;
259 }

◆ fillStreamsAndGroups()

StatusCode TrigSignatureMoni::fillStreamsAndGroups ( const std::map< std::string, TrigCompositeUtils::DecisionIDContainer > &  nameToChainsMap,
const TrigCompositeUtils::DecisionIDContainer &  dc 
) const
private

Definition at line 261 of file TrigSignatureMoni.cxx.

261  {
262  const int countOutputRow {nSteps()-1};
263  const int rateOutputRow {nBaseSteps()-1};
264  for (const auto& name : nameToChainsMap) {
265  for (TrigCompositeUtils::DecisionID id : dc) {
266  if (name.second.find(id) != name.second.end()){
267  double bin = m_nameToBinMap.at(name.first);
268  m_countHistogram->Fill(bin, countOutputRow);
269  m_rateHistogram.fill(bin, rateOutputRow);
270  m_passHistogram->Fill(bin, countOutputRow);
271  break;
272  }
273  }
274  }
275  return StatusCode::SUCCESS;
276 }

◆ handle()

void TrigSignatureMoni::handle ( const Incident &  incident)
overridevirtual

Definition at line 278 of file TrigSignatureMoni.cxx.

278  {
279  // Create and start timer after fork
280  if (incident.type() == AthenaInterprocess::UpdateAfterFork::type()) {
281  if (m_rateHistogram.getTimer() || m_sequenceHistogram.getTimer()) {
282  ATH_MSG_WARNING("Timer is already running. UpdateAfterFork incident called more than once?");
283  return;
284  }
285 
286  // Prevent from publishing empty histograms
287  if (nBinsX() > 0) {
288  m_rateHistogram.startTimer(m_duration, m_intervals);
289  }
290 
291  if (nSequenceBins() > 0) {
292  m_sequenceHistogram.startTimer(m_duration, m_intervals);
293  }
294 
295  ATH_MSG_DEBUG("Started rate timer");
296  }
297 }

◆ initHist()

StatusCode TrigSignatureMoni::initHist ( LockedHandle< TH2 > &  hist,
SG::ReadHandle< TrigConf::HLTMenu > &  hltMenuHandle,
bool  steps = true 
)
private

Definition at line 432 of file TrigSignatureMoni.cxx.

432  {
433  TAxis* x = hist->GetXaxis();
434  x->SetBinLabel(1, "All");
435  int bin = 2; // 1 is for total count, (remember bins numbering in ROOT start from 1)
436 
437  std::set<std::string> sortedChainsList;
438  for ( const TrigConf::Chain& chain: *hltMenuHandle ) {
439  sortedChainsList.insert( chain.name() );
440  }
441 
442  for ( const std::string& chainName: sortedChainsList ) {
443 
444  x->SetBinLabel( bin, chainName.c_str() );
445  m_chainIDToBinMap[ HLT::Identifier( chainName ).numeric() ] = bin;
446  bin++;
447  }
448 
449 
450  for ( const auto& stream : m_streamToChainMap){
451  x->SetBinLabel( bin, ("str_"+stream.first).c_str());
452  m_nameToBinMap[ stream.first ] = bin;
453  bin++;
454  }
455 
456  for ( const auto& stream : m_expressChainMap){
457  x->SetBinLabel( bin, ("str_"+stream.first).c_str());
458  m_nameToBinMap[ stream.first ] = bin;
459  bin++;
460  }
461 
462  for ( const auto& group : m_groupToChainMap){
463  x->SetBinLabel( bin, ("grp_"+group.first.substr(group.first.find(':')+1)).c_str() );
464  m_nameToBinMap[ group.first ] = bin;
465  bin++;
466  }
467 
468 
469  TAxis* y = hist->GetYaxis();
470  y->SetBinLabel(1, steps ? "L1" : "Input");
471  y->SetBinLabel(2, "AfterPS");
472  for ( size_t i = 0; steps && i < m_decisionCollectorTools.size(); ++i) {
473  y->SetBinLabel(3 + i, ("Step "+std::to_string(i)).c_str());
474  }
475  y->SetBinLabel(y->GetNbins()-1, "Output"); // Second to last bin
476  y->SetBinLabel(y->GetNbins(), "Express"); // Last bin
477 
478  return StatusCode::SUCCESS;
479 }

◆ initialize()

StatusCode TrigSignatureMoni::initialize ( )
overridevirtual

Definition at line 18 of file TrigSignatureMoni.cxx.

18  {
19  ATH_CHECK(m_l1DecisionsKey.initialize());
20  ATH_CHECK(m_finalDecisionKey.initialize());
21  ATH_CHECK(m_HLTMenuKey.initialize());
22  ATH_CHECK(m_L1MenuKey.initialize());
23  ATH_CHECK(m_decisionCollectorTools.retrieve());
24  ATH_CHECK(m_featureCollectorTools.retrieve());
25  ATH_CHECK(m_histSvc.retrieve());
26 
27  ATH_CHECK(m_incidentSvc.retrieve());
28  m_incidentSvc->addListener(this, AthenaInterprocess::UpdateAfterFork::type());
29 
30  return StatusCode::SUCCESS;
31 }

◆ initSeqHist()

StatusCode TrigSignatureMoni::initSeqHist ( LockedHandle< TH2 > &  hist,
std::set< std::string > &  sequenceSet 
)
private

Definition at line 481 of file TrigSignatureMoni.cxx.

481  {
482  TAxis* x = hist->GetXaxis();
483  int bin = 1;
484 
485  // Set bin labels
486  for (const std::string& seqName : sequenceSet) {
487  x->SetBinLabel(bin, seqName.c_str());
488  m_sequenceToBinMap[seqName] = bin;
489  ++bin;
490  }
491 
492  TAxis* y = hist->GetYaxis();
493  y->SetBinLabel(1, "Rate");
494 
495  return StatusCode::SUCCESS;
496 }

◆ nBaseSteps()

int TrigSignatureMoni::nBaseSteps ( ) const
private

Definition at line 428 of file TrigSignatureMoni.cxx.

428  {
429  return 4; // in, after ps, out, express
430 }

◆ nBCIDs()

int TrigSignatureMoni::nBCIDs ( ) const
private

◆ nBinsX() [1/2]

int TrigSignatureMoni::nBinsX ( ) const
private

Definition at line 412 of file TrigSignatureMoni.cxx.

412  {
413  return m_chainIDToBinMap.size() + m_groupToChainMap.size() + m_streamToChainMap.size() + m_expressChainMap.size() + 1;
414 }

◆ nBinsX() [2/2]

int TrigSignatureMoni::nBinsX ( SG::ReadHandle< TrigConf::HLTMenu > &  hltMenuHandle) const
private

Definition at line 408 of file TrigSignatureMoni.cxx.

408  {
409  return nChains(hltMenuHandle) + m_groupToChainMap.size() + m_streamToChainMap.size() + m_expressChainMap.size();
410 }

◆ nChains()

int TrigSignatureMoni::nChains ( SG::ReadHandle< TrigConf::HLTMenu > &  hltMenuHandle) const
private

Definition at line 416 of file TrigSignatureMoni.cxx.

416  {
417  return hltMenuHandle->size() + 1; // Chains + "All"
418 }

◆ nSequenceBins()

int TrigSignatureMoni::nSequenceBins ( ) const
private

Definition at line 420 of file TrigSignatureMoni.cxx.

420  {
421  return m_sequenceToBinMap.size();
422 }

◆ nSteps()

int TrigSignatureMoni::nSteps ( ) const
private

Definition at line 424 of file TrigSignatureMoni.cxx.

424  {
425  return m_decisionCollectorTools.size() + nBaseSteps();
426 }

◆ start()

StatusCode TrigSignatureMoni::start ( )
overridevirtual

Definition at line 33 of file TrigSignatureMoni.cxx.

33  {
34  SG::ReadHandle<TrigConf::L1Menu> l1MenuHandle = SG::makeHandle(m_L1MenuKey);
35  SG::ReadHandle<TrigConf::HLTMenu> hltMenuHandle = SG::makeHandle(m_HLTMenuKey);
36  ATH_CHECK(hltMenuHandle.isValid());
37 
38  // Retrieve chain information from menus
39  m_groupToChainMap.clear();
40  m_streamToChainMap.clear();
41  m_expressChainMap.clear();
42  m_chainIDToBunchMap.clear();
43 
44  std::unordered_map<std::string,std::string> mapStrNameToTypeName; // e.g. {Main -> physics_Main}
45  try {
46  for (const TrigConf::DataStructure& stream : hltMenuHandle->streams()) {
47  mapStrNameToTypeName.insert({stream.getAttribute("name"), stream.getAttribute("type")+"_"+stream.getAttribute("name")});
48  }
49  } catch (const std::exception& ex) {
50  ATH_MSG_ERROR("Exception reading stream tag configuration from the HLT menu: " << ex.what());
51  return StatusCode::FAILURE;
52  }
53 
54  for (const TrigConf::Chain& chain : *hltMenuHandle) {
55  for (const std::string& group : chain.groups()) {
56  // Save chains per RATE group
57  if (CxxUtils::starts_with (group, "RATE")){
58  m_groupToChainMap[group].insert(HLT::Identifier(chain.name()));
59  }
60  }
61 
62  // Save chain to stream map
63  for (const std::string& streamName : chain.streams()){
64  const auto it = mapStrNameToTypeName.find(streamName);
65  if (it==mapStrNameToTypeName.cend()) {
66  ATH_MSG_ERROR("Stream name " << streamName << " assigned to chain " << chain.name()
67  << " is missing from menu streams definition");
68  return StatusCode::FAILURE;
69  }
70  if (it->second == "express_express") {
71  m_expressChainMap[it->second].insert(HLT::Identifier(chain.name()));
72  } else {
73  m_streamToChainMap[it->second].insert(HLT::Identifier(chain.name()));
74  }
75  }
76  }
77 
78  // Prepare the histograms
79 
80  // Initialize SignatureAcceptance and DecisionCount histograms that will monitor
81  // chains, groups and sequences per each step
82  const int x {nBinsX(hltMenuHandle)};
83  const int y {nSteps()};
84  ATH_MSG_DEBUG( "Histogram " << x << " x " << y << " bins");
85  std::unique_ptr<TH2> hSA = std::make_unique<TH2I>("SignatureAcceptance", "Raw acceptance of signatures in;chain;step", x, 1, x + 1, y, 1, y + 1);
86  std::unique_ptr<TH2> hDC = std::make_unique<TH2I>("DecisionCount", "Positive decisions count per step;chain;step", x, 1, x + 1, y, 1, y + 1);
87 
88  ATH_CHECK(m_histSvc->regShared(m_bookingPath + "/" + name() + "/SignatureAcceptance", std::move(hSA), m_passHistogram));
89  ATH_CHECK(m_histSvc->regShared(m_bookingPath + "/" + name() + "/DecisionCount", std::move(hDC), m_countHistogram));
90 
91  ATH_CHECK(initHist(m_passHistogram, hltMenuHandle));
92  ATH_CHECK(initHist(m_countHistogram, hltMenuHandle));
93 
94  // Initialize Rate histogram to save the rates of positive decisions in given interval
95  // per chain/group/sequence per in, after ps, out steps
96  const int yr {nBaseSteps()};
97  if ( x > 0 ){
98  std::string outputRateName ("Rate" + std::to_string(m_duration) + "s");
99  m_rateHistogram.init(outputRateName, "Rate of positive decisions;chain;step",
100  x, yr, m_bookingPath + "/" + name() + '/' + outputRateName, m_histSvc).ignore();
101  ATH_CHECK(initHist(m_rateHistogram.getHistogram(), hltMenuHandle, false));
102  ATH_CHECK(initHist(m_rateHistogram.getBuffer(), hltMenuHandle, false));
103  }
104 
105  // Initialize SequencesExecutionRate histogram to save the rates of sequences execution
106  // Save sequences names to be monitored
107  std::set<std::string> sequencesSet;
108  for (auto& ctool: m_decisionCollectorTools){
109  ctool->getSequencesNames(sequencesSet);
110  }
111  const int xc = sequencesSet.size();
112  const int yc {1}; // Only rate, this histogram is really 1 D
113  if (xc > 0){
114  std::string outputSequenceName ("SequencesExecutionRate" + std::to_string(m_duration) + "s");
115  m_sequenceHistogram.init(outputSequenceName, "Rate of sequences execution;sequence;rate",
116  xc, yc, m_bookingPath + "/" + name() + '/' + outputSequenceName, m_histSvc).ignore();
117  ATH_CHECK(initSeqHist(m_sequenceHistogram.getHistogram(), sequencesSet));
118  ATH_CHECK(initSeqHist(m_sequenceHistogram.getBuffer(), sequencesSet));
119  }
120 
121  return StatusCode::SUCCESS;
122 }

◆ stop()

StatusCode TrigSignatureMoni::stop ( )
overridevirtual

Definition at line 124 of file TrigSignatureMoni.cxx.

124  {
125  m_rateHistogram.stopTimer();
126  m_sequenceHistogram.stopTimer();
127 
128  if (m_chainIDToBinMap.empty()) {
129  ATH_MSG_INFO( "No chains configured, no counts to print" );
130  return StatusCode::SUCCESS;
131  }
132 
133  auto fixedWidth = [](const std::string& s, size_t sz) {
134  std::ostringstream ss;
135  ss << std::setw(sz) << std::left << s;
136  return ss.str();
137  };
138 
139  SG::ReadHandle<TrigConf::HLTMenu> hltMenuHandle = SG::makeHandle(m_HLTMenuKey);
140  ATH_CHECK(hltMenuHandle.isValid());
141 
142  // Retrieve information whether chain was active in Step
143  std::map<std::string, std::set<int>> chainToStepsId;
144  for (const TrigConf::Chain& chain : *hltMenuHandle){
145  int nstep {1}; // Start from step=1
146  for (const std::string& seqName : chain.sequencers()){
147  // Example sequencer name is "Step1_FastCalo_electron", we need only information about Step + number
148  std::smatch stepNameMatch;
149  std::regex_search(seqName.begin(), seqName.end(), stepNameMatch, std::regex("[Ss]tep[0-9]+"));
150 
151  std::string stepName = stepNameMatch[0];
152  stepName[0] = std::toupper(stepName[0]); // Fix "stepX" -> "StepX"
153  // Check that the step name is set with the same position in the execution (empty steps support)
154  if ("Step" + std::to_string(nstep) == stepName) {
155  chainToStepsId[chain.name()].insert(nstep);
156  } else {
157  ATH_MSG_DEBUG("Missing counts for step" << nstep << " in chain " << chain.name());
158  }
159  nstep++;
160  }
161  }
162 
163  auto collToString = [&](int xbin, const LockedHandle<TH2>& hist, int startOfset=0, int endOffset=0){
164  std::string v;
165  const int stepsSize = hist->GetYaxis()->GetNbins() - nBaseSteps();
166  for (int ybin = 1; ybin <= hist->GetYaxis()->GetNbins()-endOffset; ++ybin) {
167  if (ybin > startOfset) {
168  // Skip steps where chain wasn't active
169  // ybins are for all axis labes, steps are in bins from 3 to stepsSize + 2
170  const std::string chainName = m_passHistogram->GetXaxis()->GetBinLabel(xbin);
171 
172  if (ybin < 3 || ybin > stepsSize + 2 || chainToStepsId[chainName].count(ybin - 2) != 0) {
173  v += fixedWidth(std::to_string( int(hist->GetBinContent( xbin, ybin ))) , 11);
174  } else {
175  v += fixedWidth("-", 11);
176  }
177  } else {
178  v += fixedWidth(" ", 11);
179  }
180  }
181  return v;
182  };
183 
184  std::string v;
185  v += fixedWidth("L1", 11);
186  v += fixedWidth("AfterPS", 11);
187  for (int bin = 1; bin <= m_passHistogram->GetYaxis()->GetNbins()-nBaseSteps(); ++bin) {
188  v += fixedWidth("Step" + std::to_string(bin), 11);
189  }
190  v += fixedWidth("Output", 11);
191  v += fixedWidth("Express", 11);
192 
193  ATH_MSG_INFO("Chains passing step (1st row events & 2nd row decision counts):");
194  ATH_MSG_INFO(fixedWidth("ChainName", 30) << v);
195 
196  /*
197  comment for future dev:
198  for combined chains we find x2 the number of decisions, because we count both the HypoAlg and the combo Alg decisions
199  */
200 
201  for (int bin = 1; bin <= (*m_passHistogram)->GetXaxis()->GetNbins(); ++bin) {
202  const std::string chainName = m_passHistogram->GetXaxis()->GetBinLabel(bin);
203  const std::string chainID = std::to_string( HLT::Identifier(chainName) );
204  if (CxxUtils::starts_with (chainName, "HLT")) { // print only for chains
205  ATH_MSG_INFO( chainName + " #" + chainID);
206  ATH_MSG_INFO( fixedWidth("-- #" + chainID + " Events", 30) << collToString( bin, m_passHistogram) );
207  ATH_MSG_INFO( fixedWidth("-- #" + chainID + " Features", 30) << collToString( bin, m_countHistogram , 2, 1 ) );
208  }
209  if (CxxUtils::starts_with (chainName, "All")){
210  ATH_MSG_INFO( fixedWidth(chainName, 30) << collToString( bin, m_passHistogram) );
211  }
212  }
213 
214  return StatusCode::SUCCESS;
215 }

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

LockedHandle<TH2> m_passHistogram TrigSignatureMoni::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 109 of file TrigSignatureMoni.h.

◆ ATLAS_THREAD_SAFE [2/2]

LockedHandle<TH2> m_countHistogram TrigSignatureMoni::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 110 of file TrigSignatureMoni.h.

◆ m_bookingPath

Gaudi::Property<std::string> TrigSignatureMoni::m_bookingPath { this, "HistPath", "/EXPERT/HLTFramework", "Booking path for the histogram"}
private

Definition at line 99 of file TrigSignatureMoni.h.

◆ m_chainIDToBinMap

std::map<unsigned int, int> TrigSignatureMoni::m_chainIDToBinMap
private

Chain id to histogram bin map.

Definition at line 114 of file TrigSignatureMoni.h.

◆ m_chainIDToBunchMap

std::map<unsigned int, std::set<std::string> > TrigSignatureMoni::m_chainIDToBunchMap
private

Chain ID to bunchgroup name map.

Definition at line 117 of file TrigSignatureMoni.h.

◆ m_decisionCollectorTools

ToolHandleArray<DecisionCollectorTool> TrigSignatureMoni::m_decisionCollectorTools { this, "DecisionCollectorTools", {}, "Tools that collect decisions (yes/no) for steps" }
private

Definition at line 105 of file TrigSignatureMoni.h.

◆ m_duration

Gaudi::Property<unsigned int> TrigSignatureMoni::m_duration {this, "RateIntegrationDuration", 10, "Integration time for the rate histogram in seconds"}
private

Definition at line 102 of file TrigSignatureMoni.h.

◆ m_expressChainMap

std::map<std::string, TrigCompositeUtils::DecisionIDContainer> TrigSignatureMoni::m_expressChainMap
private

Stream name to chain objects map, including only express.

Definition at line 120 of file TrigSignatureMoni.h.

◆ m_featureCollectorTools

ToolHandleArray<DecisionCollectorTool> TrigSignatureMoni::m_featureCollectorTools { this, "FeatureCollectorTools", {}, "Tools that collect decision counts for specific features for steps" }
private

Definition at line 106 of file TrigSignatureMoni.h.

◆ m_finalDecisionKey

SG::ReadHandleKey<TrigCompositeUtils::DecisionContainer> TrigSignatureMoni::m_finalDecisionKey { this, "FinalDecisionKey", "HLTNav_Summary", "Final stage of all decisions" }
private

Definition at line 93 of file TrigSignatureMoni.h.

◆ m_groupToChainMap

std::map<std::string, TrigCompositeUtils::DecisionIDContainer> TrigSignatureMoni::m_groupToChainMap
private

Group name to chain objects map.

Definition at line 118 of file TrigSignatureMoni.h.

◆ m_histSvc

ServiceHandle<ITHistSvc> TrigSignatureMoni::m_histSvc { this, "THistSvc", "THistSvc/THistSvc", "Histogramming svc" }
private

Definition at line 98 of file TrigSignatureMoni.h.

◆ m_HLTMenuKey

SG::ReadHandleKey<TrigConf::HLTMenu> TrigSignatureMoni::m_HLTMenuKey { this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu", "HLT Menu" }
private

Definition at line 94 of file TrigSignatureMoni.h.

◆ m_incidentSvc

ServiceHandle<IIncidentSvc> TrigSignatureMoni::m_incidentSvc { this, "IncidentSvc", "IncidentSvc", "Incident service"}
private

Definition at line 97 of file TrigSignatureMoni.h.

◆ m_intervals

Gaudi::Property<unsigned int> TrigSignatureMoni::m_intervals {this, "RateIntegrationIntervals", 6, "Number of the rate histogram publications"}
private

Definition at line 103 of file TrigSignatureMoni.h.

◆ m_l1DecisionsKey

SG::ReadHandleKey<TrigCompositeUtils::DecisionContainer> TrigSignatureMoni::m_l1DecisionsKey { this, "L1Decisions", "HLTSeedingSummary", "Chains activated after the L1" }
private

Definition at line 92 of file TrigSignatureMoni.h.

◆ m_L1MenuKey

SG::ReadHandleKey<TrigConf::L1Menu> TrigSignatureMoni::m_L1MenuKey { this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu" }
private

Definition at line 95 of file TrigSignatureMoni.h.

◆ m_nameToBinMap

std::map<std::string, int> TrigSignatureMoni::m_nameToBinMap
private

Sequence/group/bunchgroup name to bin map.

Definition at line 115 of file TrigSignatureMoni.h.

◆ m_rateHistogram

RateHistogram TrigSignatureMoni::m_rateHistogram
private

Definition at line 111 of file TrigSignatureMoni.h.

◆ m_sequenceHistogram

RateHistogram TrigSignatureMoni::m_sequenceHistogram
private

Definition at line 112 of file TrigSignatureMoni.h.

◆ m_sequenceToBinMap

std::map<std::string, int> TrigSignatureMoni::m_sequenceToBinMap
private

Sequence to bin map for sequence histogram.

Definition at line 116 of file TrigSignatureMoni.h.

◆ m_streamToChainMap

std::map<std::string, TrigCompositeUtils::DecisionIDContainer> TrigSignatureMoni::m_streamToChainMap
private

Stream name to chain objects map, excluding express.

Definition at line 119 of file TrigSignatureMoni.h.

The documentation for this class was generated from the following files:
test_athena_ntuple_filter.seq
seq
filter configuration ## -> we use the special sequence 'AthMasterSeq' which is run before any other a...
Definition: test_athena_ntuple_filter.py:18
query_example.row
row
Definition: query_example.py:24
TrigSignatureMoni::m_groupToChainMap
std::map< std::string, TrigCompositeUtils::DecisionIDContainer > m_groupToChainMap
Group name to chain objects map.
Definition: TrigSignatureMoni.h:118
TrigSignatureMoni::RateHistogram::getTimer
std::unique_ptr< Athena::AlgorithmTimer > & getTimer()
Definition: TrigSignatureMoni.cxx:523
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
fitman.sz
sz
Definition: fitman.py:527
CxxUtils::starts_with
bool starts_with(const char *s, const char *prefix)
Test whether one null-terminated byte string starts with another.
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
TrigCompositeUtils::DecisionID
unsigned int DecisionID
Definition: TrigComposite_v1.h:27
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
HLT::Identifier::numeric
TrigCompositeUtils::DecisionID numeric() const
numeric ID
Definition: TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h:47
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
hist_file_dump.d
d
Definition: hist_file_dump.py:137
plotmaker.hist
hist
Definition: plotmaker.py:148
TrigSignatureMoni::m_streamToChainMap
std::map< std::string, TrigCompositeUtils::DecisionIDContainer > m_streamToChainMap
Stream name to chain objects map, excluding express.
Definition: TrigSignatureMoni.h:119
TrigSignatureMoni::m_HLTMenuKey
SG::ReadHandleKey< TrigConf::HLTMenu > m_HLTMenuKey
Definition: TrigSignatureMoni.h:94
skel.it
it
Definition: skel.GENtoEVGEN.py:423
bin
Definition: BinsDiffFromStripMedian.h:43
TrigSignatureMoni::m_L1MenuKey
SG::ReadHandleKey< TrigConf::L1Menu > m_L1MenuKey
Definition: TrigSignatureMoni.h:95
TrigSignatureMoni::fillRate
StatusCode fillRate(const TrigCompositeUtils::DecisionIDContainer &, int) const
Definition: TrigSignatureMoni.cxx:229
TrigSignatureMoni::m_histSvc
ServiceHandle< ITHistSvc > m_histSvc
Definition: TrigSignatureMoni.h:98
TrigSignatureMoni::initSeqHist
StatusCode initSeqHist(LockedHandle< TH2 > &, std::set< std::string > &)
Definition: TrigSignatureMoni.cxx:481
TrigSignatureMoni::fillSequences
StatusCode fillSequences(const std::set< std::string > &) const
Definition: TrigSignatureMoni.cxx:253
x
#define x
TrigSignatureMoni::m_sequenceToBinMap
std::map< std::string, int > m_sequenceToBinMap
Sequence to bin map for sequence histogram.
Definition: TrigSignatureMoni.h:116
TrigSignatureMoni::initHist
StatusCode initHist(LockedHandle< TH2 > &, SG::ReadHandle< TrigConf::HLTMenu > &, bool=true)
Definition: TrigSignatureMoni.cxx:432
AthenaPoolTestWrite.stream
string stream
Definition: AthenaPoolTestWrite.py:12
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
TrigSignatureMoni::m_expressChainMap
std::map< std::string, TrigCompositeUtils::DecisionIDContainer > m_expressChainMap
Stream name to chain objects map, including only express.
Definition: TrigSignatureMoni.h:120
TrigSignatureMoni::fillStreamsAndGroups
StatusCode fillStreamsAndGroups(const std::map< std::string, TrigCompositeUtils::DecisionIDContainer > &, const TrigCompositeUtils::DecisionIDContainer &) const
Definition: TrigSignatureMoni.cxx:261
PrepareReferenceFile.regex
regex
Definition: PrepareReferenceFile.py:43
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:269
TrigCompositeUtils::getTerminusNode
const Decision * getTerminusNode(SG::ReadHandle< DecisionContainer > &container)
Definition: TrigCompositeUtilsRoot.cxx:243
TrigSignatureMoni::nChains
int nChains(SG::ReadHandle< TrigConf::HLTMenu > &) const
Definition: TrigSignatureMoni.cxx:416
TrigSignatureMoni::RateHistogram::startTimer
void startTimer(unsigned int duration, unsigned int intervals)
Definition: TrigSignatureMoni.cxx:531
TrigSignatureMoni::nSequenceBins
int nSequenceBins() const
Definition: TrigSignatureMoni.cxx:420
beamspotman.steps
int steps
Definition: beamspotman.py:505
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TrigSignatureMoni::fillHistogram
StatusCode fillHistogram(const TrigCompositeUtils::DecisionIDContainer &, int, LockedHandle< TH2 > &) const
Definition: TrigSignatureMoni.cxx:217
TrigConf::HLTMenu::streams
std::vector< DataStructure > streams() const
Accessor to the connected output streams.
Definition: HLTMenu.cxx:65
lumiFormat.i
int i
Definition: lumiFormat.py:92
TrigCompositeUtils::getExpressTerminusNode
const Decision * getExpressTerminusNode(const DecisionContainer &container)
Returns the express-accept navigation node from a collection or nullptr if missing.
Definition: TrigCompositeUtilsRoot.cxx:251
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
calibdata.exception
exception
Definition: calibdata.py:496
TrigSignatureMoni::m_incidentSvc
ServiceHandle< IIncidentSvc > m_incidentSvc
Definition: TrigSignatureMoni.h:97
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TrigSignatureMoni::m_chainIDToBunchMap
std::map< unsigned int, std::set< std::string > > m_chainIDToBunchMap
Chain ID to bunchgroup name map.
Definition: TrigSignatureMoni.h:117
TrigSignatureMoni::fillDecisionCount
StatusCode fillDecisionCount(const std::vector< TrigCompositeUtils::DecisionID > &, int) const
Definition: TrigSignatureMoni.cxx:237
TrigSignatureMoni::RateHistogram::init
StatusCode init(const std::string &histoName, const std::string &histoTitle, const int x, const int y, const std::string &registerPath, const ServiceHandle< ITHistSvc > &histSvc)
Definition: TrigSignatureMoni.cxx:503
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:52
TrigSignatureMoni::m_sequenceHistogram
RateHistogram m_sequenceHistogram
Definition: TrigSignatureMoni.h:112
TrigSignatureMoni::nSteps
int nSteps() const
Definition: TrigSignatureMoni.cxx:424
HLT::Identifier
Definition: TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h:20
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
TrigSignatureMoni::m_decisionCollectorTools
ToolHandleArray< DecisionCollectorTool > m_decisionCollectorTools
Definition: TrigSignatureMoni.h:105
TrigConf::HLTMenu::size
std::size_t size() const
Accessor to the number of HLT chains.
Definition: HLTMenu.cxx:35
TrigSignatureMoni::m_chainIDToBinMap
std::map< unsigned int, int > m_chainIDToBinMap
Chain id to histogram bin map.
Definition: TrigSignatureMoni.h:114
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:194
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
python.subdetectors.mmg.ids
ids
Definition: mmg.py:8
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
plotBeamSpotVxVal.bin
int bin
Definition: plotBeamSpotVxVal.py:83
TrigSignatureMoni::m_featureCollectorTools
ToolHandleArray< DecisionCollectorTool > m_featureCollectorTools
Definition: TrigSignatureMoni.h:106
TrigConf::DataStructure
Base class for Trigger configuration data and wrapper around underlying representation.
Definition: DataStructure.h:37
TrigSignatureMoni::m_intervals
Gaudi::Property< unsigned int > m_intervals
Definition: TrigSignatureMoni.h:103
TrigSignatureMoni::nBinsX
int nBinsX() const
Definition: TrigSignatureMoni.cxx:412
AthenaInterprocess::UpdateAfterFork::type
static const std::string & type()
Incident type.
Definition: Incidents.h:49
TrigSignatureMoni::m_nameToBinMap
std::map< std::string, int > m_nameToBinMap
Sequence/group/bunchgroup name to bin map.
Definition: TrigSignatureMoni.h:115
python.PyAthena.v
v
Definition: PyAthena.py:157
TrigCompositeUtils::isLegId
bool isLegId(const HLT::Identifier &legIdentifier)
Recognise whether the chain ID is a leg ID.
Definition: TrigCompositeUtilsRoot.cxx:204
DeMoScan.index
string index
Definition: DeMoScan.py:362
AthenaPoolExample_Copy.streamName
string streamName
Definition: AthenaPoolExample_Copy.py:39
TrigCompositeUtils::DecisionIDContainer
std::set< DecisionID > DecisionIDContainer
Definition: TrigComposite_v1.h:28
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
y
#define y
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TrigSignatureMoni::m_finalDecisionKey
SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > m_finalDecisionKey
Definition: TrigSignatureMoni.h:93
python.TriggerAPI.TriggerAPISession.chainName
chainName
Definition: TriggerAPISession.py:353
TrigCompositeUtils::decisionIDs
void decisionIDs(const Decision *d, DecisionIDContainer &destination)
Extracts DecisionIDs stored in the Decision object.
Definition: TrigCompositeUtilsRoot.cxx:67
HLT::Identifier::name
std::string name() const
reports human redable name if it is enabled or, empty string
Definition: HLTIdentifier.cxx:14
TrigSignatureMoni::RateHistogram::fill
void fill(const double x, const double y) const
Definition: TrigSignatureMoni.cxx:527
TrigSignatureMoni::nBaseSteps
int nBaseSteps() const
Definition: TrigSignatureMoni.cxx:428
LArCellBinning.step
step
Definition: LArCellBinning.py:158
TrigSignatureMoni::fillPassEvents
StatusCode fillPassEvents(const TrigCompositeUtils::DecisionIDContainer &, int) const
Definition: TrigSignatureMoni.cxx:233
TrigCompositeUtils::getIDFromLeg
HLT::Identifier getIDFromLeg(const HLT::Identifier &legIdentifier)
Generate the HLT::Identifier which corresponds to the chain name from the leg name.
Definition: TrigCompositeUtilsRoot.cxx:180
TrigConf::Chain
HLT chain configuration.
Definition: TrigConfData/TrigConfData/HLTChain.h:18
TrigSignatureMoni::m_duration
Gaudi::Property< unsigned int > m_duration
Definition: TrigSignatureMoni.h:102
TrigSignatureMoni::RateHistogram::stopTimer
void stopTimer()
Definition: TrigSignatureMoni.cxx:537
TrigSignatureMoni::m_bookingPath
Gaudi::Property< std::string > m_bookingPath
Definition: TrigSignatureMoni.h:99
TrigSignatureMoni::m_l1DecisionsKey
SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > m_l1DecisionsKey
Definition: TrigSignatureMoni.h:92
histogram
std::string histogram
Definition: chains.cxx:52
TrigSignatureMoni::m_rateHistogram
RateHistogram m_rateHistogram
Definition: TrigSignatureMoni.h:111
Generated on Tue Jul 2 2024 22:07:21 for ATLAS Offline Software by   doxygen 1.8.18