ATLAS Offline Software
RpcLv1RawDataSectorLogic.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // Package : RpcLv1RawDataSectorLogic
7 // Authors: A. Vest (TU Dresden), C. Rudolph (TU Dresden)
8 // February 2010
9 //
10 // DESCRIPTION:
11 // Subject: RPCLV1-->Sector Logic Offline Muon Data Quality
13 
14 #include "RpcLv1RawDataSectorLogic.h"
15 
16 #include <inttypes.h>
17 
18 #include <sstream>
19 
20 #include "MuonDQAUtils/MuonChamberNameConverter.h"
21 #include "MuonDQAUtils/MuonChambersRange.h"
22 #include "MuonDQAUtils/MuonCosmicSetup.h"
23 #include "MuonDQAUtils/MuonDQAHistMap.h"
24 
25 //***********************************************************************************************************************
26 //***********************************************************************************************************************
27 RpcLv1RawDataSectorLogic::RpcLv1RawDataSectorLogic(const std::string& type,
28  const std::string& name,
29  const IInterface* parent)
30  : ManagedMonitorToolBase(type, name, parent) {
31  declareProperty("LumiblockHist", m_lumiblockhist = false);
32  declareProperty("isMC", m_isMC = false);
33 }
34 
35 //***********************************************************************************************************************
36 StatusCode RpcLv1RawDataSectorLogic::initialize() {
37  // Init message stream
38 
39  ATH_MSG_INFO("In initializing 'RpcLv1RawDataSectorLogic': ");
40 
41  m_rpc_eventstotal = 0;
42  m_rpc_event_inarea = 0;
43  m_nTriggerHits = 0;
44  m_nTriggerHits_out = 0;
45  m_nTriggerHitsperSector = 0;
46  m_Diff_triggerBCid = 0;
47  m_in_triggerBCid = 0;
48  m_out_triggerBCid = 0;
49  m_in_rowinBCid = 0;
50  m_out_rowinBCid = 0;
51  m_Tower_out = 0;
52  m_Tower_in = 0;
53  m_in_sectorid = 0;
54 
55  ATH_CHECK(m_sectorLogicContainerKey.initialize(!m_isMC));
56  ATH_CHECK(m_eventInfo.initialize());
57 
58  // Ignore the checking code
59  ManagedMonitorToolBase::initialize().ignore();
60 
61  return StatusCode::SUCCESS;
62 }
63 
64 //***********************************************************************************************************************
65 StatusCode RpcLv1RawDataSectorLogic::StoreTriggerType() {
66  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfo);
67  ATH_MSG_DEBUG("RpcLv1RawDataSectorLogic::retrieved eventInfo");
68 
69  m_trigtype = eventInfo->level1TriggerType();
70 
71  return StatusCode::SUCCESS;
72 }
73 
74 //***********************************************************************************************************************
75 StatusCode RpcLv1RawDataSectorLogic::fillHistograms() {
76  StatusCode sc = StatusCode::SUCCESS;
77 
78  if (m_environment == AthenaMonManager::tier0 ||
79  m_environment == AthenaMonManager::tier0Raw ||
80  m_environment == AthenaMonManager::online) {
81  ATH_MSG_DEBUG(
82  "RpcLv1RawDataSectorLogic::RPCLV1SectorLogic RawData Monitoring "
83  "Histograms being filled");
84  // Retreive and store trigger type for this event
85  if (StoreTriggerType() != StatusCode::SUCCESS)
86  ATH_MSG_ERROR("Cannot find StoreTriggerType !");
87 
88  ATH_MSG_DEBUG("GetTriggerType(): " << GetTriggerType());
89 
90  // Path for Sector Logic Monitoring
91  std::string generic_path_rpclv1monitoring =
92  "Muon/MuonRawDataMonitoring/RPCLV1SectorLogic";
93 
94  // Sector Logic histogram paths
95  MonGroup rpclv1sl_shift(this,
96  generic_path_rpclv1monitoring + "/Overview",
97  run, ATTRIB_UNMANAGED);
98 
99  if (m_lumiblockhist) {
100  // per lumi block
101  MonGroup rpclv1sl_lumi_block(
102  this, generic_path_rpclv1monitoring + "/lumiblock", lumiBlock,
103  ATTRIB_UNMANAGED);
104 
105  // get histograms
106  // per lumi block
107  sc = rpclv1sl_lumi_block.getHist(
108  m_rpclv1_TriggerHitsperEventperTriggerSector_LB,
109  "SL_TriggerHits_per_Event_per_TriggerSector_LB");
110  if (sc.isFailure())
111  ATH_MSG_WARNING(
112  "SL_TriggerHits_per_Event_per_TriggerSector_LB: Histogram "
113  "could not be associated to MonGroup.");
114  sc = rpclv1sl_lumi_block.getHist(m_rpclv1_Hits_per_TriggerSector_LB,
115  "SL_Hits_per_TriggerSector_LB");
116  if (sc.isFailure())
117  ATH_MSG_WARNING(
118  "SL_Hits_per_TriggerSector_LB: Histogram could not be "
119  "associated to MonGroup.");
120  sc = rpclv1sl_lumi_block.getHist(m_rpclv1_triggerBCid_inout_LB,
121  "SL_triggerBCid_inout_LB");
122  if (sc.isFailure())
123  ATH_MSG_WARNING(
124  "SL_triggerBCid_inout_LB: Histogram could not be "
125  "associated to MonGroup.");
126  }
127 
128  // Overview
129  sc = rpclv1sl_shift.getHist(m_rpclv1_TriggerHitsperEvent,
130  "SL_TriggerHits_per_Event");
131  if (sc.isFailure())
132  ATH_MSG_WARNING(
133  "SL_TriggerHits_per_Event: Histogram could not be associated "
134  "to MonGroup.");
135 
136  sc = rpclv1sl_shift.getHist(
137  m_rpclv1_TriggerHitsperEventperTriggerSector,
138  "SL_TriggerHits_per_Event_per_TriggerSector");
139  if (sc.isFailure())
140  ATH_MSG_WARNING(
141  "SL_TriggerHits_per_Event_per_TriggerSector: Histogram could "
142  "not be associated to MonGroup.");
143 
144  sc = rpclv1sl_shift.getHist(m_rpclv1_Hits_per_TriggerSector,
145  "SL_Hits_per_TriggerSector");
146  if (sc.isFailure())
147  ATH_MSG_WARNING(
148  "SL_Hits_per_TriggerSector: Histogram could not be associated "
149  "to MonGroup.");
150 
151  sc = rpclv1sl_shift.getHist(
152  m_rpclv1_TriggerSector_vs_Pad_triggerBCid_inout,
153  "SL_TriggerSector_vs_Tower_triggerBCid_inout");
154  if (sc.isFailure())
155  ATH_MSG_WARNING(
156  "rpclv1_TriggerSector_vs_Pad_triggerBCid_inout: Histogram "
157  "could not be associated to MonGroup.");
158 
159  sc = rpclv1sl_shift.getHist(m_rpclv1_TriggerSector_vs_Pad,
160  "SL_TriggerSector_vs_Tower");
161  if (sc.isFailure())
162  ATH_MSG_WARNING(
163  "_rpclv1_TriggerSector_vs_Pad: Histogram could not be "
164  "associated to MonGroup.");
165  sc = rpclv1sl_shift.getHist(m_rpclv1_TriggerSector_vs_Pad_Pt1,
166  "SL_TriggerSector_vs_Tower_Pt1");
167  if (sc.isFailure())
168  ATH_MSG_WARNING(
169  "rpclv1_TriggerSector_vs_Pad_Pt1: Histogram could not be "
170  "associated to MonGroup.");
171  sc = rpclv1sl_shift.getHist(m_rpclv1_TriggerSector_vs_Pad_Pt2,
172  "SL_TriggerSector_vs_Tower_Pt2");
173  if (sc.isFailure())
174  ATH_MSG_WARNING(
175  "rpclv1_TriggerSector_vs_Pad_Pt2: Histogram could not be "
176  "associated to MonGroup.");
177  sc = rpclv1sl_shift.getHist(m_rpclv1_TriggerSector_vs_Pad_Pt3,
178  "SL_TriggerSector_vs_Tower_Pt3");
179  if (sc.isFailure())
180  ATH_MSG_WARNING(
181  "rpclv1_TriggerSector_vs_Pad_Pt3: Histogram could not be "
182  "associated to MonGroup.");
183  sc = rpclv1sl_shift.getHist(m_rpclv1_TriggerSector_vs_Pad_Pt4,
184  "SL_TriggerSector_vs_Tower_Pt4");
185  if (sc.isFailure())
186  ATH_MSG_WARNING(
187  "rpclv1_TriggerSector_vs_Pad_Pt4: Histogram could not be "
188  "associated to MonGroup.");
189  sc = rpclv1sl_shift.getHist(m_rpclv1_TriggerSector_vs_Pad_Pt5,
190  "SL_TriggerSector_vs_Tower_Pt5");
191  if (sc.isFailure())
192  ATH_MSG_WARNING(
193  "rpclv1_TriggerSector_vs_Pad_Pt5: Histogram could not be "
194  "associated to MonGroup.");
195  sc = rpclv1sl_shift.getHist(m_rpclv1_TriggerSector_vs_Pad_Pt6,
196  "SL_TriggerSector_vs_Tower_Pt6");
197  if (sc.isFailure())
198  ATH_MSG_WARNING(
199  "rpclv1_TriggerSector_vs_Pad_Pt6: Histogram could not be "
200  "associated to MonGroup.");
201 
202  sc = rpclv1sl_shift.getHist(m_rpclv1_triggerBCid_inout_vs_TriggerSector,
203  "SL_triggerBCid_inout_vs_TriggerSector");
204  if (sc.isFailure())
205  ATH_MSG_WARNING(
206  "SL_triggerBCid_inout_vs_TriggerSector: Histogram could not be "
207  "associated to MonGroup.");
208 
209  sc = rpclv1sl_shift.getHist(m_rpclv1_rowinBCid_vs_TriggerSector,
210  "SL_rowinBCid_vs_TriggerSector");
211  if (sc.isFailure())
212  ATH_MSG_WARNING(
213  "SL_rowinBCid_vs_TriggerSector: Histogram could not be "
214  "associated to MonGroup.");
215  sc = rpclv1sl_shift.getHist(m_rpclv1_triggerBCid_inout_vs_Tower,
216  "SL_triggerBCid_inout_vs_Tower");
217  if (sc.isFailure())
218  ATH_MSG_WARNING(
219  "SL_triggerBCid_inout_vs_Tower: Histogram could not be "
220  "associated to MonGroup.");
221  sc = rpclv1sl_shift.getHist(m_rpclv1_ptid_vs_Tower, "SL_ptid_vs_Tower");
222  if (sc.isFailure())
223  ATH_MSG_WARNING(
224  "SL_ptid_vs_Tower: Histogram could not be associated to "
225  "MonGroup.");
226 
227  sc = rpclv1sl_shift.getHist(m_rpclv1_triggerBCid_inout,
228  "SL_triggerBCid_inout");
229  if (sc.isFailure())
230  ATH_MSG_WARNING(
231  "SL_triggerBCid_inout: Histogram could not be associated to "
232  "MonGroup.");
233 
234  //---------------------------------------
235  // Fill the Sector Logic histograms
236  //---------------------------------------
237 
238  m_nTriggerHits = 0;
239 
240  if (!m_isMC) {
241  // Retrieve the Sector Logic container
242  SG::ReadHandle<RpcSectorLogicContainer> sectorLogicContainer(
243  m_sectorLogicContainerKey);
245  // Loop over the Sector Logic containers //
247  RpcSectorLogicContainer::const_iterator it =
248  sectorLogicContainer->begin();
249  for (; it != sectorLogicContainer->end(); ++it) {
250  int i_sectorid = (*it)->sectorId();
251  m_nTriggerHitsperSector = 0;
252 
253  // Loop over the trigger hits of each sector
254  RpcSectorLogic::const_iterator ithit = (*it)->begin();
255  for (; ithit != (*it)->end(); ++ithit) {
256  // from RpcSLTriggerHit
257  bool b_isInput = (*ithit)->isInput();
258  int i_rowinBcid =
259  (*ithit)->rowinBcid(); // readout window BCid
260  int i_padid = (*ithit)->padId(); // tower
261  int i_ptid = (*ithit)->ptId(); // threshold
262  int i_roi = (*ithit)->roi(); // region of interest
263  int i_triggerBcid = (*ithit)->triggerBcid();
264 
265  m_Diff_triggerBCid = 0;
266  m_in_triggerBCid = 0;
267  m_out_triggerBCid = 0;
268  m_in_rowinBCid = 0;
269  m_out_rowinBCid = 0;
270  m_Tower_in = -1;
271 
272  if (b_isInput == true) {
273  m_nTriggerHits++;
274  m_nTriggerHitsperSector++;
275 
276  // Fill hits per trigger sector histogram
277  m_rpclv1_Hits_per_TriggerSector->Fill(
278  float(i_sectorid));
279  // per lumi block
280  if (m_lumiblockhist)
281  m_rpclv1_Hits_per_TriggerSector_LB->Fill(
282  float(i_sectorid));
283 
284  // Fill Pad vs. tigger sector histograms
285  if (i_sectorid < 32)
286  m_rpclv1_TriggerSector_vs_Pad->Fill(
287  float(-(i_padid + 1)), float(i_sectorid));
288  else
289  m_rpclv1_TriggerSector_vs_Pad->Fill(
290  float((i_padid + 1)), float(i_sectorid - 32));
291 
292  if (i_ptid == 1) {
293  if (i_sectorid < 32)
294  m_rpclv1_TriggerSector_vs_Pad_Pt1->Fill(
295  float(-(i_padid + 1)), float(i_sectorid));
296  else
297  m_rpclv1_TriggerSector_vs_Pad_Pt1->Fill(
298  float((i_padid + 1)),
299  float(i_sectorid - 32));
300  }
301  if (i_ptid == 2) {
302  if (i_sectorid < 32)
303  m_rpclv1_TriggerSector_vs_Pad_Pt2->Fill(
304  float(-(i_padid + 1)), float(i_sectorid));
305  else
306  m_rpclv1_TriggerSector_vs_Pad_Pt2->Fill(
307  float((i_padid + 1)),
308  float(i_sectorid - 32));
309  }
310  if (i_ptid == 3) {
311  if (i_sectorid < 32)
312  m_rpclv1_TriggerSector_vs_Pad_Pt3->Fill(
313  float(-(i_padid + 1)), float(i_sectorid));
314  else
315  m_rpclv1_TriggerSector_vs_Pad_Pt3->Fill(
316  float((i_padid + 1)),
317  float(i_sectorid - 32));
318  }
319  if (i_ptid == 4) {
320  if (i_sectorid < 32)
321  m_rpclv1_TriggerSector_vs_Pad_Pt4->Fill(
322  float(-(i_padid + 1)), float(i_sectorid));
323  else
324  m_rpclv1_TriggerSector_vs_Pad_Pt4->Fill(
325  float((i_padid + 1)),
326  float(i_sectorid - 32));
327  }
328  if (i_ptid == 5) {
329  if (i_sectorid < 32)
330  m_rpclv1_TriggerSector_vs_Pad_Pt5->Fill(
331  float(-(i_padid + 1)), float(i_sectorid));
332  else
333  m_rpclv1_TriggerSector_vs_Pad_Pt5->Fill(
334  float((i_padid + 1)),
335  float(i_sectorid - 32));
336  }
337  if (i_ptid == 6) {
338  if (i_sectorid < 32)
339  m_rpclv1_TriggerSector_vs_Pad_Pt6->Fill(
340  float(-(i_padid + 1)), float(i_sectorid));
341  else
342  m_rpclv1_TriggerSector_vs_Pad_Pt6->Fill(
343  float((i_padid + 1)),
344  float(i_sectorid - 32));
345  }
346 
347  // Fill trigger sector vs. rowin BCid histogram
348  m_rpclv1_rowinBCid_vs_TriggerSector->Fill(
349  float(i_sectorid), float(i_rowinBcid));
350 
351  // Fill Threshold vs. Pad(Tower) histogram
352  m_rpclv1_ptid_vs_Tower->Fill(float(i_padid),
353  float(i_ptid));
354 
355  // Trigger BCid in
356  m_in_triggerBCid = i_triggerBcid;
357  // ReadOutWindow BCid in
358  m_in_rowinBCid = i_rowinBcid;
359 
360  // Tower in
361  m_Tower_in = i_padid;
362 
363  m_Tower_out = -1;
364  // Loop over the trigger hits of each sector
365  RpcSectorLogic::const_iterator ithiti = (*it)->begin();
366  for (; ithiti != (*it)->end(); ++ithiti) {
367  bool b_isInput1 = (*ithiti)->isInput();
368  int i_roi1 =
369  (*ithiti)->roi(); // region of interest
370  int i_triggerBcid1 = (*ithiti)->triggerBcid();
371  int i_rowinBcid1 = (*ithiti)->rowinBcid();
372  if (b_isInput1 == false) {
373  // Tower out calculated from ROI out
374  if (i_roi1 < 4)
375  m_Tower_out = 0;
376  if (i_roi1 >= 4 && i_roi < 8)
377  m_Tower_out = 1;
378  if (i_roi1 >= 8 && i_roi < 12)
379  m_Tower_out = 2;
380  if (i_roi1 >= 12 && i_roi < 16)
381  m_Tower_out = 3;
382  if (i_roi1 >= 16 && i_roi < 20)
383  m_Tower_out = 4;
384  if (i_roi1 >= 20 && i_roi < 24)
385  m_Tower_out = 5;
386  if (i_roi1 >= 24)
387  m_Tower_out = 6;
388 
389  // Trigger BCid out
390  m_out_triggerBCid = i_triggerBcid1;
391  // ReadOutWindow BCid in
392  m_out_rowinBCid = i_rowinBcid1;
393 
394  // Calculate Timing difference in trigger BCid
395  if ((m_Tower_out == m_Tower_in) &&
396  (m_out_rowinBCid == m_in_rowinBCid)) {
397  if (m_in_triggerBCid - m_out_triggerBCid >=
398  0)
399  m_Diff_triggerBCid = m_in_triggerBCid -
400  m_out_triggerBCid;
401  else
402  m_Diff_triggerBCid =
403  (m_in_triggerBCid -
404  m_out_triggerBCid) +
405  8;
406  }
407  }
408  }
409  }
410 
411  // Fill in/out dependent histograms & histograms with timing
412  // difference only for IN
413  if (b_isInput == true) {
414  m_rpclv1_triggerBCid_inout_vs_Tower->Fill(
415  float(m_Tower_out), float(m_Diff_triggerBCid));
416 
417  // if (i_padid == 0){
418  m_rpclv1_triggerBCid_inout_vs_TriggerSector->Fill(
419  float(i_sectorid), float(m_Diff_triggerBCid));
420  m_rpclv1_triggerBCid_inout->Fill(
421  float(m_Diff_triggerBCid));
422  // per lumi block
423  if (m_lumiblockhist)
424  m_rpclv1_triggerBCid_inout_LB->Fill(
425  float(m_Diff_triggerBCid));
426  // }
427 
428  if (i_sectorid < 32)
429  m_rpclv1_TriggerSector_vs_Pad_triggerBCid_inout
430  ->Fill(float(-(i_padid + 1)), float(i_sectorid),
431  float(m_Diff_triggerBCid));
432  else
433  m_rpclv1_TriggerSector_vs_Pad_triggerBCid_inout
434  ->Fill(float((i_padid + 1)),
435  float(i_sectorid - 32),
436  float(m_Diff_triggerBCid));
437  }
438 
439  } // End Loop over the trigger hits of each sector
440 
441  // Fill the trigger hits per event per sector histogram here
442  if (m_nTriggerHitsperSector > 0) {
443  m_rpclv1_TriggerHitsperEventperTriggerSector->Fill(
444  float(i_sectorid), float(m_nTriggerHitsperSector));
445  // per lumi block
446  if (m_lumiblockhist)
447  m_rpclv1_TriggerHitsperEventperTriggerSector_LB->Fill(
448  float(i_sectorid), float(m_nTriggerHitsperSector));
449  }
450 
451  } // End Loop over the Sector Logic containers
452  }
453 
454  // Fill the trigger hits per event histogram here
455  m_rpclv1_TriggerHitsperEvent->Fill(float(m_nTriggerHits));
456 
457  } // AthenaMonManager::tier0 || AthenaMonManager::tier0Raw
458 
459  return sc;
460 }
461 
462 //***********************************************************************************************************************
463 StatusCode RpcLv1RawDataSectorLogic::bookHistogramsRecurrent() {
464  ATH_MSG_DEBUG("Booking Histograms for RPC RawData Sector Logic Monitoring");
465 
466  StatusCode sc = StatusCode::SUCCESS;
467 
468  if (m_environment == AthenaMonManager::tier0 ||
469  m_environment == AthenaMonManager::tier0Raw ||
470  m_environment == AthenaMonManager::online) {
471  // Declare the Sector Logic histograms
472  std::string generic_path_rpclv1monitoring =
473  "Muon/MuonRawDataMonitoring/RPCLV1SectorLogic";
474 
475  MonGroup rpclv1sl_shift(this,
476  generic_path_rpclv1monitoring + "/Overview",
477  run, ATTRIB_UNMANAGED);
478 
479  if (newLumiBlockFlag() && m_lumiblockhist) {
480  MonGroup rpclv1sl_lumi_block(
481  this, generic_path_rpclv1monitoring + "/lumiblock", lumiBlock,
482  ATTRIB_UNMANAGED);
483  ATH_MSG_DEBUG("RUN : " << run);
484  ATH_MSG_DEBUG("LumiBlock : " << lumiBlock);
485 
486  //_____________________________________________________________________
487  // Sector logic statistics
488 
489  std::string rpclv1_Hits_per_TriggerSector_LB_title =
490  "SL_Hits_per_TriggerSector_LB";
491  const char* rpclv1_Hits_per_TriggerSector_LB_title_char =
492  rpclv1_Hits_per_TriggerSector_LB_title.c_str();
493 
494  TH1* rpclv1_Hits_per_TriggerSector_LB = new TH1I(
495  rpclv1_Hits_per_TriggerSector_LB_title_char,
496  rpclv1_Hits_per_TriggerSector_LB_title_char, 64, 0, 64);
497 
498  ATH_CHECK(
499  rpclv1sl_lumi_block.regHist(rpclv1_Hits_per_TriggerSector_LB));
500  rpclv1_Hits_per_TriggerSector_LB->SetFillColor(9);
501  rpclv1_Hits_per_TriggerSector_LB->GetXaxis()->SetTitle(
502  "RPC trigger sector");
503  rpclv1_Hits_per_TriggerSector_LB->GetYaxis()->SetTitle(
504  "Counts per trigger sector");
505 
506  ATH_MSG_DEBUG("INSIDE bookHistograms successfully: "
507  << rpclv1_Hits_per_TriggerSector_LB);
508 
509  //_____________________________________________________________________
510  // Trigger hits per event per Trigger Sector
511  std::string rpclv1_TriggerHitsperEventperTriggerSector_LB_title =
512  "SL_TriggerHits_per_Event_per_TriggerSector_LB";
513  const char*
514  rpclv1_TriggerHitsperEventperTriggerSector_LB_title_char =
515  rpclv1_TriggerHitsperEventperTriggerSector_LB_title.c_str();
516 
517  // Create Histogram
518  TH2* rpclv1_TriggerHitsperEventperTriggerSector_LB = new TH2I(
519  rpclv1_TriggerHitsperEventperTriggerSector_LB_title_char,
520  rpclv1_TriggerHitsperEventperTriggerSector_LB_title_char, 64, 0,
521  64, 30, -0.5, 29.5);
522 
523  ATH_CHECK(rpclv1sl_lumi_block.regHist(
524  rpclv1_TriggerHitsperEventperTriggerSector_LB));
525  rpclv1_TriggerHitsperEventperTriggerSector_LB->SetOption("COLZ");
526  rpclv1_TriggerHitsperEventperTriggerSector_LB->GetXaxis()->SetTitle(
527  "RPC trigger sector");
528  rpclv1_TriggerHitsperEventperTriggerSector_LB->GetYaxis()->SetTitle(
529  "RPC trigger hits / event");
530 
531  ATH_MSG_DEBUG("INSIDE bookHistograms successfully: "
532  << rpclv1_TriggerHitsperEventperTriggerSector_LB);
533 
534  //_____________________________________________________________________
535  // trigger BCid in vs. out per Lumi Block
536 
537  std::string rpclv1_triggerBCid_inout_LB_title =
538  "SL_triggerBCid_inout_LB";
539  const char* rpclv1_triggerBCid_inout_LB_title_char =
540  rpclv1_triggerBCid_inout_LB_title.c_str();
541 
542  TH1* rpclv1_triggerBCid_inout_LB =
543  new TH1I(rpclv1_triggerBCid_inout_LB_title_char,
544  rpclv1_triggerBCid_inout_LB_title_char, 8, 0, 8);
545 
546  ATH_CHECK(rpclv1sl_lumi_block.regHist(rpclv1_triggerBCid_inout_LB));
547  rpclv1_triggerBCid_inout_LB->SetFillColor(9);
548  rpclv1_triggerBCid_inout_LB->GetXaxis()->SetTitle(
549  "triggerBCid (in - out)");
550  rpclv1_triggerBCid_inout_LB->GetYaxis()->SetTitle("Counts");
551 
552  ATH_MSG_DEBUG("INSIDE bookHistograms successfully: "
553  << rpclv1_triggerBCid_inout_LB
554  << rpclv1_triggerBCid_inout_LB_title.c_str());
555 
556  } // isNewLumiBlock
557 
558  if (newRunFlag()) {
559  ATH_MSG_DEBUG("RUN : " << run);
560 
561  //_____________________________________________________________________
562  // rowin BCid vs Trigger Sector
563  std::string rpclv1_rowinBCid_vs_TriggerSector_title =
564  "SL_rowinBCid_vs_TriggerSector";
565  const char* rpclv1_rowinBCid_vs_TriggerSector_title_char =
566  rpclv1_rowinBCid_vs_TriggerSector_title.c_str();
567 
568  TH2* rpclv1_rowinBCid_vs_TriggerSector =
569  new TH2I(rpclv1_rowinBCid_vs_TriggerSector_title_char,
570  rpclv1_rowinBCid_vs_TriggerSector_title_char, 64, 0,
571  64, 8, 0, 8);
572 
573  ATH_CHECK(
574  rpclv1sl_shift.regHist(rpclv1_rowinBCid_vs_TriggerSector));
575  rpclv1_rowinBCid_vs_TriggerSector->GetXaxis()->SetTitle(
576  "RPC trigger sector");
577  rpclv1_rowinBCid_vs_TriggerSector->GetYaxis()->SetTitle(
578  "rowinBCid");
579  rpclv1_rowinBCid_vs_TriggerSector->SetOption("COLZ");
580 
581  ATH_MSG_DEBUG("INSIDE bookHistograms successfully: "
582  << rpclv1_rowinBCid_vs_TriggerSector
583  << rpclv1_rowinBCid_vs_TriggerSector_title.c_str());
584 
585  //_____________________________________________________________________
586  // trigger BCid (in - out) vs Tower
587  std::string rpclv1_triggerBCid_inout_vs_Tower_title =
588  "SL_triggerBCid_inout_vs_Tower";
589  const char* rpclv1_triggerBCid_inout_vs_Tower_title_char =
590  rpclv1_triggerBCid_inout_vs_Tower_title.c_str();
591 
592  TH2* rpclv1_triggerBCid_inout_vs_Tower = new TH2I(
593  rpclv1_triggerBCid_inout_vs_Tower_title_char,
594  rpclv1_triggerBCid_inout_vs_Tower_title_char, 8, 0, 8, 8, 0, 8);
595 
596  ATH_CHECK(
597  rpclv1sl_shift.regHist(rpclv1_triggerBCid_inout_vs_Tower));
598  rpclv1_triggerBCid_inout_vs_Tower->GetXaxis()->SetTitle("Tower");
599  rpclv1_triggerBCid_inout_vs_Tower->GetYaxis()->SetTitle(
600  "triggerBCid (in - out)");
601  rpclv1_triggerBCid_inout_vs_Tower->SetOption("COLZ");
602 
603  ATH_MSG_DEBUG("INSIDE bookHistograms successfully: "
604  << rpclv1_triggerBCid_inout_vs_Tower
605  << rpclv1_triggerBCid_inout_vs_Tower_title.c_str());
606 
607  //_____________________________________________________________________
608  // Sector logic statistics
609 
610  std::string rpclv1_Hits_per_TriggerSector_title =
611  "SL_Hits_per_TriggerSector";
612  const char* rpclv1_Hits_per_TriggerSector_title_char =
613  rpclv1_Hits_per_TriggerSector_title.c_str();
614 
615  TH1* rpclv1_Hits_per_TriggerSector =
616  new TH1I(rpclv1_Hits_per_TriggerSector_title_char,
617  rpclv1_Hits_per_TriggerSector_title_char, 64, 0, 64);
618 
619  ATH_CHECK(rpclv1sl_shift.regHist(rpclv1_Hits_per_TriggerSector));
620  rpclv1_Hits_per_TriggerSector->SetFillColor(9);
621  rpclv1_Hits_per_TriggerSector->GetXaxis()->SetTitle(
622  "RPC trigger sector");
623  rpclv1_Hits_per_TriggerSector->GetYaxis()->SetTitle(
624  "Counts per trigger sector");
625 
626  ATH_MSG_DEBUG("INSIDE bookHistograms successfully: "
627  << rpclv1_Hits_per_TriggerSector);
628 
629  //_____________________________________________________________________
630  // Trigger hits per event
631  std::string rpclv1_TriggerHitsperEvent_title =
632  "SL_TriggerHits_per_Event";
633  const char* rpclv1_TriggerHitsperEvent_title_char =
634  rpclv1_TriggerHitsperEvent_title.c_str();
635 
636  // Create Histogram
637  TH1* rpclv1_TriggerHitsperEvent =
638  new TH1I(rpclv1_TriggerHitsperEvent_title_char,
639  rpclv1_TriggerHitsperEvent_title_char, 30, -0.5, 29.5);
640 
641  ATH_CHECK(rpclv1sl_shift.regHist(rpclv1_TriggerHitsperEvent));
642  rpclv1_TriggerHitsperEvent->SetFillColor(9);
643  rpclv1_TriggerHitsperEvent->GetXaxis()->SetTitle(
644  "RPC trigger hits / event");
645  rpclv1_TriggerHitsperEvent->GetYaxis()->SetTitle("Counts");
646 
647  ATH_MSG_DEBUG("INSIDE bookHistograms successfully: "
648  << rpclv1_TriggerHitsperEvent);
649 
650  //_____________________________________________________________________
651  // Trigger hits per event per Trigger Sector
652  std::string rpclv1_TriggerHitsperEventperTriggerSector_title =
653  "SL_TriggerHits_per_Event_per_TriggerSector";
654  const char* rpclv1_TriggerHitsperEventperTriggerSector_title_char =
655  rpclv1_TriggerHitsperEventperTriggerSector_title.c_str();
656 
657  // Create Histogram
658  TH2* rpclv1_TriggerHitsperEventperTriggerSector =
659  new TH2I(rpclv1_TriggerHitsperEventperTriggerSector_title_char,
660  rpclv1_TriggerHitsperEventperTriggerSector_title_char,
661  64, 0, 64, 30, -0.5, 29.5);
662 
663  ATH_CHECK(rpclv1sl_shift.regHist(
664  rpclv1_TriggerHitsperEventperTriggerSector));
665  rpclv1_TriggerHitsperEventperTriggerSector->SetOption("COLZ");
666  rpclv1_TriggerHitsperEventperTriggerSector->GetXaxis()->SetTitle(
667  "RPC trigger sector");
668  rpclv1_TriggerHitsperEventperTriggerSector->GetYaxis()->SetTitle(
669  "RPC trigger hits / event");
670 
671  ATH_MSG_DEBUG("INSIDE bookHistograms successfully: "
672  << rpclv1_TriggerHitsperEventperTriggerSector);
673 
674  //_____________________________________________________________________
675  // TriggerSector_vs_Tower
676 
677  std::string rpclv1_TriggerSector_vs_Pad_triggerBCid_inout_title =
678  "SL_TriggerSector_vs_Tower_triggerBCid_inout";
679  const char*
680  rpclv1_TriggerSector_vs_Pad_triggerBCid_inout_title_char =
681  rpclv1_TriggerSector_vs_Pad_triggerBCid_inout_title.c_str();
682 
683  TH2* rpclv1_TriggerSector_vs_Pad_triggerBCid_inout = new TH2I(
684  rpclv1_TriggerSector_vs_Pad_triggerBCid_inout_title_char,
685  rpclv1_TriggerSector_vs_Pad_triggerBCid_inout_title_char, 17,
686  -8.5, 8.5, 32, 0, 32);
687 
688  ATH_CHECK(rpclv1sl_shift.regHist(
689  rpclv1_TriggerSector_vs_Pad_triggerBCid_inout));
690  rpclv1_TriggerSector_vs_Pad_triggerBCid_inout->SetOption("COLZ");
691  rpclv1_TriggerSector_vs_Pad_triggerBCid_inout->GetXaxis()->SetTitle(
692  "Tower");
693  rpclv1_TriggerSector_vs_Pad_triggerBCid_inout->GetYaxis()->SetTitle(
694  "RPC trigger sector");
695 
696  ATH_MSG_DEBUG("INSIDE bookHistograms successfully: "
697  << rpclv1_TriggerSector_vs_Pad_triggerBCid_inout);
698 
699  //_____________________________________________________________________
700  // TriggerSector_vs_Tower
701 
702  std::string rpclv1_TriggerSector_vs_Pad_title =
703  "SL_TriggerSector_vs_Tower";
704  const char* rpclv1_TriggerSector_vs_Pad_title_char =
705  rpclv1_TriggerSector_vs_Pad_title.c_str();
706 
707  TH2* rpclv1_TriggerSector_vs_Pad =
708  new TH2I(rpclv1_TriggerSector_vs_Pad_title_char,
709  rpclv1_TriggerSector_vs_Pad_title_char, 17, -8.5, 8.5,
710  32, 0, 32);
711 
712  ATH_CHECK(rpclv1sl_shift.regHist(rpclv1_TriggerSector_vs_Pad));
713  rpclv1_TriggerSector_vs_Pad->SetOption("COLZ");
714  rpclv1_TriggerSector_vs_Pad->GetXaxis()->SetTitle("Tower");
715  rpclv1_TriggerSector_vs_Pad->GetYaxis()->SetTitle(
716  "RPC trigger sector");
717 
718  ATH_MSG_DEBUG("INSIDE bookHistograms successfully: "
719  << rpclv1_TriggerSector_vs_Pad);
720 
721  //_____________________________________________________________________
722  // TriggerSector_vs_Tower_Pt1
723  std::string rpclv1_TriggerSector_vs_Pad_Pt1_title =
724  "SL_TriggerSector_vs_Tower_Pt1";
725  const char* rpclv1_TriggerSector_vs_Pad_Pt1_title_char =
726  rpclv1_TriggerSector_vs_Pad_Pt1_title.c_str();
727 
728  TH2* rpclv1_TriggerSector_vs_Pad_Pt1 =
729  new TH2I(rpclv1_TriggerSector_vs_Pad_Pt1_title_char,
730  rpclv1_TriggerSector_vs_Pad_Pt1_title_char, 17, -8.5,
731  8.5, 32, 0, 32);
732 
733  ATH_CHECK(rpclv1sl_shift.regHist(rpclv1_TriggerSector_vs_Pad_Pt1));
734  rpclv1_TriggerSector_vs_Pad_Pt1->SetOption("COLZ");
735  rpclv1_TriggerSector_vs_Pad_Pt1->GetXaxis()->SetTitle("Tower");
736  rpclv1_TriggerSector_vs_Pad_Pt1->GetYaxis()->SetTitle(
737  "RPC trigger sector");
738 
739  // TriggerSector_vs_Tower_Pt2
740  std::string rpclv1_TriggerSector_vs_Pad_Pt2_title =
741  "SL_TriggerSector_vs_Tower_Pt2";
742  const char* rpclv1_TriggerSector_vs_Pad_Pt2_title_char =
743  rpclv1_TriggerSector_vs_Pad_Pt2_title.c_str();
744 
745  TH2* rpclv1_TriggerSector_vs_Pad_Pt2 =
746  new TH2I(rpclv1_TriggerSector_vs_Pad_Pt2_title_char,
747  rpclv1_TriggerSector_vs_Pad_Pt2_title_char, 17, -8.5,
748  8.5, 32, 0, 32);
749 
750  ATH_CHECK(rpclv1sl_shift.regHist(rpclv1_TriggerSector_vs_Pad_Pt2));
751  rpclv1_TriggerSector_vs_Pad_Pt2->SetOption("COLZ");
752  rpclv1_TriggerSector_vs_Pad_Pt2->GetXaxis()->SetTitle("Tower");
753  rpclv1_TriggerSector_vs_Pad_Pt2->GetYaxis()->SetTitle(
754  "RPC trigger sector");
755 
756  // TriggerSector_vs_Tower_Pt3
757  std::string rpclv1_TriggerSector_vs_Pad_Pt3_title =
758  "SL_TriggerSector_vs_Tower_Pt3";
759  const char* rpclv1_TriggerSector_vs_Pad_Pt3_title_char =
760  rpclv1_TriggerSector_vs_Pad_Pt3_title.c_str();
761 
762  TH2* rpclv1_TriggerSector_vs_Pad_Pt3 =
763  new TH2I(rpclv1_TriggerSector_vs_Pad_Pt3_title_char,
764  rpclv1_TriggerSector_vs_Pad_Pt3_title_char, 17, -8.5,
765  8.5, 32, 0, 32);
766 
767  ATH_CHECK(rpclv1sl_shift.regHist(rpclv1_TriggerSector_vs_Pad_Pt3));
768  rpclv1_TriggerSector_vs_Pad_Pt3->SetOption("COLZ");
769  rpclv1_TriggerSector_vs_Pad_Pt3->GetXaxis()->SetTitle("Tower");
770  rpclv1_TriggerSector_vs_Pad_Pt3->GetYaxis()->SetTitle(
771  "RPC trigger sector");
772 
773  // TriggerSector_vs_Tower_Pt4
774  std::string rpclv1_TriggerSector_vs_Pad_Pt4_title =
775  "SL_TriggerSector_vs_Tower_Pt4";
776  const char* rpclv1_TriggerSector_vs_Pad_Pt4_title_char =
777  rpclv1_TriggerSector_vs_Pad_Pt4_title.c_str();
778 
779  TH2* rpclv1_TriggerSector_vs_Pad_Pt4 =
780  new TH2I(rpclv1_TriggerSector_vs_Pad_Pt4_title_char,
781  rpclv1_TriggerSector_vs_Pad_Pt4_title_char, 17, -8.5,
782  8.5, 32, 0, 32);
783 
784  ATH_CHECK(rpclv1sl_shift.regHist(rpclv1_TriggerSector_vs_Pad_Pt4));
785  rpclv1_TriggerSector_vs_Pad_Pt4->SetOption("COLZ");
786  rpclv1_TriggerSector_vs_Pad_Pt4->GetXaxis()->SetTitle("Tower");
787  rpclv1_TriggerSector_vs_Pad_Pt4->GetYaxis()->SetTitle(
788  "RPC trigger sector");
789 
790  // TriggerSector_vs_Tower_Pt5
791  std::string rpclv1_TriggerSector_vs_Pad_Pt5_title =
792  "SL_TriggerSector_vs_Tower_Pt5";
793  const char* rpclv1_TriggerSector_vs_Pad_Pt5_title_char =
794  rpclv1_TriggerSector_vs_Pad_Pt5_title.c_str();
795 
796  TH2* rpclv1_TriggerSector_vs_Pad_Pt5 =
797  new TH2I(rpclv1_TriggerSector_vs_Pad_Pt5_title_char,
798  rpclv1_TriggerSector_vs_Pad_Pt5_title_char, 17, -8.5,
799  8.5, 32, 0, 32);
800 
801  ATH_CHECK(rpclv1sl_shift.regHist(rpclv1_TriggerSector_vs_Pad_Pt5));
802  rpclv1_TriggerSector_vs_Pad_Pt5->SetOption("COLZ");
803  rpclv1_TriggerSector_vs_Pad_Pt5->GetXaxis()->SetTitle("Tower");
804  rpclv1_TriggerSector_vs_Pad_Pt5->GetYaxis()->SetTitle(
805  "RPC trigger sector");
806 
807  // TriggerSector_vs_Tower_Pt6
808  std::string rpclv1_TriggerSector_vs_Pad_Pt6_title =
809  "SL_TriggerSector_vs_Tower_Pt6";
810  const char* rpclv1_TriggerSector_vs_Pad_Pt6_title_char =
811  rpclv1_TriggerSector_vs_Pad_Pt6_title.c_str();
812 
813  TH2* rpclv1_TriggerSector_vs_Pad_Pt6 =
814  new TH2I(rpclv1_TriggerSector_vs_Pad_Pt6_title_char,
815  rpclv1_TriggerSector_vs_Pad_Pt6_title_char, 17, -8.5,
816  8.5, 32, 0, 32);
817 
818  ATH_CHECK(rpclv1sl_shift.regHist(rpclv1_TriggerSector_vs_Pad_Pt6));
819  rpclv1_TriggerSector_vs_Pad_Pt6->SetOption("COLZ");
820  rpclv1_TriggerSector_vs_Pad_Pt6->GetXaxis()->SetTitle("Tower");
821  rpclv1_TriggerSector_vs_Pad_Pt6->GetYaxis()->SetTitle(
822  "RPC trigger sector");
823 
824  //_____________________________________________________________________
825  // trigger BCid in vs. out
826 
827  std::string rpclv1_triggerBCid_inout_vs_TriggerSector_title =
828  "SL_triggerBCid_inout_vs_TriggerSector";
829  const char* rpclv1_triggerBCid_inout_vs_TriggerSector_title_char =
830  rpclv1_triggerBCid_inout_vs_TriggerSector_title.c_str();
831 
832  TH2* rpclv1_triggerBCid_inout_vs_TriggerSector =
833  new TH2I(rpclv1_triggerBCid_inout_vs_TriggerSector_title_char,
834  rpclv1_triggerBCid_inout_vs_TriggerSector_title_char,
835  64, 0, 64, 8, 0, 8);
836 
837  ATH_CHECK(rpclv1sl_shift.regHist(
838  rpclv1_triggerBCid_inout_vs_TriggerSector));
839  rpclv1_triggerBCid_inout_vs_TriggerSector->SetOption("COLZ");
840  rpclv1_triggerBCid_inout_vs_TriggerSector->GetXaxis()->SetTitle(
841  "RPC trigger sector");
842  rpclv1_triggerBCid_inout_vs_TriggerSector->GetYaxis()->SetTitle(
843  "triggerBCid (in - out)");
844 
845  ATH_MSG_DEBUG("INSIDE bookHistograms successfully: "
846  << rpclv1_triggerBCid_inout_vs_TriggerSector);
847 
848  //_____________________________________________________________________
849  // PtID (Threshold)
850 
851  std::string rpclv1_ptid_vs_Tower_title = "SL_ptid_vs_Tower";
852  const char* rpclv1_ptid_vs_Tower_title_char =
853  rpclv1_ptid_vs_Tower_title.c_str();
854 
855  TH2* rpclv1_ptid_vs_Tower =
856  new TH2I(rpclv1_ptid_vs_Tower_title_char,
857  rpclv1_ptid_vs_Tower_title_char, 8, 0, 8, 6, 1, 7);
858 
859  ATH_CHECK(rpclv1sl_shift.regHist(rpclv1_ptid_vs_Tower));
860  rpclv1_ptid_vs_Tower->SetOption("COLZ");
861  rpclv1_ptid_vs_Tower->GetXaxis()->SetTitle("Tower");
862  rpclv1_ptid_vs_Tower->GetYaxis()->SetTitle("Threshold");
863 
864  ATH_MSG_DEBUG("INSIDE bookHistograms successfully: "
865  << rpclv1_ptid_vs_Tower
866  << rpclv1_ptid_vs_Tower_title.c_str());
867 
868  //_____________________________________________________________________
869  // trigger BCid in vs. out
870 
871  std::string rpclv1_triggerBCid_inout_title = "SL_triggerBCid_inout";
872  const char* rpclv1_triggerBCid_inout_title_char =
873  rpclv1_triggerBCid_inout_title.c_str();
874 
875  TH1* rpclv1_triggerBCid_inout =
876  new TH1I(rpclv1_triggerBCid_inout_title_char,
877  rpclv1_triggerBCid_inout_title_char, 8, 0, 8);
878 
879  ATH_CHECK(rpclv1sl_shift.regHist(rpclv1_triggerBCid_inout));
880  rpclv1_triggerBCid_inout->SetFillColor(9);
881  rpclv1_triggerBCid_inout->GetXaxis()->SetTitle(
882  "triggerBCid (in - out)");
883  rpclv1_triggerBCid_inout->GetYaxis()->SetTitle("Counts");
884 
885  ATH_MSG_DEBUG("INSIDE bookHistograms successfully: "
886  << rpclv1_triggerBCid_inout
887  << rpclv1_triggerBCid_inout_title.c_str());
888 
889  } // isNewRun
890 
891  } // AthenaMonManager::tier0 || AthenaMonManager::tier0Raw
892 
893  return sc;
894 }
TH2::Fill
int Fill(double, double)
Definition: rootspy.cxx:382
RpcLv1RawDataSectorLogic::m_sectorLogicContainerKey
SG::ReadHandleKey< RpcSectorLogicContainer > m_sectorLogicContainerKey
Definition: RpcLv1RawDataSectorLogic.h:59
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
RpcLv1RawDataSectorLogic::m_rpclv1_rowinBCid_vs_TriggerSector
TH2 * m_rpclv1_rowinBCid_vs_TriggerSector
Definition: RpcLv1RawDataSectorLogic.h:86
RpcLv1RawDataSectorLogic::initialize
StatusCode initialize()
Definition: RpcLv1RawDataSectorLogic.cxx:36
ManagedMonitorToolBase::lumiBlock
@ lumiBlock
Definition: ManagedMonitorToolBase.h:114
TH1I
Definition: rootspy.cxx:332
RpcLv1RawDataSectorLogic::m_rpclv1_TriggerSector_vs_Pad
TH2 * m_rpclv1_TriggerSector_vs_Pad
Definition: RpcLv1RawDataSectorLogic.h:79
RpcLv1RawDataSectorLogic::m_rpclv1_TriggerHitsperEventperTriggerSector_LB
TH2 * m_rpclv1_TriggerHitsperEventperTriggerSector_LB
Definition: RpcLv1RawDataSectorLogic.h:75
ManagedMonitorToolBase
Provides functionality for users to implement and save histograms, ntuples, and summary data,...
Definition: ManagedMonitorToolBase.h:74
RpcLv1RawDataSectorLogic::m_in_triggerBCid
int m_in_triggerBCid
Definition: RpcLv1RawDataSectorLogic.h:98
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
RpcLv1RawDataSectorLogic::m_rpclv1_Hits_per_TriggerSector_LB
TH1 * m_rpclv1_Hits_per_TriggerSector_LB
Definition: RpcLv1RawDataSectorLogic.h:74
skel.it
it
Definition: skel.GENtoEVGEN.py:423
RpcLv1RawDataSectorLogic::m_isMC
bool m_isMC
Definition: RpcLv1RawDataSectorLogic.h:68
RpcLv1RawDataSectorLogic::m_eventInfo
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo
Definition: RpcLv1RawDataSectorLogic.h:61
RpcLv1RawDataSectorLogic::m_rpclv1_TriggerSector_vs_Pad_Pt2
TH2 * m_rpclv1_TriggerSector_vs_Pad_Pt2
Definition: RpcLv1RawDataSectorLogic.h:81
RpcLv1RawDataSectorLogic::m_trigtype
int m_trigtype
Definition: RpcLv1RawDataSectorLogic.h:57
RpcLv1RawDataSectorLogic::StoreTriggerType
StatusCode StoreTriggerType()
Definition: RpcLv1RawDataSectorLogic.cxx:65
RpcLv1RawDataSectorLogic::m_nTriggerHits
int m_nTriggerHits
Definition: RpcLv1RawDataSectorLogic.h:94
RpcLv1RawDataSectorLogic::GetTriggerType
int GetTriggerType() const
Definition: RpcLv1RawDataSectorLogic.h:56
RpcLv1RawDataSectorLogic::m_out_triggerBCid
int m_out_triggerBCid
Definition: RpcLv1RawDataSectorLogic.h:99
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
MuonChamberNameConverter.h
RpcLv1RawDataSectorLogic.h
RpcLv1RawDataSectorLogic::m_rpclv1_TriggerSector_vs_Pad_Pt5
TH2 * m_rpclv1_TriggerSector_vs_Pad_Pt5
Definition: RpcLv1RawDataSectorLogic.h:84
RpcLv1RawDataSectorLogic::m_rpclv1_TriggerSector_vs_Pad_Pt3
TH2 * m_rpclv1_TriggerSector_vs_Pad_Pt3
Definition: RpcLv1RawDataSectorLogic.h:82
RpcLv1RawDataSectorLogic::m_in_rowinBCid
int m_in_rowinBCid
Definition: RpcLv1RawDataSectorLogic.h:100
RpcLv1RawDataSectorLogic::m_in_sectorid
int m_in_sectorid
Definition: RpcLv1RawDataSectorLogic.h:104
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition: ManagedMonitorToolBase.h:138
RpcLv1RawDataSectorLogic::m_rpclv1_TriggerHitsperEventperTriggerSector
TH2 * m_rpclv1_TriggerHitsperEventperTriggerSector
Definition: RpcLv1RawDataSectorLogic.h:73
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:669
MuonChambersRange.h
AthenaMonManager::tier0
@ tier0
Definition: AthenaMonManager.h:49
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
RpcLv1RawDataSectorLogic::m_rpclv1_TriggerHitsperEvent
TH1 * m_rpclv1_TriggerHitsperEvent
Definition: RpcLv1RawDataSectorLogic.h:72
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TH2I
Definition: rootspy.cxx:410
AthenaMonManager::online
@ online
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::ATTRIB_UNMANAGED
@ ATTRIB_UNMANAGED
Definition: ManagedMonitorToolBase.h:131
test_pyathena.parent
parent
Definition: test_pyathena.py:15
AthenaMonManager::tier0Raw
@ tier0Raw
Definition: AthenaMonManager.h:49
MuonCosmicSetup.h
RpcLv1RawDataSectorLogic::m_rpclv1_Hits_per_TriggerSector
TH1 * m_rpclv1_Hits_per_TriggerSector
Definition: RpcLv1RawDataSectorLogic.h:71
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
run
Definition: run.py:1
RpcLv1RawDataSectorLogic::m_rpclv1_ptid_vs_Tower
TH2 * m_rpclv1_ptid_vs_Tower
Definition: RpcLv1RawDataSectorLogic.h:89
RpcLv1RawDataSectorLogic::m_rpc_event_inarea
int m_rpc_event_inarea
Definition: RpcLv1RawDataSectorLogic.h:65
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
MuonDQAHistMap.h
RpcLv1RawDataSectorLogic::m_nTriggerHitsperSector
int m_nTriggerHitsperSector
Definition: RpcLv1RawDataSectorLogic.h:96
TH1::Fill
int Fill(double)
Definition: rootspy.cxx:285
RpcLv1RawDataSectorLogic::RpcLv1RawDataSectorLogic
RpcLv1RawDataSectorLogic(const std::string &type, const std::string &name, const IInterface *parent)
Definition: RpcLv1RawDataSectorLogic.cxx:27
TH2
Definition: rootspy.cxx:373
ManagedMonitorToolBase::MonGroup::regHist
StatusCode regHist(TH1 *h)
Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical ...
Definition: ManagedMonitorToolBase.cxx:195
ManagedMonitorToolBase::m_environment
AthenaMonManager::Environment_t m_environment
Definition: ManagedMonitorToolBase.h:902
RpcLv1RawDataSectorLogic::m_lumiblockhist
bool m_lumiblockhist
Definition: RpcLv1RawDataSectorLogic.h:67
RpcLv1RawDataSectorLogic::m_rpclv1_triggerBCid_inout_vs_TriggerSector
TH2 * m_rpclv1_triggerBCid_inout_vs_TriggerSector
Definition: RpcLv1RawDataSectorLogic.h:90
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
RpcLv1RawDataSectorLogic::m_Diff_triggerBCid
int m_Diff_triggerBCid
Definition: RpcLv1RawDataSectorLogic.h:97
RpcLv1RawDataSectorLogic::m_rpclv1_TriggerSector_vs_Pad_Pt1
TH2 * m_rpclv1_TriggerSector_vs_Pad_Pt1
Definition: RpcLv1RawDataSectorLogic.h:80
RpcLv1RawDataSectorLogic::m_Tower_in
int m_Tower_in
Definition: RpcLv1RawDataSectorLogic.h:103
RpcLv1RawDataSectorLogic::m_Tower_out
int m_Tower_out
Definition: RpcLv1RawDataSectorLogic.h:102
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
RpcLv1RawDataSectorLogic::m_rpclv1_triggerBCid_inout
TH1 * m_rpclv1_triggerBCid_inout
Definition: RpcLv1RawDataSectorLogic.h:87
ManagedMonitorToolBase::MonGroup::getHist
StatusCode getHist(TH1 *&h, const std::string &hName)
Returns a TH1 via the pointer passed as the first argument.
Definition: ManagedMonitorToolBase.cxx:209
RpcLv1RawDataSectorLogic::m_rpclv1_TriggerSector_vs_Pad_Pt4
TH2 * m_rpclv1_TriggerSector_vs_Pad_Pt4
Definition: RpcLv1RawDataSectorLogic.h:83
RpcLv1RawDataSectorLogic::m_rpclv1_triggerBCid_inout_vs_Tower
TH2 * m_rpclv1_triggerBCid_inout_vs_Tower
Definition: RpcLv1RawDataSectorLogic.h:92
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TH1
Definition: rootspy.cxx:268
RpcLv1RawDataSectorLogic::m_rpclv1_TriggerSector_vs_Pad_triggerBCid_inout
TH2 * m_rpclv1_TriggerSector_vs_Pad_triggerBCid_inout
Definition: RpcLv1RawDataSectorLogic.h:78
RpcLv1RawDataSectorLogic::m_rpc_eventstotal
int m_rpc_eventstotal
Definition: RpcLv1RawDataSectorLogic.h:64
RpcLv1RawDataSectorLogic::m_rpclv1_TriggerSector_vs_Pad_Pt6
TH2 * m_rpclv1_TriggerSector_vs_Pad_Pt6
Definition: RpcLv1RawDataSectorLogic.h:85
RpcLv1RawDataSectorLogic::m_nTriggerHits_out
int m_nTriggerHits_out
Definition: RpcLv1RawDataSectorLogic.h:95
xAOD::EventInfo_v1::level1TriggerType
uint16_t level1TriggerType() const
The Level-1 trigger type.
RpcLv1RawDataSectorLogic::m_out_rowinBCid
int m_out_rowinBCid
Definition: RpcLv1RawDataSectorLogic.h:101
ManagedMonitorToolBase::newLumiBlockFlag
bool newLumiBlockFlag() const
Definition: ManagedMonitorToolBase.h:853
RpcLv1RawDataSectorLogic::fillHistograms
virtual StatusCode fillHistograms()
An inheriting class should either override this function or fillHists().
Definition: RpcLv1RawDataSectorLogic.cxx:75
readCCLHist.float
float
Definition: readCCLHist.py:83
RpcLv1RawDataSectorLogic::bookHistogramsRecurrent
virtual StatusCode bookHistogramsRecurrent()
An inheriting class should either override this function, bookHists() or bookHistograms().
Definition: RpcLv1RawDataSectorLogic.cxx:463
RpcLv1RawDataSectorLogic::m_rpclv1_triggerBCid_inout_LB
TH1 * m_rpclv1_triggerBCid_inout_LB
Definition: RpcLv1RawDataSectorLogic.h:76
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
ManagedMonitorToolBase::newRunFlag
bool newRunFlag() const
Definition: ManagedMonitorToolBase.h:854
Generated on Tue Jul 2 2024 21:25:44 for ATLAS Offline Software by   doxygen 1.8.18