ATLAS Offline Software
RpcLv1RawDataValAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // Package : RpcLv1RawDataValAlg
7 // Authors: N. Benekos(Illinois) - M. Bianco(INFN-Lecce) - G.
8 // Chiodini(INFN-Lecce) - A. Guida (INFN-Lecce) March 2008
9 //
10 // DESCRIPTION:
11 // Subject: RPCLV1-->Offline Muon Data Quality
13 
14 #include "RpcLv1RawDataValAlg.h"
15 
16 #include <inttypes.h>
17 
18 #include <sstream>
19 
20 #include "AthenaMonitoring/AthenaMonManager.h"
21 #include "GaudiKernel/MsgStream.h"
22 #include "MuonDQAUtils/MuonChamberNameConverter.h"
23 #include "MuonDQAUtils/MuonChambersRange.h"
24 #include "MuonDQAUtils/MuonCosmicSetup.h"
25 #include "MuonDQAUtils/MuonDQAHistMap.h"
26 
27 static const int NMAXHIT = 200;
28 
30 
31 RpcLv1RawDataValAlg::RpcLv1RawDataValAlg(const std::string& type,
32  const std::string& name,
33  const IInterface* parent)
34  : ManagedMonitorToolBase(type, name, parent) {
35  // Declare the properties
36  declareProperty("CheckCabling", m_checkCabling = false);
37  declareProperty("RpcLv1File", m_rpclv1file = false);
38  declareProperty("RpcLv1Hist", m_rpclv1hist = false);
39  declareProperty("RpcLv1Prof", m_rpclv1prof = false);
40  declareProperty("RpcLv1ReduceNbins", m_rpclv1reducenbins = 2);
41  declareProperty("ChamberName", m_chamberName = "XXX");
42  declareProperty("StationSize", m_StationSize = "XXX");
43  declareProperty("StationEta", m_StationEta = -100);
44  declareProperty("StationPhi", m_StationPhi = -100);
45  declareProperty("LastEvent", m_lastEvent = 0);
46  declareProperty("Sector", m_sector = 0);
47  declareProperty("CosmicStation", m_cosmicStation = 0);
48  declareProperty("Side", m_side = 0);
49  declareProperty("Clusters", m_doClusters = false);
50  declareProperty("doCoolDB", m_doCoolDB = false);
51 }
52 
53 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
54 
55 StatusCode RpcLv1RawDataValAlg::initialize() {
56  ATH_MSG_INFO("in initializing RpcLv1RawDataValAlg");
57 
58  ATH_MSG_INFO("properties are ");
59  ATH_MSG_INFO("RpcLv1Prof " << m_rpclv1prof);
60  ATH_MSG_INFO("RpcLv1Hist " << m_rpclv1hist);
61  ATH_MSG_INFO("RpcLv1ReduceNbins " << m_rpclv1reducenbins);
62  StatusCode sc;
63 
64  // Initialize the IdHelper
65  StoreGateSvc* detStore = nullptr;
66  sc = service("DetectorStore", detStore);
67  if (sc.isFailure()) {
68  ATH_MSG_FATAL("DetectorStore service not found !");
69  return StatusCode::FAILURE;
70  }
71 
72  // MuonDetectorManager from the conditions store
73  ATH_CHECK(m_DetectorManagerKey.initialize());
74 
75  ATH_CHECK(m_idHelperSvc.retrieve());
76  ATH_CHECK(m_readKey.initialize());
77 
78  std::vector<std::string> hardware_name_list;
79  std::vector<std::string> layer_name_list;
80  std::vector<std::string> layervslayer_name_list;
81  std::vector<std::string> layerPhivsEta_name_list;
82  std::vector<std::string> layerPhivsEtaSector_name_list;
83  hardware_name_list.push_back("XXX");
84 
85  ManagedMonitorToolBase::initialize()
86  .ignore(); // Ignore the checking code;
87 
88  ATH_CHECK(m_eventInfo.initialize());
89  ATH_CHECK(m_rpcRdoKey.initialize());
90 
91  return StatusCode::SUCCESS;
92 }
93 
94 StatusCode RpcLv1RawDataValAlg::StoreTriggerType() {
95  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfo);
96 
97  m_trigtype = eventInfo->level1TriggerType();
98 
99  return StatusCode::SUCCESS;
100 }
101 
102 /*----------------------------------------------------------------------------------*/
103 StatusCode RpcLv1RawDataValAlg::fillHistograms()
104 /*----------------------------------------------------------------------------------*/
105 {
106  StatusCode sc = StatusCode::SUCCESS;
107 
108  if (m_environment == AthenaMonManager::tier0 ||
109  m_environment == AthenaMonManager::tier0Raw ||
110  m_environment == AthenaMonManager::online) {
111  ATH_MSG_DEBUG(
112  "RpcLv1RawDataValAlg::RPCLV1 RawData Monitoring Histograms being "
113  "filled");
114 
115  if (StoreTriggerType() != StatusCode::SUCCESS) {
116  ATH_MSG_ERROR("Could not find StoreTriggerType");
117  } // retreive and store trigger type for this event
118 
119  ATH_MSG_DEBUG("GetTriggerType() " << GetTriggerType());
120 
121  // MuonDetectorManager from the conditions store
122  SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{
123  m_DetectorManagerKey};
124  const MuonGM::MuonDetectorManager* MuonDetMgr =
125  DetectorManagerHandle.cptr();
126  if (!MuonDetMgr) {
127  ATH_MSG_ERROR(
128  "nullptr to the read MuonDetectorManager conditions object");
129  return StatusCode::FAILURE;
130  }
131 
132  int i_triggertimelowpt = -1;
133  int i_triggertimehighpt = -1;
134  int n_triggerlowpt = 0;
135  int n_triggerlowpt_eta = 0;
136  int n_triggerlowpt_phi = 0;
137  int n_triggerhighpt = 0;
138  int n_triggerhighpt_eta = 0;
139  int n_triggerhighpt_phi = 0;
140 
141  int IJKtriggerLowPtPhi = 0;
142  int IJKtriggerLowPtEta = 0;
143  int IJKtriggerHighPtPhi = 0;
144  int IJKtriggerHighPtEta = 0;
145 
146  int nFiredChannels = 0;
147 
148  int PhiOr[64][4][4][32] = {{{{0}}}};
149 
150  // Prepare the retrieval of the RpcPadContainer
151 
152  SG::ReadHandle<RpcPadContainer> rpcRDO(m_rpcRdoKey);
153 
154  // begin loop to get trigger time
155  for (RpcPadContainer::const_iterator rdoColli = rpcRDO->begin();
156  rdoColli != rpcRDO->end(); ++rdoColli) {
157  const RpcPad* rdoColl = *rdoColli;
158  // Now loop on the RDO to find the ones with trigger hits ijk=6
159  if ((rdoColl)->size() != 0) {
160  RpcPad::const_iterator itCM = (rdoColl)->begin();
161  for (; itCM != (rdoColl)->end(); ++itCM) {
162  RpcCoinMatrix::const_iterator itChan = (*itCM)->begin();
163 
164  for (; itChan != (*itCM)->end(); ++itChan) {
165  nFiredChannels++;
166 
167  int i_cmaId = (*itCM)->onlineId();
168  int i_bcId = (*itChan)->bcid();
169  int i_time = (*itChan)->time();
170  int i_ijk = (*itChan)->ijk();
171 
172  if (i_ijk == 6) {
173  if (i_cmaId < 4) {
174  n_triggerlowpt++;
175  i_triggertimelowpt += i_bcId * 8 + i_time;
176  if (i_cmaId < 2) { // i_cmaId==0 || i_cmaId==1
177  n_triggerlowpt_phi++;
178  } else {
179  n_triggerlowpt_eta++;
180  }
181  } else {
182  n_triggerhighpt++;
183  i_triggertimehighpt += i_bcId * 8 + i_time;
184  if (i_cmaId <
185  6) { // i_cmaId==4 || i_cmaId==5
186  n_triggerhighpt_phi++;
187  } else {
188  n_triggerhighpt_eta++;
189  }
190  }
191  }
192  }
193  }
194  }
195  }
196  // end loop to get trigger time
197 
198  if (n_triggerlowpt > 0)
199  i_triggertimelowpt = i_triggertimelowpt / n_triggerlowpt;
200  if (n_triggerhighpt > 0)
201  i_triggertimehighpt = i_triggertimehighpt / n_triggerhighpt;
202 
203  // counts rpc hits
204  std::string generic_path_rpclv1monitoring =
205  "Muon/MuonRawDataMonitoring/RPCLV1";
206 
207  MonGroup rpclv1prd_shift(this,
208  generic_path_rpclv1monitoring + "/Overview",
209  run, ATTRIB_UNMANAGED);
210  MonGroup rpclv1_shift_dqmf(this,
211  generic_path_rpclv1monitoring + "/GLOBAL",
212  run, ATTRIB_UNMANAGED);
213  MonGroup rpcCoolDb(this, generic_path_rpclv1monitoring + "/CoolDB", run,
214  ATTRIB_UNMANAGED);
215 
216  TH1* rpclv1_hitperEvent = nullptr;
217  sc = rpclv1prd_shift.getHist(rpclv1_hitperEvent, "rpclv1_hitperEvent");
218  if (sc.isFailure())
219  ATH_MSG_WARNING(
220  "couldn't register rpclv1_hitperEvent hist to MonGroup");
221  rpclv1_hitperEvent->Fill(float(nFiredChannels));
222 
223  TH1* rpclv1triggerlowpt_etastat = nullptr;
224  sc = rpclv1prd_shift.getHist(rpclv1triggerlowpt_etastat,
225  "Trigger_Hits_LowPt_eta_Stat");
226  if (sc.isFailure())
227  ATH_MSG_WARNING(
228  "couldn't register rpclv1triggerlowpt_etastat hist to "
229  "MonGroup");
230  rpclv1triggerlowpt_etastat->Fill(float(n_triggerlowpt_eta));
231 
232  TH1* rpclv1triggerlowpt_phistat = nullptr;
233  sc = rpclv1prd_shift.getHist(rpclv1triggerlowpt_phistat,
234  "Trigger_Hits_LowPt_phi_Stat");
235  if (sc.isFailure())
236  ATH_MSG_WARNING(
237  "couldn't register rpclv1triggerlowpt_phistat hist to "
238  "MonGroup");
239  rpclv1triggerlowpt_phistat->Fill(float(n_triggerlowpt_phi));
240 
241  TH2* rpclv1triggerlowpt_etaphistat = nullptr;
242  sc = rpclv1prd_shift.getHist(rpclv1triggerlowpt_etaphistat,
243  "Trigger_Hits_Lowpt_etaphi_Stat");
244  if (sc.isFailure())
245  ATH_MSG_WARNING(
246  "couldn't register Trigger_Hits_Lowpt_etaphi_Stat hist to "
247  "MonGroup");
248  rpclv1triggerlowpt_etaphistat->Fill(float(n_triggerlowpt_phi),
249  float(n_triggerlowpt_eta));
250 
251  TH1* rpclv1triggerhighpt_etastat = nullptr;
252  sc = rpclv1prd_shift.getHist(rpclv1triggerhighpt_etastat,
253  "Trigger_Hits_HighPt_eta_Stat");
254  if (sc.isFailure())
255  ATH_MSG_WARNING(
256  "couldn't register rpclv1triggerhighpt_eta_stat hist to "
257  "MonGroup");
258  rpclv1triggerhighpt_etastat->Fill(float(n_triggerhighpt_eta));
259 
260  TH1* rpclv1triggerhighpt_phistat = nullptr;
261  sc = rpclv1prd_shift.getHist(rpclv1triggerhighpt_phistat,
262  "Trigger_Hits_HighPt_phi_Stat");
263  if (sc.isFailure())
264  ATH_MSG_WARNING(
265  "couldn't register rpclv1triggerhighpt_phi_stat hist to "
266  "MonGroup");
267  rpclv1triggerhighpt_phistat->Fill(float(n_triggerhighpt_phi));
268 
269  TH2* rpclv1triggerhighpt_etaphistat = nullptr;
270  sc = rpclv1prd_shift.getHist(rpclv1triggerhighpt_etaphistat,
271  "Trigger_Hits_HighPt_etaphi_Stat");
272  if (sc.isFailure())
273  ATH_MSG_WARNING(
274  "couldn't register Trigger_Hits_HighPt_etaphi_Stat hist to "
275  "MonGroup");
276  rpclv1triggerhighpt_etaphistat->Fill(float(n_triggerhighpt_phi),
277  float(n_triggerhighpt_eta));
278 
279  TH2* rpclv1ROI_LowPt = nullptr;
280  sc = rpclv1prd_shift.getHist(rpclv1ROI_LowPt, "ROI_LowPt_distribution");
281  if (sc.isFailure())
282  ATH_MSG_WARNING(
283  "couldn't register ROI_LowPt_distribution hist to MonGroup");
284 
285  TH2* rpclv1ROI_HighPt = nullptr;
286  sc = rpclv1prd_shift.getHist(rpclv1ROI_HighPt,
287  "ROI_HighPt_distribution");
288  if (sc.isFailure())
289  ATH_MSG_WARNING(
290  "couldn't register ROI_HighPt_distribution hist to MonGroup");
291 
292  TH1* rpclv1sectorlogicstat = nullptr;
293  sc = rpclv1prd_shift.getHist(rpclv1sectorlogicstat,
294  "SLChannel_per_SectorLogic");
295  if (sc.isFailure())
296  ATH_MSG_WARNING(
297  "couldn't register rpclv1sectorlogicstat hist to MonGroup");
298 
299  TH1* rpclv1towervslogicstat = nullptr;
300  sc = rpclv1prd_shift.getHist(rpclv1towervslogicstat,
301  "PadChannel_per_SectorLogic");
302  if (sc.isFailure())
303  ATH_MSG_WARNING(
304  "couldn't register rpclv1towervslogicstat hist to MonGroup");
305 
306  TH2* rpclv1cmalogicstat = nullptr;
307  sc = rpclv1prd_shift.getHist(rpclv1cmalogicstat,
308  "CMChannel_per_SectorLogic");
309  if (sc.isFailure())
310  ATH_MSG_WARNING(
311  "couldn't register rpclv1cmalogicstat hist to MonGroup");
312 
313  TH1* rpclv1_BCid_per_TriggerCorr = nullptr;
314  sc = rpclv1prd_shift.getHist(rpclv1_BCid_per_TriggerCorr,
315  "rpclv1_BCid_per_TriggerCorrelation");
316  if (sc.isFailure())
317  ATH_MSG_WARNING(
318  "couldn't register rpclv1_BCid_per_TriggerCorr hist to "
319  "MonGroup");
320 
321  TH2* rpclv1_BCid_vs_SL = nullptr;
322  sc = rpclv1_shift_dqmf.getHist(rpclv1_BCid_vs_SL,
323  "rpclv1_BCid_vs_SectorLogic");
324  if (sc.isFailure())
325  ATH_MSG_WARNING(
326  "couldn't register rpclv1_BCid_vs_SectorLogic hist to "
327  "MonGroup");
328 
329  TH2* rpclv1_LPt_BCid_vs_SL = nullptr;
330  sc = rpclv1_shift_dqmf.getHist(rpclv1_LPt_BCid_vs_SL,
331  "rpclv1_LPt_BCid_vs_SectorLogic");
332  if (sc.isFailure())
333  ATH_MSG_WARNING(
334  "couldn't register rpclv1_LPt_BCid_vs_SectorLogic hist to "
335  "MonGroup");
336 
337  TH2* rpclv1_HPt_BCid_vs_SL = nullptr;
338  sc = rpclv1_shift_dqmf.getHist(rpclv1_HPt_BCid_vs_SL,
339  "rpclv1_HPt_BCid_vs_SectorLogic");
340  if (sc.isFailure())
341  ATH_MSG_WARNING(
342  "couldn't register rpclv1_HPt_BCid_vs_SectorLogic hist to "
343  "MonGroup");
344 
345  TH1* rpclv1_BCid_per_TriggerType = nullptr;
346  sc = rpclv1_shift_dqmf.getHist(rpclv1_BCid_per_TriggerType,
347  "rpclv1_BCid_per_TriggerType");
348  if (sc.isFailure())
349  ATH_MSG_WARNING(
350  "couldn't register rpclv1_BCid_per_TriggerType hist to "
351  "MonGroup");
352 
353  TH2* rpclv1_TriggerCond_vs_SL = nullptr;
354  sc = rpclv1_shift_dqmf.getHist(rpclv1_TriggerCond_vs_SL,
355  "TriggerCondition_vs_SectorLogic");
356  if (sc.isFailure())
357  ATH_MSG_WARNING(
358  "couldn't register TriggerCondition_vs_SectorLogic hist to "
359  "MonGroup");
360 
361  // logical or
362  TH2* rpclv1_logicalOR_LowPt0 = nullptr;
363  sc = rpclv1prd_shift.getHist(rpclv1_logicalOR_LowPt0,
364  "PhiLogicalOR_LowPt0");
365  if (sc.isFailure())
366  ATH_MSG_WARNING("couldn't get PhiLogicalOR_LowPt0 hist ");
367 
368  TH2* rpclv1_logicalOR_LowPt1 = nullptr;
369  sc = rpclv1prd_shift.getHist(rpclv1_logicalOR_LowPt1,
370  "PhiLogicalOR_LowPt1");
371  if (sc.isFailure())
372  ATH_MSG_WARNING("couldn't get PhiLogicalOR_LowPt1 hist ");
373 
374  TH2* rpclv1_logicalOR_HighPt0 = nullptr;
375  sc = rpclv1prd_shift.getHist(rpclv1_logicalOR_HighPt0,
376  "PhiLogicalOR_HighPt0");
377  if (sc.isFailure())
378  ATH_MSG_WARNING("couldn't get PhiLogicalOR_HighPt0 hist ");
379 
380  TH2* rpclv1_logicalOR_HighPt1 = nullptr;
381  sc = rpclv1prd_shift.getHist(rpclv1_logicalOR_HighPt1,
382  "PhiLogicalOR_HighPt1");
383  if (sc.isFailure())
384  ATH_MSG_WARNING("couldn't get PhiLogicalOR_HighPt1 hist ");
385 
386  TH2* TriggerCondition_vs_CM = nullptr;
387  sc = rpclv1prd_shift.getHist(TriggerCondition_vs_CM,
388  "Trigger_Condition_vs_CM");
389  if (sc.isFailure())
390  ATH_MSG_WARNING("couldn't get TriggerCondition_vs_CM hist ");
391 
392  for (RpcPadContainer::const_iterator rdoColli = rpcRDO->begin();
393  rdoColli != rpcRDO->end(); ++rdoColli) {
394  const RpcPad* rdoColl = *rdoColli;
395  // Now loop on the RDO to find the ones with trigger hits ijk=6
396  if ((rdoColl)->size() != 0) {
397  RpcPad::const_iterator itCM = (rdoColl)->begin();
398  for (; itCM != (rdoColl)->end(); ++itCM) {
399  RpcCoinMatrix::const_iterator itChan = (*itCM)->begin();
400 
401  for (; itChan != (*itCM)->end(); ++itChan) {
402  int i_sector = (rdoColl)->sector();
403  int i_padId = (rdoColl)->onlineId();
404  int i_cmaId = (*itCM)->onlineId();
405  int i_bcId = (*itChan)->bcid();
406  int i_time = (*itChan)->time();
407  int i_ijk = (*itChan)->ijk();
408  int i_channel = (*itChan)->channel();
409  {
410  if (i_ijk == 6) {
411  // look for thresholds ijk=7 in the next rdo's
412  // ijk=6,6...,7 with the same time
413  int i_thr = 99;
414  RpcCoinMatrix::const_iterator itChanThr;
415  int thrskip = 0;
416  for (itChanThr = itChan + 1;
417  itChanThr != (*itCM)->end(); ++itChanThr) {
418  if (thrskip == 1)
419  continue;
420  if ((*itChanThr)->ijk() < 6) {
421  thrskip = 1; // search finish
422  continue;
423  }
424  if ((*itChanThr)->bcid() != i_bcId ||
425  (*itChanThr)->time() != i_time) {
426  thrskip = 1; // error if there are
427  // different timing
428  i_thr = 98;
429  continue;
430  }
431  if ((*itChanThr)->ijk() == 7 &&
432  (*itChanThr)->bcid() == i_bcId &&
433  (*itChanThr)->time() == i_time) {
434  i_thr = (*itChanThr)->thr();
435  thrskip = 1; // search finish
436  continue;
437  }
438  }
439 
440  rpclv1_BCid_per_TriggerCorr->Fill(
441  m_trigtype, i_bcId + 8 * int(i_cmaId / 4));
442 
443  for (int k = 0; k != 8 + 1; k++) {
444  int trigBinType =
445  m_trigtype & int(pow(2, float(k)));
446  if (trigBinType != 0)
447  rpclv1_BCid_per_TriggerType->Fill(
448  k, i_bcId + 8 * int(i_cmaId / 4));
449  }
450 
451  rpclv1_BCid_vs_SL->Fill(
452  i_sector, i_bcId + 8 * int(i_cmaId / 4));
453 
454  if (i_cmaId < 4) {
455  rpclv1_LPt_BCid_vs_SL->Fill(i_sector,
456  i_bcId);
457  } else {
458  rpclv1_HPt_BCid_vs_SL->Fill(i_sector,
459  i_bcId);
460  }
461 
462  // Trigger conditions selection begin
463  int NtriggerLowPtPhi = 0;
464  int NtriggerLowPtEta = 0;
465  int NtriggerHighPtPhi = 0;
466  int NtriggerHighPtEta = 0;
467 
468  IJKtriggerLowPtPhi = 0;
469  IJKtriggerLowPtEta = 0;
470  IJKtriggerHighPtPhi = 0;
471  IJKtriggerHighPtEta = 0;
472 
473  RpcCoinMatrix::const_iterator itChan3 =
474  (*itCM)->begin();
475  for (; itChan3 != (*itCM)->end(); ++itChan3) {
476  int ijk_trigger = (*itChan3)->ijk();
477  if (ijk_trigger > 5)
478  continue;
479 
480  int Layertrigger = ijk_trigger;
481  if (ijk_trigger == 3)
482  Layertrigger = Layertrigger - 1;
483  if (ijk_trigger == 4)
484  Layertrigger = Layertrigger - 1;
485  if (ijk_trigger == 5)
486  Layertrigger = Layertrigger - 2;
487 
488  if (i_cmaId < 2) {
489  IJKtriggerLowPtPhi =
490  IJKtriggerLowPtPhi |
491  int(pow(2, float(Layertrigger)));
492  NtriggerLowPtPhi++;
493  }
494  if (i_cmaId == 2 || i_cmaId == 3) {
495  IJKtriggerLowPtEta =
496  IJKtriggerLowPtEta |
497  int(pow(2, float(Layertrigger)));
498  NtriggerLowPtEta++;
499  }
500  if (i_cmaId == 4 || i_cmaId == 5) {
501  IJKtriggerHighPtPhi =
502  IJKtriggerHighPtPhi |
503  int(pow(2, float(Layertrigger)));
504  NtriggerHighPtPhi++;
505  }
506  if (i_cmaId == 6 || i_cmaId == 7) {
507  IJKtriggerHighPtEta =
508  IJKtriggerHighPtEta |
509  int(pow(2, float(Layertrigger)));
510  NtriggerHighPtEta++;
511  }
512 
513  // trigger road
514  if (!m_rpclv1hist)
515  continue;
516  if (ijk_trigger < 2)
517  continue;
518  int ConfirmCh = (*itChan3)->channel();
519  if (ijk_trigger == 3)
520  ConfirmCh += 32;
521  if (ijk_trigger == 5)
522  ConfirmCh += 32;
523 
524  char sectorlogic_name_char[1000];
525  sprintf(sectorlogic_name_char,
526  "SectorLogic%d", i_sector);
527  std::string sectorlogic_name =
528  sectorlogic_name_char;
529  char tower_name_char[1000];
530  sprintf(tower_name_char, "Tower%d",
531  i_padId);
532  std::string tower_name = tower_name_char;
533  char cma_name_char[1000];
534  sprintf(cma_name_char, "Cma%d", i_cmaId);
535  std::string cma_name = cma_name_char;
536  char thr_name_char[1000];
537  sprintf(thr_name_char, "Thr%d", i_thr);
538  std::string thr_name = thr_name_char;
539 
540  bool histo_flag = true;
541  for (std::vector<
542  std::string>::const_iterator iter =
543  m_sectorlogicTowerCma_name_list2
544  .begin();
545  iter !=
546  m_sectorlogicTowerCma_name_list2.end();
547  ++iter) {
548  if ((sectorlogic_name + tower_name +
549  cma_name + thr_name) == *iter) {
550  histo_flag = false;
551  }
552  }
553  if (histo_flag) {
554  m_sectorlogicTowerCma_name_list2
555  .push_back(sectorlogic_name +
556  tower_name + cma_name +
557  thr_name);
558  ATH_CHECK(
559  bookRPCLV1TriggerRoadHistograms(
560  sectorlogic_name, tower_name,
561  cma_name, thr_name));
562  }
563 
564  const MuonDQAHistList& hists =
565  m_stationHists.getList(
566  sectorlogic_name);
567  TH2* RPCLV1TriggerRoad = hists.getH2(
568  sectorlogic_name + "_" + tower_name +
569  cma_name + thr_name + "_TriggerRoad");
570  if (RPCLV1TriggerRoad) {
571  RPCLV1TriggerRoad->Fill(
572  float(i_channel), float(ConfirmCh));
573  } else {
574  ATH_MSG_DEBUG(
575  "RPCLV1TriggerRoad not in hist "
576  "list!");
577  }
578  }
579 
580  // fill histo Trigger Conditions
581  TH2* rpclv1_TriggerLy_vs_SL = nullptr;
582  sc = rpclv1prd_shift.getHist(
583  rpclv1_TriggerLy_vs_SL,
584  "TriggerLayer_vs_SectorLogic");
585  if (sc.isFailure())
586  ATH_MSG_WARNING(
587  "couldn't get "
588  "TriggerCondition_vs_SectorLogic hist "
589  "to MonGroup");
590 
591  if (NtriggerLowPtPhi > 0) {
592  TH1* rpclv1Trigger_cond_LowPt_phi = nullptr;
593  sc = rpclv1prd_shift.getHist(
594  rpclv1Trigger_cond_LowPt_phi,
595  "Trigger_Condition_LowPt_Phi");
596  if (sc.isFailure())
597  ATH_MSG_WARNING(
598  "couldn't register "
599  "Trigger_Layer_LowPt_Phi hist to "
600  "MonGroup");
601  rpclv1Trigger_cond_LowPt_phi->Fill(
602  float(IJKtriggerLowPtPhi));
603  rpclv1_TriggerLy_vs_SL->Fill(
604  i_sector,
605  IJKtriggerLowPtPhi); // general
606  TriggerCondition_vs_CM->Fill(
607  i_sector * 56 + i_padId * 8 + i_cmaId,
608  IJKtriggerLowPtPhi);
609  }
610  if (NtriggerLowPtEta > 0) {
611  TH1* rpclv1Trigger_cond_LowPt_eta = nullptr;
612  sc = rpclv1prd_shift.getHist(
613  rpclv1Trigger_cond_LowPt_eta,
614  "Trigger_Condition_LowPt_Eta");
615  if (sc.isFailure())
616  ATH_MSG_WARNING(
617  "couldn't "
618  "registerTrigger_Condition_LowPt_"
619  "Eta hist to MonGroup");
620  rpclv1Trigger_cond_LowPt_eta->Fill(
621  float(IJKtriggerLowPtEta));
622  rpclv1_TriggerLy_vs_SL->Fill(
623  i_sector,
624  IJKtriggerLowPtEta); // general
625  TriggerCondition_vs_CM->Fill(
626  i_sector * 56 + i_padId * 8 + i_cmaId,
627  IJKtriggerLowPtEta);
628  }
629  if (NtriggerHighPtPhi > 0) {
630  TH1* rpclv1Trigger_cond_HighPt_phi =
631  nullptr;
632  sc = rpclv1prd_shift.getHist(
633  rpclv1Trigger_cond_HighPt_phi,
634  "Trigger_Condition_HighPt_Phi");
635  if (sc.isFailure())
636  ATH_MSG_WARNING(
637  "couldn't "
638  "registerTrigger_Condition_LowPt_"
639  "Eta hist to MonGroup");
640  rpclv1Trigger_cond_HighPt_phi->Fill(
641  float(IJKtriggerHighPtPhi));
642  rpclv1_TriggerLy_vs_SL->Fill(
643  i_sector,
644  IJKtriggerHighPtPhi + 16); // general
645  TriggerCondition_vs_CM->Fill(
646  i_sector * 56 + i_padId * 8 + i_cmaId,
647  IJKtriggerHighPtPhi);
648  }
649  if (NtriggerHighPtEta > 0) {
650  TH1* rpclv1Trigger_cond_HighPt_eta =
651  nullptr;
652  sc = rpclv1prd_shift.getHist(
653  rpclv1Trigger_cond_HighPt_eta,
654  "Trigger_Condition_HighPt_Eta");
655  if (sc.isFailure())
656  ATH_MSG_WARNING(
657  "couldn't "
658  "registerTrigger_Condition_LowPt_"
659  "Eta hist to MonGroup");
660  rpclv1Trigger_cond_HighPt_eta->Fill(
661  float(IJKtriggerHighPtEta));
662  rpclv1_TriggerLy_vs_SL->Fill(
663  i_sector,
664  IJKtriggerHighPtEta + 16); // general
665  TriggerCondition_vs_CM->Fill(
666  i_sector * 56 + i_padId * 8 + i_cmaId,
667  IJKtriggerHighPtEta);
668  }
669 
670  int n_trigLow_ly = 0;
671  int n_trigHigh_ly = 0;
672  for (int k = 0; k != 4; k++) {
673  if (((IJKtriggerLowPtPhi |
674  IJKtriggerLowPtEta) &
675  int(pow(2, float(k)))) != 0)
676  n_trigLow_ly++;
677  }
678  if (NtriggerLowPtPhi > 0 ||
679  NtriggerLowPtEta > 0) {
680  rpclv1_TriggerCond_vs_SL->Fill(
681  i_sector, n_trigLow_ly);
682  }
683  if (((IJKtriggerHighPtPhi |
684  IJKtriggerHighPtEta) &
685  1) != 0) {
686  for (int k = 2; k != 4; k++) { // k=1
687  if (((IJKtriggerHighPtPhi |
688  IJKtriggerHighPtEta) &
689  int(pow(2, float(k)))) != 0)
690  n_trigHigh_ly++;
691  }
692  if (n_trigHigh_ly == 0) {
693  rpclv1_TriggerCond_vs_SL->Fill(i_sector,
694  5);
695  } // bin 5-> only trigger from LowPt
696  else {
697  rpclv1_TriggerCond_vs_SL->Fill(
698  i_sector, n_trigHigh_ly + 5);
699  }
700  }
701  // Trigger conditions selection end
702 
703  int i_cma_phi = i_cmaId;
704  RpcPad::const_iterator itCM2 =
705  (rdoColl)->begin();
706  for (; itCM2 != (rdoColl)->end(); ++itCM2) {
707  int i_cmaId2 = (*itCM2)->onlineId();
708  int i_cma_eta = i_cmaId2;
709 
710  // RoI and trigger conditions selection
711  // begin
712  if (i_cmaId < 2) { // phi coincidence LowPt
713  if (i_cma_eta == 2 || i_cma_eta == 3) {
714  RpcCoinMatrix::const_iterator
715  itChan2 = (*itCM2)->begin();
716  for (; itChan2 != (*itCM2)->end();
717  ++itChan2) {
718  if ((*itChan2)->ijk() == 6) {
719  int roi =
720  4 * i_padId +
721  i_cma_phi +
722  2 * (i_cma_eta - 2);
723  rpclv1ROI_LowPt->Fill(
724  float(i_sector),
725  float(roi));
726  }
727  }
728  }
729  } else if (i_cmaId == 4 ||
730  i_cmaId ==
731  5) { // phi coincidence
732  // HighPt
733  if (i_cma_eta == 6 || i_cma_eta == 7) {
734  RpcCoinMatrix::const_iterator
735  itChan2 = (*itCM2)->begin();
736  for (; itChan2 != (*itCM2)->end();
737  ++itChan2) {
738  if ((*itChan2)->ijk() == 6) {
739  int roi =
740  4 * i_padId +
741  i_cma_phi - 4 +
742  2 * (i_cma_eta - 6);
743  rpclv1ROI_HighPt->Fill(
744  float(i_sector),
745  float(roi));
746  }
747  }
748  }
749  }
750  // end RoI selection
751 
752  } // end loop on CM2
753 
754  } // end if ijk=6 of i_channel
755 
756  // logical or
757  if (i_ijk > 1 && i_ijk < 6) {
758  if (i_cmaId == 0 || i_cmaId == 1) {
759  PhiOr[i_sector][i_cmaId][i_ijk - 2]
760  [i_channel] =
761  PhiOr[i_sector][i_cmaId][i_ijk - 2]
762  [i_channel] |
763  int(pow(2, float(i_padId)));
764  }
765  if (i_cmaId == 4 || i_cmaId == 5) {
766  PhiOr[i_sector][i_cmaId - 2][i_ijk - 2]
767  [i_channel] =
768  PhiOr[i_sector][i_cmaId - 2]
769  [i_ijk - 2][i_channel] |
770  int(pow(2, float(i_padId)));
771  }
772  }
773  // SL stat
774  rpclv1sectorlogicstat->Fill(float(i_sector));
775 
776  // tower stat
777  rpclv1towervslogicstat->Fill(float(i_sector),
778  float(i_padId));
779 
780  // cma per sector logic
781  rpclv1cmalogicstat->Fill(
782  float(i_sector), float(i_padId * 8 + i_cmaId));
783 
784  char sectorlogic_name_char[1000];
785  sprintf(sectorlogic_name_char, "SectorLogic%d",
786  i_sector);
787  std::string sectorlogic_name =
788  sectorlogic_name_char;
789  char tower_name_char[1000];
790  sprintf(tower_name_char, "Tower%d", i_padId);
791  std::string tower_name = tower_name_char;
792  char cma_name_char[1000];
793  sprintf(cma_name_char, "Cma%d", i_cmaId);
794  std::string cma_name = cma_name_char;
795  char ijk_name_char[1000];
796  sprintf(ijk_name_char, "ijk%d", i_ijk);
797  std::string ijk_name = ijk_name_char;
798 
799  std::string generic_path_RPCLV1cmatimevschcxx =
800  generic_path_rpclv1monitoring + "/" +
801  sectorlogic_name + "/";
802  generic_path_RPCLV1cmatimevschcxx += tower_name;
803  generic_path_RPCLV1cmatimevschcxx +=
804  "/rpclv1cosmic_cmatimevsch";
805  generic_path_RPCLV1cmatimevschcxx += cma_name;
806 
807  std::string
808  generic_path_RPCLV1cmatimetriggervschcxx =
809  generic_path_rpclv1monitoring + "/" +
810  sectorlogic_name + "/";
811  generic_path_RPCLV1cmatimetriggervschcxx +=
812  tower_name;
813  generic_path_RPCLV1cmatimetriggervschcxx +=
814  "/rpclv1cosmic_cmatimetriggervsch";
815  generic_path_RPCLV1cmatimetriggervschcxx +=
816  cma_name;
817 
818  // Fill time histograms begin
819  if (m_rpclv1hist) {
820  bool histo_flag = true;
821  for (std::vector<std::string>::const_iterator
822  iter = m_sectorlogicTowerCma_name_list
823  .begin();
824  iter !=
825  m_sectorlogicTowerCma_name_list.end();
826  ++iter) {
827  if ((sectorlogic_name + tower_name +
828  cma_name) == *iter) {
829  histo_flag = false;
830  }
831  }
832  if (histo_flag) {
833  m_sectorlogicTowerCma_name_list.push_back(
834  sectorlogic_name + tower_name +
835  cma_name);
836  ATH_CHECK(bookRPCLV1cmatimevschHistograms(
837  sectorlogic_name, tower_name,
838  cma_name));
839  }
840 
841  const MuonDQAHistList& hists =
842  m_stationHists.getList(sectorlogic_name);
843  TH2* RPCLV1cmatimevsch = hists.getH2(
844  sectorlogic_name + "_" + tower_name +
845  cma_name + "_time_vs_channel");
846  if (RPCLV1cmatimevsch) {
847  RPCLV1cmatimevsch->Fill(
848  float(i_channel + i_ijk * 32),
849  float(i_bcId * 8 + i_time));
850  } else {
851  ATH_MSG_DEBUG(
852  "RPCLV1cmatimevsch not in hist list!");
853  }
854 
855  if (n_triggerlowpt > 0) {
856  TH2* RPCLV1cmatimetriggervsch = hists.getH2(
857  sectorlogic_name + "_" + tower_name +
858  cma_name +
859  "_(time-triggertime)_vs_channel");
860  if (RPCLV1cmatimetriggervsch) {
861  RPCLV1cmatimetriggervsch->Fill(
862  float(i_channel + i_ijk * 32),
863  float(i_bcId * 8 + i_time -
864  i_triggertimelowpt));
865  } else {
866  ATH_MSG_DEBUG(
867  "RPCLV1cmatimetriggervsch not in "
868  "hist list!");
869  }
870  }
871  } // Fill time histograms end
872 
873  // profiles
874  if (m_rpclv1prof) {
875  int shift_ijk = 0;
876  int shift_pad = 1;
877 
878  int shift_cm = 0;
879  std::string cma_name_p;
880  char cma_name_p_char[1000];
881  if (i_cmaId == 1 || i_cmaId == 3 ||
882  i_cmaId == 5 || i_cmaId == 7) {
883  sprintf(cma_name_p_char, "Cma%d_%d",
884  i_cmaId - 1, i_cmaId);
885  cma_name_p = cma_name_p_char;
886  shift_cm = 32;
887  } else {
888  sprintf(cma_name_p_char, "Cma%d_%d",
889  i_cmaId, i_cmaId + 1);
890  cma_name_p = cma_name_p_char;
891  shift_cm = 0;
892  }
893 
894  std::string ijk_name_p;
895  if (i_ijk == 2 || i_ijk == 3) {
896  ijk_name_p = "ijk2_3";
897  shift_pad = 2;
898  shift_cm = shift_cm * 2;
899  } else {
900  if (i_ijk == 4 || i_ijk == 5) {
901  ijk_name_p = "ijk4_5";
902  shift_pad = 2;
903  shift_cm = shift_cm * 2;
904  } else {
905  ijk_name_p = ijk_name;
906  }
907  }
908 
909  if (i_ijk == 3 || i_ijk == 5) {
910  shift_ijk = 32;
911  }
912 
913  bool histo_flag = true;
914  for (std::vector<std::string>::const_iterator
915  iter = m_profile_list.begin();
916  iter != m_profile_list.end(); ++iter) {
917  if ((sectorlogic_name + cma_name_p +
918  ijk_name_p) == *iter) {
919  histo_flag = false;
920  }
921  }
922  if (histo_flag) {
923  m_profile_list.push_back(sectorlogic_name +
924  cma_name_p +
925  ijk_name_p);
926  // bookRPCLV1ProfilesHistograms( i_sector,
927  // sectorlogic_name, i_cmaId, cma_name_p,
928  // i_ijk, ijk_name_p );
929  // // compilation warning to i_cmaId
930  ATH_CHECK(bookRPCLV1ProfilesHistograms(
931  i_sector, sectorlogic_name, cma_name_p,
932  i_ijk, ijk_name_p));
933  }
934  const MuonDQAHistList& hists2 =
935  m_stationHists.getList(sectorlogic_name);
936  TH1* RPCLV1Profiles = hists2.getH1(
937  sectorlogic_name + "_" + cma_name_p + "_" +
938  ijk_name_p + "_Profiles");
939  if (RPCLV1Profiles) {
940  RPCLV1Profiles->Fill(float(
941  i_padId * shift_pad * 64 + shift_cm +
942  shift_ijk + i_channel));
943  } else {
944  ATH_MSG_DEBUG(
945  "RPCLV1Profiles not in hist list!");
946  }
947  }
948  }
949 
950  if (m_doCoolDB) {
951  uint16_t side = 0;
952  uint16_t slogic = i_sector;
953  if (slogic > 31) {
954  slogic -= 32;
955  side = 1;
956  }
957  uint16_t padId = i_padId;
958  uint16_t cmaId = i_cmaId;
959  uint16_t ijk = i_ijk;
960  uint16_t channel = i_channel;
961 
962  SG::ReadCondHandle<RpcCablingCondData> readHandle{
963  m_readKey};
964  const RpcCablingCondData* readCdo{*readHandle};
965  // Get the list of offline channels corresponding to
966  // the online identifier
967  std::list<Identifier> idList =
968  readCdo->give_strip_id(
969  side, slogic, padId, cmaId, ijk, channel,
970  &m_idHelperSvc->rpcIdHelper());
971  std::list<Identifier>::const_iterator it_list;
972 
973  for (it_list = idList.begin();
974  it_list != idList.end(); ++it_list) {
975  // and add the digit to the collection
976  Identifier prdcoll_id = *it_list;
977 
978  std::vector<std::string>
979  rpclayersectorsidename =
980  RpcGM::RpcLayerSectorSideName(
981  m_idHelperSvc->rpcIdHelper(),
982  prdcoll_id, 0);
983  std::string sector_dphi_layer =
984  rpclayersectorsidename[12];
985 
986  std::vector<int> RpcStrip =
987  RpcGM::RpcStripShift(
988  MuonDetMgr,
989  m_idHelperSvc->rpcIdHelper(),
990  prdcoll_id, 0);
991  int strip_dbindex =
992  (RpcGM::RpcStripShift(
993  MuonDetMgr,
994  m_idHelperSvc->rpcIdHelper(),
995  prdcoll_id, 0))
996  .at(16); // cool strip profile
997  if (m_doCoolDB) {
998  TH1* rpcCool_StripProfile = nullptr;
999  if (cmaId == 0 || cmaId == 2 ||
1000  cmaId == 4 || cmaId == 6)
1001  sc = rpcCoolDb.getHist(
1002  rpcCool_StripProfile,
1003  sector_dphi_layer +
1004  "_ProfileDataCMeven");
1005  if (cmaId == 1 || cmaId == 3 ||
1006  cmaId == 5 || cmaId == 7)
1007  sc = rpcCoolDb.getHist(
1008  rpcCool_StripProfile,
1009  sector_dphi_layer +
1010  "_ProfileDataCModd");
1011  if (sc.isFailure())
1012  ATH_MSG_WARNING(
1013  "couldn't get "
1014  << sector_dphi_layer
1015  << "_ProfileDataCMeven or odd");
1016  if (rpcCool_StripProfile) {
1017  rpcCool_StripProfile->Fill(
1018  strip_dbindex);
1019  }
1020  }
1021  }
1022  } // m_doCoolDB
1023 
1024  } // loop over chan
1025  } // loop over CM
1026  } // if RDO_pad_size>0
1027  } // pads loop
1028 
1029  // Fill logical OR histograms
1030  // PhiOr[sector logic][cm][ijk][channel]
1031  // LowPt0 cm 0 1 ijk 2 3 PhiOr: 0 1 0 1
1032  // LowPt1 cm 0 1 ijk 4 5 0 1 2 3
1033  // HighPt0 cm 4 5 ijk 2 3 2 3 0 1
1034  // HighPt1 cm 4 5 ijk 4 5 2 3 2 3
1035  for (int iSL = 0; iSL != 64; iSL++) {
1036  for (int k = 0; k != 2; k++) {
1037  for (int iCh = 0; iCh != 32; iCh++) {
1038  if (PhiOr[iSL][0 + k][0 + k][iCh] != 0)
1039  rpclv1_logicalOR_LowPt0->Fill(
1040  iSL + 1, PhiOr[iSL][0 + k][0 + k][iCh]);
1041  if (PhiOr[iSL][0 + k][2 + k][iCh] != 0)
1042  rpclv1_logicalOR_LowPt1->Fill(
1043  iSL + 1, PhiOr[iSL][0 + k][2 + k][iCh]);
1044  if (PhiOr[iSL][2 + k][0 + k][iCh] != 0)
1045  rpclv1_logicalOR_HighPt0->Fill(
1046  iSL + 1, PhiOr[iSL][2 + k][0 + k][iCh]);
1047  if (PhiOr[iSL][2 + k][2 + k][iCh] != 0)
1048  rpclv1_logicalOR_HighPt1->Fill(
1049  iSL + 1, PhiOr[iSL][2 + k][2 + k][iCh]);
1050  }
1051  }
1052  }
1053 
1054  } // AthenaMonManager::tier0 || AthenaMonManager::tier0Raw
1055 
1056  return sc; // statuscode check
1057 }
1058 
1059 /*----------------------------------------------------------------------------------*/
1060 StatusCode RpcLv1RawDataValAlg::bookHistogramsRecurrent()
1061 /*----------------------------------------------------------------------------------*/
1062 {
1063  ATH_MSG_DEBUG("RPC RawData Monitoring Histograms being booked");
1064 
1065  StatusCode sc = StatusCode::SUCCESS;
1066 
1067  if (m_environment == AthenaMonManager::tier0 ||
1068  m_environment == AthenaMonManager::tier0Raw ||
1069  m_environment == AthenaMonManager::online) {
1070  // declare a group of histograms
1071  std::string generic_path_rpclv1monitoring =
1072  "Muon/MuonRawDataMonitoring/RPCLV1";
1073 
1074  MonGroup rpclv1prd_shift(this,
1075  generic_path_rpclv1monitoring + "/Overview",
1076  run, ATTRIB_UNMANAGED);
1077  MonGroup rpclv1_shift_dqmf(this,
1078  generic_path_rpclv1monitoring + "/GLOBAL",
1079  run, ATTRIB_UNMANAGED);
1080  MonGroup rpcCoolDb(this, generic_path_rpclv1monitoring + "/CoolDB", run,
1081  ATTRIB_UNMANAGED);
1082 
1083  // MuonDetectorManager from the conditions store
1084  SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{
1085  m_DetectorManagerKey};
1086  const MuonGM::MuonDetectorManager* MuonDetMgr =
1087  DetectorManagerHandle.cptr();
1088  if (!MuonDetMgr) {
1089  ATH_MSG_ERROR(
1090  "nullptr to the read MuonDetectorManager conditions object");
1091  return StatusCode::FAILURE;
1092  }
1093 
1094  if (newRunFlag()) {
1095  ATH_MSG_DEBUG("RPCLV1 RawData Monitoring : isNewRun");
1096 
1097  // Trigger Layers vs SL
1098  std::string rpclv1_TriggerLy_vs_SL_title =
1099  "TriggerLayer_vs_SectorLogic";
1100  const char* rpclv1_TriggerLy_vs_SL_title_char =
1101  rpclv1_TriggerLy_vs_SL_title.c_str();
1102 
1103  TH2* rpclv1_TriggerLy_vs_SL = new TH2I(
1104  rpclv1_TriggerLy_vs_SL_title_char,
1105  rpclv1_TriggerLy_vs_SL_title_char, 64, 0, 64, 32, 0, 32);
1106  sc = rpclv1prd_shift.regHist(rpclv1_TriggerLy_vs_SL);
1107  if (sc.isFailure()) {
1108  ATH_MSG_FATAL(
1109  "rpclv1_TriggerLy_vs_SL Failed to register histogram ");
1110  return sc;
1111  }
1112  rpclv1_TriggerLy_vs_SL->GetXaxis()->SetTitle("Sector Logic");
1113  rpclv1_TriggerLy_vs_SL->GetYaxis()->SetTitle("");
1114  rpclv1_TriggerLy_vs_SL->SetOption("COLZ");
1115 
1116  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1117  << rpclv1_TriggerLy_vs_SL
1118  << rpclv1_TriggerLy_vs_SL_title.c_str());
1119  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1120  ATH_MSG_DEBUG("RUN : " << run);
1121  ATH_MSG_DEBUG("Booked rpclv1_TriggerLy_vs_SL successfully");
1122 
1123  // set label for Trigger Layer vs SL histograms
1124  for (int ie = 1; ie != 16; ie++) {
1125  std::ostringstream YLabel;
1126  YLabel << "L=";
1127  int first = 0;
1128  for (int layer = 0; layer != 4; layer++) {
1129  int bit = (ie >> layer) & 1;
1130  if (bit == 1) {
1131  if (first == 0) {
1132  YLabel << layer;
1133  } else {
1134  YLabel << "," << layer;
1135  }
1136  first = 1;
1137  rpclv1_TriggerLy_vs_SL->GetYaxis()->SetBinLabel(
1138  ie + 1, YLabel.str().c_str()); // low pt
1139  rpclv1_TriggerLy_vs_SL->GetYaxis()->SetBinLabel(
1140  ie + 1 + 16, YLabel.str().c_str()); // high pt
1141  }
1142  }
1143  }
1144 
1145  // trigger conditions per CM
1146  // n bin x = 8 cm * 7 pad * 64 sector logic
1147  int n_bin_trigCm = 8 * 7 * 64;
1148  std::string rpclv1_TriggerCond_vs_CM_title =
1149  "Trigger_Condition_vs_CM";
1150  const char* rpclv1_TriggerCond_vs_CM_title_char =
1151  rpclv1_TriggerCond_vs_CM_title.c_str();
1152  TH2* rpclv1_TriggerCond_vs_CM =
1153  new TH2I(rpclv1_TriggerCond_vs_CM_title_char,
1154  rpclv1_TriggerCond_vs_CM_title_char, n_bin_trigCm, 1,
1155  n_bin_trigCm + 1, 16, 0, 16);
1156  sc = rpclv1prd_shift.regHist(rpclv1_TriggerCond_vs_CM);
1157 
1158  rpclv1_TriggerCond_vs_CM->GetXaxis()->SetTitle(
1159  "CM + Pad*8 + SL*56");
1160  rpclv1_TriggerCond_vs_CM->GetYaxis()->SetTitle("");
1161  rpclv1_TriggerCond_vs_CM->SetOption("COLZ");
1162 
1163  // set label for Trigger conditions per CM
1164  rpclv1_TriggerCond_vs_CM->GetYaxis()->SetBinLabel(1, "No Hits");
1165  for (int ie = 1; ie != 16; ie++) {
1166  std::ostringstream YLabel;
1167  YLabel << "L=";
1168  int first = 0;
1169  for (int layer = 0; layer != 4; layer++) {
1170  int bit = (ie >> layer) & 1;
1171  if (bit == 1) {
1172  if (first == 0) {
1173  YLabel << layer;
1174  } else {
1175  YLabel << "," << layer;
1176  }
1177  first = 1;
1178  rpclv1_TriggerCond_vs_CM->GetYaxis()->SetBinLabel(
1179  ie + 1, YLabel.str().c_str());
1180  }
1181  }
1182  }
1183 
1184  // logical OR
1185 
1186  std::vector<std::string> LyNameVec;
1187  LyNameVec.push_back("LowPt0");
1188  LyNameVec.push_back("LowPt1");
1189  LyNameVec.push_back("HighPt0");
1190  LyNameVec.push_back("HighPt1");
1191 
1192  // n bin x = 64 sector logic
1193  // n bin y = 2 ^ ( nPad=7 ) = 128
1194  int n_bin_logOR = 64;
1195 
1196  for (std::vector<std::string>::const_iterator it =
1197  LyNameVec.begin();
1198  it != LyNameVec.end(); ++it) {
1199  std::string rpclv1_logicalOR_title = "PhiLogicalOR_" + *it;
1200  const char* rpclv1_logicalOR_title_char =
1201  rpclv1_logicalOR_title.c_str();
1202  TH2* rpclv1_logicalOR = new TH2I(
1203  rpclv1_logicalOR_title_char, rpclv1_logicalOR_title_char,
1204  n_bin_logOR, 0, n_bin_logOR, 128, 0, 128);
1205  sc = rpclv1prd_shift.regHist(rpclv1_logicalOR);
1206 
1207  rpclv1_logicalOR->GetXaxis()->SetTitle("Sector Logic");
1208  // rpclv1_logicalOR->GetYaxis()->SetTitle("Pad") ;
1209  rpclv1_logicalOR->SetOption("COLZ");
1210  rpclv1_logicalOR->GetYaxis()->SetLabelSize(0.03);
1211  for (int ie = 0 + 1; ie != 128; ie++) {
1212  std::ostringstream YLabel;
1213  YLabel << "pad";
1214  for (int k = 0; k != 8; k++) {
1215  if ((int(pow(2, float(k))) & ie) != 0) {
1216  YLabel << " " << k;
1217  }
1218  }
1219  rpclv1_logicalOR->GetYaxis()->SetBinLabel(
1220  ie + 1, YLabel.str().c_str());
1221  }
1222  }
1223 
1224  // SHIFT histograms
1225  // Trigger conditions vs SL
1226  std::string rpclv1_TriggerCond_vs_SL_title =
1227  "TriggerCondition_vs_SectorLogic";
1228  const char* rpclv1_TriggerCond_vs_SL_title_char =
1229  rpclv1_TriggerCond_vs_SL_title.c_str();
1230 
1231  TH2* rpclv1_TriggerCond_vs_SL = new TH2I(
1232  rpclv1_TriggerCond_vs_SL_title_char,
1233  rpclv1_TriggerCond_vs_SL_title_char, 64, 0, 64, 7, 1, 8);
1234  sc = rpclv1_shift_dqmf.regHist(rpclv1_TriggerCond_vs_SL);
1235  if (sc.isFailure()) {
1236  ATH_MSG_FATAL(
1237  "rpclv1_TriggerCond_vs_SL Failed to register histogram ");
1238  return sc;
1239  }
1240  rpclv1_TriggerCond_vs_SL->GetXaxis()->SetTitle("Sector Logic");
1241  rpclv1_TriggerCond_vs_SL->GetYaxis()->SetTitle("");
1242  rpclv1_TriggerCond_vs_SL->GetYaxis()->SetTitleSize(0.03);
1243  rpclv1_TriggerCond_vs_SL->SetOption("COLZ");
1244 
1245  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1246  << rpclv1_TriggerCond_vs_SL
1247  << rpclv1_TriggerCond_vs_SL_title.c_str());
1248  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1249  ATH_MSG_DEBUG("RUN : " << run);
1250  ATH_MSG_DEBUG("Booked rpclv1_TriggerCond_vs_SL successfully");
1251 
1252  // set label for Trigger Condition vs SL histograms
1253  rpclv1_TriggerCond_vs_SL->GetYaxis()->SetBinLabel(
1254  1, "1/4 Lpt "); // low pt
1255  rpclv1_TriggerCond_vs_SL->GetYaxis()->SetBinLabel(2, "2/4 Lpt ");
1256  rpclv1_TriggerCond_vs_SL->GetYaxis()->SetBinLabel(3, "3/4 Lpt ");
1257  rpclv1_TriggerCond_vs_SL->GetYaxis()->SetBinLabel(4, "4/4 Lpt ");
1258  rpclv1_TriggerCond_vs_SL->GetYaxis()->SetBinLabel(
1259  5, "Lpt+0/2Hpt"); // high pt
1260  rpclv1_TriggerCond_vs_SL->GetYaxis()->SetBinLabel(6, "Lpt+1/2Hpt");
1261  rpclv1_TriggerCond_vs_SL->GetYaxis()->SetBinLabel(7, "Lpt+2/2Hpt");
1262 
1263  // BCid (ijk==6) vs SL
1264  std::string rpclv1_BCid_vs_SL_title = "rpclv1_BCid_vs_SectorLogic";
1265  const char* rpclv1_BCid_vs_SL_title_char =
1266  rpclv1_BCid_vs_SL_title.c_str();
1267 
1268  TH2* rpclv1_BCid_vs_SL =
1269  new TH2I(rpclv1_BCid_vs_SL_title_char,
1270  rpclv1_BCid_vs_SL_title_char, 64, 0, 64, 8 * 2, 0, 16);
1271  sc = rpclv1_shift_dqmf.regHist(rpclv1_BCid_vs_SL);
1272  if (sc.isFailure()) {
1273  ATH_MSG_FATAL(
1274  "rpclv1_BCid_vs_SectorLogic Failed to register histogram ");
1275  return sc;
1276  }
1277  rpclv1_BCid_vs_SL->GetXaxis()->SetTitle(
1278  "Triggered RPC Sector Logic");
1279  rpclv1_BCid_vs_SL->GetYaxis()->SetTitle(
1280  "BCId+HPtTrigger*8 for trigger hits");
1281  rpclv1_BCid_vs_SL->SetOption("COLZ");
1282 
1283  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1284  << rpclv1_BCid_vs_SL
1285  << rpclv1_BCid_vs_SL_title.c_str());
1286  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1287  ATH_MSG_DEBUG("RUN : " << run);
1288  ATH_MSG_DEBUG("Booked rpclv1_BCid_vs_SectorLogic successfully");
1289 
1290  // LPt BCid (ijk==6) vs SL
1291  std::string rpclv1_LPt_BCid_vs_SL_title =
1292  "rpclv1_LPt_BCid_vs_SectorLogic";
1293  const char* rpclv1_LPt_BCid_vs_SL_title_char =
1294  rpclv1_LPt_BCid_vs_SL_title.c_str();
1295 
1296  TH2* rpclv1_LPt_BCid_vs_SL =
1297  new TH2I(rpclv1_LPt_BCid_vs_SL_title_char,
1298  rpclv1_LPt_BCid_vs_SL_title_char, 64, 0, 64, 8, 0, 8);
1299  sc = rpclv1_shift_dqmf.regHist(rpclv1_LPt_BCid_vs_SL);
1300  if (sc.isFailure()) {
1301  ATH_MSG_FATAL(
1302  "rpclv1_BCid_vs_SectorLogic Failed to register histogram ");
1303  return sc;
1304  }
1305  rpclv1_LPt_BCid_vs_SL->GetXaxis()->SetTitle(
1306  "Triggered LPt RPC Sector Logic");
1307  rpclv1_LPt_BCid_vs_SL->GetYaxis()->SetTitle("Trigger hits BCid");
1308  rpclv1_LPt_BCid_vs_SL->SetOption("COLZ");
1309 
1310  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1311  << rpclv1_LPt_BCid_vs_SL
1312  << rpclv1_LPt_BCid_vs_SL_title.c_str());
1313  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1314  ATH_MSG_DEBUG("RUN : " << run);
1315  ATH_MSG_DEBUG("Booked rpclv1_BCid_vs_SectorLogic successfully");
1316 
1317  // BCid (ijk==6) vs SL
1318  std::string rpclv1_HPt_BCid_vs_SL_title =
1319  "rpclv1_HPt_BCid_vs_SectorLogic";
1320  const char* rpclv1_HPt_BCid_vs_SL_title_char =
1321  rpclv1_HPt_BCid_vs_SL_title.c_str();
1322 
1323  TH2* rpclv1_HPt_BCid_vs_SL =
1324  new TH2I(rpclv1_HPt_BCid_vs_SL_title_char,
1325  rpclv1_HPt_BCid_vs_SL_title_char, 64, 0, 64, 8, 0, 8);
1326  sc = rpclv1_shift_dqmf.regHist(rpclv1_HPt_BCid_vs_SL);
1327  if (sc.isFailure()) {
1328  ATH_MSG_FATAL(
1329  "rpclv1_BCid_vs_SectorLogic Failed to register histogram ");
1330  return sc;
1331  }
1332  rpclv1_HPt_BCid_vs_SL->GetXaxis()->SetTitle(
1333  "Triggered HPt RPC Sector Logic");
1334  rpclv1_HPt_BCid_vs_SL->GetYaxis()->SetTitle("Trigger hits BCid");
1335  rpclv1_HPt_BCid_vs_SL->SetOption("COLZ");
1336 
1337  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1338  << rpclv1_HPt_BCid_vs_SL
1339  << rpclv1_HPt_BCid_vs_SL_title.c_str());
1340  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1341  ATH_MSG_DEBUG("RUN : " << run);
1342  ATH_MSG_DEBUG("Booked rpclv1_BCid_vs_SectorLogic successfully");
1343 
1345 
1346  // hits per event
1347  std::string rpclv1_hitperEvent_title = "rpclv1_hitperEvent";
1348  const char* rpclv1_hitperEvent_title_char =
1349  rpclv1_hitperEvent_title.c_str();
1350 
1351  TH1* rpclv1_hitperEvent =
1352  new TH1I(rpclv1_hitperEvent_title_char,
1353  rpclv1_hitperEvent_title_char, NMAXHIT, 0., NMAXHIT);
1354  sc = rpclv1prd_shift.regHist(rpclv1_hitperEvent);
1355  if (sc.isFailure()) {
1356  ATH_MSG_FATAL(
1357  "rpclv1_hitperEvent Failed to register histogram ");
1358  return sc;
1359  }
1360  rpclv1_hitperEvent->SetFillColor(42);
1361  rpclv1_hitperEvent->GetXaxis()->SetTitle("RPC hit / event");
1362  rpclv1_hitperEvent->GetYaxis()->SetTitle("Counts");
1363 
1364  ATH_MSG_DEBUG("INSIDE bookHistograms : " << rpclv1_hitperEvent);
1365  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1366  ATH_MSG_DEBUG("RUN : " << run);
1367  ATH_MSG_DEBUG("Booked rpclv1_hitperEvent successfully");
1368 
1369  // lowpt ETA trigger hits stat
1370  std::string generic_path_rpclv1triggerlowpt_etastat =
1371  generic_path_rpclv1monitoring + "/Overview";
1372  std::string rpclv1triggerlowpt_etastat_title =
1373  "Trigger_Hits_LowPt_eta_Stat";
1374  const char* rpclv1triggerlowpt_etastat_title_char =
1375  rpclv1triggerlowpt_etastat_title.c_str();
1376 
1377  TH1* rpclv1triggerlowpt_etastat =
1378  new TH1I(rpclv1triggerlowpt_etastat_title_char,
1379  rpclv1triggerlowpt_etastat_title_char, 15, 0, 15);
1380  sc = rpclv1prd_shift.regHist(rpclv1triggerlowpt_etastat);
1381  if (sc.isFailure()) {
1382  ATH_MSG_FATAL(
1383  "rpclv1triggerlowpt_etastat Failed to register histogram ");
1384  return sc;
1385  }
1386  rpclv1triggerlowpt_etastat->SetFillColor(42);
1387  rpclv1triggerlowpt_etastat->GetXaxis()->SetTitle(
1388  "LowPt eta trigger hits / event");
1389  rpclv1triggerlowpt_etastat->GetYaxis()->SetTitle("Counts");
1390 
1391  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1392  << rpclv1triggerlowpt_etastat
1393  << generic_path_rpclv1triggerlowpt_etastat.c_str());
1394  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1395  ATH_MSG_DEBUG("RUN : " << run);
1396  ATH_MSG_DEBUG("Booked rpclv1triggerlowpt_etastat successfully");
1397 
1399 
1400  // lowpt PHI trigger hits stat
1401  std::string generic_path_rpclv1triggerlowpt_phistat =
1402  generic_path_rpclv1monitoring + "/Overview";
1403  std::string rpclv1triggerlowpt_phistat_title =
1404  "Trigger_Hits_LowPt_phi_Stat";
1405  const char* rpclv1triggerlowpt_phistat_title_char =
1406  rpclv1triggerlowpt_phistat_title.c_str();
1407 
1408  TH1* rpclv1triggerlowpt_phistat =
1409  new TH1I(rpclv1triggerlowpt_phistat_title_char,
1410  rpclv1triggerlowpt_phistat_title_char, 15, 0, 15);
1411  sc = rpclv1prd_shift.regHist(rpclv1triggerlowpt_phistat);
1412  if (sc.isFailure()) {
1413  ATH_MSG_FATAL(
1414  "rpclv1triggerlowpt_phistat Failed to register histogram ");
1415  return sc;
1416  }
1417  rpclv1triggerlowpt_phistat->SetFillColor(42);
1418  rpclv1triggerlowpt_phistat->GetXaxis()->SetTitle(
1419  "LowPt phi trigger hits / event");
1420  rpclv1triggerlowpt_phistat->GetYaxis()->SetTitle("Counts");
1421 
1422  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1423  << rpclv1triggerlowpt_phistat
1424  << generic_path_rpclv1triggerlowpt_phistat.c_str());
1425  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1426  ATH_MSG_DEBUG("RUN : " << run);
1427  ATH_MSG_DEBUG("Booked rpclv1triggerlowpt_phistat successfully");
1428 
1430 
1431  // lowpt ETA-PHI trigger hits stat
1432  std::string generic_path_rpclv1triggerlowpt_etaphistat =
1433  generic_path_rpclv1monitoring + "/Overview";
1434  std::string rpclv1triggerlowpt_etaphistat_title =
1435  "Trigger_Hits_Lowpt_etaphi_Stat";
1436  const char* rpclv1triggerlowpt_etaphistat_title_char =
1437  rpclv1triggerlowpt_etaphistat_title.c_str();
1438 
1439  TH2* rpclv1triggerlowpt_etaphistat = new TH2I(
1440  rpclv1triggerlowpt_etaphistat_title_char,
1441  rpclv1triggerlowpt_etaphistat_title_char, 15, 0, 15, 15, 0, 15);
1442  sc = rpclv1prd_shift.regHist(rpclv1triggerlowpt_etaphistat);
1443  if (sc.isFailure()) {
1444  ATH_MSG_FATAL(
1445  "rpclv1triggerlowpt_etaphistat Failed to register "
1446  "histogram ");
1447  return sc;
1448  }
1449  rpclv1triggerlowpt_etaphistat->SetOption("COLZ");
1450  rpclv1triggerlowpt_etaphistat->GetXaxis()->SetTitle(
1451  "LowPt phi trigger hits / event");
1452  rpclv1triggerlowpt_etaphistat->GetYaxis()->SetTitle(
1453  "LowPt eta trigger hits / event");
1454 
1455  ATH_MSG_DEBUG(
1456  "INSIDE bookHistograms : "
1457  << rpclv1triggerlowpt_etaphistat
1458  << generic_path_rpclv1triggerlowpt_etaphistat.c_str());
1459  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1460  ATH_MSG_DEBUG("RUN : " << run);
1461  ATH_MSG_DEBUG("Booked rpclv1triggerlowpt_etaphistat successfully");
1462 
1464 
1465  // highpt ETA trigger hits stat
1466  std::string generic_path_rpclv1triggerhighpt_etastat =
1467  generic_path_rpclv1monitoring + "/Overview";
1468  std::string rpclv1triggerhighpt_etastat_title =
1469  "Trigger_Hits_HighPt_eta_Stat";
1470  const char* rpclv1triggerhighpt_etastat_title_char =
1471  rpclv1triggerhighpt_etastat_title.c_str();
1472  TH1* rpclv1triggerhighpt_etastat =
1473  new TH1I(rpclv1triggerhighpt_etastat_title_char,
1474  rpclv1triggerhighpt_etastat_title_char, 15, 0, 15);
1475  sc = rpclv1prd_shift.regHist(rpclv1triggerhighpt_etastat);
1476  if (sc.isFailure()) {
1477  ATH_MSG_FATAL(
1478  "rpclv1triggerhighpt_etastat Failed to register "
1479  "histogram ");
1480  return sc;
1481  }
1482  rpclv1triggerhighpt_etastat->SetFillColor(42);
1483  rpclv1triggerhighpt_etastat->GetXaxis()->SetTitle(
1484  "HighPt eta trigger hits / event");
1485  rpclv1triggerhighpt_etastat->GetYaxis()->SetTitle("Counts");
1486 
1487  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1488  << rpclv1triggerhighpt_etastat
1489  << generic_path_rpclv1triggerhighpt_etastat.c_str());
1490  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1491  ATH_MSG_DEBUG("RUN : " << run);
1492  ATH_MSG_DEBUG(
1493  "Booked rpclv1triggertimehighpt_etastat successfully");
1494 
1496 
1497  // highpt PHI trigger hits stat
1498  std::string generic_path_rpclv1triggerhighpt_phistat =
1499  generic_path_rpclv1monitoring + "/Overview";
1500  std::string rpclv1triggerhighpt_phistat_title =
1501  "Trigger_Hits_HighPt_phi_Stat";
1502  const char* rpclv1triggerhighpt_phistat_title_char =
1503  rpclv1triggerhighpt_phistat_title.c_str();
1504  TH1* rpclv1triggerhighpt_phistat =
1505  new TH1I(rpclv1triggerhighpt_phistat_title_char,
1506  rpclv1triggerhighpt_phistat_title_char, 15, 0, 15);
1507  sc = rpclv1prd_shift.regHist(rpclv1triggerhighpt_phistat);
1508  if (sc.isFailure()) {
1509  ATH_MSG_FATAL(
1510  "rpclv1triggerhighpt_phistat Failed to register "
1511  "histogram ");
1512  return sc;
1513  }
1514  rpclv1triggerhighpt_phistat->SetFillColor(42);
1515  rpclv1triggerhighpt_phistat->GetXaxis()->SetTitle(
1516  "HighPt phi trigger hits / event");
1517  rpclv1triggerhighpt_phistat->GetYaxis()->SetTitle("Counts");
1518 
1519  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1520  << rpclv1triggerhighpt_phistat
1521  << generic_path_rpclv1triggerhighpt_phistat.c_str());
1522  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1523  ATH_MSG_DEBUG("RUN : " << run);
1524  ATH_MSG_DEBUG(
1525  "Booked rpclv1triggertimehighpt_phistat successfully");
1526 
1528 
1529  // highpt ETA - PHI trigger hits stat
1530  std::string generic_path_rpclv1triggerhighpt_etaphistat =
1531  generic_path_rpclv1monitoring + "/Overview";
1532  std::string rpclv1triggerhighpt_etaphistat_title =
1533  "Trigger_Hits_HighPt_etaphi_Stat";
1534  const char* rpclv1triggerhighpt_etaphistat_title_char =
1535  rpclv1triggerhighpt_etaphistat_title.c_str();
1536  TH2* rpclv1triggerhighpt_etaphistat =
1537  new TH2I(rpclv1triggerhighpt_etaphistat_title_char,
1538  rpclv1triggerhighpt_etaphistat_title_char, 15, 0, 15,
1539  15, 0, 15);
1540  sc = rpclv1prd_shift.regHist(rpclv1triggerhighpt_etaphistat);
1541  if (sc.isFailure()) {
1542  ATH_MSG_FATAL(
1543  "rpclv1triggerhighpt_etaphistat Failed to register "
1544  "histogram ");
1545  return sc;
1546  }
1547  rpclv1triggerhighpt_etaphistat->SetOption("COLZ");
1548  rpclv1triggerhighpt_etaphistat->GetXaxis()->SetTitle(
1549  "HighPt phi trigger hits / event");
1550  rpclv1triggerhighpt_etaphistat->GetYaxis()->SetTitle(
1551  "HighPt eta trigger hits / event");
1552 
1553  ATH_MSG_DEBUG(
1554  "INSIDE bookHistograms : "
1555  << rpclv1triggerhighpt_etaphistat
1556  << generic_path_rpclv1triggerhighpt_etaphistat.c_str());
1557  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1558  ATH_MSG_DEBUG("RUN : " << run);
1559  ATH_MSG_DEBUG(
1560  "Booked rpclv1triggertimehighpt_etaphistat successfully");
1561 
1563 
1564  // sector logic statistics
1565  std::string generic_path_rpclv1sectorlogicstat =
1566  generic_path_rpclv1monitoring + "/Overview";
1567  std::string rpclv1sectorlogicstat_title =
1568  "SLChannel_per_SectorLogic";
1569  const char* rpclv1sectorlogicstat_title_char =
1570  rpclv1sectorlogicstat_title.c_str();
1571  TH1* rpclv1sectorlogicstat =
1572  new TH1I(rpclv1sectorlogicstat_title_char,
1573  rpclv1sectorlogicstat_title_char, 64, 0, 64);
1574  sc = rpclv1prd_shift.regHist(rpclv1sectorlogicstat);
1575  if (sc.isFailure()) {
1576  ATH_MSG_FATAL(
1577  "rpclv1sectorlogicstat Failed to register histogram ");
1578  return sc;
1579  }
1580  rpclv1sectorlogicstat->SetFillColor(42);
1581  rpclv1sectorlogicstat->GetXaxis()->SetTitle("SectorLogic");
1582  rpclv1sectorlogicstat->GetYaxis()->SetTitle("Counts/Sector Logic ");
1583 
1584  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1585  << rpclv1sectorlogicstat
1586  << generic_path_rpclv1sectorlogicstat.c_str());
1587  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1588  ATH_MSG_DEBUG("RUN : " << run);
1589  ATH_MSG_DEBUG("Booked rpclv1sectorlogicstat successfully");
1590 
1592 
1593  // tower per sector logic statistics
1594  std::string generic_path_rpclv1towervslogicstat =
1595  generic_path_rpclv1monitoring + "/Overview";
1596  std::string rpclv1towervslogicstat_title =
1597  "PadChannel_per_SectorLogic";
1598  const char* rpclv1towervslogicstat_title_char =
1599  rpclv1towervslogicstat_title.c_str();
1600  TH2* rpclv1towervslogicstat =
1601  new TH2I(rpclv1towervslogicstat_title_char,
1602  rpclv1towervslogicstat_title_char, 64, 0, 64, 8, 0, 8);
1603  sc = rpclv1prd_shift.regHist(rpclv1towervslogicstat);
1604  if (sc.isFailure()) {
1605  ATH_MSG_FATAL(
1606  "rpclv1towervslogicstat Failed to register histogram ");
1607  return sc;
1608  }
1609  rpclv1towervslogicstat->SetFillColor(42);
1610  rpclv1towervslogicstat->SetOption("COLZ");
1611  rpclv1towervslogicstat->GetXaxis()->SetTitle("SectorLogic");
1612  rpclv1towervslogicstat->GetYaxis()->SetTitle("Pad");
1613 
1614  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1615  << rpclv1towervslogicstat
1616  << generic_path_rpclv1towervslogicstat.c_str());
1617  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1618  ATH_MSG_DEBUG("RUN : " << run);
1619  ATH_MSG_DEBUG("Booked rpclv1towervslogicstat successfully");
1620 
1622 
1623  // cma channel per sector logic stat
1624  std::string generic_path_rpclv1cmalogicstat =
1625  generic_path_rpclv1monitoring + "/Overview";
1626  std::string rpclv1cmalogicstat_title = "CMChannel_per_SectorLogic";
1627  const char* rpclv1cmalogicstat_title_char =
1628  rpclv1cmalogicstat_title.c_str();
1629  TH2* rpclv1cmalogicstat = new TH2I(rpclv1cmalogicstat_title_char,
1630  rpclv1cmalogicstat_title_char,
1631  64, 0, 64, 8 * 8, 0, 8 * 8);
1632  sc = rpclv1prd_shift.regHist(rpclv1cmalogicstat);
1633  if (sc.isFailure()) {
1634  ATH_MSG_FATAL(
1635  "rpclv1cmalogicstat Failed to register histogram ");
1636  return sc;
1637  }
1638  rpclv1cmalogicstat->SetFillColor(42);
1639  rpclv1cmalogicstat->SetOption("COLZ");
1640  rpclv1cmalogicstat->GetXaxis()->SetTitle("SectorLogic");
1641  rpclv1cmalogicstat->GetYaxis()->SetTitle("Pad*8+Cma");
1642 
1643  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1644  << rpclv1cmalogicstat
1645  << generic_path_rpclv1cmalogicstat.c_str());
1646  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1647  ATH_MSG_DEBUG("RUN : " << run);
1648  ATH_MSG_DEBUG("Booked rpclv1cmalogicstat successfully");
1649 
1651 
1652  // ROI distribution Low Pt
1653  std::string generic_path_rpclv1ROI_LowPt =
1654  generic_path_rpclv1monitoring + "/Overview";
1655  std::string rpclv1ROI_LowPt_title = "ROI_LowPt_distribution";
1656  const char* rpclv1ROI_LowPt_title_char =
1657  rpclv1ROI_LowPt_title.c_str();
1658  TH2* rpclv1ROI_LowPt =
1659  new TH2I(rpclv1ROI_LowPt_title_char, rpclv1ROI_LowPt_title_char,
1660  64, 0, 64, 28, 0, 28);
1661  sc = rpclv1prd_shift.regHist(rpclv1ROI_LowPt);
1662  if (sc.isFailure()) {
1663  ATH_MSG_FATAL("rpclv1ROI_LowPt Failed to register histogram ");
1664  return sc;
1665  }
1666  rpclv1ROI_LowPt->SetOption("COLZ");
1667  rpclv1ROI_LowPt->GetXaxis()->SetTitle("SectorLogic");
1668  rpclv1ROI_LowPt->GetYaxis()->SetTitle("Region of Interest");
1669 
1670  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1671  << rpclv1ROI_LowPt << rpclv1ROI_LowPt_title.c_str());
1672  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1673  ATH_MSG_DEBUG("RUN : " << run);
1674  ATH_MSG_DEBUG("Booked rpclv1ROI_LowPt successfully");
1675 
1677 
1678  // ROI distribution High Pt
1679  std::string generic_path_rpclv1ROI_HighPt =
1680  generic_path_rpclv1monitoring + "/Overview";
1681  std::string rpclv1ROI_HighPt_title = "ROI_HighPt_distribution";
1682  const char* rpclv1ROI_HighPt_title_char =
1683  rpclv1ROI_HighPt_title.c_str();
1684  TH2* rpclv1ROI_HighPt =
1685  new TH2I(rpclv1ROI_HighPt_title_char,
1686  rpclv1ROI_HighPt_title_char, 64, 0, 64, 28, 0, 28);
1687  sc = rpclv1prd_shift.regHist(rpclv1ROI_HighPt);
1688  if (sc.isFailure()) {
1689  ATH_MSG_FATAL("rpclv1ROI_HighPt Failed to register histogram ");
1690  return sc;
1691  }
1692  rpclv1ROI_HighPt->SetOption("COLZ");
1693  rpclv1ROI_HighPt->GetXaxis()->SetTitle("SectorLogic");
1694  rpclv1ROI_HighPt->GetYaxis()->SetTitle("Region of Interest");
1695 
1696  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1697  << rpclv1ROI_HighPt
1698  << rpclv1ROI_HighPt_title.c_str());
1699  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1700  ATH_MSG_DEBUG("RUN : " << run);
1701  ATH_MSG_DEBUG("Booked rpclv1ROI_HighPt successfully");
1702 
1704 
1705  // Trigger_Cond LowPt PHI
1706  std::string generic_path_rpclv1Trigger_cond_LowPt_phi =
1707  generic_path_rpclv1monitoring + "/Overview";
1708  std::string rpclv1Trigger_cond_LowPt_phi_title =
1709  "Trigger_Condition_LowPt_Phi";
1710  const char* rpclv1Trigger_cond_LowPt_phi_title_char =
1711  rpclv1Trigger_cond_LowPt_phi_title.c_str();
1712  TH1* rpclv1Trigger_cond_LowPt_phi =
1713  new TH1I(rpclv1Trigger_cond_LowPt_phi_title_char,
1714  rpclv1Trigger_cond_LowPt_phi_title_char, 16, 0, 16);
1715  sc = rpclv1prd_shift.regHist(rpclv1Trigger_cond_LowPt_phi);
1716  if (sc.isFailure()) {
1717  ATH_MSG_FATAL(
1718  "Trigger_Condition_LowPt_Phi Failed to register "
1719  "histogram ");
1720  return sc;
1721  }
1722  rpclv1Trigger_cond_LowPt_phi->SetFillColor(42);
1723  rpclv1Trigger_cond_LowPt_phi->GetXaxis()->SetTitle(
1724  "Trigger Conditions: 0=Pivot0, 1=Pivot1, 2=LowPt0, 3=LowPt1");
1725  rpclv1Trigger_cond_LowPt_phi->GetYaxis()->SetTitle("Counts");
1726  rpclv1Trigger_cond_LowPt_phi->GetXaxis()->SetBinLabel(1, "None");
1727  rpclv1Trigger_cond_LowPt_phi->GetXaxis()->SetBinLabel(1, "None");
1728 
1729  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1730  << rpclv1Trigger_cond_LowPt_phi
1731  << rpclv1Trigger_cond_LowPt_phi_title.c_str());
1732  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1733  ATH_MSG_DEBUG("RUN : " << run);
1734  ATH_MSG_DEBUG("Booked Trigger_Condition_LowPt_Phi successfully");
1735 
1737 
1738  // Trigger_Cond LowPt ETA
1739  std::string generic_path_rpclv1Trigger_cond_LowPt_eta =
1740  generic_path_rpclv1monitoring + "/Overview";
1741  std::string rpclv1Trigger_cond_LowPt_eta_title =
1742  "Trigger_Condition_LowPt_Eta";
1743  const char* rpclv1Trigger_cond_LowPt_eta_title_char =
1744  rpclv1Trigger_cond_LowPt_eta_title.c_str();
1745  TH1* rpclv1Trigger_cond_LowPt_eta =
1746  new TH1I(rpclv1Trigger_cond_LowPt_eta_title_char,
1747  rpclv1Trigger_cond_LowPt_eta_title_char, 16, 0, 16);
1748  sc = rpclv1prd_shift.regHist(rpclv1Trigger_cond_LowPt_eta);
1749  if (sc.isFailure()) {
1750  ATH_MSG_FATAL(
1751  "Trigger_Condition_LowPt_eta Failed to register "
1752  "histogram ");
1753  return sc;
1754  }
1755  rpclv1Trigger_cond_LowPt_eta->SetFillColor(42);
1756  rpclv1Trigger_cond_LowPt_eta->GetXaxis()->SetTitle(
1757  "Trigger Conditions: 0=Pivot0, 1=Pivot1, 2=LowPt0, 3=LowPt1");
1758  rpclv1Trigger_cond_LowPt_eta->GetYaxis()->SetTitle("Counts");
1759  rpclv1Trigger_cond_LowPt_eta->GetXaxis()->SetBinLabel(1, "None");
1760  rpclv1Trigger_cond_LowPt_eta->GetXaxis()->SetBinLabel(1, "None");
1761 
1762  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1763  << rpclv1Trigger_cond_LowPt_eta
1764  << rpclv1Trigger_cond_LowPt_eta_title.c_str());
1765  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1766  ATH_MSG_DEBUG("RUN : " << run);
1767  ATH_MSG_DEBUG("Booked Trigger_Condition_LowPt_eta successfully");
1768 
1770 
1771  // Trigger_Cond HighPt PHI
1772  std::string generic_path_rpclv1Trigger_cond_HighPt_phi =
1773  generic_path_rpclv1monitoring + "/Overview";
1774  std::string rpclv1Trigger_cond_HighPt_phi_title =
1775  "Trigger_Condition_HighPt_Phi";
1776  const char* rpclv1Trigger_cond_HighPt_phi_title_char =
1777  rpclv1Trigger_cond_HighPt_phi_title.c_str();
1778  TH1* rpclv1Trigger_cond_HighPt_phi =
1779  new TH1I(rpclv1Trigger_cond_HighPt_phi_title_char,
1780  rpclv1Trigger_cond_HighPt_phi_title_char, 16, 0, 16);
1781  sc = rpclv1prd_shift.regHist(rpclv1Trigger_cond_HighPt_phi);
1782  if (sc.isFailure()) {
1783  ATH_MSG_FATAL(
1784  "Trigger_Condition_HighPt_Phi Failed to register "
1785  "histogram ");
1786  return sc;
1787  }
1788  rpclv1Trigger_cond_HighPt_phi->SetFillColor(42);
1789  rpclv1Trigger_cond_HighPt_phi->GetXaxis()->SetTitle(
1790  "Trigger Conditions: 0=Trigger from LowPt, 2=HighPt0, "
1791  "3=HighPt1");
1792  rpclv1Trigger_cond_HighPt_phi->GetYaxis()->SetTitle("Counts");
1793  rpclv1Trigger_cond_HighPt_phi->GetXaxis()->SetBinLabel(1, "None");
1794  rpclv1Trigger_cond_HighPt_phi->GetXaxis()->SetBinLabel(1, "None");
1795 
1796  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1797  << rpclv1Trigger_cond_HighPt_phi
1798  << rpclv1Trigger_cond_HighPt_phi_title.c_str());
1799  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1800  ATH_MSG_DEBUG("RUN : " << run);
1801  ATH_MSG_DEBUG("Booked Trigger_Condition_HighPt_Phi successfully");
1802 
1804 
1805  // Trigger_Cond HighPt ETA
1806  std::string generic_path_rpclv1Trigger_cond_HighPt_eta =
1807  generic_path_rpclv1monitoring + "/Overview";
1808  std::string rpclv1Trigger_cond_HighPt_eta_title =
1809  "Trigger_Condition_HighPt_Eta";
1810  const char* rpclv1Trigger_cond_HighPt_eta_title_char =
1811  rpclv1Trigger_cond_HighPt_eta_title.c_str();
1812  TH1* rpclv1Trigger_cond_HighPt_eta =
1813  new TH1I(rpclv1Trigger_cond_HighPt_eta_title_char,
1814  rpclv1Trigger_cond_HighPt_eta_title_char, 16, 0, 16);
1815  sc = rpclv1prd_shift.regHist(rpclv1Trigger_cond_HighPt_eta);
1816  if (sc.isFailure()) {
1817  ATH_MSG_FATAL(
1818  "Trigger_Condition_HighPt_eta Failed to register "
1819  "histogram ");
1820  return sc;
1821  }
1822  rpclv1Trigger_cond_HighPt_eta->SetFillColor(42);
1823  rpclv1Trigger_cond_HighPt_eta->GetXaxis()->SetTitle(
1824  "Trigger Conditions: 0 =Trigger from LowPt, 2=HighPt0, "
1825  "3=HighPt1");
1826  rpclv1Trigger_cond_HighPt_eta->GetYaxis()->SetTitle("Counts");
1827  rpclv1Trigger_cond_HighPt_eta->GetXaxis()->SetBinLabel(1, "None");
1828  rpclv1Trigger_cond_HighPt_eta->GetXaxis()->SetBinLabel(1, "None");
1829 
1830  ATH_MSG_DEBUG("INSIDE bookHistograms : "
1831  << rpclv1Trigger_cond_HighPt_eta
1832  << rpclv1Trigger_cond_HighPt_eta_title.c_str());
1833  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1834  ATH_MSG_DEBUG("RUN : " << run);
1835  ATH_MSG_DEBUG("Booked Trigger_Condition_HighPt_eta successfully");
1836 
1838 
1839  // set label for Trigger Condition histograms
1840  for (int ie = 1; ie != 16; ie++) {
1841  std::ostringstream XLabel;
1842  XLabel << "L=";
1843  int first = 0;
1844  for (int layer = 0; layer != 4; layer++) {
1845  int bit = (ie >> layer) & 1;
1846  if (bit == 1) {
1847  if (first == 0) {
1848  XLabel << layer;
1849  } else {
1850  XLabel << "," << layer;
1851  }
1852  first = 1;
1853  rpclv1Trigger_cond_LowPt_phi->GetXaxis()->SetBinLabel(
1854  ie + 1, XLabel.str().c_str());
1855  rpclv1Trigger_cond_LowPt_phi->GetXaxis()->SetBinLabel(
1856  ie + 1, XLabel.str().c_str());
1857 
1858  rpclv1Trigger_cond_LowPt_eta->GetXaxis()->SetBinLabel(
1859  ie + 1, XLabel.str().c_str());
1860  rpclv1Trigger_cond_LowPt_eta->GetXaxis()->SetBinLabel(
1861  ie + 1, XLabel.str().c_str());
1862 
1863  rpclv1Trigger_cond_HighPt_phi->GetXaxis()->SetBinLabel(
1864  ie + 1, XLabel.str().c_str());
1865  rpclv1Trigger_cond_HighPt_phi->GetXaxis()->SetBinLabel(
1866  ie + 1, XLabel.str().c_str());
1867 
1868  rpclv1Trigger_cond_HighPt_eta->GetXaxis()->SetBinLabel(
1869  ie + 1, XLabel.str().c_str());
1870  rpclv1Trigger_cond_HighPt_eta->GetXaxis()->SetBinLabel(
1871  ie + 1, XLabel.str().c_str());
1872  }
1873  }
1874  }
1875 
1877 
1878  /*
1879  //mean time-trigger time
1880  std::string m_generic_path_rpclv1triggertimemean =
1881  generic_path_rpclv1monitoring+"/Overview"; std::string
1882  m_rpclv1triggertimemean_title = "Mean time - Mean Trigger time";
1883  const char* m_rpclv1triggertimemean_title_char =
1884  m_rpclv1triggertimemean_title.c_str (); TH2
1885  *rpclv1triggertimemean=new
1886  TH2I(m_rpclv1triggertimemean_title_char,m_rpclv1triggertimemean_title_char,
1887  1000, 0, 1000, 64, 0, 64 );
1888  sc=rpclv1prd_shift.regHist(rpclv1triggertimemean) ;
1889  if(sc.isFailure()) { ATH_MSG_FATAL ( "rpclv1triggertimemean Failed
1890  to register histogram " ); return sc;
1891  }
1892  rpclv1triggertimemean->SetFillColor(42);
1893  rpclv1triggertimemean->GetXaxis()->SetTitle("16channelgroup + ijk*2
1894  + Cma*12 + Tower*100");
1895  rpclv1triggertimemean->GetYaxis()->SetTitle("SectorLogic");
1896 
1897  ATH_MSG_DEBUG ( "INSIDE bookHistograms : " << rpclv1triggertimemean
1898  << m_generic_path_rpclv1triggertimemean.c_str() ); ATH_MSG_DEBUG (
1899  "SHIFT : " << shift ); ATH_MSG_DEBUG ( "RUN : " << run );
1900  ATH_MSG_DEBUG ( "Booked rpclv1triggertimemean successfully" );
1901 
1903 
1904  //RMS time-trigger time
1905  std::string m_generic_path_rpclv1triggertimeRMS =
1906  generic_path_rpclv1monitoring+"/Overview"; std::string
1907  m_rpclv1triggertimeRMS_title = "RMS of time - Trigger time"; const
1908  char* m_rpclv1triggertimeRMS_title_char =
1909  m_rpclv1triggertimeRMS_title.c_str (); TH2 *rpclv1triggertimeRMS=new
1910  TH2I(m_rpclv1triggertimeRMS_title_char,m_rpclv1triggertimeRMS_title_char,
1911  1000, 0, 1000, 64, 0, 64
1912  ); sc=rpclv1prd_shift.regHist(rpclv1triggertimeRMS) ;
1913  if(sc.isFailure()) { ATH_MSG_FATAL ( "rpclv1triggertimeRMS Failed to
1914  register histogram " ); return sc;
1915  }
1916  rpclv1triggertimeRMS->SetFillColor(42);
1917  rpclv1triggertimeRMS->GetXaxis()->SetTitle("16channelgroup + ijk*2 +
1918  Cma*12 + Tower*100);
1919  rpclv1triggertimeRMS->GetYaxis()->SetTitle("SectorLogic");
1920 
1921  ATH_MSG_DEBUG ( "INSIDE bookHistograms : " << rpclv1triggertimeRMS
1922  << m_generic_path_rpclv1triggertimeRMS.c_str() ); ATH_MSG_DEBUG (
1923  "SHIFT : " << shift ); ATH_MSG_DEBUG ( "RUN : " << run );
1924  ATH_MSG_DEBUG ( "Booked rpclv1triggertimeRMS successfully" );
1925 
1926  */
1927 
1929 
1930  // BCid_per_TriggerType
1931  std::string rpclv1_BCid_per_TriggerType_title =
1932  "rpclv1_BCid_per_TriggerType";
1933  const char* rpclv1_BCid_per_TriggerType_title_char =
1934  rpclv1_BCid_per_TriggerType_title.c_str();
1935 
1936  TH2* rpclv1_BCid_per_TriggerType = new TH2I(
1937  rpclv1_BCid_per_TriggerType_title_char,
1938  rpclv1_BCid_per_TriggerType_title_char, 8, 0, 8, 8 * 2, 0, 16);
1939  sc = rpclv1_shift_dqmf.regHist(rpclv1_BCid_per_TriggerType);
1940  if (sc.isFailure()) {
1941  ATH_MSG_FATAL(
1942  "rpclv1_BCid_per_TriggerType Failed to register "
1943  "histogram ");
1944  return sc;
1945  }
1946  rpclv1_BCid_per_TriggerType->SetFillColor(42);
1947  rpclv1_BCid_per_TriggerType->GetXaxis()->SetTitle("Trigger Type");
1948  rpclv1_BCid_per_TriggerType->GetYaxis()->SetTitle(
1949  "BCId+HPtTrigger*8 for trigger hits");
1950  rpclv1_BCid_per_TriggerType->SetOption("COLZ");
1951 
1952  ATH_MSG_DEBUG(
1953  "INSIDE bookHistograms : " << rpclv1_BCid_per_TriggerType);
1954  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1955  ATH_MSG_DEBUG("RUN : " << run);
1956  ATH_MSG_DEBUG("Booked rpclv1_BCid_per_TriggerType successfully");
1957  //
1958 
1959  // BCid_per_TriggerCorrelation
1960  std::string rpclv1_BCid_per_TriggerCorr_title =
1961  "rpclv1_BCid_per_TriggerCorrelation";
1962  const char* rpclv1_BCid_per_TriggerCorr_title_char =
1963  rpclv1_BCid_per_TriggerCorr_title.c_str();
1964 
1965  TH2* rpclv1_BCid_per_TriggerCorr =
1966  new TH2I(rpclv1_BCid_per_TriggerCorr_title_char,
1967  rpclv1_BCid_per_TriggerCorr_title_char, 256, 0, 256,
1968  8 * 2, 0, 16);
1969  sc = rpclv1prd_shift.regHist(rpclv1_BCid_per_TriggerCorr);
1970  if (sc.isFailure()) {
1971  ATH_MSG_FATAL(
1972  "rpclv1_BCid_per_TriggerCorr Failed to register "
1973  "histogram ");
1974  return sc;
1975  }
1976  rpclv1_BCid_per_TriggerCorr->SetFillColor(42);
1977  rpclv1_BCid_per_TriggerCorr->GetXaxis()->SetTitle("Trigger Corr");
1978  rpclv1_BCid_per_TriggerCorr->GetYaxis()->SetTitle(
1979  "BCId+HPtTrigger*8 for trigger hits");
1980  rpclv1_BCid_per_TriggerCorr->SetOption("COLZ");
1981 
1982  ATH_MSG_DEBUG(
1983  "INSIDE bookHistograms : " << rpclv1_BCid_per_TriggerCorr);
1984  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
1985  ATH_MSG_DEBUG("RUN : " << run);
1986  ATH_MSG_DEBUG("Booked rpclv1_BCid_per_TriggerCorr successfully");
1987  //
1988 
1989  // cool histogram
1990  // strip profile -> noise and dead strips
1991  if (m_doCoolDB) {
1992  std::vector<std::string> DB_list;
1993  // DB_list.push_back( "StripId" );
1994  DB_list.push_back("ProfileCabling");
1995  DB_list.push_back("ProfileDataCModd");
1996  DB_list.push_back("ProfileDataCMeven");
1997 
1998  for (std::vector<std::string>::const_iterator iter =
1999  DB_list.begin();
2000  iter != DB_list.end(); ++iter) {
2001  for (int isec = 0; isec != 16; isec++) {
2002  for (int idblPhi = 0; idblPhi != 2; idblPhi++) {
2003  bookRPCCoolHistograms(iter, isec, idblPhi,
2004  "Pivot0");
2005  bookRPCCoolHistograms(iter, isec, idblPhi,
2006  "Pivot1");
2007  bookRPCCoolHistograms(iter, isec, idblPhi,
2008  "LowPt0");
2009  bookRPCCoolHistograms(iter, isec, idblPhi,
2010  "LowPt1");
2011  bookRPCCoolHistograms(iter, isec, idblPhi,
2012  "HighPt0");
2013  bookRPCCoolHistograms(iter, isec, idblPhi,
2014  "HighPt1");
2015  }
2016  }
2017  }
2018 
2019  for (uint16_t side = 0; side != 2; side++) {
2020  for (uint16_t slogic = 0; slogic != 32; slogic++) {
2021  for (uint16_t padId = 0; padId != 9; padId++) {
2022  for (uint16_t cmaId = 0; cmaId != 8; cmaId++) {
2023  for (uint16_t ijk = 0; ijk != 6; ijk++) {
2024  if (cmaId > 3 && ijk < 2)
2025  continue;
2026  for (uint16_t channel = 0; channel != 32;
2027  channel++) {
2028  SG::ReadCondHandle<RpcCablingCondData>
2029  readHandle{m_readKey};
2030  const RpcCablingCondData* readCdo{
2031  *readHandle};
2032  // Get the list of offline channels
2033  // corresponding to the online
2034  // identifier
2035  std::list<Identifier> idList =
2036  readCdo->give_strip_id(
2037  side, slogic, padId, cmaId, ijk,
2038  channel,
2039  &m_idHelperSvc->rpcIdHelper());
2040  std::list<Identifier>::const_iterator
2041  it_list;
2042 
2043  for (it_list = idList.begin();
2044  it_list != idList.end();
2045  ++it_list) {
2046  // and add the digit to the
2047  // collection
2048  Identifier prdcoll_id = *it_list;
2049  std::vector<std::string>
2050  rpclayersectorsidename = RpcGM::
2051  RpcLayerSectorSideName(
2052  m_idHelperSvc
2053  ->rpcIdHelper(),
2054  prdcoll_id, 0);
2055  std::string sector_dphi_layer =
2056  rpclayersectorsidename[12];
2057 
2058  std::vector<int> RpcStrip =
2059  RpcGM::RpcStripShift(
2060  MuonDetMgr,
2061  m_idHelperSvc
2062  ->rpcIdHelper(),
2063  prdcoll_id, 0);
2064  int strip_dbindex =
2065  (RpcGM::RpcStripShift(
2066  MuonDetMgr,
2067  m_idHelperSvc
2068  ->rpcIdHelper(),
2069  prdcoll_id, 0))
2070  .at(16); // cool strip
2071  // profile
2072  if (m_doCoolDB) {
2073  TH1* rpcCool_PanelIdHist =
2074  nullptr;
2075  sc = rpcCoolDb.getHist(
2076  rpcCool_PanelIdHist,
2077  sector_dphi_layer +
2078  "_ProfileCabling");
2079  if (sc.isFailure())
2080  ATH_MSG_WARNING(
2081  "couldn't get "
2082  << sector_dphi_layer
2083  << "_ProfileCabling");
2084 
2085  if (rpcCool_PanelIdHist) {
2086  rpcCool_PanelIdHist->Fill(
2087  strip_dbindex);
2088  }
2089  }
2090  }
2091  }
2092  }
2093  }
2094  }
2095  }
2096  }
2097 
2098  } // end if (m_doCoolDB)
2099 
2100  } // isNewRun
2101 
2102  } // AthenaMonManager::tier0 || AthenaMonManager::tier0Raw
2103 
2104  return sc;
2105 }
2106 
2107 StatusCode RpcLv1RawDataValAlg::bookRPCLV1cmatimevschHistograms(
2108  const std::string& sectorlogic_name, const std::string& tower_name,
2109  const std::string& cma_name) {
2110  StatusCode sc = StatusCode::SUCCESS;
2111 
2112  if (m_environment == AthenaMonManager::tier0 ||
2113  m_environment == AthenaMonManager::tier0Raw) {
2114  // declare a group of histograms
2115  std::string generic_path_rpclv1monitoring =
2116  "Muon/MuonRawDataMonitoring/RPCLV1";
2117  MonGroup rpclv1prd_expert(
2118  this,
2119  generic_path_rpclv1monitoring + "/TriggerRoad/" + sectorlogic_name,
2120  run, ATTRIB_UNMANAGED);
2121  MuonDQAHistList& lst = m_stationHists.getList(sectorlogic_name);
2122 
2123  std::string generic_path_RPCLV1cmatimevsch =
2124  generic_path_rpclv1monitoring + "/" + sectorlogic_name + "/" +
2125  tower_name + "/rpclv1cosmic_cmatimevsch" + cma_name;
2126  std::string RPCLV1cmatimevsch_title =
2127  sectorlogic_name + "_" + tower_name + cma_name + "_time_vs_channel";
2128  const char* RPCLV1cmatimevsch_title_char =
2129  RPCLV1cmatimevsch_title.c_str();
2130  TH2* RPCLV1cmatimevsch =
2131  new TH2I(RPCLV1cmatimevsch_title_char, RPCLV1cmatimevsch_title_char,
2132  32 * 7 / m_rpclv1reducenbins, 0, 32 * 7, 64, 0, 64);
2133  lst.addHist(RPCLV1cmatimevsch);
2134  RPCLV1cmatimevsch->SetFillColor(42);
2135  RPCLV1cmatimevsch->SetMarkerColor(1);
2136  RPCLV1cmatimevsch->SetMarkerStyle(21);
2137  RPCLV1cmatimevsch->SetMarkerSize(0.2);
2138  RPCLV1cmatimevsch->GetXaxis()->SetTitle("Channel + 32 * ijk");
2139  RPCLV1cmatimevsch->GetYaxis()->SetTitle("Time=bcId*8+ticks");
2140 
2141  ATH_MSG_DEBUG("INSIDE bookRPCLV1cmatimevschHistograms : "
2142  << RPCLV1cmatimevsch
2143  << generic_path_RPCLV1cmatimevsch.c_str());
2144  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
2145  ATH_MSG_DEBUG("RUN : " << run);
2146 
2147  sc = rpclv1prd_expert.regHist(RPCLV1cmatimevsch);
2148  if (sc.isFailure())
2149  ATH_MSG_WARNING(
2150  "couldn't register RPCLV1cmatimevsch hist to MonGroup");
2151 
2152  std::string generic_path_RPCLV1cmatimetriggervsch =
2153  generic_path_rpclv1monitoring + "/" + sectorlogic_name + "/" +
2154  tower_name + "/rpclv1cosmic_cmatimetriggervsch" + cma_name;
2155  std::string RPCLV1cmatimetriggervsch_title =
2156  sectorlogic_name + "_" + tower_name + cma_name +
2157  "_(time-triggertime)_vs_channel";
2158  const char* RPCLV1cmatimetriggervsch_title_char =
2159  RPCLV1cmatimetriggervsch_title.c_str();
2160 
2161  TH2* RPCLV1cmatimetriggervsch =
2162  new TH2I(RPCLV1cmatimetriggervsch_title_char,
2163  RPCLV1cmatimetriggervsch_title_char,
2164  32 * 7 / m_rpclv1reducenbins, 0, 32 * 7, 2 * 64, -64, 64);
2165  lst.addHist(RPCLV1cmatimetriggervsch);
2166  RPCLV1cmatimetriggervsch->SetFillColor(42);
2167  RPCLV1cmatimetriggervsch->SetMarkerColor(1);
2168  RPCLV1cmatimetriggervsch->SetMarkerStyle(21);
2169  RPCLV1cmatimetriggervsch->SetMarkerSize(0.2);
2170  RPCLV1cmatimetriggervsch->GetXaxis()->SetTitle("Channel + 32 * ijk");
2171  RPCLV1cmatimetriggervsch->GetYaxis()->SetTitle("Time=bcId*8+ticks");
2172 
2173  ATH_MSG_DEBUG("INSIDE bookRPCLV1cmatimevschHistograms : "
2174  << RPCLV1cmatimetriggervsch
2175  << generic_path_RPCLV1cmatimetriggervsch.c_str());
2176  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
2177  ATH_MSG_DEBUG("RUN : " << run);
2178 
2179  sc = rpclv1prd_expert.regHist(RPCLV1cmatimetriggervsch);
2180  if (sc.isFailure())
2181  ATH_MSG_WARNING(
2182  "couldn't register RPCLV1cmatimetriggervsch hist to MonGroup");
2183 
2184  } // AthenaMonManager::tier0 || AthenaMonManager::tier0Raw
2185  return sc;
2186 }
2187 
2188 StatusCode RpcLv1RawDataValAlg::bookRPCLV1TriggerRoadHistograms(
2189  const std::string& sectorlogic_name, const std::string& tower_name,
2190  const std::string& cma_name, const std::string& thr_name)
2191 
2192 {
2193  // Trigger Road LowPt vs ijk channel
2194  StatusCode sc = StatusCode::SUCCESS;
2195 
2196  if (m_environment == AthenaMonManager::tier0 ||
2197  m_environment == AthenaMonManager::tier0Raw) {
2198  // declare a group of histograms
2199  std::string generic_path_rpclv1monitoring =
2200  "Muon/MuonRawDataMonitoring/RPCLV1";
2201  MonGroup rpclv1prd_expert(
2202  this,
2203  generic_path_rpclv1monitoring + "/TriggerRoad/" + sectorlogic_name,
2204  run, ATTRIB_UNMANAGED);
2205  MuonDQAHistList& lst = m_stationHists.getList(sectorlogic_name);
2206 
2207  std::string generic_path_RPCLV1TriggerRoad =
2208  generic_path_rpclv1monitoring + "/" + sectorlogic_name + "/" +
2209  tower_name + "/rpclv1cosmic_TriggerRoad" + cma_name + thr_name;
2210  std::string RPCLV1TriggerRoad_title = sectorlogic_name + "_" +
2211  tower_name + cma_name + thr_name +
2212  "_TriggerRoad";
2213  const char* RPCLV1TriggerRoad_title_char =
2214  RPCLV1TriggerRoad_title.c_str();
2215  TH2* RPCLV1TriggerRoad = new TH2I(
2216  RPCLV1TriggerRoad_title_char, RPCLV1TriggerRoad_title_char,
2217  32 / m_rpclv1reducenbins, 0, 32, 64 / m_rpclv1reducenbins, 0, 64);
2218  lst.addHist(RPCLV1TriggerRoad);
2219  RPCLV1TriggerRoad->SetOption("COLZ");
2220  RPCLV1TriggerRoad->GetXaxis()->SetTitle("Channel (ijk=6)");
2221  RPCLV1TriggerRoad->GetYaxis()->SetTitle("Confirm channel");
2222 
2223  ATH_MSG_DEBUG("INSIDE bookRPCLV1TriggerRoadHistograms : "
2224  << RPCLV1TriggerRoad
2225  << generic_path_RPCLV1TriggerRoad.c_str());
2226  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
2227  ATH_MSG_DEBUG("RUN : " << run);
2228 
2229  sc = rpclv1prd_expert.regHist(RPCLV1TriggerRoad);
2230  if (sc.isFailure())
2231  ATH_MSG_WARNING(
2232  "couldn't register RPCLV1TriggerRoad hist to MonGroup");
2233 
2234  } // AthenaMonManager::tier0 || AthenaMonManager::tier0Raw
2235  return sc;
2236 }
2237 
2239 // void RpcLv1RawDataValAlg::bookRPCLV1ProfilesHistograms(int m_i_sector,
2240 // std::string sectorlogic_name, int m_i_cmaId, std::string cma_name, int
2241 // m_i_ijk, std::string m_ijk_name)
2242 StatusCode RpcLv1RawDataValAlg::bookRPCLV1ProfilesHistograms(
2243  int i_sector, const std::string& sectorlogic_name,
2244  const std::string& cma_name, int i_ijk, const std::string& ijk_name) {
2245  // book profiles histograms
2246 
2247  StatusCode sc = StatusCode::SUCCESS;
2248  if (m_environment == AthenaMonManager::tier0 ||
2249  m_environment == AthenaMonManager::tier0Raw) {
2250  int N_pad = 6;
2251  std::string cm_ch_label = "64";
2252  std::string pad_ch_label = "128";
2253 
2254  // declare a group of histograms
2255  std::string generic_path_rpclv1monitoring =
2256  "Muon/MuonRawDataMonitoring/RPCLV1";
2257  MonGroup rpclv1prd_expert(
2258  this,
2259  generic_path_rpclv1monitoring + "/Profiles/" + sectorlogic_name,
2260  run, ATTRIB_UNMANAGED);
2261  MuonDQAHistList& lst = m_stationHists.getList(sectorlogic_name);
2262 
2263  std::string generic_path_RPCLV1Profiles =
2264  generic_path_rpclv1monitoring + "/" + sectorlogic_name + "_" +
2265  cma_name + "_" + ijk_name + "_profiles";
2266 
2267  if ((i_sector % 4) == 0 || (i_sector % 4) == 3) {
2268  N_pad = 7;
2269  }
2270  int N_bin_profile = 0;
2271  if (i_ijk < 2 || i_ijk == 6) {
2272  N_bin_profile = 2 * 32 * N_pad;
2273  cm_ch_label = "32";
2274  pad_ch_label = "64";
2275  } else {
2276  N_bin_profile = 2 * 64 * N_pad;
2277  }
2278  /*
2279  if ( m_i_cmaId==0 || m_i_cmaId==1 ) { cma_name="Cma0_1" ; }
2280  if ( m_i_cmaId==2 || m_i_cmaId==3 ) { cma_name="Cma2_3" ; }
2281  if ( m_i_cmaId==4 || m_i_cmaId==5 ) { cma_name="Cma4_5" ; }
2282  if ( m_i_cmaId==6 || m_i_cmaId==7 ) { cma_name="Cma6_7" ; }
2283 
2284  if ( i_ijk==2 || i_ijk==3 ) { ijk_name="ijk2_3" ; }
2285  if ( i_ijk==4 || i_ijk==5 ) { ijk_name="ijk4_5" ; } */
2286 
2287  std::string RPCLV1Profiles_title =
2288  sectorlogic_name + "_" + cma_name + "_" + ijk_name + "_Profiles";
2289  const char* RPCLV1Profiles_title_char = RPCLV1Profiles_title.c_str();
2290  TH1* RPCLV1Profiles =
2291  new TH1I(RPCLV1Profiles_title_char, RPCLV1Profiles_title_char,
2292  N_bin_profile / m_rpclv1reducenbins, 0, N_bin_profile);
2293  lst.addHist(RPCLV1Profiles);
2294 
2295  std::string x_axis_title = "Channel+ (ijk-ijk_off)*32 +cm*" +
2296  cm_ch_label + " +pad*" + pad_ch_label;
2297  const char* x_axis_title_char = x_axis_title.c_str();
2298  RPCLV1Profiles->GetXaxis()->SetTitle(x_axis_title_char);
2299  RPCLV1Profiles->GetYaxis()->SetTitle("Counts ");
2300  RPCLV1Profiles->SetFillColor(42); // 38
2301 
2302  ATH_MSG_DEBUG("INSIDE bookRPCLV1ProfilesHistograms : "
2303  << RPCLV1Profiles << generic_path_RPCLV1Profiles.c_str());
2304  // ATH_MSG_DEBUG ( "SHIFT : " << shift );
2305  ATH_MSG_DEBUG("RUN : " << run);
2306 
2307  sc = rpclv1prd_expert.regHist(RPCLV1Profiles);
2308  if (sc.isFailure())
2309  ATH_MSG_WARNING(
2310  "couldn't register RPCLV1Profiles hist to MonGroup");
2311 
2312  } // AthenaMonManager::tier0 || AthenaMonManager::tier0Raw
2313 
2314  return sc;
2315 }
2316 
2317 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2318 
2319 void RpcLv1RawDataValAlg::bookRPCCoolHistograms(
2320  std::vector<std::string>::const_iterator& iter, int isec, int idblPhi,
2321  const std::string& layer) {
2322  StatusCode sc = StatusCode::SUCCESS;
2323 
2324  std::string generic_path_rpcmonitoring =
2325  "Muon/MuonRawDataMonitoring/RPCLV1";
2326  MonGroup rpcCoolDb(this, generic_path_rpcmonitoring + "/CoolDB", run,
2327  ATTRIB_UNMANAGED);
2328 
2329  char histName_char[100];
2330  sprintf(histName_char, "Sector%.2d_%s_dblPhi%d", isec + 1, layer.c_str(),
2331  idblPhi + 1);
2332  // example: Sector01_Pivot0_dblPhi1_StripId
2333 
2334  std::string histName = histName_char;
2335  histName += "_";
2336  histName += *iter; // histName += m_coolQuantity ;
2337  int istatPhi = int(isec / 2);
2338  int iName = 0;
2339  int kName = 0;
2340  int ig = 0;
2341  int iNameMax = 0;
2342  int ir = 0;
2343 
2344  if (isec == 12) {
2345  // if ( layer.find("Pivot",0) )
2346  if (layer == "Pivot0" || layer == "Pivot1") {
2347  iName = 1;
2348  iNameMax = 2;
2349  ir = 2;
2350  ig = atoi((layer.substr(5, 1)).c_str());
2351  }
2352  if (layer == "LowPt0" || layer == "LowPt1") {
2353  iName = 1;
2354  iNameMax = 2;
2355  ir = 1;
2356  ig = atoi((layer.substr(5, 1)).c_str());
2357  }
2358  if (layer == "HighPt0" || layer == "HighPt1") {
2359  iName = 4;
2360  iNameMax = iName;
2361  ir = 1;
2362  ig = atoi((layer.substr(6, 1)).c_str());
2363  }
2364  } // sector 13
2365  else if (isec == 11 || isec == 13) {
2366  if (layer == "Pivot0" || layer == "Pivot1") {
2367  iName = 8;
2368  iNameMax = 10;
2369  ir = 2;
2370  ig = atoi((layer.substr(5, 1)).c_str());
2371  }
2372  if (layer == "LowPt0" || layer == "LowPt1") {
2373  iName = 8;
2374  iNameMax = iName;
2375  ir = 1;
2376  ig = atoi((layer.substr(5, 1)).c_str());
2377  }
2378  if (layer == "HighPt0" || layer == "HighPt1") {
2379  iName = 9; // or 10 ;
2380  iNameMax = 10;
2381  ir = 1; // doubletR=2 -> upgrade of Atlas
2382  ig = atoi((layer.substr(6, 1)).c_str());
2383  }
2384  } // end sectors 12 and 14
2385  else {
2386  // if ( layer.find("Pivot",0) )
2387  if (layer == "Pivot0" || layer == "Pivot1") {
2388  iName = 2 + (isec % 2);
2389  ir = 2;
2390  ig = atoi((layer.substr(5, 1)).c_str());
2391  }
2392  if (layer == "LowPt0" || layer == "LowPt1") {
2393  iName = 2 + (isec % 2);
2394  ir = 1;
2395  ig = atoi((layer.substr(5, 1)).c_str());
2396  }
2397  if (layer == "HighPt0" || layer == "HighPt1") {
2398  iName = 4 + (isec % 2);
2399  ir = 1;
2400  ig = atoi((layer.substr(6, 1)).c_str());
2401  }
2402  iNameMax = iName;
2403  }
2404 
2405  kName = iName;
2406  if (iName == 1)
2407  kName = 53;
2408 
2409  int NTotStripsSideA = 1;
2410  int NTotStripsSideC = 1;
2411 
2412  // MuonDetectorManager from the conditions store
2413  SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{
2414  m_DetectorManagerKey};
2415  const MuonGM::MuonDetectorManager* MuonDetMgr =
2416  DetectorManagerHandle.cptr();
2417  if (!MuonDetMgr) {
2418  ATH_MSG_ERROR(
2419  "nullptr to the read MuonDetectorManager conditions object");
2420  return;
2421  }
2422  Identifier rpcId = m_idHelperSvc->rpcIdHelper().channelID(
2423  kName, 1, istatPhi + 1, ir, 1, idblPhi + 1, 1, 1,
2424  1); // last 3 arguments are: int doubletPhi, int gasGap, int
2425  // measuresPhi, int strip
2426  if (!rpcId.is_valid()) {
2427  ATH_MSG_WARNING("Could not get valid Identifier for stationName="
2428  << kName << ", eta=1, phi=" << istatPhi + 1
2429  << ", doubletR=" << ir);
2430  }
2431  const MuonGM::RpcReadoutElement* rpc =
2432  MuonDetMgr->getRpcReadoutElement(rpcId);
2433 
2434  if (rpc) {
2435  Identifier idr = rpc->identify();
2436  std::vector<int> rpcstripshift = RpcGM::RpcStripShift(
2437  MuonDetMgr, m_idHelperSvc->rpcIdHelper(), idr, 0);
2438  NTotStripsSideA = rpcstripshift[6] + rpcstripshift[17];
2439  }
2440  rpcId = m_idHelperSvc->rpcIdHelper().channelID(
2441  kName, -1, istatPhi + 1, ir, 1, idblPhi + 1, 1, 1,
2442  1); // last 3 arguments are: int doubletPhi, int gasGap, int
2443  // measuresPhi, int strip
2444  if (!rpcId.is_valid()) {
2445  ATH_MSG_WARNING("Could not get valid Identifier for stationName="
2446  << kName << ", eta=-1, phi=" << istatPhi + 1
2447  << ", doubletR=" << ir);
2448  }
2449  rpc = MuonDetMgr->getRpcReadoutElement(rpcId);
2450 
2451  if (rpc) {
2452  Identifier idr = rpc->identify();
2453  std::vector<int> rpcstripshift = RpcGM::RpcStripShift(
2454  MuonDetMgr, m_idHelperSvc->rpcIdHelper(), idr, 0);
2455  NTotStripsSideC = rpcstripshift[7] + rpcstripshift[18];
2456  }
2457 
2458  TH1* rpcCoolHisto = new TH1F(histName.c_str(), histName.c_str(),
2459  NTotStripsSideC + NTotStripsSideA,
2460  -NTotStripsSideC, NTotStripsSideA);
2461 
2462  sc = rpcCoolDb.regHist(rpcCoolHisto);
2463  if (sc.isFailure())
2464  ATH_MSG_WARNING("couldn't register " << histName << "hist to MonGroup");
2465  rpcCoolHisto->GetXaxis()->SetTitle("strip");
2466 
2467  // Fill strip Id histogram
2468  if ((histName.find("ProfileCabling", 0)) != std::string::npos) {
2469  TH1* rpcCool_PanelIdHist = nullptr;
2470  sc = rpcCoolDb.getHist(rpcCool_PanelIdHist, histName);
2471  if (sc.isFailure())
2472  ATH_MSG_WARNING("couldn't get " << histName << " hist");
2473  rpcCool_PanelIdHist->GetYaxis()->SetTitle("strip Id");
2474  rpcCool_PanelIdHist->SetBit(TH1::kIsAverage);
2475  int rpcElemPhiStrip;
2476  int rpcElemEtaStrip;
2477  int coolStripIndex = 0;
2478 
2479  for (int ieta = 0; ieta != 17; ieta++) {
2480  for (int iNameF = iName; iNameF != iNameMax + 1; iNameF++) {
2481  kName = iNameF;
2482  if (iNameF == 1)
2483  kName = 53;
2484  if (kName > 10 && kName != 53)
2485  continue;
2486  for (int iz = 0; iz != 3; iz++) {
2487  int irc = ir;
2488  if (std::abs(ieta - 8) == 7 && ir == 1 && kName == 2)
2489  continue;
2490  if (isec == 12 && std::abs(ieta - 8) == 6 && ir == 1 &&
2491  kName == 2)
2492  continue;
2493  if (std::abs(ieta - 8) == 7 && ir == 2)
2494  irc = 1;
2495  if (isec == 12 && std::abs(ieta - 8) == 6 && ir == 2)
2496  irc = 1;
2497 
2498  rpcId = m_idHelperSvc->rpcIdHelper().channelID(
2499  kName, ieta - 8, istatPhi + 1, irc, iz + 1, idblPhi + 1,
2500  1, 1,
2501  1); // last 3 arguments are: int doubletPhi, int
2502  // gasGap, int measuresPhi, int strip
2503  if (!rpcId.is_valid()) {
2504  ATH_MSG_WARNING(
2505  "Could not get valid Identifier for stationName="
2506  << kName << ", eta=" << ieta - 8
2507  << ", phi=" << istatPhi + 1 << ", doubletR=" << irc
2508  << ", doubletZ=" << iz + 1
2509  << ", doubletPhi=" << idblPhi + 1);
2510  continue;
2511  }
2512  const MuonGM::RpcReadoutElement* rpc =
2513  MuonDetMgr->getRpcReadoutElement(rpcId);
2514  if (!rpc)
2515  continue;
2516 
2517  if (iz + 1 != rpc->getDoubletZ()) {
2518  continue;
2519  }
2520  Identifier idr =
2521  m_idHelperSvc->rpcIdHelper().parentID(rpc->identify());
2522  rpcElemPhiStrip = int(rpc->NphiStrips());
2523  rpcElemEtaStrip = int(rpc->NetaStrips());
2524 
2525  for (int istripEta = 0; istripEta != rpcElemEtaStrip;
2526  istripEta++) {
2527  Identifier strip_id =
2528  m_idHelperSvc->rpcIdHelper().channelID(
2529  idr, iz + 1, idblPhi + 1, ig + 1, 0,
2530  istripEta + 1);
2531  if (strip_id == 0)
2532  continue;
2533  coolStripIndex =
2534  (RpcGM::RpcStripShift(MuonDetMgr,
2535  m_idHelperSvc->rpcIdHelper(),
2536  strip_id, 0))
2537  .at(16);
2538  rpcCool_PanelIdHist->Fill(coolStripIndex, -1);
2539  }
2540  for (int istripPhi = 0; istripPhi != rpcElemPhiStrip;
2541  istripPhi++) {
2542  Identifier strip_id =
2543  m_idHelperSvc->rpcIdHelper().channelID(
2544  idr, iz + 1, idblPhi + 1, ig + 1, 1,
2545  istripPhi + 1);
2546  if (strip_id == 0)
2547  continue;
2548  coolStripIndex =
2549  (RpcGM::RpcStripShift(MuonDetMgr,
2550  m_idHelperSvc->rpcIdHelper(),
2551  strip_id, 0))
2552  .at(16);
2553  rpcCool_PanelIdHist->Fill(coolStripIndex, -1);
2554  }
2555 
2556  } // end loop on doubletZ
2557  }
2558  } // end loop on stationeta
2559 
2560  } // end fill cool histograms with panelId
2561 }
2562 
2563 StatusCode RpcLv1RawDataValAlg::procHistograms() {
2564  ATH_MSG_DEBUG("RpcLv1RawDataValAlg procHistograms()");
2565  return StatusCode::SUCCESS;
2566 }
MuonGM::MuonDetectorManager::getRpcReadoutElement
const RpcReadoutElement * getRpcReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:168
TH2::Fill
int Fill(double, double)
Definition: rootspy.cxx:382
RpcLv1RawDataValAlg::m_DetectorManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_DetectorManagerKey
Definition: RpcLv1RawDataValAlg.h:94
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
RpcCablingCondData::give_strip_id
std::list< Identifier > give_strip_id(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int PADId, unsigned short int CMAId, unsigned short ijk, unsigned short int Channel, const RpcIdHelper *rpcId) const
Definition: RpcCablingCondData.cxx:269
RpcLv1RawDataValAlg::m_sector
int m_sector
Definition: RpcLv1RawDataValAlg.h:74
AddEmptyComponent.histName
string histName
Definition: AddEmptyComponent.py:64
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:28
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
RpcLv1RawDataValAlg::StoreTriggerType
StatusCode StoreTriggerType()
Definition: RpcLv1RawDataValAlg.cxx:94
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
RpcLv1RawDataValAlg::m_rpclv1file
bool m_rpclv1file
Definition: RpcLv1RawDataValAlg.h:88
TH1I
Definition: rootspy.cxx:332
ManagedMonitorToolBase
Provides functionality for users to implement and save histograms, ntuples, and summary data,...
Definition: ManagedMonitorToolBase.h:74
RpcLv1RawDataValAlg::m_doCoolDB
bool m_doCoolDB
Definition: RpcLv1RawDataValAlg.h:106
RpcLv1RawDataValAlg::bookHistogramsRecurrent
virtual StatusCode bookHistogramsRecurrent()
An inheriting class should either override this function, bookHists() or bookHistograms().
Definition: RpcLv1RawDataValAlg.cxx:1060
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
RpcLv1RawDataValAlg::m_doClusters
bool m_doClusters
Definition: RpcLv1RawDataValAlg.h:86
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
RpcLv1RawDataValAlg.h
skel.it
it
Definition: skel.GENtoEVGEN.py:423
RpcLv1RawDataValAlg::RpcLv1RawDataValAlg
RpcLv1RawDataValAlg(const std::string &type, const std::string &name, const IInterface *parent)
Definition: RpcLv1RawDataValAlg.cxx:31
MuonGM::RpcReadoutElement
An RpcReadoutElement corresponds to a single RPC module; therefore typicaly a barrel muon station con...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/RpcReadoutElement.h:54
RpcLv1RawDataValAlg::m_rpclv1hist
bool m_rpclv1hist
Definition: RpcLv1RawDataValAlg.h:89
covarianceTool.XLabel
XLabel
Definition: covarianceTool.py:538
RpcLv1RawDataValAlg::procHistograms
virtual StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition: RpcLv1RawDataValAlg.cxx:2563
RpcLv1RawDataValAlg::m_rpcRdoKey
SG::ReadHandleKey< RpcPadContainer > m_rpcRdoKey
Definition: RpcLv1RawDataValAlg.h:79
Identifier::is_valid
bool is_valid() const
Check if id is in a valid state.
RpcGM::RpcStripShift
std::vector< int > RpcStripShift(const MuonGM::MuonDetectorManager *muonMgr, const RpcIdHelper &rpcIdHelper, Identifier prdcoll_id, int irpctriggerInfo)
Definition: RpcGlobalUtilities.cxx:17
RpcLv1RawDataValAlg::bookRPCLV1cmatimevschHistograms
StatusCode bookRPCLV1cmatimevschHistograms(const std::string &m_sectorlogic_name, const std::string &m_tower_name, const std::string &m_cma_name)
Definition: RpcLv1RawDataValAlg.cxx:2107
RpcLv1RawDataValAlg::m_checkCabling
bool m_checkCabling
Definition: RpcLv1RawDataValAlg.h:87
RpcLv1RawDataValAlg::m_rpclv1reducenbins
int m_rpclv1reducenbins
Definition: RpcLv1RawDataValAlg.h:91
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
MuonDQAHistList::addHist
void addHist(TH1 *p)
Definition: MuonDQAHistMap.h:37
MuonChamberNameConverter.h
RpcCablingCondData
Definition: RpcCablingCondData.h:21
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
PlotCalibFromCool.ie
ie
Definition: PlotCalibFromCool.py:420
TRT::Hit::side
@ side
Definition: HitInfo.h:83
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition: ManagedMonitorToolBase.h:138
StoreGateSvc
The Athena Transient Store API.
Definition: StoreGateSvc.h:128
RpcLv1RawDataValAlg::initialize
StatusCode initialize()
Definition: RpcLv1RawDataValAlg.cxx:55
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
RpcLv1RawDataValAlg::m_side
int m_side
Definition: RpcLv1RawDataValAlg.h:75
RpcLv1RawDataValAlg::m_trigtype
int m_trigtype
Definition: RpcLv1RawDataValAlg.h:72
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:669
MuonChambersRange.h
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:88
AthenaMonManager::tier0
@ tier0
Definition: AthenaMonManager.h:49
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
RpcLv1RawDataValAlg::m_stationHists
MuonDQAHistMap m_stationHists
Definition: RpcLv1RawDataValAlg.h:68
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
RpcLv1RawDataValAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: RpcLv1RawDataValAlg.h:98
TH2I
Definition: rootspy.cxx:410
AthenaMonManager::online
@ online
Definition: AthenaMonManager.h:49
RpcLv1RawDataValAlg::GetTriggerType
int GetTriggerType() const
Definition: RpcLv1RawDataValAlg.h:71
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
RpcLv1RawDataValAlg::m_lastEvent
int m_lastEvent
Definition: RpcLv1RawDataValAlg.h:112
MuonGM::RpcReadoutElement::NphiStrips
int NphiStrips() const
returns the number of phi strips
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
AthenaMonManager.h
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition: IdentifiableContainerMT.h:242
MakeTH3DFromTH2Ds.hists
hists
Definition: MakeTH3DFromTH2Ds.py:72
run
Definition: run.py:1
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
RpcLv1RawDataValAlg::m_profile_list
std::vector< std::string > m_profile_list
Definition: RpcLv1RawDataValAlg.h:84
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:236
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
TH1::Fill
int Fill(double)
Definition: rootspy.cxx:285
RpcLv1RawDataValAlg::m_cosmicStation
int m_cosmicStation
Definition: RpcLv1RawDataValAlg.h:113
TH2
Definition: rootspy.cxx:373
MuonGM::RpcReadoutElement::NetaStrips
int NetaStrips() const
returns the number of eta strips
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
RpcLv1RawDataValAlg::m_sectorlogicTowerCma_name_list2
std::vector< std::string > m_sectorlogicTowerCma_name_list2
Definition: RpcLv1RawDataValAlg.h:83
ManagedMonitorToolBase::m_environment
AthenaMonManager::Environment_t m_environment
Definition: ManagedMonitorToolBase.h:902
RpcLv1RawDataValAlg::m_StationEta
int m_StationEta
Definition: RpcLv1RawDataValAlg.h:110
RpcLv1RawDataValAlg::bookRPCLV1TriggerRoadHistograms
StatusCode bookRPCLV1TriggerRoadHistograms(const std::string &m_sectorlogic_name, const std::string &m_tower_name, const std::string &m_cma_name, const std::string &m_thr_name)
Definition: RpcLv1RawDataValAlg.cxx:2188
RpcLv1RawDataValAlg::m_StationPhi
int m_StationPhi
Definition: RpcLv1RawDataValAlg.h:111
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
RpcLv1RawDataValAlg::bookRPCLV1ProfilesHistograms
StatusCode bookRPCLV1ProfilesHistograms(int m_i_sector, const std::string &m_sectorlogic_name, const std::string &m_cma_name, int m_i_ijk, const std::string &m_ijk_name)
profile cabling
Definition: RpcLv1RawDataValAlg.cxx:2242
MuonDQAHistMap::getList
MuonDQAHistList & getList(std::string station_name)
Definition: MuonDQAHistMap.h:118
RpcLv1RawDataValAlg::m_StationSize
std::string m_StationSize
Definition: RpcLv1RawDataValAlg.h:109
RpcLv1RawDataValAlg::bookRPCCoolHistograms
void bookRPCCoolHistograms(std::vector< std::string >::const_iterator &m_iter, int, int, const std::string &m_layer)
Definition: RpcLv1RawDataValAlg.cxx:2319
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
RpcLv1RawDataValAlg::m_rpclv1prof
bool m_rpclv1prof
Definition: RpcLv1RawDataValAlg.h:90
RpcPad
Definition: RpcPad.h:21
MuonDQAHistList
Definition: MuonDQAHistMap.h:31
ir
int ir
counter of the current depth
Definition: fastadd.cxx:49
RpcLv1RawDataValAlg::m_readKey
SG::ReadCondHandleKey< RpcCablingCondData > m_readKey
Definition: RpcLv1RawDataValAlg.h:101
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
RpcLv1RawDataValAlg::m_chamberName
std::string m_chamberName
Definition: RpcLv1RawDataValAlg.h:108
MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:49
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
RpcLv1RawDataValAlg::m_sectorlogicTowerCma_name_list
std::vector< std::string > m_sectorlogicTowerCma_name_list
Definition: RpcLv1RawDataValAlg.h:82
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TH1
Definition: rootspy.cxx:268
RpcGM::RpcLayerSectorSideName
std::vector< std::string > RpcLayerSectorSideName(const RpcIdHelper &rpcIdHelper, Identifier prdcoll_id, int irpctriggerInfo)
Definition: RpcGlobalUtilities.cxx:468
DeMoScan.first
bool first
Definition: DeMoScan.py:534
MuonGM::MuonReadoutElement::identify
Identifier identify() const override final
Returns the ATLAS Identifier of the MuonReadOutElement.
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:184
MuonDQAHistList::getH1
TH1 * getH1(const std::string &hist_name) const
Definition: MuonDQAHistMap.h:43
xAOD::EventInfo_v1::level1TriggerType
uint16_t level1TriggerType() const
The Level-1 trigger type.
RpcLv1RawDataValAlg::fillHistograms
virtual StatusCode fillHistograms()
An inheriting class should either override this function or fillHists().
Definition: RpcLv1RawDataValAlg.cxx:103
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
MuonGM::RpcReadoutElement::getDoubletZ
int getDoubletZ() const
return DoubletZ value for the given readout element
RpcLv1RawDataValAlg::m_eventInfo
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo
Definition: RpcLv1RawDataValAlg.h:77
readCCLHist.float
float
Definition: readCCLHist.py:83
fitman.k
k
Definition: fitman.py:528
xAOD::RpcStrip
RpcStrip_v1 RpcStrip
Defined the version of the RpcStrip.
Definition: RpcStrip.h:12
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