ATLAS Offline Software
MdtRawDataValAlg.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 : MdtRawDataValAlg
7 // Authors: N. Benekos(Illinois)
8 // A. Cortes (Illinois)
9 // G. Dedes (MPI)
10 // Orin Harris (University of Washington)
11 // Justin Griffiths (University of Washington)
12 // Oct. 2007
13 //
14 // DESCRIPTION:
15 // Subject: MDT-->Offline Muon Data Quality
17 
18 #include "MdtRawDataValAlg.h"
19 
20 #include "AnalysisTriggerEvent/LVL1_ROI.h"
21 #include "AthenaMonitoring/AthenaMonManager.h"
22 #include "GaudiKernel/MsgStream.h"
23 #include "GeoModelUtilities/GeoGetIds.h"
24 #include "Identifier/Identifier.h"
25 #include "Identifier/IdentifierHash.h"
26 #include "MdtCalibFitters/MTStraightLine.h"
27 #include "MuonCalibIdentifier/MuonFixedId.h"
28 #include "MuonChamberIDSelector.h"
29 #include "MuonDQAUtils/MuonChamberNameConverter.h"
30 #include "MuonDQAUtils/MuonChambersRange.h"
31 #include "MuonDQAUtils/MuonDQAHistMap.h"
32 #include "MuonIdHelpers/MdtIdHelper.h"
33 #include "MuonRIO_OnTrack/MdtDriftCircleOnTrack.h"
34 #include "MuonReadoutGeometry/MuonStation.h"
35 #include "MuonSegment/MuonSegment.h"
36 #include "TrkEventPrimitives/FitQuality.h"
37 #include "TrkTrack/Track.h"
38 #include "TrkTrack/TrackCollection.h"
39 #include "xAODMuon/Muon.h"
40 #include "xAODTracking/TrackParticle.h"
41 #include "xAODTracking/TrackParticleContainer.h"
42 #include "xAODTracking/TrackingPrimitives.h"
43 // root includes
44 #include <TH1F.h>
45 #include <TH2F.h>
46 
47 #include <cmath>
48 #include <sstream>
49 
50 namespace {
51  // the tube number of a tube in a tubeLayer in encoded in the GeoSerialIdentifier (modulo maxNTubesPerLayer)
52  constexpr unsigned int maxNTubesPerLayer = MdtIdHelper::maxNTubesPerLayer;
53 
54  enum { enumBarrelA, enumBarrelC, enumEndCapA, enumEndCapC };
55  enum { enumBarrel, enumEndCap };
56  enum { enumInner, enumMiddle, enumOuter, enumExtra };
57 } // namespace
58 
60 // *********************************************************************
61 // Public Methods
62 // *********************************************************************
63 
64 MdtRawDataValAlg::MdtRawDataValAlg(const std::string& type, const std::string& name, const IInterface* parent) :
65  ManagedMonitorToolBase(type, name, parent),
66  m_muonSelectionTool(this, "MuonSelectionTool", "CP::MuonSelectionTool/MuonSelectionTool"),
67  m_MdtDQFilterTools(this) {
68  // Declare the properties
69  declareProperty("DoMdtEsd", m_doMdtESD = false);
70  declareProperty("DoChamber2DHist", m_chamber_2D = true);
71  declareProperty("DoChamberHist", m_doChamberHists = true);
72  declareProperty("DoOnlineMonitoring", m_isOnline = false);
73  declareProperty("maskNoisyTubes", m_maskNoisyTubes = true);
74  declareProperty("ChamberName", m_chamberName = "XXX");
75  declareProperty("StationSize", m_StationSize = "XXX");
76  declareProperty("StationEta", m_StationEta = -100);
77  declareProperty("StationPhi", m_StationPhi = -100);
78  declareProperty("ADCCut", m_ADCCut = 50.);
79  declareProperty("ADCCutForBackground", m_ADCCut_Bkgrd = 80.);
80  declareProperty("Eff_nHits", m_nb_hits = 5.);
81  declareProperty("Eff_roadWidth", m_road_width = 2.);
82  declareProperty("Eff_chi2Cut", m_chi2_cut = 10.);
83  declareProperty("AtlasFilterTool", m_MdtDQFilterTools);
84  declareProperty("Title", m_title);
85  // Global Histogram controls
86  declareProperty("do_mdtChamberHits", m_do_mdtChamberHits = true);
87  declareProperty("do_mdttdccut_sector", m_do_mdttdccut_sector = true);
88  declareProperty("do_mdtchamberstatphislice", m_do_mdtchamberstatphislice = true);
89  // Chamber wise histogram control
90  declareProperty("do_mdttdc", m_do_mdttdc = true);
91  declareProperty("do_mdttdccut_ML1", m_do_mdttdccut_ML1 = true);
92  declareProperty("do_mdttdccut_ML2", m_do_mdttdccut_ML2 = true);
93  declareProperty("do_mdtadc_onSegm_ML1", m_do_mdtadc_onSegm_ML1 = true);
94  declareProperty("do_mdtadc_onSegm_ML2", m_do_mdtadc_onSegm_ML2 = true);
95  declareProperty("do_mdttdccut_RPCtrig_ML1", m_do_mdttdccut_RPCtrig_ML1 = true);
96  declareProperty("do_mdttdccut_TGCtrig_ML1", m_do_mdttdccut_TGCtrig_ML1 = true);
97  declareProperty("do_mdttdccut_RPCtrig_ML2", m_do_mdttdccut_RPCtrig_ML2 = true);
98  declareProperty("do_mdttdccut_TGCtrig_ML2", m_do_mdttdccut_TGCtrig_ML2 = true);
99  declareProperty("do_mdtadc", m_do_mdtadc = true);
100  declareProperty("do_mdttdcadc", m_do_mdttdcadc = true);
101  declareProperty("do_mdtmultil", m_do_mdtmultil = true);
102  declareProperty("do_mdtlayer", m_do_mdtlayer = true);
103  declareProperty("do_mdttube", m_do_mdttube = true);
104  declareProperty("do_mdttube_bkgrd", m_do_mdttube_bkgrd = true);
105  declareProperty("do_mdttube_fornoise", m_do_mdttube_fornoise = true);
106  declareProperty("do_mdttube_masked", m_do_mdttube_masked = true);
107  declareProperty("do_mdtmezz", m_do_mdtmezz = true);
108  declareProperty("do_mdt_effEntries", m_do_mdt_effEntries = true);
109  declareProperty("do_mdt_effCounts", m_do_mdt_effCounts = true);
110  declareProperty("do_mdt_effPerTube", m_do_mdt_effPerTube = false);
111  declareProperty("do_mdt_DRvsDT", m_do_mdt_DRvsDT = true);
112  declareProperty("do_mdt_DRvsDRerr", m_do_mdt_DRvsDRerr = false);
113  declareProperty("do_mdt_DRvsSegD", m_do_mdt_DRvsSegD = true);
114  declareProperty("do_mdttubenoise", m_do_mdttubenoise = false);
115  declareProperty("do_mdttdctube", m_do_mdttdctube = false);
116  declareProperty("nHits_NoiseThreshold", m_HighOccThreshold = 16000.);
117 }
118 
119 MdtRawDataValAlg::~MdtRawDataValAlg() = default;
120 /*---------------------------------------------------------*/
121 StatusCode MdtRawDataValAlg::initialize()
122 /*---------------------------------------------------------*/
123 {
124  // initialize to stop coverity bugs
125  m_MdtNHitsvsRpcNHits = nullptr;
126  for (unsigned int i = 0; i < 4; i++) {
127  m_overalltdcadcPRLumi[i] = nullptr;
128  m_overalltdccut_segm_PR_Lumi[i] = nullptr;
129  m_overalladc_segm_PR_Lumi[i] = nullptr;
130  m_overalladcPRLumi[i] = nullptr;
131  m_overalladccutPRLumi[i] = nullptr;
132  m_overalltdccutPRLumi_RPCtrig[i] = nullptr;
133  m_overalltdccutPRLumi_TGCtrig[i] = nullptr;
134  m_overallPR_mdt_DRvsDT[i] = nullptr;
135  m_overallPR_mdt_DRvsSegD[i] = nullptr;
136  m_mdteffperchamber_InnerMiddleOuter[i] = nullptr;
137  m_overalladcPR_HighOcc[i] = nullptr;
138  m_overalltdcPR_HighOcc[i] = nullptr;
139  m_overalltdcadcPR_HighOcc[i] = nullptr;
140  m_overalltdcPR_HighOcc_ADCCut[i] = nullptr;
141 
142  if (i == 3) continue;
143  m_mdtxydet[i] = nullptr;
144  m_mdtrzdet[i] = nullptr;
145  m_mdthitsperML_byLayer[i] = nullptr;
146  if (i == 2) continue;
147  m_mdthitsperchamber_InnerMiddleOuterLumi[i] = nullptr;
148  m_mdthitsperchamber_InnerMiddleOuter_HighOcc[i] = nullptr;
149  m_mdthitsperchamber_onSegm_InnerMiddleOuterLumi[i] = nullptr;
150  }
151  for (auto& i : m_mdtchamberstatphislice) { i = nullptr; }
152 
153  // init message stream
154  ATH_MSG_INFO("initialize MdtRawDataValAlg");
155 
156  ATH_MSG_DEBUG("******************");
157  ATH_MSG_DEBUG("doMdtESD: " << m_doMdtESD);
158  ATH_MSG_DEBUG("******************");
159 
160  // If Online ensure that lowStat histograms are made at the runLevel and that _lowStat suffix is suppressed
161  if (m_isOnline)
162  m_mg = std::make_unique<MDTMonGroupStruct>(this, m_title, ManagedMonitorToolBase::run,
163  ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "");
164  else
165  m_mg = std::make_unique<MDTMonGroupStruct>(this, m_title, ManagedMonitorToolBase::lowStat,
166  ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "_lowStat");
167 
168  // If online monitoring turn off chamber by chamber hists
169  if (m_isOnline) m_doChamberHists = false;
170 
171  // MuonDetectorManager from the conditions store
172  ATH_CHECK(m_DetectorManagerKey.initialize());
173  ATH_CHECK(m_idHelperSvc.retrieve());
174  ATH_CHECK(m_MdtDQFilterTools.retrieve());
175  ATH_CHECK(m_muonSelectionTool.retrieve());
176  ATH_CHECK(detStore()->retrieve(m_detMgr));
177 
178  // back to MDTS...
179  if (m_maskNoisyTubes)
180  m_masked_tubes = std::make_unique<MDTNoisyTubes>();
181  else
182  m_masked_tubes = std::make_unique<MDTNoisyTubes>(false);
183  mdtchamberId();
184 
185  ATH_CHECK(m_l1RoiKey.initialize());
186  ATH_CHECK(m_muonKey.initialize());
187  ATH_CHECK(m_segm_type.initialize());
188  ATH_CHECK(m_key_mdt.initialize());
189  ATH_CHECK(m_key_rpc.initialize());
190  ATH_CHECK(m_eventInfo.initialize());
191 
192  ATH_CHECK(ManagedMonitorToolBase::initialize());
193 
194  // MuonDetectorManager from the Detector Store
195  std::string managerName = "Muon";
196  const MuonGM::MuonDetectorManager* MuonDetMgrDS = nullptr;
197  ATH_CHECK(detStore()->retrieve(MuonDetMgrDS));
198  ATH_MSG_DEBUG(" Found the MuonGeoModel Manager from the Detector Store");
199 
200  m_BMGpresent = m_idHelperSvc->mdtIdHelper().stationNameIndex("BMG") != -1;
201  if (m_BMGpresent) {
202  ATH_MSG_INFO("Processing configuration for layouts with BMG chambers.");
203  m_BMGid = m_idHelperSvc->mdtIdHelper().stationNameIndex("BMG");
204  for (int phi = 6; phi < 8; phi++) { // phi sectors
205  for (int eta = 1; eta < 4; eta++) { // eta sectors
206  for (int side = -1; side < 2; side += 2) { // side
207  if (!MuonDetMgrDS->getMuonStation("BMG", side * eta, phi)) continue;
208  for (int roe = 1; roe <= (MuonDetMgrDS->getMuonStation("BMG", side * eta, phi))->nMuonReadoutElements();
209  roe++) { // iterate on readout elemets
210  const MuonGM::MdtReadoutElement* mdtRE = dynamic_cast<const MuonGM::MdtReadoutElement*>(
211  (MuonDetMgrDS->getMuonStation("BMG", side * eta, phi))->getMuonReadoutElement(roe)); // has to be an MDT
212  if (mdtRE) initDeadChannels(mdtRE);
213  }
214  }
215  }
216  }
217  }
218 
219  return StatusCode::SUCCESS;
220 }
221 
222 /*----------------------------------------------------------------------------------*/
223 StatusCode MdtRawDataValAlg::bookHistogramsRecurrent()
224 /*----------------------------------------------------------------------------------*/
225 {
226  // changed for booking unmanaged histograms for MIG2
227 
228  StatusCode sc = StatusCode::SUCCESS;
229 
230  if (newRunFlag() || newLowStatIntervalFlag()) {
231  sc = bookMDTSummaryHistograms(/* isNewEventsBlock,*/ newLumiBlockFlag(), newRunFlag());
232  if (sc.isFailure()) {
233  ATH_MSG_FATAL("Failed to bookMDTSummaryHistograms");
234  return sc;
235  }
236  sc = bookMDTOverviewHistograms(/* isNewEventsBlock,*/ newLumiBlockFlag(), newRunFlag());
237  if (sc.isFailure()) {
238  ATH_MSG_FATAL("Failed to bookMDTOverviewHistograms");
239  return sc;
240  }
241  }
242 
243  // if(isNewEventsBlock) {}
244  if (newLumiBlockFlag()) {}
245  if (newRunFlag()) {
246  ATH_MSG_DEBUG("MDT RawData Monitoring from ESD : newRunFlag()");
247  // Book All Chambers
248  // Protection against newRunFlag()()
249  int counter = 0;
250  sc = GetTimingInfo();
251  if (sc.isFailure()) {
252  ATH_MSG_ERROR(" Cannot GetTimingInfo ");
253  return sc;
254  }
255  m_firstTime = m_time;
256 
257  sc = GetEventNum();
258  if (sc.isFailure()) {
259  ATH_MSG_ERROR(" Cannot GetEventNum ");
260  return sc;
261  }
262  m_firstEvent = m_eventNum;
263 
264  ATH_MSG_DEBUG("MdtRawDataValAlg::MDT RawData Monitoring Histograms being filled");
265 
266  for (std::vector<Identifier>::const_iterator itr = m_chambersId.begin(); itr != m_chambersId.end(); ++itr, ++counter) {
267  std::string hardware_name =
268  convertChamberName(m_idHelperSvc->mdtIdHelper().stationName(*itr), m_idHelperSvc->mdtIdHelper().stationEta(*itr),
269  m_idHelperSvc->mdtIdHelper().stationPhi(*itr), "MDT");
270  // Skip Chambers That Do NOT Exist
271  if (hardware_name == "BML6A13" || hardware_name == "BML6C13") continue;
272 
273  std::unique_ptr<MDTChamber>& chamber = m_hist_hash_list[m_chambersIdHash.at(counter)];
274  chamber = std::make_unique<MDTChamber>(hardware_name);
275 
276  m_hardware_name_list.insert(hardware_name);
277  chamber->SetMDTHitsPerChamber_IMO_Bin(
278  dynamic_cast<TH2F*>(m_mdthitsperchamber_InnerMiddleOuterLumi[chamber->GetBarrelEndcapEnum()]));
279  chamber->SetMDTHitsPerChamber_IMO_Bin(
280  dynamic_cast<TH2F*>(m_mdthitsperchamber_InnerMiddleOuter_HighOcc[chamber->GetBarrelEndcapEnum()]));
281  chamber->SetMDTHitsPerML_byLayer_Bins(
282  dynamic_cast<TH2F*>(m_mdthitspermultilayerLumi[chamber->GetRegionEnum()][chamber->GetLayerEnum()]),
283  dynamic_cast<TH2F*>(m_mdthitsperML_byLayer[(chamber->GetLayerEnum() < 3 ? chamber->GetLayerEnum() : 0)]));
284  if (m_doChamberHists) { sc = bookMDTHistograms(chamber.get(), *itr); }
285  }
286 
287  } // if newRunFlag()
288 
289  return sc;
290 }
291 
292 /*----------------------------------------------------------------------------------*/
293 StatusCode MdtRawDataValAlg::fillHistograms()
294 /*----------------------------------------------------------------------------------*/
295 {
296  StatusCode sc = StatusCode::SUCCESS;
297 
298  // Set ATLASReadyFlag
299  setIsATLASReady();
300 
301  m_numberOfEvents++;
302 
303  // Get lumiblock, event number, timing info
304  sc = fillLumiBlock();
305  if (sc.isFailure()) {
306  ATH_MSG_ERROR("Could Not Get LumiBlock Info");
307  return sc;
308  }
309  sc = GetEventNum();
310  if (sc.isFailure()) {
311  ATH_MSG_ERROR("Could Not Get Event Num Info");
312  return sc;
313  }
314  sc = GetTimingInfo();
315  if (sc.isFailure()) {
316  ATH_MSG_ERROR(" Cannot GetTimingInfo ");
317  return sc;
318  }
319  ATH_MSG_DEBUG("MdtRawDataValAlg::MDT RawData Monitoring Histograms being filled");
320 
321  //
322  // Retrieve the LVL1 Muon RoIs:
323  //
324  StoreTriggerType(L1_UNKNOWN);
325  try {
326  SG::ReadHandle<xAOD::MuonRoIContainer> muonRoIs(m_l1RoiKey);
327  if (muonRoIs.isPresent() && muonRoIs.isValid()) {
328  // sroe: was verbose
329  ATH_MSG_VERBOSE("Retrieved LVL1MuonRoIs object with key: " << m_l1RoiKey.key());
330  for (const xAOD::MuonRoI_v1* roi : *muonRoIs) {
331  if (roi->getSource() == xAOD::MuonRoI::RoISource::Barrel) StoreTriggerType(L1_BARREL);
332  if (roi->getSource() == xAOD::MuonRoI::RoISource::Endcap) StoreTriggerType(L1_ENDCAP);
333  }
334  }
335  } catch (SG::ExcNoAuxStore& excpt) { ATH_MSG_INFO("SG::ExcNoAuxStore caught, " << m_l1RoiKey.key() << " not available."); }
336  // declare MDT stuff
337  SG::ReadHandle<Muon::MdtPrepDataContainer> mdt_container(m_key_mdt);
338 
339  ATH_MSG_DEBUG("****** mdtContainer->size() : " << mdt_container->size());
340 
341  int nColl = 0; // Number of MDT chambers with hits
342  int nColl_ADCCut = 0; // Number of MDT chambers with hits above ADC cut
343  int nPrd = 0; // Total number of MDT prd digits
344  int nPrdcut = 0; // Total number of MDT prd digits with a cut on ADC>50.
345 
346  // declare RPC stuff
347  SG::ReadHandle<Muon::RpcPrepDataContainer> rpc_container(m_key_rpc);
348 
349  ATH_MSG_DEBUG("****** rpc->size() : " << rpc_container->size());
350 
351  Muon::RpcPrepDataContainer::const_iterator containerIt;
352 
354  float Nhitsrpc = 0;
355  for (containerIt = rpc_container->begin(); containerIt != rpc_container->end(); ++containerIt) {
356  for (Muon::RpcPrepDataCollection::const_iterator rpcPrd = (*containerIt)->begin(); rpcPrd != (*containerIt)->end(); ++rpcPrd) {
357  ++Nhitsrpc;
358  }
359  }
360  float Nhitsmdt = 0;
361  bool isNoiseBurstCandidate = false;
362  Muon::MdtPrepDataContainer::const_iterator MdtcontainerIt;
363  for (MdtcontainerIt = mdt_container->begin(); MdtcontainerIt != mdt_container->end(); ++MdtcontainerIt) {
364  for (Muon::MdtPrepDataCollection::const_iterator mdtCollection = (*MdtcontainerIt)->begin();
365  mdtCollection != (*MdtcontainerIt)->end(); ++mdtCollection) {
366  ++Nhitsmdt;
367  }
368  }
369  if (Nhitsmdt > m_HighOccThreshold) isNoiseBurstCandidate = true;
370  std::string type = "MDT";
371  std::string hardware_name;
372 
373  std::map<std::string, float> evnt_hitsperchamber_map;
374  std::set<std::string> chambers_from_tracks;
375 
376  if (m_doMdtESD) {
377  if (m_environment == AthenaMonManager::tier0 || m_environment == AthenaMonManager::tier0ESD ||
378  m_environment == AthenaMonManager::online) {
379  SG::ReadHandle<xAOD::MuonContainer> muons(m_muonKey);
380 
381  for (const auto* const mu : *muons) {
382  if (!(mu->muonType() == xAOD::Muon::Combined)) continue;
383  xAOD::Muon::Quality quality = m_muonSelectionTool->getQuality(*mu);
384  if (!(quality <= xAOD::Muon::Medium)) continue;
385  const xAOD::TrackParticle* tp = mu->primaryTrackParticle();
386  if (tp) {
387  const Trk::Track* trk = tp->track();
388  if (!trk) { continue; }
389 
390  uint8_t ntri_eta = 0;
391  uint8_t n_phi = 0;
392  tp->summaryValue(ntri_eta, xAOD::numberOfTriggerEtaLayers);
393  tp->summaryValue(n_phi, xAOD::numberOfPhiLayers);
394  if (ntri_eta + n_phi == 0) continue;
395 
396  for (const Trk::MeasurementBase* hit : *trk->measurementsOnTrack()) {
397  const Trk::RIO_OnTrack* rot_from_track = dynamic_cast<const Trk::RIO_OnTrack*>(hit);
398  if (!rot_from_track) continue;
399  Identifier rotId = rot_from_track->identify();
400  if (!m_idHelperSvc->isMdt(rotId)) continue;
401  IdentifierHash mdt_idHash;
402  MDTChamber* mdt_chamber = nullptr;
403  m_idHelperSvc->mdtIdHelper().get_module_hash(rotId, mdt_idHash);
404  sc = getChamber(mdt_idHash, mdt_chamber);
405  std::string mdt_chambername = mdt_chamber->getName();
406  chambers_from_tracks.insert(mdt_chambername);
407  }
408  }
409  }
410 
411  // loop in MdtPrepDataContainer
412  for (Muon::MdtPrepDataContainer::const_iterator containerIt = mdt_container->begin(); containerIt != mdt_container->end();
413  ++containerIt) {
414  if (containerIt == mdt_container->end() || containerIt->empty()) continue; // check if there are counts
415  nColl++;
416 
417  bool isHit_above_ADCCut = false;
418  // loop over hits
419  for (const auto* mdtCollection : **containerIt) {
420  nPrd++;
421  hardware_name = getChamberName(mdtCollection);
422  float adc = mdtCollection->adc();
423  if (hardware_name.compare(0, 3, "BMG") == 0) adc /= 4.;
424  if (adc > m_ADCCut) {
425  nPrdcut++;
426  isHit_above_ADCCut = true;
427  }
428 
429  sc = fillMDTOverviewHistograms(mdtCollection, isNoiseBurstCandidate);
430  if (sc.isSuccess()) {
431  ATH_MSG_DEBUG("Filled MDTOverviewHistograms");
432  } else {
433  ATH_MSG_ERROR("Failed to fill MDTOverviewHistograms");
434  return sc;
435  }
436 
437  sc = fillMDTSummaryHistograms(mdtCollection, chambers_from_tracks, isNoiseBurstCandidate);
438  if (sc.isSuccess()) {
439  ATH_MSG_DEBUG("Filled MDTSummaryHistograms ");
440  } else {
441  ATH_MSG_ERROR("Failed to Fill MDTSummaryHistograms");
442  return sc;
443  }
444 
445  if (m_doChamberHists) {
446  if (isATLASReady()) sc = fillMDTHistograms(mdtCollection);
447  if (sc.isSuccess()) {
448  ATH_MSG_DEBUG("Filled MDThistograms (chamber by chamber histos)");
449  } else {
450  ATH_MSG_ERROR("Failed to Fill MDTHistograms");
451  return sc;
452  }
453  }
454  std::map<std::string, float>::iterator iter_hitsperchamber = evnt_hitsperchamber_map.find(hardware_name);
455  if (iter_hitsperchamber == evnt_hitsperchamber_map.end()) {
456  evnt_hitsperchamber_map.insert(make_pair(hardware_name, 1));
457  } else {
458  iter_hitsperchamber->second += 1;
459  }
460 
461  if (adc > m_ADCCut) {
462  std::map<std::string, float>::iterator iter_hitsperchamber = m_hitsperchamber_map.find(hardware_name);
463  if (iter_hitsperchamber == m_hitsperchamber_map.end()) {
464  m_hitsperchamber_map.insert(make_pair(hardware_name, 1));
465  } else {
466  iter_hitsperchamber->second += 1;
467  }
468  }
469 
470  // } //chamber name selection
471 
472  } // for loop over hits
473  if (isHit_above_ADCCut) nColl_ADCCut++;
474  } // loop in MdtPrepDataContainer
475 
476  int nHighOccChambers = 0;
477  std::map<std::string, float>::iterator iterstat;
478 
479  for (iterstat = evnt_hitsperchamber_map.begin(); iterstat != evnt_hitsperchamber_map.end(); ++iterstat) {
480  std::string hardware_name = iterstat->first;
481  std::map<std::string, float>::iterator iter_tubesperchamber = m_tubesperchamber_map.find(hardware_name);
482  float nTubes = iter_tubesperchamber->second;
483  float hits = iterstat->second;
484  float occ = hits / nTubes;
485  if (occ > 0.1) nHighOccChambers++;
486  }
487  if (m_nummdtchamberswithHighOcc)
488  m_nummdtchamberswithHighOcc->Fill(nHighOccChambers);
489  else { ATH_MSG_DEBUG("m_nummdtchamberswithHighOcc not in hist list!"); }
490 
491  m_MdtNHitsvsRpcNHits->Fill(nPrd, Nhitsrpc);
492 
493  // TotalNumber_of_MDT_hits_per_event with cut on ADC
494  if (m_mdteventscutLumi)
495  m_mdteventscutLumi->Fill(nPrdcut);
496  else { ATH_MSG_DEBUG("m_mdteventscutLumi not in hist list!"); }
497 
498  // TotalNumber_of_MDT_hits_per_event with cut on ADC (for high mult. evt)
499  if (m_mdteventscutLumi_big)
500  m_mdteventscutLumi_big->Fill(nPrdcut);
501  else { ATH_MSG_DEBUG("m_mdteventscutLumi_big not in hist list!"); }
502 
503  // TotalNumber_of_MDT_hits_per_event without cut on ADC
504  if (m_mdteventsLumi)
505  m_mdteventsLumi->Fill(nPrd);
506  else { ATH_MSG_DEBUG("m_mdteventsLumi not in hist list!"); }
507 
508  // TotalNumber_of_MDT_hits_per_event without cut on ADC (for high mult. evt)
509  if (m_mdteventsLumi_big)
510  m_mdteventsLumi_big->Fill(nPrd);
511  else { ATH_MSG_DEBUG("m_mdteventsLumi_big not in hist list!"); }
512 
513  if (m_mdtglobalhitstime) m_mdtglobalhitstime->Fill(m_time - m_firstTime);
514 
515  // Number_of_Chambers_with_hits_per_event
516  if (m_nummdtchamberswithhits)
517  m_nummdtchamberswithhits->Fill(nColl);
518  else { ATH_MSG_DEBUG("m_nummdtchamberswithhits not in hist list!"); }
519 
520  // Number_of_Chambers_with_hits_per_event_ADCCut
521  if (m_nummdtchamberswithhits_ADCCut)
522  m_nummdtchamberswithhits_ADCCut->Fill(nColl_ADCCut);
523  else { ATH_MSG_DEBUG("m_nummdtchamberswithhits_ADCCut not in hist list!"); }
524 
525  } // m_environment == AthenaMonManager::tier0 || m_environment == AthenaMonManager::tier0ESD
526  } // m_doMdtESD==true
527 
528  SG::ReadHandle<Trk::SegmentCollection> segms(m_segm_type);
529 
530  if (isATLASReady()) sc = handleEvent_effCalc(segms.cptr()); //, mdt_container );
531  if (sc.isFailure()) {
532  ATH_MSG_ERROR("Couldn't handleEvent_effCalc ");
533  return sc;
534  }
535 
536  return sc;
537 }
538 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
539 
540 StatusCode MdtRawDataValAlg::procHistograms(/*bool isEndOfEventsBlock, bool isEndOfLumiBlock, bool isEndOfRun */) {
541  StatusCode sc = StatusCode::SUCCESS;
542  // if(isEndOfEventsBlock) {}
543  if (endOfLumiBlockFlag()) {}
544  // Replicate lowStat histograms to run directory if stable beam
545  if (endOfLumiBlockFlag() && isATLASReady() && !m_isOnline) {
546  // Book tdc adccut per region per lowStat
547  sc = regHist((TH1F*)m_overalltdccut_segm_PR_Lumi[enumBarrelA]->Clone(), m_mg->mongroup_brA_shift);
548  sc = regHist((TH1F*)m_overalltdccut_segm_PR_Lumi[enumBarrelC]->Clone(), m_mg->mongroup_brC_shift);
549  sc = regHist((TH1F*)m_overalltdccut_segm_PR_Lumi[enumEndCapA]->Clone(), m_mg->mongroup_ecA_shift);
550  sc = regHist((TH1F*)m_overalltdccut_segm_PR_Lumi[enumEndCapC]->Clone(), m_mg->mongroup_ecC_shift);
551  sc = regHist((TH1F*)m_overalltdccutPRLumi[enumBarrelA]->Clone(), m_mg->mongroup_brA_shift);
552  sc = regHist((TH1F*)m_overalltdccutPRLumi[enumBarrelC]->Clone(), m_mg->mongroup_brC_shift);
553  sc = regHist((TH1F*)m_overalltdccutPRLumi[enumEndCapA]->Clone(), m_mg->mongroup_ecA_shift);
554  sc = regHist((TH1F*)m_overalltdccutPRLumi[enumEndCapC]->Clone(), m_mg->mongroup_ecC_shift);
555 
556  // Book adc adccut per region on & off segment
557  sc = regHist((TH1F*)m_overalladc_segm_PR_Lumi[enumBarrelA]->Clone(), m_mg->mongroup_brA_shift);
558  sc = regHist((TH1F*)m_overalladc_segm_PR_Lumi[enumBarrelC]->Clone(), m_mg->mongroup_brC_shift);
559  sc = regHist((TH1F*)m_overalladc_segm_PR_Lumi[enumEndCapA]->Clone(), m_mg->mongroup_ecA_shift);
560  sc = regHist((TH1F*)m_overalladc_segm_PR_Lumi[enumEndCapC]->Clone(), m_mg->mongroup_ecC_shift);
561  sc = regHist((TH1F*)m_overalladcPRLumi[enumBarrelA]->Clone(), m_mg->mongroup_brA_shift);
562  sc = regHist((TH1F*)m_overalladcPRLumi[enumBarrelC]->Clone(), m_mg->mongroup_brC_shift);
563  sc = regHist((TH1F*)m_overalladcPRLumi[enumEndCapA]->Clone(), m_mg->mongroup_ecA_shift);
564  sc = regHist((TH1F*)m_overalladcPRLumi[enumEndCapC]->Clone(), m_mg->mongroup_ecC_shift);
565  sc = regHist((TH1F*)m_overalladccutPRLumi[enumBarrelA]->Clone(), m_mg->mongroup_brA_shift);
566  sc = regHist((TH1F*)m_overalladccutPRLumi[enumBarrelC]->Clone(), m_mg->mongroup_brC_shift);
567  sc = regHist((TH1F*)m_overalladccutPRLumi[enumEndCapA]->Clone(), m_mg->mongroup_ecA_shift);
568  sc = regHist((TH1F*)m_overalladccutPRLumi[enumEndCapC]->Clone(), m_mg->mongroup_ecC_shift);
569 
570  // TriggerAware TDC
571  sc = regHist((TH1F*)m_overalltdccutPRLumi_RPCtrig[enumBarrelA]->Clone(), m_mg->mongroup_brA_shift);
572  sc = regHist((TH1F*)m_overalltdccutPRLumi_RPCtrig[enumBarrelC]->Clone(), m_mg->mongroup_brC_shift);
573  sc = regHist((TH1F*)m_overalltdccutPRLumi_RPCtrig[enumEndCapA]->Clone(), m_mg->mongroup_ecA_shift);
574  sc = regHist((TH1F*)m_overalltdccutPRLumi_RPCtrig[enumEndCapC]->Clone(), m_mg->mongroup_ecC_shift);
575  sc = regHist((TH1F*)m_overalltdccutPRLumi_TGCtrig[enumBarrelA]->Clone(), m_mg->mongroup_brA_shift);
576  sc = regHist((TH1F*)m_overalltdccutPRLumi_TGCtrig[enumBarrelC]->Clone(), m_mg->mongroup_brC_shift);
577  sc = regHist((TH1F*)m_overalltdccutPRLumi_TGCtrig[enumEndCapA]->Clone(), m_mg->mongroup_ecA_shift);
578  sc = regHist((TH1F*)m_overalltdccutPRLumi_TGCtrig[enumEndCapC]->Clone(), m_mg->mongroup_ecC_shift);
579 
580  // Book tdcadc per region per lowStat
581  sc = regHist((TH2F*)m_overalltdcadcPRLumi[enumBarrelA]->Clone(), m_mg->mongroup_brA_shift);
582  sc = regHist((TH2F*)m_overalltdcadcPRLumi[enumBarrelC]->Clone(), m_mg->mongroup_brC_shift);
583  sc = regHist((TH2F*)m_overalltdcadcPRLumi[enumEndCapA]->Clone(), m_mg->mongroup_ecA_shift);
584  sc = regHist((TH2F*)m_overalltdcadcPRLumi[enumEndCapC]->Clone(), m_mg->mongroup_ecC_shift);
585 
586  // Book Global Hit Coverage/ML by Layer(Inner, Middle, Outer)
587  sc = regHist((TH2F*)m_mdthitsperML_byLayer[enumInner]->Clone(), m_mg->mongroup_overview_shift);
588  sc = regHist((TH2F*)m_mdthitsperML_byLayer[enumMiddle]->Clone(), m_mg->mongroup_overview_shift);
589  sc = regHist((TH2F*)m_mdthitsperML_byLayer[enumOuter]->Clone(), m_mg->mongroup_overview_shift);
590 
591  for (int iecap = 0; iecap < 4; iecap++) { // BA,BC,EA,EC
592  for (int ilayer = 0; ilayer < 4; ilayer++) { // inner, middle, outer, extra
594  // Number of hits/effs per Multilayer
596  if (iecap == enumBarrelA)
597  sc = regHist((TH2F*)m_mdthitspermultilayerLumi[iecap][ilayer]->Clone(), m_mg->mongroup_brA_shift);
598  else if (iecap == enumBarrelC)
599  sc = regHist((TH2F*)m_mdthitspermultilayerLumi[iecap][ilayer]->Clone(), m_mg->mongroup_brC_shift);
600  else if (iecap == enumEndCapA)
601  sc = regHist((TH2F*)m_mdthitspermultilayerLumi[iecap][ilayer]->Clone(), m_mg->mongroup_ecA_shift);
602  else
603  sc = regHist((TH2F*)m_mdthitspermultilayerLumi[iecap][ilayer]->Clone(), m_mg->mongroup_ecC_shift);
604 
605  if (sc.isFailure()) {
606  ATH_MSG_ERROR("mdthitspermultilayer Failed to register histogram");
607  return sc;
608  }
609  ATH_MSG_DEBUG("Inside LowStat Loop, iecap=" << iecap << ", ilayer=" << ilayer);
610 
612  // Number of hits per chamber (all sectors in one plot)
614  if (ilayer == 0 && ((iecap == 0 || iecap == 2))) {
615  ATH_MSG_DEBUG("Bookint mdthitsperchamber_InnerMiddleOuter");
616  sc = regHist((TH2F*)m_mdthitsperchamber_InnerMiddleOuterLumi[iecap / 2]->Clone(), m_mg->mongroup_overview_shift);
617  sc = regHist((TH2F*)m_mdthitsperchamber_InnerMiddleOuter_HighOcc[iecap / 2]->Clone(), m_mg->mongroup_overview_shift);
618 
619  ATH_MSG_DEBUG("Bookint m_mdthitsperchamber_onSegm_InnerMiddleOuterLumi");
620  sc = regHist((TH2F*)m_mdthitsperchamber_onSegm_InnerMiddleOuterLumi[iecap / 2]->Clone(),
621  m_mg->mongroup_overview_recoMon);
622 
623  if (sc.isFailure()) {
624  ATH_MSG_ERROR("mdthitsperchamber_InnerMiddleOuter Failed to register histogram");
625  return sc;
626  }
627  } // end if(ilayer==0&&(iecap==0||iecap==2) )
628  } // layer
629  } // ecap
630 
632  // histo path for overall tdccut spectrum
633  sc = regHist((TH1F*)m_overalltdccutLumi->Clone(), m_mg->mongroup_overview_shift);
634 
636  // histo path for overall tdccut spectrum (along segms)
637  sc = regHist((TH1F*)m_overalltdccut_segm_Lumi->Clone(), m_mg->mongroup_overview_shift);
638 
640  // histo path for overall adc spectrum (along segms)
641  sc = regHist((TH1F*)m_overalladc_segm_Lumi->Clone(), m_mg->mongroup_overview_shift);
642 
644  // histo path for overall adc spectrum
645  sc = regHist((TH1F*)m_overalladc_Lumi->Clone(), m_mg->mongroup_overview_shift);
646 
648  // histo path for TotalNumber_of_MDT_hits_per_event with a cut on ADC
649  sc = regHist((TH1F*)m_mdteventscutLumi->Clone(), m_mg->mongroup_overview_shift);
651  // histo path for TotalNumber_of_MDT_hits_per_event with a cut on ADC (for high mult. events)
652  sc = regHist((TH1F*)m_mdteventscutLumi_big->Clone(), m_mg->mongroup_overview_shift);
654  // histo path for TotalNumber_of_MDT_hits_per_event without a cut on ADC
655  sc = regHist((TH1F*)m_mdteventsLumi->Clone(), m_mg->mongroup_overview_shift);
657  // histo path for TotalNumber_of_MDT_hits_per_event without a cut on ADC (for high mult. events)
658  sc = regHist((TH1F*)m_mdteventsLumi_big->Clone(), m_mg->mongroup_overview_shift);
659 
660  // histo path for overall tdc vs adc spectrum
661  sc = regHist((TH2F*)m_overalltdcadcLumi->Clone(), m_mg->mongroup_overview_shift);
662  }
663 
664  if (endOfRunFlag()) {
665  ATH_MSG_DEBUG("********Reached Last Event in MdtRawDataValAlg !!!");
666  ATH_MSG_DEBUG("MdtRawDataValAlg finalize()");
667 
668  if (m_mdtchamberstat) {
669  m_mdtchamberstat->SetStats(0);
670  m_mdtchamberstat->LabelsDeflate("X");
671  }
672  std::map<std::string, float>::iterator iterstat;
673  char c[3] = " ";
674  for (iterstat = m_hitsperchamber_map.begin(); iterstat != m_hitsperchamber_map.end(); ++iterstat) {
675  const char* chambername_char = iterstat->first.c_str();
676  float hits = iterstat->second;
677  if (m_mdtchamberstat) m_mdtchamberstat->Fill(chambername_char, hits);
678 
680  // Look for chamber names like XXXXXNMYYYYY where NM is a number in 01...16. And do it efficiently:
681  if (iterstat->first.length() < 7) continue;
682  c[0] = chambername_char[5];
683  c[1] = chambername_char[6];
684  if (!(c[0] == '0' || c[0] == '1') || c[1] < '0' || c[1] > '9') continue;
685  int i(atoi(c) - 1);
686  if (i < 0 || i > 15) continue;
687  // Now fill the histogram
688  TH1* h = m_mdtchamberstatphislice[i];
689  if (h) h->Fill(chambername_char, hits);
690  } // for in m_hitsperchamber_map
691 
692  if (m_mdtchamberstat) m_mdtchamberstat->LabelsDeflate("X");
693 
694  // Deflate phislice m_mdtchamberstatphislice
695  for (int j = 0; j <= 15; ++j) {
696  if (m_mdtchamberstatphislice[j]) m_mdtchamberstatphislice[j]->LabelsDeflate("X");
697  }
698 
699  } // endOfRunFlag()
700 
701  return sc;
702 }
703 
704 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
705 // input hardware name as produced from convertChamberName()
706 StatusCode MdtRawDataValAlg::bookMDTHistograms(MDTChamber* chamber, Identifier digcoll_id) {
707  StatusCode sc = StatusCode::SUCCESS;
708 
709  std::string hardware_name = chamber->getName();
710  IdentifierHash idHash;
711  m_idHelperSvc->mdtIdHelper().get_module_hash(digcoll_id, idHash);
712 
713  int tubeIdMax = GetTubeMax(digcoll_id, hardware_name);
714 
715  // declare a group of histograms
716  std::string subdir_path = hardware_name.substr(0, 1) + hardware_name.substr(4, 1);
717  if (subdir_path.at(1) == 'B') subdir_path.at(1) = 'A'; // Place BOG0B12,14 in MDTBA
718 
719  MonGroup* mongroup_chambers_expert = nullptr;
720  if (subdir_path == "BA")
721  mongroup_chambers_expert = &(m_mg->mongroup_chambers_expert_MDTBA);
722  else if (subdir_path == "BC")
723  mongroup_chambers_expert = &(m_mg->mongroup_chambers_expert_MDTBC);
724  else if (subdir_path == "EA")
725  mongroup_chambers_expert = &(m_mg->mongroup_chambers_expert_MDTEA);
726  else
727  mongroup_chambers_expert = &(m_mg->mongroup_chambers_expert_MDTEC);
728 
730  // histo path for mdt EfficiencyEntries
732  if (m_do_mdt_effEntries)
733  sc = bookMDTHisto_chambers(chamber->mdt_effEntries, hardware_name + "_MDT_Station_EFFENTRIES", "tubeID", "Number of Entries",
734  tubeIdMax, 1, tubeIdMax + 1, *mongroup_chambers_expert);
735 
737  // histo path for mdt EfficiencyCounts
739  if (m_do_mdt_effCounts)
740  sc = bookMDTHisto_chambers(chamber->mdt_effCounts, hardware_name + "_MDT_Station_EFFCOUNTS", "tubeID", "Number of Counts",
741  tubeIdMax, 1, tubeIdMax + 1, *mongroup_chambers_expert);
742 
744  // histo path for mdt EfficiencyPerTube
746  if (m_do_mdt_effPerTube)
747  sc = bookMDTHisto_chambers(chamber->mdt_effPerTube, hardware_name + "_MDT_Station_EFFPERTUBE", "tubeID", "Efficiency", tubeIdMax, 1,
748  tubeIdMax + 1, *mongroup_chambers_expert);
749 
751  // histo path for mdt tdc
753  if (m_do_mdttdc)
754  sc = bookMDTHisto_chambers(chamber->mdttdc, hardware_name + "_MDT_Station_TDC", "[nsec]", "Number of Entries", 100, 0, 2000.,
755  *mongroup_chambers_expert);
756 
758  // histo path for mdt tdccut ML1
760  if (m_do_mdttdccut_ML1)
761  sc = bookMDTHisto_chambers(chamber->mdttdccut_ML1, hardware_name + "_MDT_Station_TDC_ML1_ADCCut", "[nsec]", "Number of Entries",
762  100, 0, 2000., *mongroup_chambers_expert);
763 
765  // histo path for mdt tdccut ML2
767  if (m_do_mdttdccut_ML2)
768  sc = bookMDTHisto_chambers(chamber->mdttdccut_ML2, hardware_name + "_MDT_Station_TDC_ML2_ADCCut", "[nsec]", "Number of Entries",
769  100, 0, 2000., *mongroup_chambers_expert);
771  // histo path for mdt adc on segment ML1
773  if (m_do_mdtadc_onSegm_ML1)
774  sc = bookMDTHisto_chambers(chamber->mdtadc_onSegm_ML1, hardware_name + "_MDT_Station_ADC_onSegm_ML1", "[adc counts]",
775  "Number of Entries", 100, 0, 400., *mongroup_chambers_expert);
776 
778  // histo path for mdt adc on segment ML2
780  if (m_do_mdtadc_onSegm_ML2)
781  sc = bookMDTHisto_chambers(chamber->mdtadc_onSegm_ML2, hardware_name + "_MDT_Station_ADC_onSegm_ML2", "[adc counts]",
782  "Number of Entries", 100, 0, 400., *mongroup_chambers_expert);
783 
785  // histo path for mdt adc
787  if (m_do_mdtadc)
788  sc = bookMDTHisto_chambers(chamber->mdtadc, hardware_name + "_MDT_Station_ADC", "[adc counts]", "Number of Entries", 100, 0, 400.,
789  *mongroup_chambers_expert);
790 
792  // histo path for mdt layer
793  if (m_do_mdtlayer)
794  sc = bookMDTHisto_chambers(chamber->mdtlayer, hardware_name + "_MDT_Station_LAYER_ADCCut", "layerID", "Number of Entries", 10, 0,
795  10., *mongroup_chambers_expert);
796 
798  // histo path for mdt tube
799  if (m_do_mdttube)
800  sc = bookMDTHisto_chambers(chamber->mdttube, hardware_name + "_MDT_Station_TUBE_ADCCut", "tubeID", "Number of Entries", tubeIdMax,
801  1, tubeIdMax + 1, *mongroup_chambers_expert);
802 
804  // histo path for mdt tube masked info
805  if (m_do_mdttube_masked) {
806  sc = bookMDTHisto_chambers(chamber->mdttube_masked, hardware_name + "_MDT_Station_TUBE_masked", "tubeID", "Number of Entries",
807  tubeIdMax, 1, tubeIdMax + 1, *mongroup_chambers_expert);
808  sc = fillMDTMaskedTubes(idHash, chamber->getName(), chamber->mdttube_masked);
809  }
810 
812  // histo path for mdt mezzannine
813  if (m_do_mdtmezz)
814  sc = bookMDTHisto_chambers(chamber->mdtmezz, hardware_name + "_MDT_Station_MEZZ_ADCCut", "mezzID", "Number of Entries", 20, 0, 20.,
815  *mongroup_chambers_expert);
816 
818  // 2D hists
819  if (m_chamber_2D) {
821  // histo path for mdt tdcadc
822  if (m_do_mdttdcadc)
823  sc = bookMDTHisto_chambers_2D(chamber->mdttdcadc, hardware_name + "_MDT_Station_TDCADC", "[nsec]", "[adc counts]", 50, 0, 2000.,
824  20., 0., 400., *mongroup_chambers_expert);
825 
827  // histo path for mdt drift radius vs drift time
828  if (m_do_mdt_DRvsDT)
829  sc = bookMDTHisto_chambers_2D(chamber->mdt_DRvsDT, hardware_name + "_MDT_Station_DRvsDT", "Drift Radius [mm]",
830  "Drift Time [nsec]", 80, -20, 20., 120, -200., 1000., *mongroup_chambers_expert);
831 
832  // //////////////////////////////////////////////////////////////////////////////////////
833  // //histo path for mdt drift radius vs drift time
834  if (m_do_mdt_DRvsDRerr)
835  sc = bookMDTHisto_chambers_2D(chamber->mdt_DRvsDRerr, hardware_name + "_MDT_Station_DRvsDRerr", "Drift Radius [mm]",
836  "Error [mm]", 80, -20, 20., 80, -5., 5., *mongroup_chambers_expert);
837 
839  // histo path for mdt drift radius vs drift time
840  if (m_do_mdt_DRvsSegD)
841  sc = bookMDTHisto_chambers_2D(chamber->mdt_DRvsSegD, hardware_name + "_MDT_Station_DRvsSegD", "Drift Radius [mm]",
842  "Segm dist. to tube [mm]", 80, -20, 20., 80, -20., 20., *mongroup_chambers_expert);
843  }
844 
845  ATH_MSG_DEBUG("Booked bookMDTHistograms successfully");
846 
847  return sc;
848 }
849 
850 StatusCode MdtRawDataValAlg::bookMDTSummaryHistograms(/* bool isNewEventsBlock, */ bool newLumiBlock, bool newRun) {
851  StatusCode sc = StatusCode::SUCCESS;
852  // if( isNewEventsBlock ){}
853  if (newLumiBlock) {}
854  // book these histos as lowStat interval if not online monitoring
855  if ((newLowStatIntervalFlag() && !m_isOnline) || (m_isOnline && newRun)) {
856  // Book tdc adccut per region per lowStat
857  sc = bookMDTHisto_overview(m_overalltdccut_segm_PR_Lumi[enumBarrelA], "MDTTDC_segm_Summary_ADCCut_BA", "[nsec]",
858  "Number of Entries", 120, 0., 2000., m_mg->mongroup_brA_shiftLumi);
859  sc = bookMDTHisto_overview(m_overalltdccut_segm_PR_Lumi[enumBarrelC], "MDTTDC_segm_Summary_ADCCut_BC", "[nsec]",
860  "Number of Entries", 120, 0., 2000., m_mg->mongroup_brC_shiftLumi);
861  sc = bookMDTHisto_overview(m_overalltdccut_segm_PR_Lumi[enumEndCapA], "MDTTDC_segm_Summary_ADCCut_EA", "[nsec]",
862  "Number of Entries", 120, 0., 2000., m_mg->mongroup_ecA_shiftLumi);
863  sc = bookMDTHisto_overview(m_overalltdccut_segm_PR_Lumi[enumEndCapC], "MDTTDC_segm_Summary_ADCCut_EC", "[nsec]",
864  "Number of Entries", 120, 0., 2000., m_mg->mongroup_ecC_shiftLumi);
865  sc = bookMDTHisto_overview(m_overalltdccutPRLumi[enumBarrelA], "MDTTDC_Summary_ADCCut_BA", "[nsec]", "Number of Entries", 120, 0.,
866  2000., m_mg->mongroup_brA_shiftLumi);
867  sc = bookMDTHisto_overview(m_overalltdccutPRLumi[enumBarrelC], "MDTTDC_Summary_ADCCut_BC", "[nsec]", "Number of Entries", 120, 0.,
868  2000., m_mg->mongroup_brC_shiftLumi);
869  sc = bookMDTHisto_overview(m_overalltdccutPRLumi[enumEndCapA], "MDTTDC_Summary_ADCCut_EA", "[nsec]", "Number of Entries", 120, 0.,
870  2000., m_mg->mongroup_ecA_shiftLumi);
871  sc = bookMDTHisto_overview(m_overalltdccutPRLumi[enumEndCapC], "MDTTDC_Summary_ADCCut_EC", "[nsec]", "Number of Entries", 120, 0.,
872  2000., m_mg->mongroup_ecC_shiftLumi);
873 
874  // Book adc adccut per region on & off segment
875  sc = bookMDTHisto_overview(m_overalladc_segm_PR_Lumi[enumBarrelA], "MDTADC_segm_Summary_BA", "[adc counts]", "Number of Entries",
876  100, 0.5, 400.5, m_mg->mongroup_brA_shiftLumi);
877  sc = bookMDTHisto_overview(m_overalladc_segm_PR_Lumi[enumBarrelC], "MDTADC_segm_Summary_BC", "[adc counts]", "Number of Entries",
878  100, 0.5, 400.5, m_mg->mongroup_brC_shiftLumi);
879  sc = bookMDTHisto_overview(m_overalladc_segm_PR_Lumi[enumEndCapA], "MDTADC_segm_Summary_EA", "[adc counts]", "Number of Entries",
880  100, 0.5, 400.5, m_mg->mongroup_ecA_shiftLumi);
881  sc = bookMDTHisto_overview(m_overalladc_segm_PR_Lumi[enumEndCapC], "MDTADC_segm_Summary_EC", "[adc counts]", "Number of Entries",
882  100, 0.5, 400.5, m_mg->mongroup_ecC_shiftLumi);
883  sc = bookMDTHisto_overview(m_overalladcPRLumi[enumBarrelA], "MDTADC_Summary_BA", "[adc counts]", "Number of Entries", 100, 0., 400.,
884  m_mg->mongroup_brA_shiftLumi);
885  sc = bookMDTHisto_overview(m_overalladcPRLumi[enumBarrelC], "MDTADC_Summary_BC", "[adc counts]", "Number of Entries", 100, 0., 400.,
886  m_mg->mongroup_brC_shiftLumi);
887  sc = bookMDTHisto_overview(m_overalladcPRLumi[enumEndCapA], "MDTADC_Summary_EA", "[adc counts]", "Number of Entries", 100, 0., 400.,
888  m_mg->mongroup_ecA_shiftLumi);
889  sc = bookMDTHisto_overview(m_overalladcPRLumi[enumEndCapC], "MDTADC_Summary_EC", "[adc counts]", "Number of Entries", 100, 0., 400.,
890  m_mg->mongroup_ecC_shiftLumi);
891  sc = bookMDTHisto_overview(m_overalladccutPRLumi[enumBarrelA], "MDTADC_Summary_ADCCut_BA", "[adc counts]", "Number of Entries", 100,
892  0., 400., m_mg->mongroup_brA_shiftLumi);
893  sc = bookMDTHisto_overview(m_overalladccutPRLumi[enumBarrelC], "MDTADC_Summary_ADCCut_BC", "[adc counts]", "Number of Entries", 100,
894  0., 400., m_mg->mongroup_brC_shiftLumi);
895  sc = bookMDTHisto_overview(m_overalladccutPRLumi[enumEndCapA], "MDTADC_Summary_ADCCut_EA", "[adc counts]", "Number of Entries", 100,
896  0., 400., m_mg->mongroup_ecA_shiftLumi);
897  sc = bookMDTHisto_overview(m_overalladccutPRLumi[enumEndCapC], "MDTADC_Summary_ADCCut_EC", "[adc counts]", "Number of Entries", 100,
898  0., 400., m_mg->mongroup_ecC_shiftLumi);
899 
900  // TriggerAware TDC
901  sc = bookMDTHisto_overview(m_overalltdccutPRLumi_RPCtrig[enumBarrelA], "MDTTDC_Summary_ADCCut_BA_RPC", "[nsec]",
902  "Number of Entries", 120, 0., 2000., m_mg->mongroup_brA_shiftLumi);
903  sc = bookMDTHisto_overview(m_overalltdccutPRLumi_RPCtrig[enumBarrelC], "MDTTDC_Summary_ADCCut_BC_RPC", "[nsec]",
904  "Number of Entries", 120, 0., 2000., m_mg->mongroup_brC_shiftLumi);
905  sc = bookMDTHisto_overview(m_overalltdccutPRLumi_RPCtrig[enumEndCapA], "MDTTDC_Summary_ADCCut_EA_RPC", "[nsec]",
906  "Number of Entries", 120, 0., 2000., m_mg->mongroup_ecA_shiftLumi);
907  sc = bookMDTHisto_overview(m_overalltdccutPRLumi_RPCtrig[enumEndCapC], "MDTTDC_Summary_ADCCut_EC_RPC", "[nsec]",
908  "Number of Entries", 120, 0., 2000., m_mg->mongroup_ecC_shiftLumi);
909  sc = bookMDTHisto_overview(m_overalltdccutPRLumi_TGCtrig[enumBarrelA], "MDTTDC_Summary_ADCCut_BA_TGC", "[nsec]",
910  "Number of Entries", 120, 0., 2000., m_mg->mongroup_brA_shiftLumi);
911  sc = bookMDTHisto_overview(m_overalltdccutPRLumi_TGCtrig[enumBarrelC], "MDTTDC_Summary_ADCCut_BC_TGC", "[nsec]",
912  "Number of Entries", 120, 0., 2000., m_mg->mongroup_brC_shiftLumi);
913  sc = bookMDTHisto_overview(m_overalltdccutPRLumi_TGCtrig[enumEndCapA], "MDTTDC_Summary_ADCCut_EA_TGC", "[nsec]",
914  "Number of Entries", 120, 0., 2000., m_mg->mongroup_ecA_shiftLumi);
915  sc = bookMDTHisto_overview(m_overalltdccutPRLumi_TGCtrig[enumEndCapC], "MDTTDC_Summary_ADCCut_EC_TGC", "[nsec]",
916  "Number of Entries", 120, 0., 2000., m_mg->mongroup_ecC_shiftLumi);
917 
918  // Book tdcadc per region per lowStat
919  sc = bookMDTHisto_overview_2D(m_overalltdcadcPRLumi[enumBarrelA], "Overall_TDCADC_spectrum_BA", "[nsec]", "[adc counts]", 50, 0,
920  2000., 20., 0., 400., m_mg->mongroup_brA_shiftLumi);
921  sc = bookMDTHisto_overview_2D(m_overalltdcadcPRLumi[enumBarrelC], "Overall_TDCADC_spectrum_BC", "[nsec]", "[adc counts]", 50, 0,
922  2000., 20., 0., 400., m_mg->mongroup_brC_shiftLumi);
923  sc = bookMDTHisto_overview_2D(m_overalltdcadcPRLumi[enumEndCapA], "Overall_TDCADC_spectrum_EA", "[nsec]", "[adc counts]", 50, 0,
924  2000., 20., 0., 400., m_mg->mongroup_ecA_shiftLumi);
925  sc = bookMDTHisto_overview_2D(m_overalltdcadcPRLumi[enumEndCapC], "Overall_TDCADC_spectrum_EC", "[nsec]", "[adc counts]", 50, 0,
926  2000., 20., 0., 400., m_mg->mongroup_ecC_shiftLumi);
927 
928  // Book Global Hit Coverage/ML by Layer(Inner, Middle, Outer)
929  sc = bookMDTHisto_overview_2D(m_mdthitsperML_byLayer[enumInner], "NumberOfHitsInMDTInner_ADCCut", "#eta station", "#phi station", 1,
930  0, 1, 1, 0, 1, m_mg->mongroup_overview_shiftLumi);
931  sc = bookMDTHisto_overview_2D(m_mdthitsperML_byLayer[enumMiddle], "NumberOfHitsInMDTMiddle_ADCCut", "#eta station", "#phi station",
932  1, 0, 1, 1, 0, 1, m_mg->mongroup_overview_shiftLumi);
933  sc = bookMDTHisto_overview_2D(m_mdthitsperML_byLayer[enumOuter], "NumberOfHitsInMDTOuter_ADCCut", "#eta station", "#phi station", 1,
934  0, 1, 1, 0, 1, m_mg->mongroup_overview_shiftLumi);
935  sc = binMdtGlobal_byLayer(m_mdthitsperML_byLayer[enumInner], m_mdthitsperML_byLayer[enumMiddle], m_mdthitsperML_byLayer[enumOuter]);
936  // histo path for MDT Summary plots Barrel-EndCap
937  std::string ecap[4] = {"BA", "BC", "EA", "EC"};
938  std::string layer[4] = {"Inner", "Middle", "Outer", "Extra"};
939  std::string MDTHits_BE[2] = {"Barrel", "EndCap"};
940 
941  for (int iecap = 0; iecap < 4; iecap++) { // BA,BC,EA,EC
942  for (int ilayer = 0; ilayer < 4; ilayer++) { // inner, middle, outer, extra
944  // Number of hits/effs per Multilayer
946  if (iecap == enumBarrelA)
947  sc = bookMDTHisto_overview_2D(m_mdthitspermultilayerLumi[iecap][ilayer],
948  "NumberOfHitsIn" + ecap[iecap] + layer[ilayer] + "PerMultiLayer_ADCCut", "[Eta]",
949  "[Phi,Multilayer]", 1, 0, 1, 1, 0, 1, m_mg->mongroup_brA_shiftLumi);
950  else if (iecap == enumBarrelC)
951  sc = bookMDTHisto_overview_2D(m_mdthitspermultilayerLumi[iecap][ilayer],
952  "NumberOfHitsIn" + ecap[iecap] + layer[ilayer] + "PerMultiLayer_ADCCut", "[Eta]",
953  "[Phi,Multilayer]", 1, 0, 1, 1, 0, 1, m_mg->mongroup_brC_shiftLumi);
954  else if (iecap == enumEndCapA)
955  sc = bookMDTHisto_overview_2D(m_mdthitspermultilayerLumi[iecap][ilayer],
956  "NumberOfHitsIn" + ecap[iecap] + layer[ilayer] + "PerMultiLayer_ADCCut", "[Eta]",
957  "[Phi,Multilayer]", 1, 0, 1, 1, 0, 1, m_mg->mongroup_ecA_shiftLumi);
958  else
959  sc = bookMDTHisto_overview_2D(m_mdthitspermultilayerLumi[iecap][ilayer],
960  "NumberOfHitsIn" + ecap[iecap] + layer[ilayer] + "PerMultiLayer_ADCCut", "[Eta]",
961  "[Phi,Multilayer]", 1, 0, 1, 1, 0, 1, m_mg->mongroup_ecC_shiftLumi);
962 
963  std::string xAxis = ecap[iecap].substr(0, 1) + layer[ilayer].substr(0, 1) + ecap[iecap].substr(1, 1);
964  sc = binMdtRegional(m_mdthitspermultilayerLumi[iecap][ilayer], xAxis);
965 
966  if (sc.isFailure()) {
967  ATH_MSG_ERROR("mdthitspermultilayer Failed to register histogram lowStat");
968  return sc;
969  }
970  ATH_MSG_DEBUG("Inside LowStat Loop, iecap=" << iecap << ", ilayer=" << ilayer);
971 
973  // Number of hits per chamber (all sectors in one plot)
975  if (ilayer == 0 && ((iecap == 0 || iecap == 2))) {
976  ATH_MSG_DEBUG("Bookint mdthitsperchamber_InnerMiddleOuter LowStat");
977  sc = bookMDTHisto_overview_2D(m_mdthitsperchamber_InnerMiddleOuterLumi[iecap / 2],
978  "NumberOfHitsIn" + MDTHits_BE[iecap / 2] + "PerChamber_ADCCut", "[Eta]", "[Layer,Phi]", 1,
979  0, 1, 1, 0, 1, m_mg->mongroup_overview_shiftLumi);
980  sc = binMdtGlobal(m_mdthitsperchamber_InnerMiddleOuterLumi[iecap / 2], MDTHits_BE[iecap / 2].at(0));
981 
982  sc = bookMDTHisto_overview_2D(m_mdthitsperchamber_InnerMiddleOuter_HighOcc[iecap / 2],
983  "NumberOfHitsIn" + MDTHits_BE[iecap / 2] + "PerChamber_ADCCut_NoiseBurst", "[Eta]",
984  "[Layer,Phi]", 1, 0, 1, 1, 0, 1, m_mg->mongroup_overview_shiftLumi);
985  sc = binMdtGlobal(m_mdthitsperchamber_InnerMiddleOuter_HighOcc[iecap / 2], MDTHits_BE[iecap / 2].at(0));
986 
987  ATH_MSG_DEBUG("Bookint m_mdthitsperchamber_onSegm_InnerMiddleOuterLumi LowStat");
988  sc = bookMDTHisto_overview_2D(m_mdthitsperchamber_onSegm_InnerMiddleOuterLumi[iecap / 2],
989  "NumberOfHitsIn" + MDTHits_BE[iecap / 2] + "PerChamber_onSegm_ADCCut", "[Eta]",
990  "[Layer,Phi]", 1, 0, 1, 1, 0, 1, m_mg->mongroup_overview_shiftLumi_recoMon);
991  sc = binMdtGlobal(m_mdthitsperchamber_onSegm_InnerMiddleOuterLumi[iecap / 2], MDTHits_BE[iecap / 2].at(0));
992 
993  if (sc.isFailure()) {
994  ATH_MSG_ERROR("mdthitsperchamber_InnerMiddleOuter Failed to register histogram in lowStat");
995  return sc;
996  }
997  } // end if(ilayer==0&&(iecap==0||iecap==2) )
998  } // layer
999  } // ecap
1000  } // newLowStatIntervalFlag()
1001 
1002  if (newRun) {
1003  // //Book t0 tmax tdrift summary plots
1004  // //Just create these in the post-processing
1005 
1006  // histo path for MDT Summary plots Barrel-EndCap
1007  std::string ecap[4] = {"BA", "BC", "EA", "EC"};
1008  std::string layer[4] = {"Inner", "Middle", "Outer", "Extra"};
1009  std::string MDTHits_BE[2] = {"Barrel", "EndCap"};
1010  std::string crate[4] = {"01", "02", "03", "04"};
1011 
1012  for (int iecap = 0; iecap < 4; iecap++) { // BA,BC,EA,EC
1013  for (int ilayer = 0; ilayer < 4; ilayer++) { // inner, middle, outer, extra
1015  // Number of hits/effs per Multilayer
1017  // To-do Remove these from ESD monitoring in place of Post-Processing
1018  if (iecap == enumBarrelA) {
1019  sc = bookMDTHisto_overview_2D(m_mdteffpermultilayer[iecap][ilayer],
1020  "effsIn" + ecap[iecap] + layer[ilayer] + "PerMultiLayer_ADCCut", "[Eta]",
1021  "[Phi,Multilayer]", 1, 0, 1, 1, 0, 1, m_mg->mongroup_brA_shift);
1022  } else if (iecap == enumBarrelC) {
1023  sc = bookMDTHisto_overview_2D(m_mdteffpermultilayer[iecap][ilayer],
1024  "effsIn" + ecap[iecap] + layer[ilayer] + "PerMultiLayer_ADCCut", "[Eta]",
1025  "[Phi,Multilayer]", 1, 0, 1, 1, 0, 1, m_mg->mongroup_brC_shift);
1026  } else if (iecap == enumEndCapA) {
1027  sc = bookMDTHisto_overview_2D(m_mdteffpermultilayer[iecap][ilayer],
1028  "effsIn" + ecap[iecap] + layer[ilayer] + "PerMultiLayer_ADCCut", "[Eta]",
1029  "[Phi,Multilayer]", 1, 0, 1, 1, 0, 1, m_mg->mongroup_ecA_shift);
1030  } else {
1031  sc = bookMDTHisto_overview_2D(m_mdteffpermultilayer[iecap][ilayer],
1032  "effsIn" + ecap[iecap] + layer[ilayer] + "PerMultiLayer_ADCCut", "[Eta]",
1033  "[Phi,Multilayer]", 1, 0, 1, 1, 0, 1, m_mg->mongroup_ecC_shift);
1034  }
1035 
1036  std::string xAxis = ecap[iecap].substr(0, 1) + layer[ilayer].substr(0, 1) + ecap[iecap].substr(1, 1);
1037  sc = binMdtRegional(m_mdteffpermultilayer[iecap][ilayer], xAxis);
1038 
1039  if (sc.isFailure()) {
1040  ATH_MSG_ERROR("mdthitspermultilayer Failed to register histogram ");
1041  return sc;
1042  }
1043  ATH_MSG_DEBUG("Inside Loop, iecap=" << iecap << ", ilayer=" << ilayer);
1044 
1046  // Number of hits per chamber (all sectors in one plot)
1048  if (ilayer == 0 && ((iecap == 0 || iecap == 2))) {
1049  ATH_MSG_DEBUG("Bookint m_mdteffperchamber_InnerMiddleOuter");
1050  sc = bookMDTHisto_overview_2D(m_mdteffperchamber_InnerMiddleOuter[iecap / 2],
1051  "effsIn" + MDTHits_BE[iecap / 2] + "PerChamber_ADCCut", "[Eta]", "[Layer,Phi]", 1, 0, 1,
1052  1, 0, 1, m_mg->mongroup_overview_shift);
1053 
1054  sc = binMdtGlobal(m_mdteffperchamber_InnerMiddleOuter[iecap / 2], MDTHits_BE[iecap / 2].at(0));
1055 
1056  if (sc.isFailure()) {
1057  ATH_MSG_ERROR("mdthitsperchamber_InnerMiddleOuter Failed to register histogram ");
1058  return sc;
1059  }
1060  } // end if(ilayer==0&&(iecap==0||iecap==2) )
1061 
1062  // Book adc, tdc histograms for noise burst monitoring
1063  sc = bookMDTHisto_overview(m_overalladcPR_HighOcc[enumBarrelA], "MDTADC_NoiseBursts_BA", "[adc counts]",
1064  "Number of Entries", 100, 0., 400., m_mg->mongroup_brA_shift);
1065  sc = bookMDTHisto_overview(m_overalladcPR_HighOcc[enumBarrelC], "MDTADC_NoiseBursts_BC", "[adc counts]",
1066  "Number of Entries", 100, 0., 400., m_mg->mongroup_brC_shift);
1067  sc = bookMDTHisto_overview(m_overalladcPR_HighOcc[enumEndCapA], "MDTADC_NoiseBursts_EA", "[adc counts]",
1068  "Number of Entries", 100, 0., 400., m_mg->mongroup_ecA_shift);
1069  sc = bookMDTHisto_overview(m_overalladcPR_HighOcc[enumEndCapC], "MDTADC_NoiseBursts_EC", "[adc counts]",
1070  "Number of Entries", 100, 0., 400., m_mg->mongroup_ecC_shift);
1071  sc = bookMDTHisto_overview_2D(m_overalltdcadcPR_HighOcc[enumBarrelA], "Overall_TDCADC_spectrum_BA_NoiseBursts", "[nsec]",
1072  "[adc counts]", 50, 0, 2000., 40, 0., 400., m_mg->mongroup_brA_shift);
1073  sc = bookMDTHisto_overview_2D(m_overalltdcadcPR_HighOcc[enumBarrelC], "Overall_TDCADC_spectrum_BC_NoiseBursts", "[nsec]",
1074  "[adc counts]", 50, 0, 2000., 40, 0., 400., m_mg->mongroup_brC_shift);
1075  sc = bookMDTHisto_overview_2D(m_overalltdcadcPR_HighOcc[enumEndCapA], "Overall_TDCADC_spectrum_EA_NoiseBursts", "[nsec]",
1076  "[adc counts]", 50, 0, 2000., 40, 0., 400., m_mg->mongroup_ecA_shift);
1077  sc = bookMDTHisto_overview_2D(m_overalltdcadcPR_HighOcc[enumEndCapC], "Overall_TDCADC_spectrum_EC_NoiseBursts", "[nsec]",
1078  "[adc counts]", 50, 0, 2000., 40, 0., 400., m_mg->mongroup_ecC_shift);
1079  sc = bookMDTHisto_overview(m_overalltdcPR_HighOcc[enumBarrelA], "MDTTDC_NoiseBursts_BA", "[nsec]", "Number of Entries", 120,
1080  0., 2000., m_mg->mongroup_brA_shift);
1081  sc = bookMDTHisto_overview(m_overalltdcPR_HighOcc[enumBarrelC], "MDTTDC_NoiseBursts_BC", "[nsec]", "Number of Entries", 120,
1082  0., 2000., m_mg->mongroup_brC_shift);
1083  sc = bookMDTHisto_overview(m_overalltdcPR_HighOcc[enumEndCapA], "MDTTDC_NoiseBursts_EA", "[nsec]", "Number of Entries", 120,
1084  0., 2000., m_mg->mongroup_ecA_shift);
1085  sc = bookMDTHisto_overview(m_overalltdcPR_HighOcc[enumEndCapC], "MDTTDC_NoiseBursts_EC", "[nsec]", "Number of Entries", 120,
1086  0., 2000., m_mg->mongroup_ecC_shift);
1087  sc = bookMDTHisto_overview(m_overalltdcPR_HighOcc_ADCCut[enumBarrelA], "MDTTDC_NoiseBursts_ADCCut_BA", "[nsec]",
1088  "Number of Entries", 120, 0., 2000., m_mg->mongroup_brA_shift);
1089  sc = bookMDTHisto_overview(m_overalltdcPR_HighOcc_ADCCut[enumBarrelC], "MDTTDC_NoiseBursts_ADCCut_BC", "[nsec]",
1090  "Number of Entries", 120, 0., 2000., m_mg->mongroup_brC_shift);
1091  sc = bookMDTHisto_overview(m_overalltdcPR_HighOcc_ADCCut[enumEndCapA], "MDTTDC_NoiseBursts_ADCCut_EA", "[nsec]",
1092  "Number of Entries", 120, 0., 2000., m_mg->mongroup_ecA_shift);
1093  sc = bookMDTHisto_overview(m_overalltdcPR_HighOcc_ADCCut[enumEndCapC], "MDTTDC_NoiseBursts_ADCCut_EC", "[nsec]",
1094  "Number of Entries", 120, 0., 2000., m_mg->mongroup_ecC_shift);
1096  // Book occupancy as function of lumiblock
1098 
1099  if (ilayer != 3) { // put extras in outer
1100  std::string lbhisttitle;
1101  if (ilayer == 2)
1102  lbhisttitle = "OccupancyVsLB_" + ecap[iecap] + layer[ilayer] + "PlusExtra";
1103  else
1104  lbhisttitle = "OccupancyVsLB_" + ecap[iecap] + layer[ilayer];
1105  if (iecap == enumBarrelA) {
1106  sc = bookMDTHisto_OccVsLB(m_mdtoccvslb[iecap][ilayer], lbhisttitle, "LB", "[Eta,Phi]", 834, 1, 2502, 100, 1, 100,
1107  m_mg->mongroup_brA_shift);
1108  if (sc.isFailure()) {
1109  ATH_MSG_ERROR("m_mdtoccvslb Failed to register histogram ");
1110  return sc;
1111  }
1112  } else if (iecap == enumBarrelC) {
1113  sc = bookMDTHisto_OccVsLB(m_mdtoccvslb[iecap][ilayer], lbhisttitle, "LB", "[Eta,Phi]", 834, 1, 2502, 100, 0, 100,
1114  m_mg->mongroup_brC_shift);
1115  if (sc.isFailure()) {
1116  ATH_MSG_ERROR("m_mdtoccvslb Failed to register histogram ");
1117  return sc;
1118  }
1119  } else if (iecap == enumEndCapA) {
1120  sc = bookMDTHisto_OccVsLB(m_mdtoccvslb[iecap][ilayer], lbhisttitle, "LB", "[Eta,Phi]", 834, 1, 2502, 100, 0, 100,
1121  m_mg->mongroup_ecA_shift);
1122  if (sc.isFailure()) {
1123  ATH_MSG_ERROR("m_mdtoccvslb Failed to register histogram ");
1124  return sc;
1125  }
1126  } else {
1127  sc = bookMDTHisto_OccVsLB(m_mdtoccvslb[iecap][ilayer], lbhisttitle, "LB", "[Eta,Phi]", 834, 1, 2502, 100, 0, 100,
1128  m_mg->mongroup_ecC_shift);
1129  if (sc.isFailure()) {
1130  ATH_MSG_ERROR("m_mdtoccvslb Failed to register histogram ");
1131  return sc;
1132  }
1133  }
1134 
1135  sc = binMdtOccVsLB(m_mdtoccvslb[iecap][ilayer], iecap, ilayer);
1136  if (sc.isFailure()) {
1137  ATH_MSG_ERROR("m_mdtoccvslb Failed to register histogram ");
1138  return sc;
1139  }
1140  }
1141 
1143  // Book occupancy as function of lumiblock by crate
1145 
1146  std::string lbCrate_histtitle = "OccupancyVsLB_" + ecap[iecap] + crate[ilayer];
1147  if (iecap == enumBarrelA) {
1148  sc = bookMDTHisto_OccVsLB(m_mdtoccvslb_by_crate[iecap][ilayer], lbCrate_histtitle, "LB", "[Eta,Phi]", 834, 1, 2502, 100,
1149  1, 100, m_mg->mongroup_brA_shift);
1150  if (sc.isFailure()) {
1151  ATH_MSG_ERROR("m_mdtoccvslb_by_crate Failed to register histogram ");
1152  return sc;
1153  }
1154  } else if (iecap == enumBarrelC) {
1155  sc = bookMDTHisto_OccVsLB(m_mdtoccvslb_by_crate[iecap][ilayer], lbCrate_histtitle, "LB", "[Eta,Phi]", 834, 1, 2502, 100,
1156  0, 100, m_mg->mongroup_brC_shift);
1157  if (sc.isFailure()) {
1158  ATH_MSG_ERROR("m_mdtoccvslb_by_crate Failed to register histogram ");
1159  return sc;
1160  }
1161  } else if (iecap == enumEndCapA) {
1162  sc = bookMDTHisto_OccVsLB(m_mdtoccvslb_by_crate[iecap][ilayer], lbCrate_histtitle, "LB", "[Eta,Phi]", 834, 1, 2502, 100,
1163  0, 100, m_mg->mongroup_ecA_shift);
1164  if (sc.isFailure()) {
1165  ATH_MSG_ERROR("m_mdtoccvslb_by_crate Failed to register histogram ");
1166  return sc;
1167  }
1168  } else {
1169  sc = bookMDTHisto_OccVsLB(m_mdtoccvslb_by_crate[iecap][ilayer], lbCrate_histtitle, "LB", "[Eta,Phi]", 834, 1, 2502, 100,
1170  0, 100, m_mg->mongroup_ecC_shift);
1171  if (sc.isFailure()) {
1172  ATH_MSG_ERROR("m_mdtoccvslb_by_crate Failed to register histogram ");
1173  return sc;
1174  }
1175  }
1176 
1177  sc = binMdtOccVsLB_Crate(m_mdtoccvslb_by_crate[iecap][ilayer], iecap, ilayer);
1178  if (sc.isFailure()) {
1179  ATH_MSG_ERROR("m_mdtoccvslb_by_crate Failed to register histogram ");
1180  return sc;
1181  }
1182 
1183  std::string perSectors_summary_histtitle = "OccupancyPerSectorVsLB";
1184  sc = bookMDTHisto_OccVsLB(m_mdtoccvslb_summaryPerSector, perSectors_summary_histtitle, "LB", "[Phi]", 834, 1, 2502, 100, 1,
1185  100, m_mg->mongroup_overview_shift);
1186  if (sc.isFailure()) {
1187  ATH_MSG_ERROR(" mdtoccvslb_summaryPerSector Failed to register histogram ");
1188  return sc;
1189  }
1190  m_mdtoccvslb_summaryPerSector->SetBins(834, 1, 2502, 64, 0, 64);
1191  m_mdtoccvslb_summaryPerSector->GetYaxis()->SetBinLabel(1, "BA");
1192  m_mdtoccvslb_summaryPerSector->GetYaxis()->SetBinLabel(17, "BC");
1193  m_mdtoccvslb_summaryPerSector->GetYaxis()->SetBinLabel(33, "EA");
1194  m_mdtoccvslb_summaryPerSector->GetYaxis()->SetBinLabel(49, "EC");
1195 
1196  std::string lbCrate_ontrack_histtitle = "OccupancyVsLB_ontrack_" + ecap[iecap] + crate[ilayer];
1197  if (iecap == enumBarrelA) {
1198  sc = bookMDTHisto_OccVsLB(m_mdtoccvslb_ontrack_by_crate[iecap][ilayer], lbCrate_ontrack_histtitle, "LB", "[Eta,Phi]",
1199  834, 1, 2502, 100, 1, 100, m_mg->mongroup_brA_shift);
1200  if (sc.isFailure()) {
1201  ATH_MSG_ERROR("mdtoccvslb_ontrack_by_crate Failed to register histogram ");
1202  return sc;
1203  }
1204  } else if (iecap == enumBarrelC) {
1205  sc = bookMDTHisto_OccVsLB(m_mdtoccvslb_ontrack_by_crate[iecap][ilayer], lbCrate_ontrack_histtitle, "LB", "[Eta,Phi]",
1206  834, 1, 2502, 100, 0, 100, m_mg->mongroup_brC_shift);
1207  if (sc.isFailure()) {
1208  ATH_MSG_ERROR("mdtoccvslb_ontrack_by_crate Failed to register histogram ");
1209  return sc;
1210  }
1211  } else if (iecap == enumEndCapA) {
1212  sc = bookMDTHisto_OccVsLB(m_mdtoccvslb_ontrack_by_crate[iecap][ilayer], lbCrate_ontrack_histtitle, "LB", "[Eta,Phi]",
1213  834, 1, 2502, 100, 0, 100, m_mg->mongroup_ecA_shift);
1214  if (sc.isFailure()) {
1215  ATH_MSG_ERROR("mdtoccvslb_ontrack_by_crate Failed to register histogram ");
1216  return sc;
1217  }
1218  } else {
1219  sc = bookMDTHisto_OccVsLB(m_mdtoccvslb_ontrack_by_crate[iecap][ilayer], lbCrate_ontrack_histtitle, "LB", "[Eta,Phi]",
1220  834, 1, 2502, 100, 0, 100, m_mg->mongroup_ecC_shift);
1221  if (sc.isFailure()) {
1222  ATH_MSG_ERROR("mdtoccvslb_ontrack_by_crate Failed to register histogram ");
1223  return sc;
1224  }
1225  }
1226 
1227  sc = binMdtOccVsLB_Crate(m_mdtoccvslb_ontrack_by_crate[iecap][ilayer], iecap, ilayer);
1228  if (sc.isFailure()) {
1229  ATH_MSG_ERROR("mdtoccvslb_by_crate Failed to register histogram ");
1230  return sc;
1231  }
1232 
1234  // Finished number of MDT hits per multilayer
1236  for (int iPhi = 0; iPhi < 16; ++iPhi) {
1237  std::string Phi = std::to_string(iPhi + 1); // iPhi starts from zero
1238 
1240  if (ilayer == 0 && iecap == 0) {
1241  // Initialize to zero
1242  m_mdtchamberstatphislice[iPhi] = nullptr;
1243  if (m_do_mdtchamberstatphislice) {
1244  sc = bookMDTHisto_overview(m_mdtchamberstatphislice[iPhi], "MDTHitsOccup_ADCCut_Sector" + Phi, "",
1245  "Counts/Chamber", 1, 0., 1., m_mg->mongroup_sectors_expert);
1246  }
1247  }
1248 
1250  if (!(iecap <= 1 && ilayer == enumExtra &&
1251  iPhi % 2 != 1)) { // for barrel no odd-sectored extra layers // !(ilayer==enumExtra && iecap>=2) ) {
1252  // //don't do layer 'Extra' for endcaps
1253  std::string title_MDTHitSummary = "MDTHits_ADCCut_" + ecap[iecap] + "_" + layer[ilayer] + "_StPhi" + Phi;
1254  int max = (iecap < 2 && ilayer == 0) ? 11 : 7;
1255  int nbins = (iecap < 2 && ilayer == 0) ? 10 : 6;
1256 
1257  // Initialize to zero
1258  m_mdtChamberHits[iecap][ilayer][iPhi] = nullptr;
1259  if (m_do_mdtChamberHits) {
1260  if (iecap == 0)
1261  sc = bookMDTHisto_overview(m_mdtChamberHits[iecap][ilayer][iPhi], title_MDTHitSummary.c_str(), "StationEta",
1262  "Counts/Chamber", nbins, 1, max, m_mg->mongroup_brA_hits_expert);
1263  if (iecap == 1)
1264  sc = bookMDTHisto_overview(m_mdtChamberHits[iecap][ilayer][iPhi], title_MDTHitSummary.c_str(), "StationEta",
1265  "Counts/Chamber", nbins, 1, max, m_mg->mongroup_brC_hits_expert);
1266  if (iecap == 2)
1267  sc = bookMDTHisto_overview(m_mdtChamberHits[iecap][ilayer][iPhi], title_MDTHitSummary.c_str(), "StationEta",
1268  "Counts/Chamber", nbins, 1, max, m_mg->mongroup_ecA_hits_expert);
1269  if (iecap == 3)
1270  sc = bookMDTHisto_overview(m_mdtChamberHits[iecap][ilayer][iPhi], title_MDTHitSummary.c_str(), "StationEta",
1271  "Counts/Chamber", nbins, 1, max, m_mg->mongroup_ecC_hits_expert);
1272  }
1273 
1274  if (sc.isFailure()) {
1275  ATH_MSG_ERROR("m_mdtChamberHits per eta and phi Failed to register histogram ");
1276  return sc;
1277  }
1278 
1279  // ATH_MSG_DEBUG("SHIFT : " << shift );
1280  ATH_MSG_DEBUG("RUN : " << run);
1282 
1284  std::string title_MDTTDCSummary = "MDTTDC_ADCCut_" + ecap[iecap] + "_" + layer[ilayer] + "_StPhi" + Phi;
1285 
1286  // Initialize to zero
1287  m_mdttdccut_sector[iecap][ilayer][iPhi] = nullptr;
1288  if (m_do_mdttdccut_sector) {
1289  if (iecap == 0)
1290  sc = bookMDTHisto_overview(m_mdttdccut_sector[iecap][ilayer][iPhi], title_MDTTDCSummary.c_str(), "[nsec]",
1291  "number of entries", 100, 0, 2000., m_mg->mongroup_brA_tdc_expert);
1292  if (iecap == 1)
1293  sc = bookMDTHisto_overview(m_mdttdccut_sector[iecap][ilayer][iPhi], title_MDTTDCSummary.c_str(), "[nsec]",
1294  "number of entries", 100, 0, 2000., m_mg->mongroup_brC_tdc_expert);
1295  if (iecap == 2)
1296  sc = bookMDTHisto_overview(m_mdttdccut_sector[iecap][ilayer][iPhi], title_MDTTDCSummary.c_str(), "[nsec]",
1297  "number of entries", 100, 0, 2000., m_mg->mongroup_ecA_tdc_expert);
1298  if (iecap == 3)
1299  sc = bookMDTHisto_overview(m_mdttdccut_sector[iecap][ilayer][iPhi], title_MDTTDCSummary.c_str(), "[nsec]",
1300  "number of entries", 100, 0, 2000., m_mg->mongroup_ecC_tdc_expert);
1301  }
1302 
1303  if (sc.isFailure()) {
1304  ATH_MSG_ERROR("m_mdttdccut_sector per eta and phi Failed to register histogram ");
1305  return sc;
1306  }
1307  }
1308 
1309  } // loop in phi
1310  } // loop in layer
1311  } // loop in ecap
1312  } // newRunFlag()
1313 
1314  ATH_MSG_DEBUG("LEAVING MDTSUMMARYBOOK");
1315  return sc;
1316 }
1317 
1318 StatusCode MdtRawDataValAlg::bookMDTOverviewHistograms(/* bool isNewEventsBlock,*/ bool newLumiBlock, bool newRun) {
1319  StatusCode sc = StatusCode::SUCCESS;
1320 
1321  // if( isNewEventsBlock ){}
1322  if (newLumiBlock) {}
1323  // book these histos as lowStat interval if not online monitoring
1324  if ((newLowStatIntervalFlag() && !m_isOnline) || (m_isOnline && newRun)) {
1326  // histo path for overall tdccut spectrum
1327  sc = bookMDTHisto_overview(m_overalltdccutLumi, "Overall_TDC_ADCCut_spectrum", "[nsec]", "Number of Entries", 120, 0., 2000.,
1328  m_mg->mongroup_overview_shiftLumi);
1329 
1331  // histo path for overall tdccut spectrum (along segms)
1332  sc = bookMDTHisto_overview(m_overalltdccut_segm_Lumi, "Overall_TDC_onSegm_ADCCut_spectrum", "[nsec]", "Number of Entries", 120, 0.,
1333  2000., m_mg->mongroup_overview_shiftLumi);
1334 
1336  // histo path for overall adc spectrum (along segms)
1337  sc = bookMDTHisto_overview(m_overalladc_segm_Lumi, "Overall_ADC_onSegm_spectrum", "[adc counts]", "Number of Entries", 100, 0.,
1338  400., m_mg->mongroup_overview_shiftLumi);
1339 
1341  // histo path for overall adc spectrum
1342  sc = bookMDTHisto_overview(m_overalladc_Lumi, "Overall_ADC_spectrum", "[adc counts]", "Number of Entries", 100, 0., 400.,
1343  m_mg->mongroup_overview_shiftLumi);
1344 
1346  // histo path for TotalNumber_of_MDT_hits_per_event with a cut on ADC
1347  sc = bookMDTHisto_overview(m_mdteventscutLumi, "TotalNumber_of_MDT_hits_per_event_ADCCut", "[counts]", "Number of Events", 400, 0.,
1348  10000., m_mg->mongroup_overview_shiftLumi);
1350  // histo path for TotalNumber_of_MDT_hits_per_event with a cut on ADC (for high mult. events)
1351  sc = bookMDTHisto_overview(m_mdteventscutLumi_big, "TotalNumber_of_MDT_hits_per_event_big_ADCCut", "[counts]", "Number of Events",
1352  200, 0., 100000., m_mg->mongroup_overview_shiftLumi);
1354  // histo path for TotalNumber_of_MDT_hits_per_event without a cut on ADC
1355  sc = bookMDTHisto_overview(m_mdteventsLumi, "TotalNumber_of_MDT_hits_per_event", "[counts]", "Number of Events", 500, 0., 20000.,
1356  m_mg->mongroup_overview_shiftLumi);
1357 
1359  // histo path for TotalNumber_of_MDT_hits_per_event without a cut on ADC (for high mult. events)
1360  sc = bookMDTHisto_overview(m_mdteventsLumi_big, "TotalNumber_of_MDT_hits_per_event_big", "[counts]", "Number of Events", 200, 0.,
1361  100000., m_mg->mongroup_overview_shiftLumi);
1362 
1364  // histo path for overall tdc vs adc spectrum
1365  sc = bookMDTHisto_overview_2D(m_overalltdcadcLumi, "Overall_TDCADC_spectrum", "[nsec]", "[adc counts]", 50, 0, 2000., 20., 0., 400.,
1366  m_mg->mongroup_overview_shiftLumi);
1367  }
1368 
1369  if (newRun) {
1370  // histo path for Time_large_global_hits with a cut on ADC
1371  sc = bookMDTHisto_overview(m_mdtglobalhitstime, "Time_large_global_hits", "time", "Number of Events", 10000, 0., 10000.,
1372  m_mg->mongroup_overview_shift);
1373 
1374  // histo path for m_MdtNHitsvsRpcNHits
1375  sc = bookMDTHisto_overview_2D(m_MdtNHitsvsRpcNHits, "m_MdtNHitsvsRpcNHits", "# MDT hits", "# RPC hits", 1000, 0., 100000., 100, 0.,
1376  10000., m_mg->mongroup_overview_shift);
1378  // histo path for overall tdccut spectrum
1379  sc = bookMDTHisto_overview(m_overalltdcHighOcc, "Overall_TDC_spectrum_NoiseBursts", "[nsec]", "Number of Entries", 120, 0., 2000.,
1380  m_mg->mongroup_overview_shift);
1382  // histo path for overall adc spectrum
1383  sc = bookMDTHisto_overview(m_overalladc_HighOcc, "Overall_ADC_spectrum_NoiseBursts", "[adc counts]", "Number of Entries", 100, 0.,
1384  400., m_mg->mongroup_overview_shift);
1386  // histo path for overall tdc vs adc spectrum
1387  sc = bookMDTHisto_overview_2D(m_overalltdcadcHighOcc, "Overall_TDCADC_spectrum_NoiseBursts", "[nsec]", "[adc counts]", 50, 0, 2000.,
1388  20., 0., 400., m_mg->mongroup_overview_shift);
1390  // histo path for Number_of_MDTs_with_hits_per_event
1391  sc = bookMDTHisto_overview(m_nummdtchamberswithhits, "number_of_Chambers_with_hits_per_event", "[Number_of_MDT_chambers_with_hits]",
1392  "Number of Entries", 400, 0., 1600., m_mg->mongroup_overview_shift);
1393 
1394  // histo path for Number_of_MDTs_with_hits_per_event
1395  sc = bookMDTHisto_overview(m_nummdtchamberswithHighOcc, "number_of_Chambers_with_high_occupancy_per_event",
1396  "[Number_of_MDT_chambers_with_high_occupancy]", "Number of Entries", 200, 0., 800.,
1397  m_mg->mongroup_overview_shift);
1398 
1400  // histo path for Number_of_MDTs_with_hits_per_event_ADCCut
1401  sc =
1402  bookMDTHisto_overview(m_nummdtchamberswithhits_ADCCut, "number_of_Chambers_with_hits_per_event_ADCCut",
1403  "[Number_of_MDT_chambers_with_hits]", "Number of Entries", 400, 0., 1600., m_mg->mongroup_overview_shift);
1404 
1406  // Histo Path for Number_of_MDT_hits_per_chamber
1407  sc = bookMDTHisto_overview(m_mdtchamberstat, "Number_of_MDT_hits_per_chamber_ADCCut", "MDTChamber", "Counts/Chamber", 1, 0., 1.,
1408  m_mg->mongroup_overview_expert);
1409  for (auto itr : m_chambersId) {
1410  std::string hardware_name = getChamberName(itr);
1411  // Skip Chambers That Do NOT Exist
1412  if (hardware_name == "BML6A13" || hardware_name == "BML6C13") continue;
1413  m_mdtchamberstat->Fill(hardware_name.c_str(), 0.0);
1414  }
1415  m_mdtchamberstat->Reset();
1416  m_mdtchamberstat->LabelsOption("a");
1417  m_mdtchamberstat->GetXaxis()->LabelsOption("v");
1418 
1420  // histo path for Number_of_MDTHits_inRZView_Global and Number_of_MDTHits_inYXView_Global for EndCap, Barrel and Overlap
1421  // respectively
1422  std::string mdtreg[3] = {"Barrel", "Overlap", "EndCap"};
1423  std::string generic_path_mdtrzxydet = "MDT/Overview";
1424 
1425  for (int imdtreg = 0; imdtreg < 3; imdtreg++) {
1427  sc = bookMDTHisto_overview_2D(m_mdtrzdet[imdtreg], "Number_of_" + mdtreg[imdtreg] + "MDTHits_inRZView_Global_ADCCut",
1428  "MDT-GlobalZ(mm)", "MDT-GlobalR(mm)", 250, -25000., 25000., 120, 0., 12000.,
1429  m_mg->mongroup_overview_shift_geometry);
1430 
1432  sc = bookMDTHisto_overview_2D(m_mdtxydet[imdtreg], "Number_of_" + mdtreg[imdtreg] + "MDTHits_inYXView_Global_ADCCut",
1433  "MDT-GlobalX(mm)", "MDT-GlobalY(mm)", 150, -15000., 15000., 150, -15000., 15000.,
1434  m_mg->mongroup_overview_shift_geometry);
1435  }
1436 
1437  } // newRun
1438  return sc;
1439 }
1440 
1441 StatusCode MdtRawDataValAlg::fillMDTHistograms(const Muon::MdtPrepData* mdtCollection) {
1442  // fill chamber by chamber histos
1443  StatusCode sc = StatusCode::SUCCESS;
1444  Identifier digcoll_id = (mdtCollection)->identify();
1445  IdentifierHash digcoll_idHash = (mdtCollection)->collectionHash();
1446 
1447  MDTChamber* chamber;
1448  sc = getChamber(digcoll_idHash, chamber);
1449  if (!sc.isSuccess()) {
1450  ATH_MSG_ERROR("Could Not Retrieve MDTChamber w/ ID " << digcoll_idHash);
1451  return sc;
1452  }
1453 
1454  std::string hardware_name = chamber->getName();
1455 
1456  // //convert layer numbering from 1->4 to 1->8
1457  // //check if we are in 2nd multilayer
1458  // //then add 4 if large chamber, 3 if small chamber
1459  int mdtlayer = m_idHelperSvc->mdtIdHelper().tubeLayer(digcoll_id);
1460  if (m_idHelperSvc->mdtIdHelper().multilayer(digcoll_id) == 2) {
1461  if (hardware_name.at(1) == 'I' && hardware_name.at(3) != '8')
1462  mdtlayer += 4;
1463  else
1464  mdtlayer += 3;
1465  }
1466  int tubeMax = m_idHelperSvc->mdtIdHelper().tubeMax(digcoll_id);
1467  int mdttube = m_idHelperSvc->mdtIdHelper().tube(digcoll_id) + (mdtlayer - 1) * tubeMax;
1468  ChamberTubeNumberCorrection(mdttube, hardware_name, m_idHelperSvc->mdtIdHelper().tube(digcoll_id), mdtlayer - 1);
1469 
1470  bool isNoisy = m_masked_tubes->isNoisy(mdtCollection);
1471 
1472  std::string tube_str = std::to_string(mdttube);
1473 
1474  float tdc = mdtCollection->tdc() * 25.0 / 32.0;
1475  // Note: the BMG is digitized with 200ps which is not same as other MDT chambers with 25/32=781.25ps
1476  if (hardware_name.compare(0, 3, "BMG") == 0) tdc = mdtCollection->tdc() * 0.2;
1477  float adc = mdtCollection->adc();
1478  if (hardware_name.compare(0, 3, "BMG") == 0) adc /= 4.;
1479 
1480  if (chamber->mdttdc) {
1481  chamber->mdttdc->Fill(tdc);
1482  } else {
1483  ATH_MSG_DEBUG("mdttdc not in hist list!");
1484  }
1485 
1486  int mdtMultLayer = m_idHelperSvc->mdtIdHelper().multilayer(digcoll_id);
1487 
1488  // trigger specific
1489  if (adc > m_ADCCut && !isNoisy) {
1490  if (chamber->mdttdccut_ML1 && mdtMultLayer == 1) { chamber->mdttdccut_ML1->Fill(tdc); }
1491  if (chamber->mdttdccut_ML2 && mdtMultLayer == 2) { chamber->mdttdccut_ML2->Fill(tdc); }
1492  }
1493 
1494  if (chamber->mdtadc) { chamber->mdtadc->Fill(adc); }
1495 
1496  if (chamber->mdttdcadc && adc > 0) { chamber->mdttdcadc->Fill(tdc, adc); }
1497 
1498  if (chamber->mdtlayer) {
1499  if ((adc > m_ADCCut && !isNoisy)) chamber->mdtlayer->Fill(mdtlayer);
1500  }
1501 
1502  if (chamber->mdttube) {
1503  if ((adc > m_ADCCut)) chamber->mdttube->Fill(mdttube);
1504  }
1505  if (chamber->mdtmezz) {
1506  if (adc > m_ADCCut) chamber->mdtmezz->Fill(mezzmdt(digcoll_id));
1507  }
1508 
1509  return sc;
1510 }
1511 
1512 StatusCode MdtRawDataValAlg::fillMDTSummaryHistograms(const Muon::MdtPrepData* mdtCollection, std::set<std::string> chambers_from_tracks,
1513  bool& isNoiseBurstCandidate) {
1514  StatusCode sc = StatusCode::SUCCESS;
1515  Identifier digcoll_id = (mdtCollection)->identify();
1516  IdentifierHash digcoll_idHash = (mdtCollection)->collectionHash();
1517 
1518  MDTChamber* chamber;
1519  sc = getChamber(digcoll_idHash, chamber);
1520  if (!sc.isSuccess()) {
1521  ATH_MSG_ERROR("Could Not Retrieve MDTChamber w/ ID " << digcoll_idHash);
1522  return sc;
1523  }
1524  bool isNoisy = m_masked_tubes->isNoisy(mdtCollection);
1525 
1526  int ibarrel = chamber->GetBarrelEndcapEnum();
1527  int iregion = chamber->GetRegionEnum();
1528  int ilayer = chamber->GetLayerEnum();
1529  int icrate = chamber->GetCrate();
1530  int stationEta = chamber->GetStationEta();
1531  int stationPhi = chamber->GetStationPhi();
1532  std::string chambername = chamber->getName();
1533  bool is_on_track = false;
1534  for (const auto& ch : chambers_from_tracks) {
1535  if (chambername == ch) is_on_track = true;
1536  }
1537  bool isBIM = (chambername.at(2) == 'M');
1538  float tdc = mdtCollection->tdc() * 25.0 / 32.0;
1539  // Note: the BMG is digitized with 200ps which is not same as other MDT chambers with 25/32=781.25ps
1540  if (chambername.compare(0, 3, "BMG") == 0) tdc = mdtCollection->tdc() * 0.2;
1541  float adc = mdtCollection->adc();
1542  if (chambername.compare(0, 3, "BMG") == 0) adc /= 4.;
1543 
1544  if (m_mdtChamberHits[iregion][ilayer][stationPhi] && adc > m_ADCCut)
1545  m_mdtChamberHits[iregion][ilayer][stationPhi]->Fill(std::abs(stationEta));
1546 
1547  int mlayer_n = m_idHelperSvc->mdtIdHelper().multilayer(digcoll_id);
1548 
1549  // Fill Barrel - Endcap Multilayer Hits
1550  if (!isNoisy && adc > 0) {
1551  m_overalltdcadcPRLumi[iregion]->Fill(tdc, adc);
1552  if (isNoiseBurstCandidate) m_overalltdcadcPR_HighOcc[iregion]->Fill(tdc, adc);
1553  }
1554  if (!isNoisy) {
1555  m_overalladcPRLumi[iregion]->Fill(adc);
1556  if (isNoiseBurstCandidate) {
1557  m_overalltdcPR_HighOcc[iregion]->Fill(tdc);
1558  m_overalladcPR_HighOcc[iregion]->Fill(adc);
1559  }
1560  }
1561  if (adc > m_ADCCut && !isNoisy) {
1562  m_mdthitsperchamber_InnerMiddleOuterLumi[ibarrel]->AddBinContent(chamber->GetMDTHitsPerChamber_IMO_Bin(), 1.);
1563  m_mdthitsperchamber_InnerMiddleOuterLumi[ibarrel]->SetEntries(m_mdthitsperchamber_InnerMiddleOuterLumi[ibarrel]->GetEntries() + 1);
1564 
1565  m_mdthitspermultilayerLumi[iregion][ilayer]->AddBinContent(chamber->GetMDTHitsPerML_Bin(mlayer_n), 1.);
1566  m_mdthitspermultilayerLumi[iregion][ilayer]->SetEntries(m_mdthitspermultilayerLumi[iregion][ilayer]->GetEntries() + 1);
1567 
1568  // We put the "extras" on the inner histogram to avoid creating separate histogram.
1569  m_mdthitsperML_byLayer[(ilayer < 3 ? ilayer : enumInner)]->AddBinContent(chamber->GetMDTHitsPerML_byLayer_Bin(mlayer_n), 1.);
1570  m_mdthitsperML_byLayer[(ilayer < 3 ? ilayer : enumInner)]->SetEntries(
1571  m_mdthitsperML_byLayer[(ilayer < 3 ? ilayer : enumInner)]->GetEntries() + 1);
1572 
1573  m_overalladccutPRLumi[iregion]->Fill(adc);
1574  m_overalltdccutPRLumi[iregion]->Fill(tdc);
1575  if (isNoiseBurstCandidate) {
1576  m_mdthitsperchamber_InnerMiddleOuter_HighOcc[ibarrel]->AddBinContent(chamber->GetMDTHitsPerChamber_IMO_Bin(), 1.);
1577  m_mdthitsperchamber_InnerMiddleOuter_HighOcc[ibarrel]->SetEntries(
1578  m_mdthitsperchamber_InnerMiddleOuter_HighOcc[ibarrel]->GetEntries() + 1);
1579  m_overalltdcPR_HighOcc_ADCCut[iregion]->Fill(tdc);
1580  }
1581 
1582  if (HasTrigBARREL()) m_overalltdccutPRLumi_RPCtrig[iregion]->Fill(tdc);
1583  if (HasTrigENDCAP()) m_overalltdccutPRLumi_TGCtrig[iregion]->Fill(tdc);
1584 
1585  //
1586  // Fill occupancy vs. Lumiblock
1587  if (ilayer != 3)
1588  m_mdtoccvslb[iregion][ilayer]->Fill(m_lumiblock, get_bin_for_LB_hist(iregion, ilayer, stationPhi, stationEta, isBIM));
1589  else
1590  m_mdtoccvslb[iregion][2]->Fill(
1591  m_lumiblock, get_bin_for_LB_hist(iregion, ilayer, stationPhi, stationEta, isBIM)); // Put extras in with outer
1592 
1593  m_mdtoccvslb_summaryPerSector->Fill(m_lumiblock, stationPhi + iregion * 16);
1594 
1595  // correct readout crate info for BEE,BIS7/8
1596  int crate_region = iregion;
1597  if (chambername.compare(0, 3, "BEE") == 0 || (chambername.compare(0, 3, "BIS") == 0 && (stationEta == 7 || stationEta == 8))) {
1598  if (iregion == 0) crate_region = 2;
1599  if (iregion == 1) crate_region = 3;
1600  }
1601  // use stationPhi+1 becuase that's the actual phi, not phi indexed from zero.
1602  m_mdtoccvslb_by_crate[crate_region][icrate - 1]->Fill(
1603  m_lumiblock, get_bin_for_LB_crate_hist(crate_region, icrate, stationPhi + 1, stationEta, chambername));
1604 
1605  if (is_on_track) {
1606  m_mdtoccvslb_ontrack_by_crate[crate_region][icrate - 1]->Fill(
1607  m_lumiblock, get_bin_for_LB_crate_hist(crate_region, icrate, stationPhi + 1, stationEta, chambername));
1608  }
1609  }
1610 
1611  return sc;
1612 }
1613 
1614 StatusCode MdtRawDataValAlg::fillMDTOverviewHistograms(const Muon::MdtPrepData* mdtCollection, bool& isNoiseBurstCandidate) {
1615  StatusCode sc = StatusCode::SUCCESS;
1616  Identifier digcoll_id = (mdtCollection)->identify();
1617 
1618  std::string hardware_name = getChamberName(mdtCollection);
1619  bool isNoisy = m_masked_tubes->isNoisy(mdtCollection);
1620 
1621  // MuonDetectorManager from the conditions store
1622  SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey};
1623  const MuonGM::MuonDetectorManager* MuonDetMgr = DetectorManagerHandle.cptr();
1624  if (MuonDetMgr == nullptr) {
1625  ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
1626  return StatusCode::FAILURE;
1627  }
1628 
1629  const MuonGM::MdtReadoutElement* pReadoutElementMDT = MuonDetMgr->getMdtReadoutElement(digcoll_id);
1630  const Amg::Vector3D mdtgPos = pReadoutElementMDT->tubePos(digcoll_id); // global position of the wire
1631  float mdt_tube_eta = mdtgPos.eta();
1632  float mdt_tube_x = mdtgPos.x();
1633  float mdt_tube_y = mdtgPos.y();
1634  float mdt_tube_z = mdtgPos.z();
1635  float mdt_tube_perp = mdtgPos.perp();
1636 
1637  float tdc = mdtCollection->tdc() * 25.0 / 32.0;
1638  // Note: the BMG is digitized with 200ps which is not same as other MDT chambers with 25/32=781.25ps
1639  if (hardware_name.compare(0, 3, "BMG") == 0) tdc = mdtCollection->tdc() * 0.2;
1640  float adc = mdtCollection->adc();
1641  if (hardware_name.compare(0, 3, "BMG") == 0) adc /= 4.;
1642 
1643  // Barrel -->Fill MDT Global RZ and YX
1644  if (adc > m_ADCCut) {
1645  if (std::abs(mdt_tube_eta) > 0. && std::abs(mdt_tube_eta) < 0.9) {
1646  m_mdtrzdet[0]->Fill(mdt_tube_z, mdt_tube_perp);
1647  m_mdtxydet[0]->Fill(mdt_tube_x, mdt_tube_y);
1648  }
1649  // OverLap -->Fill MDT Global RZ and YX
1650  if (std::abs(mdt_tube_eta) > 0.9 && std::abs(mdt_tube_eta) < 1.2) {
1651  m_mdtrzdet[1]->Fill(mdt_tube_z, mdt_tube_perp);
1652  m_mdtxydet[1]->Fill(mdt_tube_x, mdt_tube_y);
1653  }
1654  // EndCap -->Fill MDT Global RZ and YX
1655  if (std::abs(mdt_tube_eta) > 1.2 && std::abs(mdt_tube_eta) < 2.7) {
1656  m_mdtrzdet[2]->Fill(mdt_tube_z, mdt_tube_perp);
1657  m_mdtxydet[2]->Fill(mdt_tube_x, mdt_tube_y);
1658  }
1659  }
1660 
1661  if (m_overalltdcadcLumi && !isNoisy && adc > 0)
1662  m_overalltdcadcLumi->Fill(tdc, adc);
1663  else if (!m_overalltdcadcLumi)
1664  ATH_MSG_DEBUG("m_overalltdcadcLumi not in hist list!");
1665 
1666  if (m_overalladc_Lumi) {
1667  m_overalladc_Lumi->Fill(adc);
1668  } else
1669  ATH_MSG_DEBUG("m_overalladc_Lumi not in hist list!");
1670 
1671  if (isNoiseBurstCandidate) {
1672  if (m_overalladc_HighOcc && !isNoisy) {
1673  m_overalladc_HighOcc->Fill(adc);
1674  } else
1675  ATH_MSG_DEBUG("m_overalladc_HighOcc not in hist list!");
1676  if (m_overalltdcadcHighOcc && adc > 0) {
1677  m_overalltdcadcHighOcc->Fill(tdc, adc);
1678  } else
1679  ATH_MSG_DEBUG("m_overalltdcadcHighOcc not in hist list!");
1680  if (m_overalltdcHighOcc) {
1681  m_overalltdcHighOcc->Fill(tdc);
1682  } else
1683  ATH_MSG_DEBUG("m_overalltdcHighOcc not in hist list!");
1684  if (m_overalltdcHighOcc_ADCCut && adc > m_ADCCut) {
1685  m_overalltdcHighOcc_ADCCut->Fill(tdc);
1686  } else
1687  ATH_MSG_DEBUG("m_overalltdcHighOcc_ADCCut not in hist list!");
1688  }
1689 
1690  if (adc > m_ADCCut) {
1691  if (m_overalltdccutLumi && !isNoisy) m_overalltdccutLumi->Fill(tdc);
1692  if (!m_overalltdccutLumi) ATH_MSG_DEBUG("overalltdccut not in hist list");
1693  }
1694 
1695  return sc;
1696 }
1697 
1698 // Code for measuring tube efficiencies and tdc/adc based on hits along segments
1699 // Strategy:
1700 // First loop over hits along segments and store hits
1701 // Identify the MLs affected for each segment
1702 // Loop over the tubes in the affected MLs and identify tubes traversed by segment vector (these represent the denom in the efficiency calc)
1703 // Find traversed tubes that also have a hit along the segment (these represent the num in the efficiency calc)
1704 // Details:
1705 // * To avoid double-counting hits (for tdc/adc fills) due to overlapping segments, use a set called store_ROTs
1706 // * To avoid double-counting hits (for eff calc) due to overlapping segments, use a set called store_effTubes
1707 // * The above 2 sets need not have the same size, because in the latter case some tubes are missed because they are slightly too
1708 // far away from the segment vector -- these tubes are simply excluded from the eff calc.
1709 // Additionally the latter case is complicated because for overlapping traversed tubes,
1710 // we must preference the ones that are part of a segment that records a hit in those tubes
1711 StatusCode MdtRawDataValAlg::handleEvent_effCalc(
1712  const Trk::SegmentCollection* segms) { //, const Muon::MdtPrepDataContainer* mdt_container) {
1713  StatusCode sc = StatusCode::SUCCESS;
1714  std::string type = "MDT";
1715  std::set<TubeTraversedBySegment, TubeTraversedBySegment_cmp> store_effTubes;
1716  std::set<Identifier> store_ROTs;
1717 
1718  // MuonDetectorManager from the conditions store
1719  SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey};
1720  const MuonGM::MuonDetectorManager* MuonDetMgr = DetectorManagerHandle.cptr();
1721  if (MuonDetMgr == nullptr) {
1722  ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
1723  return StatusCode::FAILURE;
1724  }
1725 
1726  // LOOP OVER SEGMENTS
1727  for (const auto* segm : *segms) {
1728  const Muon::MuonSegment* segment = dynamic_cast<const Muon::MuonSegment*>(segm);
1729  if (segment == nullptr) {
1730  ATH_MSG_DEBUG("no pointer to segment!!!");
1731  break;
1732  }
1733  if (segment->numberOfContainedROTs() < m_nb_hits || segment->numberOfContainedROTs() <= 0 ||
1734  segment->fitQuality()->chiSquared() / segment->fitQuality()->doubleNumberDoF() > m_chi2_cut) {
1735  continue;
1736  }
1737 
1738  // Gather hits used in segment
1739  std::vector<Identifier> ROTs_chamber;
1740  std::vector<int> ROTs_tube;
1741  std::vector<int> ROTs_L;
1742  std::vector<int> ROTs_ML;
1743  std::vector<float> ROTs_DR;
1744  std::vector<float> ROTs_DRerr;
1745  std::vector<float> ROTs_DT;
1746  for (unsigned int irot = 0; irot < segment->numberOfContainedROTs(); irot++) {
1747  const Trk::RIO_OnTrack* rot = segment->rioOnTrack(irot);
1748  const Muon::MdtDriftCircleOnTrack* mrot = dynamic_cast<const Muon::MdtDriftCircleOnTrack*>(rot);
1749  if (mrot) {
1750  Identifier tmpid = rot->identify();
1751  IdentifierHash idHash;
1752  MDTChamber* chamber = nullptr;
1753  m_idHelperSvc->mdtIdHelper().get_module_hash(tmpid, idHash);
1754  sc = getChamber(idHash, chamber);
1755  std::string chambername = chamber->getName();
1756  float adc = mrot->prepRawData()->adc();
1757  if (chambername.compare(0, 3, "BMG") == 0) adc /= 4.;
1758  if (m_overalladc_segm_Lumi) m_overalladc_segm_Lumi->Fill(adc);
1759  if (store_ROTs.insert(tmpid).second) { // Let's not double-count hits belonging to multiple segments
1760 
1761  double tdc = mrot->prepRawData()->tdc() * 25.0 / 32.0;
1762  // Note: the BMG is digitized with 200ps which is not same as other MDT chambers with 25/32=781.25ps
1763  if (chambername.compare(0, 3, "BMG") == 0) tdc = mrot->prepRawData()->tdc() * 0.2;
1764  // double tdc = mrot->driftTime()+500;
1765  int iregion = chamber->GetRegionEnum();
1766  int ilayer = chamber->GetLayerEnum();
1767  int statphi = chamber->GetStationPhi();
1768  int ibarrel_endcap = chamber->GetBarrelEndcapEnum();
1769  // hard cut to adc only to present this histogram
1770  if (m_overalladc_segm_PR_Lumi[iregion] && adc > 50.) m_overalladc_segm_PR_Lumi[iregion]->Fill(adc);
1771  if (adc > m_ADCCut) { // This is somewhat redundant because this is usual cut for segment-reconstruction, but that's OK
1772  if (statphi > 15) {
1773  ATH_MSG_ERROR("MDT StationPhi: " << statphi << " Is too high. Chamber name: " << chamber->getName());
1774  continue;
1775  }
1776 
1777  if (m_mdttdccut_sector[iregion][ilayer][statphi]) m_mdttdccut_sector[iregion][ilayer][statphi]->Fill(tdc);
1778  // Fill Overview Plots
1779  if (m_overalltdccut_segm_Lumi) m_overalltdccut_segm_Lumi->Fill(tdc);
1780  if (m_overalltdccut_segm_PR_Lumi[iregion]) m_overalltdccut_segm_PR_Lumi[iregion]->Fill(tdc);
1781 
1782  if (m_mdthitsperchamber_onSegm_InnerMiddleOuterLumi[ibarrel_endcap]) {
1783  m_mdthitsperchamber_onSegm_InnerMiddleOuterLumi[ibarrel_endcap]->AddBinContent(
1784  chamber->GetMDTHitsPerChamber_IMO_Bin(), 1.);
1785  m_mdthitsperchamber_onSegm_InnerMiddleOuterLumi[ibarrel_endcap]->SetEntries(
1786  m_mdthitsperchamber_onSegm_InnerMiddleOuterLumi[ibarrel_endcap]->GetEntries() + 1);
1787  }
1788  }
1789  int mdtMultLayer = m_idHelperSvc->mdtIdHelper().multilayer(tmpid);
1790  if (chamber->mdtadc_onSegm_ML1 && mdtMultLayer == 1) { chamber->mdtadc_onSegm_ML1->Fill(adc); }
1791  if (chamber->mdtadc_onSegm_ML2 && mdtMultLayer == 2) { chamber->mdtadc_onSegm_ML2->Fill(adc); }
1792  }
1793  // This information needs to be stored fully for each segment (for calculations below), so deal with these duplicates later
1794  // (otherwise we may not check a traversed ML for a differently pointing overlapping segment, for example)
1795 
1796  ROTs_chamber.push_back(tmpid);
1797  ROTs_ML.push_back(m_idHelperSvc->mdtIdHelper().multilayer(tmpid));
1798  ROTs_L.push_back(m_idHelperSvc->mdtIdHelper().tubeLayer(tmpid));
1799  ROTs_tube.push_back(m_idHelperSvc->mdtIdHelper().tube(tmpid));
1800  ROTs_DR.push_back(mrot->driftRadius());
1801  ROTs_DRerr.push_back((mrot->localCovariance())(Trk::driftRadius, Trk::driftRadius)); // always returns value 2.0
1802  ROTs_DT.push_back(mrot->driftTime());
1803  }
1804  }
1805  // Finished gathering hits used in segment
1806 
1807  if (m_doChamberHists) { // Don't perform this block if not doing chamber by chamber hists
1808 
1809  // Find unique chambers (since above we stored one chamber for every tube)
1810  // Also store the MLs affected by the ROTs, since we don't necessarily want to look for traversed tubes in entire chamber
1811  std::vector<Identifier> unique_chambers;
1812  std::vector<std::vector<int> > unique_chambers_ML;
1813  for (unsigned i = 0; i < ROTs_chamber.size(); i++) {
1814  bool isUnique = true;
1815  for (unsigned j = 0; j < unique_chambers.size(); j++) {
1816  if (getChamberName(ROTs_chamber.at(i)) == getChamberName(unique_chambers.at(j))) {
1817  isUnique = false;
1818  if (!AinB(ROTs_ML.at(i), unique_chambers_ML.at(j))) unique_chambers_ML.at(j).push_back(ROTs_ML.at(i));
1819  break;
1820  }
1821  }
1822  if (isUnique) {
1823  unique_chambers.push_back(ROTs_chamber.at(i));
1824  std::vector<int> tmp_ML;
1825  tmp_ML.push_back(ROTs_ML.at(i));
1826  unique_chambers_ML.push_back(tmp_ML);
1827  }
1828  }
1829  // Done finding unique chambers
1830 
1831  // Loop over the unique chambers
1832  // Here we store the tubes in each chamber that were traversed by the segment
1833  std::vector<Identifier> traversed_station_id;
1834  std::vector<int> traversed_tube;
1835  std::vector<int> traversed_L;
1836  std::vector<int> traversed_ML;
1837  std::vector<float> traversed_distance;
1838  for (unsigned i_chamber = 0; i_chamber < unique_chambers.size(); i_chamber++) {
1839  Identifier station_id = unique_chambers.at(i_chamber);
1840  if (!m_idHelperSvc->isMdt(station_id)) { ATH_MSG_DEBUG("Found non-MDT station identifier in segm-based mdt eff calc"); }
1841  std::string hardware_name = getChamberName(station_id);
1842 
1843  // SEGMENT track
1844  const MuonGM::MdtReadoutElement* detEl = MuonDetMgr->getMdtReadoutElement(station_id);
1845  Amg::Transform3D gToStation = detEl->GlobalToAmdbLRSTransform();
1846  Amg::Vector3D segPosG(segment->globalPosition());
1847  Amg::Vector3D segDirG(segment->globalDirection());
1848  Amg::Vector3D segPosL = gToStation * segPosG;
1849  Amg::Vector3D segDirL = gToStation.linear() * segDirG;
1850  MuonCalib::MTStraightLine segment_track =
1851  MuonCalib::MTStraightLine(segPosL, segDirL, Amg::Vector3D(0, 0, 0), Amg::Vector3D(0, 0, 0));
1852 
1853  // Loop over tubes in chamber, find those along segment
1854  for (int ML : unique_chambers_ML.at(i_chamber)) {
1855  Identifier newId = m_idHelperSvc->mdtIdHelper().channelID(
1856  hardware_name.substr(0, 3), m_idHelperSvc->mdtIdHelper().stationEta(station_id),
1857  m_idHelperSvc->mdtIdHelper().stationPhi(station_id), ML, 1, 1);
1858  auto [tubeMin, tubeMax] = m_idHelperSvc->mdtIdHelper().tubeMinMax(newId);
1859  auto [tubeLayerMin, tubeLayerMax] = m_idHelperSvc->mdtIdHelper().tubeLayerMinMax(newId);
1860  CorrectTubeMax(hardware_name, tubeMax);
1861  CorrectLayerMax(hardware_name, tubeLayerMax);
1862  for (int i_tube = tubeMin; i_tube <= tubeMax; i_tube++) {
1863  for (int i_layer = tubeLayerMin; i_layer <= tubeLayerMax; i_layer++) {
1864  const MuonGM::MdtReadoutElement* MdtRoEl = MuonDetMgr->getMdtReadoutElement(newId);
1865  Identifier tubeId = m_idHelperSvc->mdtIdHelper().channelID(newId, ML, i_layer, i_tube);
1866  if (m_BMGpresent && m_idHelperSvc->mdtIdHelper().stationName(newId) == m_BMGid) {
1867  std::map<Identifier, std::vector<Identifier> >::iterator myIt = m_DeadChannels.find(MdtRoEl->identify());
1868  if (myIt != m_DeadChannels.end()) {
1869  if (std::find((myIt->second).begin(), (myIt->second).end(), tubeId) != (myIt->second).end()) {
1870  ATH_MSG_DEBUG("Skipping tube with identifier "
1871  << m_idHelperSvc->mdtIdHelper().show_to_string(tubeId));
1872  continue;
1873  }
1874  }
1875  }
1876  Amg::Vector3D TubePos = MdtRoEl->GlobalToAmdbLRSCoords(MdtRoEl->tubePos(tubeId));
1877  MuonCalib::MTStraightLine tube_track =
1878  MuonCalib::MTStraightLine(TubePos, Amg::Vector3D::UnitX(), Amg::Vector3D(0, 0, 0), Amg::Vector3D(0, 0, 0));
1879  double distance = std::abs(segment_track.signDistFrom(tube_track));
1880  if (distance < (MdtRoEl->innerTubeRadius())) {
1881  traversed_station_id.push_back(station_id);
1882  traversed_tube.push_back(i_tube);
1883  traversed_L.push_back(i_layer);
1884  traversed_ML.push_back(ML);
1885  traversed_distance.push_back(segment_track.signDistFrom(tube_track));
1886  }
1887  }
1888  }
1889  }
1890  }
1891  // Done looping over the unqiue chambers
1892 
1893  // Loop over traversed tubes that were stored above
1894  // Here we fill the DRvsDT/DRvsSegD histos, as well is unique hits and traversed tubes to calculate efficiencies
1895  if (traversed_tube.size() < 20) { // quality cut here -- 20 traversed tubes is ridiculous and generates low efficiencies (these
1896  // are due to non-pointing segments)
1897  for (unsigned k = 0; k < traversed_tube.size(); k++) {
1898  std::string hardware_name = getChamberName(traversed_station_id.at(k));
1899  // GET HISTS
1900  IdentifierHash idHash;
1901  m_idHelperSvc->mdtIdHelper().get_module_hash(traversed_station_id.at(k), idHash);
1902  MDTChamber* chamber;
1903  sc = getChamber(idHash, chamber);
1904  if (!sc.isSuccess()) {
1905  ATH_MSG_ERROR("Could Not Retrieve MDTChamber w/ ID " << idHash);
1906  return sc;
1907  }
1908 
1909  bool hit_flag = false;
1910  for (unsigned j = 0; j < ROTs_tube.size(); j++) {
1911  if ((getChamberName(ROTs_chamber.at(j)) == hardware_name) && (traversed_tube.at(k) == ROTs_tube.at(j)) &&
1912  (traversed_L.at(k) == ROTs_L.at(j)) &&
1913  (traversed_ML.at(k) == ROTs_ML.at(j))) { // found traversed tube with hit used in segment
1914  hit_flag = true;
1915  if (chamber->mdt_DRvsDT) chamber->mdt_DRvsDT->Fill(ROTs_DR.at(j), ROTs_DT.at(j));
1916  if (chamber->mdt_DRvsDRerr)
1917  chamber->mdt_DRvsDRerr->Fill(ROTs_DR.at(j), ROTs_DRerr.at(j)); // plot appears useless
1918  if (chamber->mdt_DRvsSegD) chamber->mdt_DRvsSegD->Fill(ROTs_DR.at(j), traversed_distance.at(k));
1919  break;
1920  }
1921  }
1922  Identifier newId = m_idHelperSvc->mdtIdHelper().channelID(
1923  hardware_name.substr(0, 3), m_idHelperSvc->mdtIdHelper().stationEta(traversed_station_id.at(k)),
1924  m_idHelperSvc->mdtIdHelper().stationPhi(traversed_station_id.at(k)), traversed_ML.at(k), 1, 1);
1925  int tubeLayerMax = m_idHelperSvc->mdtIdHelper().tubeLayerMax(newId);
1926  m_idHelperSvc->mdtIdHelper().get_module_hash(newId, idHash);
1927 
1928  CorrectLayerMax(hardware_name, tubeLayerMax); // ChamberTubeNumberCorrection handles the tubeMax problem
1929  int mdtlayer = ((traversed_L.at(k) - 1) + (traversed_ML.at(k) - 1) * tubeLayerMax);
1930  int tubeMax = m_idHelperSvc->mdtIdHelper().tubeMax(newId);
1931  int ibin = traversed_tube.at(k) + mdtlayer * tubeMax;
1932  ChamberTubeNumberCorrection(ibin, hardware_name, traversed_tube.at(k), mdtlayer);
1933  // Store info for eff calc
1934  // (Here we make sure we are removing duplicates from overlapping segments by using sets)
1935  std::set<TubeTraversedBySegment, TubeTraversedBySegment_cmp>::iterator it;
1936  TubeTraversedBySegment tmp_effTube = TubeTraversedBySegment(hardware_name, ibin, hit_flag, idHash);
1937  TubeTraversedBySegment tmp_effTube_Hit = TubeTraversedBySegment(hardware_name, ibin, true, idHash);
1938  TubeTraversedBySegment tmp_effTube_noHit = TubeTraversedBySegment(hardware_name, ibin, false, idHash);
1939  it = store_effTubes.find(tmp_effTube_Hit);
1940  if (hit_flag || (it == store_effTubes.end()))
1941  store_effTubes.insert(tmp_effTube); // Insert if w/hit, but if w/o hit then only insert if no already stored w/ hit
1942  it = store_effTubes.find(tmp_effTube_noHit);
1943  if (hit_flag && (it != store_effTubes.end()))
1944  store_effTubes.erase(it); // If w/ hit, and the same tube is stored w/o hit, remove duplicate w/o hit
1945  }
1946  }
1947  // Done looping over traversed tubes
1948 
1949  } // m_doChamberHists
1950  }
1951 
1952  // Fill effentries/effcounts hists for efficiency calculation
1953  if (m_doChamberHists) { // Don't perform this block if not doing chamber by chamber hists
1954  for (const auto& store_effTube : store_effTubes) {
1955  // GET HISTS
1956  MDTChamber* chamber;
1957  sc = getChamber(store_effTube.idHash, chamber);
1958  if (!sc.isSuccess()) {
1959  ATH_MSG_ERROR("Could Not Retrieve MDTChamber w/ ID " << store_effTube.idHash);
1960  return sc;
1961  }
1962  if (chamber->mdt_effEntries) chamber->mdt_effEntries->Fill(store_effTube.tubeBin);
1963  if (store_effTube.isHit && chamber->mdt_effCounts) { chamber->mdt_effCounts->Fill(store_effTube.tubeBin); }
1964  }
1965  }
1966 
1967  return sc;
1968 }
1969 
1970 void MdtRawDataValAlg::initDeadChannels(const MuonGM::MdtReadoutElement* mydetEl) {
1971  PVConstLink cv = mydetEl->getMaterialGeom(); // it is "Multilayer"
1972  int nGrandchildren = cv->getNChildVols();
1973  if (nGrandchildren <= 0) return;
1974 
1975  std::vector<int> tubes;
1976  geoGetIds([&](int id) { tubes.push_back(id); }, &*cv);
1977  std::sort(tubes.begin(), tubes.end());
1978 
1979  Identifier detElId = mydetEl->identify();
1980 
1981  int name = m_idHelperSvc->mdtIdHelper().stationName(detElId);
1982  int eta = m_idHelperSvc->mdtIdHelper().stationEta(detElId);
1983  int phi = m_idHelperSvc->mdtIdHelper().stationPhi(detElId);
1984  int ml = m_idHelperSvc->mdtIdHelper().multilayer(detElId);
1985  std::vector<Identifier> deadTubes;
1986 
1987  std::vector<int>::iterator it = tubes.begin();
1988  for (int layer = 1; layer <= mydetEl->getNLayers(); layer++) {
1989  for (int tube = 1; tube <= mydetEl->getNtubesperlayer(); tube++) {
1990  int want_id = layer * maxNTubesPerLayer + tube;
1991  if (it != tubes.end() && *it == want_id) {
1992  ++it;
1993  } else {
1994  it = std::lower_bound(tubes.begin(), tubes.end(), want_id);
1995  if (it != tubes.end() && *it == want_id) {
1996  ++it;
1997  } else {
1998  Identifier deadTubeId = m_idHelperSvc->mdtIdHelper().channelID(name, eta, phi, ml, layer, tube);
1999  deadTubes.push_back(deadTubeId);
2000  ATH_MSG_VERBOSE("adding dead tube (" << tube << "), layer(" << layer << "), phi(" << phi << "), eta(" << eta
2001  << "), name(" << name << "), multilayerId(" << ml << ") and identifier "
2002  << deadTubeId << " .");
2003  }
2004  }
2005  }
2006  }
2007  std::sort(deadTubes.begin(), deadTubes.end());
2008  m_DeadChannels[detElId] = deadTubes;
2009 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
MdtRawDataValAlg::ChamberTubeNumberCorrection
static void ChamberTubeNumberCorrection(int &tubeNum, std::string_view hardware_name, int tubePos, int numLayers)
Definition: MDTRawDataUtils.cxx:929
MdtRawDataValAlg::m_chambersIdHash
std::vector< IdentifierHash > m_chambersIdHash
Definition: MdtRawDataValAlg.h:186
MdtRawDataValAlg::binMdtOccVsLB_Crate
virtual StatusCode binMdtOccVsLB_Crate(TH2 *&h, int region, int crate)
Definition: MDTRawDataUtils.cxx:1588
MdtRawDataValAlg::bookMDTHisto_chambers_2D
virtual StatusCode bookMDTHisto_chambers_2D(TH2F_LW *&h, TString, TString, TString, int, float, float, int, float, float, MonGroup &)
Definition: MDTRawDataUtils.cxx:996
MdtRawDataValAlg::m_mdttdccut_sector
TH1 * m_mdttdccut_sector[4][4][16]
Definition: MdtRawDataValAlg.h:280
MdtRawDataValAlg::m_overalltdcHighOcc
TH1 * m_overalltdcHighOcc
Definition: MdtRawDataValAlg.h:235
MdtRawDataValAlg::m_DetectorManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_DetectorManagerKey
Definition: MdtRawDataValAlg.h:122
TH2::Fill
int Fill(double, double)
Definition: rootspy.cxx:382
MdtRawDataValAlg::m_eventNum
int m_eventNum
Definition: MdtRawDataValAlg.h:170
MdtRawDataValAlg::m_nummdtchamberswithHighOcc
TH1 * m_nummdtchamberswithHighOcc
Definition: MdtRawDataValAlg.h:258
convertChamberName
std::string convertChamberName(int, int, int, const std::string &)
Definition: MuonDQA/MuonDQAUtils/src/MuonChamberNameConverter.cxx:10
MdtRawDataValAlg::m_chamber_2D
bool m_chamber_2D
Definition: MdtRawDataValAlg.h:199
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:129
MdtRawDataValAlg::m_HighOccThreshold
float m_HighOccThreshold
Definition: MdtRawDataValAlg.h:323
MdtRawDataValAlg::m_hist_hash_list
std::vector< std::unique_ptr< MDTChamber > > m_hist_hash_list
Definition: MdtRawDataValAlg.h:283
MuonGM::MdtReadoutElement::getNLayers
int getNLayers() const
Returns the number of tube layers inside the multilayer.
MdtRawDataValAlg::m_key_mdt
SG::ReadHandleKey< Muon::MdtPrepDataContainer > m_key_mdt
Definition: MdtRawDataValAlg.h:203
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
MdtRawDataValAlg::m_do_mdttube_fornoise
bool m_do_mdttube_fornoise
Definition: MdtRawDataValAlg.h:308
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
MdtRawDataValAlg::setIsATLASReady
void setIsATLASReady()
Definition: MDTRawDataUtils.cxx:1157
MdtRawDataValAlg::m_muonSelectionTool
ToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
Definition: MdtRawDataValAlg.h:119
DetType::Endcap
@ Endcap
Definition: DetType.h:14
max
#define max(a, b)
Definition: cfImp.cxx:41
MdtRawDataValAlg::m_do_mdt_DRvsSegD
bool m_do_mdt_DRvsSegD
Definition: MdtRawDataValAlg.h:316
MdtRawDataValAlg::m_do_mdttdccut_RPCtrig_ML2
bool m_do_mdttdccut_RPCtrig_ML2
Definition: MdtRawDataValAlg.h:300
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Muon::MdtDriftCircleOnTrack::prepRawData
virtual const MdtPrepData * prepRawData() const override final
Returns the PrepRawData used to create this corrected measurement.
Definition: MdtDriftCircleOnTrack.h:257
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
MdtRawDataValAlg::m_do_mdttdccut_RPCtrig_ML1
bool m_do_mdttdccut_RPCtrig_ML1
Definition: MdtRawDataValAlg.h:298
MdtRawDataValAlg::m_do_mdt_DRvsDRerr
bool m_do_mdt_DRvsDRerr
Definition: MdtRawDataValAlg.h:315
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
MdtRawDataValAlg::m_overalladcPRLumi
TH1 * m_overalladcPRLumi[4]
Definition: MdtRawDataValAlg.h:229
MuonGM::MdtReadoutElement::innerTubeRadius
double innerTubeRadius() const
Returns the inner tube radius excluding the aluminium walls.
MdtRawDataValAlg::m_StationEta
int m_StationEta
Definition: MdtRawDataValAlg.h:208
MdtRawDataValAlg::m_chambersId
std::vector< Identifier > m_chambersId
Definition: MdtRawDataValAlg.h:185
MdtRawDataValAlg::m_maskNoisyTubes
bool m_maskNoisyTubes
Definition: MdtRawDataValAlg.h:198
ManagedMonitorToolBase
Provides functionality for users to implement and save histograms, ntuples, and summary data,...
Definition: ManagedMonitorToolBase.h:74
TH2F
Definition: rootspy.cxx:420
MdtRawDataValAlg::CorrectLayerMax
static void CorrectLayerMax(const std::string &hardware_name, int &numLayers)
Definition: MDTRawDataUtils.cxx:953
Muon.h
calibdata.chamber
chamber
Definition: calibdata.py:32
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
MdtRawDataValAlg::m_mdteventsLumi_big
TH1 * m_mdteventsLumi_big
Definition: MdtRawDataValAlg.h:252
ManagedMonitorToolBase::endOfLumiBlockFlag
bool endOfLumiBlockFlag() const
Definition: ManagedMonitorToolBase.h:858
MdtRawDataValAlg::m_hitsperchamber_map
std::map< std::string, float > m_hitsperchamber_map
Definition: MdtRawDataValAlg.h:189
MTStraightLine.h
MdtRawDataValAlg::m_mdtoccvslb_by_crate
TH2 * m_mdtoccvslb_by_crate[4][4]
Definition: MdtRawDataValAlg.h:273
MdtRawDataValAlg::m_mdtoccvslb_ontrack_by_crate
TH2 * m_mdtoccvslb_ontrack_by_crate[4][4]
Definition: MdtRawDataValAlg.h:274
MdtRawDataValAlg::m_overalltdcadcLumi
TH2 * m_overalltdcadcLumi
Definition: MdtRawDataValAlg.h:220
MdtRawDataValAlg::m_isOnline
bool m_isOnline
Definition: MdtRawDataValAlg.h:197
MdtRawDataValAlg::m_masked_tubes
std::unique_ptr< MDTNoisyTubes > m_masked_tubes
Definition: MdtRawDataValAlg.h:116
MdtRawDataValAlg::bookMDTSummaryHistograms
virtual StatusCode bookMDTSummaryHistograms(bool newLumiBlock, bool newRun)
Definition: MdtRawDataValAlg.cxx:850
MuonGM::MuonReadoutElement::GlobalToAmdbLRSTransform
virtual Amg::Transform3D GlobalToAmdbLRSTransform() const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonReadoutElement.cxx:153
MdtRawDataValAlg::m_firstEvent
int m_firstEvent
Definition: MdtRawDataValAlg.h:171
MdtRawDataValAlg::m_overalltdcadcPR_HighOcc
TH2 * m_overalltdcadcPR_HighOcc[4]
Definition: MdtRawDataValAlg.h:238
MdtRawDataValAlg::get_bin_for_LB_hist
static int get_bin_for_LB_hist(int region, int layer, int phi, int eta, bool isBIM)
Definition: MDTRawDataUtils.cxx:1229
skel.it
it
Definition: skel.GENtoEVGEN.py:423
MdtRawDataValAlg::m_overalltdcHighOcc_ADCCut
TH1 * m_overalltdcHighOcc_ADCCut
Definition: MdtRawDataValAlg.h:236
IdentifiableContainerMT::size
size_t size() const
Duplicate of fullSize for backwards compatability.
Definition: IdentifiableContainerMT.h:209
MdtRawDataValAlg::mdtchamberId
void mdtchamberId()
Definition: MDTRawDataUtils.cxx:1054
L1_ENDCAP
@ L1_ENDCAP
Definition: MdtRawDataValAlg.h:62
MdtRawDataValAlg::getChamber
StatusCode getChamber(IdentifierHash id, MDTChamber *&chamber)
Definition: MDTRawDataUtils.cxx:1220
MdtRawDataValAlg::m_mdteventsLumi
TH1 * m_mdteventsLumi
Definition: MdtRawDataValAlg.h:251
ParticleTest.tp
tp
Definition: ParticleTest.py:25
MdtRawDataValAlg::m_mdteventscutLumi_big
TH1 * m_mdteventscutLumi_big
Definition: MdtRawDataValAlg.h:250
MdtRawDataValAlg::m_numberOfEvents
int m_numberOfEvents
Definition: MdtRawDataValAlg.h:174
MdtRawDataValAlg::CorrectTubeMax
static void CorrectTubeMax(const std::string &hardware_name, int &numTubes)
Definition: MDTRawDataUtils.cxx:948
MdtRawDataValAlg::m_segm_type
SG::ReadHandleKey< Trk::SegmentCollection > m_segm_type
Definition: MdtRawDataValAlg.h:176
MdtRawDataValAlg::m_nummdtchamberswithhits
TH1 * m_nummdtchamberswithhits
Definition: MdtRawDataValAlg.h:256
MdtRawDataValAlg::m_mdteffpermultilayer
TH2 * m_mdteffpermultilayer[4][4]
Definition: MdtRawDataValAlg.h:266
MdtRawDataValAlg::HasTrigENDCAP
bool HasTrigENDCAP()
Definition: MdtRawDataValAlg.h:162
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
Phi
@ Phi
Definition: RPCdef.h:8
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
MdtDriftCircleOnTrack.h
MdtRawDataValAlg::m_firstTime
uint32_t m_firstTime
Definition: MdtRawDataValAlg.h:173
MdtRawDataValAlg::m_StationSize
std::string m_StationSize
Definition: MdtRawDataValAlg.h:202
MdtRawDataValAlg::m_overalltdcadcHighOcc
TH2 * m_overalltdcadcHighOcc
Definition: MdtRawDataValAlg.h:234
MdtRawDataValAlg::m_do_mdtChamberHits
bool m_do_mdtChamberHits
Definition: MdtRawDataValAlg.h:291
MdtRawDataValAlg::m_MdtDQFilterTools
ToolHandleArray< IDQFilterTool > m_MdtDQFilterTools
Definition: MdtRawDataValAlg.h:168
Muon::MdtPrepData::adc
int adc() const
Returns the ADC (typically range is 0 to 250)
Definition: MdtPrepData.h:166
GeoGetIds.h
Visitor to collect all IDs under a GeoModel node.
MdtRawDataValAlg::AinB
static bool AinB(int A, std::vector< int > &B)
Definition: MDTRawDataUtils.cxx:1132
MdtRawDataValAlg::m_nummdtchamberswithhits_ADCCut
TH1 * m_nummdtchamberswithhits_ADCCut
Definition: MdtRawDataValAlg.h:257
MdtRawDataValAlg::m_chamberName
std::string m_chamberName
Definition: MdtRawDataValAlg.h:201
MdtRawDataValAlg::getChamberName
std::string getChamberName(const Muon::MdtPrepData *)
Definition: MDTRawDataUtils.cxx:1209
MdtRawDataValAlg::m_do_mdttdccut_sector
bool m_do_mdttdccut_sector
Definition: MdtRawDataValAlg.h:292
MdtRawDataValAlg::m_road_width
float m_road_width
Definition: MdtRawDataValAlg.h:321
MdtRawDataValAlg::GetTubeMax
int GetTubeMax(const Identifier &digcoll_id, std::string_view hardware_name)
Definition: MDTRawDataUtils.cxx:1096
MdtRawDataValAlg::m_do_mdtlayer
bool m_do_mdtlayer
Definition: MdtRawDataValAlg.h:305
MdtRawDataValAlg::procHistograms
virtual StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition: MdtRawDataValAlg.cxx:540
MdtRawDataValAlg::m_do_mdttube_bkgrd
bool m_do_mdttube_bkgrd
Definition: MdtRawDataValAlg.h:307
MdtRawDataValAlg::m_hardware_name_list
std::set< std::string > m_hardware_name_list
Definition: MdtRawDataValAlg.h:187
Muon::MdtDriftCircleOnTrack::driftTime
double driftTime() const
Returns the value of the drift time used to obtain the drift radius.
Definition: MdtDriftCircleOnTrack.h:280
MdtRawDataValAlg::m_do_mdttube
bool m_do_mdttube
Definition: MdtRawDataValAlg.h:306
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
DetType::Barrel
@ Barrel
Definition: DetType.h:14
MuonChamberNameConverter.h
MdtRawDataValAlg::bookMDTHisto_OccVsLB
virtual StatusCode bookMDTHisto_OccVsLB(TH2 *&h, TString, TString, TString, int, float, float, int, float, float, MonGroup &)
Definition: MDTRawDataUtils.cxx:1012
MdtRawDataValAlg::m_mdteffperchamber_InnerMiddleOuter
TH2 * m_mdteffperchamber_InnerMiddleOuter[4]
Definition: MdtRawDataValAlg.h:270
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
MdtRawDataValAlg::handleEvent_effCalc
StatusCode handleEvent_effCalc(const Trk::SegmentCollection *segms)
Definition: MdtRawDataValAlg.cxx:1711
MdtRawDataValAlg::m_overalltdccut_segm_PR_Lumi
TH1 * m_overalltdccut_segm_PR_Lumi[4]
Definition: MdtRawDataValAlg.h:226
MdtRawDataValAlg::m_overalltdccut_segm_Lumi
TH1 * m_overalltdccut_segm_Lumi
Definition: MdtRawDataValAlg.h:223
MdtRawDataValAlg::bookMDTHisto_overview
virtual StatusCode bookMDTHisto_overview(TH1 *&, TString, TString, TString, int, float, float, MonGroup &)
Definition: MDTRawDataUtils.cxx:957
TRT::Hit::side
@ side
Definition: HitInfo.h:83
Track.h
MdtRawDataValAlg::m_do_mdttubenoise
bool m_do_mdttubenoise
Definition: MdtRawDataValAlg.h:317
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
tubeMax
double tubeMax
Definition: MDT_ResponseTest.cxx:31
MdtRawDataValAlg::m_do_mdtadc
bool m_do_mdtadc
Definition: MdtRawDataValAlg.h:302
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition: ManagedMonitorToolBase.h:138
MdtRawDataValAlg::m_overalltdccutPRLumi
TH1 * m_overalltdccutPRLumi[4]
Definition: MdtRawDataValAlg.h:227
AthenaMonManager::tier0ESD
@ tier0ESD
Definition: AthenaMonManager.h:49
MdtRawDataValAlg::m_detMgr
const MuonGM::MuonDetectorManager * m_detMgr
Definition: MdtRawDataValAlg.h:330
MdtRawDataValAlg::m_overallPR_mdt_DRvsSegD
TH2 * m_overallPR_mdt_DRvsSegD[4]
Definition: MdtRawDataValAlg.h:246
MDTChamber
Definition: MDTChamber.h:22
MuonGM::MuonReadoutElement::GlobalToAmdbLRSCoords
virtual Amg::Vector3D GlobalToAmdbLRSCoords(const Amg::Vector3D &x) const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonReadoutElement.cxx:149
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
MdtRawDataValAlg::m_StationPhi
int m_StationPhi
Definition: MdtRawDataValAlg.h:209
TubeTraversedBySegment
Definition: MdtRawDataValAlg.h:64
MuonGM::MuonDetectorManager::getMdtReadoutElement
const MdtReadoutElement * getMdtReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:204
xAOD::numberOfTriggerEtaLayers
@ numberOfTriggerEtaLayers
layers with trigger eta hits [unit8_t].
Definition: TrackingPrimitives.h:292
MdtRawDataValAlg::m_overalladcPR_HighOcc
TH1 * m_overalladcPR_HighOcc[4]
Definition: MdtRawDataValAlg.h:241
MdtRawDataValAlg::GetEventNum
StatusCode GetEventNum()
Definition: MDTRawDataUtils.cxx:1175
MdtRawDataValAlg::m_overalltdcPR_HighOcc_ADCCut
TH1 * m_overalltdcPR_HighOcc_ADCCut[4]
Definition: MdtRawDataValAlg.h:240
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:669
MuonChambersRange.h
L1_BARREL
@ L1_BARREL
Definition: MdtRawDataValAlg.h:62
MuonGM::MdtReadoutElement
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MdtReadoutElement.h:50
MuonChamberIDSelector.h
lumiFormat.i
int i
Definition: lumiFormat.py:92
AthenaMonManager::tier0
@ tier0
Definition: AthenaMonManager.h:49
MdtRawDataValAlg::bookMDTOverviewHistograms
virtual StatusCode bookMDTOverviewHistograms(bool newLumiBlock, bool newRun)
Definition: MdtRawDataValAlg.cxx:1318
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
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
AthenaMonManager::online
@ online
Definition: AthenaMonManager.h:49
MdtRawDataValAlg::m_do_mdttube_masked
bool m_do_mdttube_masked
Definition: MdtRawDataValAlg.h:309
LArG4ShowerLibProcessing.hits
hits
Definition: LArG4ShowerLibProcessing.py:136
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
Trk::driftRadius
@ driftRadius
trt, straws
Definition: ParamDefs.h:59
MdtRawDataValAlg::m_mdtChamberHits
TH1 * m_mdtChamberHits[4][4][16]
Definition: MdtRawDataValAlg.h:262
ManagedMonitorToolBase::newLowStatIntervalFlag
bool newLowStatIntervalFlag() const
Flag functions allowing clients to determine when to book new and process old histograms; values are ...
Definition: ManagedMonitorToolBase.h:849
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
LVL1_ROI.h
TrackCollection.h
MdtRawDataValAlg::m_do_mdt_effCounts
bool m_do_mdt_effCounts
Definition: MdtRawDataValAlg.h:312
xAOD::MuonRoI_v1
Class describing a LVL1 muon region of interest.
Definition: MuonRoI_v1.h:33
MdtRawDataValAlg::isATLASReady
bool isATLASReady() const
Definition: MdtRawDataValAlg.h:112
MdtRawDataValAlg::m_l1RoiKey
SG::ReadHandleKey< xAOD::MuonRoIContainer > m_l1RoiKey
Definition: MdtRawDataValAlg.h:205
MdtRawDataValAlg::get_bin_for_LB_crate_hist
int get_bin_for_LB_crate_hist(int region, int layer, int phi, int eta, std::string_view chamber)
Definition: MDTRawDataUtils.cxx:1886
test_pyathena.parent
parent
Definition: test_pyathena.py:15
MdtRawDataValAlg::m_overallPR_mdt_DRvsDT
TH2 * m_overallPR_mdt_DRvsDT[4]
Definition: MdtRawDataValAlg.h:245
MdtRawDataValAlg::~MdtRawDataValAlg
virtual ~MdtRawDataValAlg()
MdtRawDataValAlg::m_do_mdttdcadc
bool m_do_mdttdcadc
Definition: MdtRawDataValAlg.h:303
MdtRawDataValAlg::m_do_mdtadc_onSegm_ML2
bool m_do_mdtadc_onSegm_ML2
Definition: MdtRawDataValAlg.h:297
MdtIdHelper.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
MdtRawDataValAlg::binMdtGlobal_byLayer
virtual StatusCode binMdtGlobal_byLayer(TH2 *, TH2 *, TH2 *)
Definition: MDTRawDataUtils.cxx:756
MdtRawDataValAlg::fillHistograms
virtual StatusCode fillHistograms()
An inheriting class should either override this function or fillHists().
Definition: MdtRawDataValAlg.cxx:293
run
Definition: run.py:1
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
MdtRawDataValAlg::fillMDTHistograms
virtual StatusCode fillMDTHistograms(const Muon::MdtPrepData *)
Definition: MdtRawDataValAlg.cxx:1441
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:236
MdtRawDataValAlg::m_mg
std::unique_ptr< MDTMonGroupStruct > m_mg
Definition: MdtRawDataValAlg.h:115
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
Muon::MdtDriftCircleOnTrack::driftRadius
double driftRadius() const
Returns the value of the drift radius.
Definition: MdtDriftCircleOnTrack.h:277
MdtRawDataValAlg::m_key_rpc
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_key_rpc
Definition: MdtRawDataValAlg.h:204
MdtRawDataValAlg::bookMDTHisto_chambers
virtual StatusCode bookMDTHisto_chambers(TH1F_LW *&, TString, TString, TString, int, float, float, MonGroup &)
Definition: MDTRawDataUtils.cxx:970
MdtRawDataValAlg::m_do_mdttdctube
bool m_do_mdttdctube
Definition: MdtRawDataValAlg.h:318
TH1::Fill
int Fill(double)
Definition: rootspy.cxx:285
MdtRawDataValAlg::m_mdthitsperML_byLayer
TH2 * m_mdthitsperML_byLayer[3]
Definition: MdtRawDataValAlg.h:271
MdtRawDataValAlg::m_do_mdtmultil
bool m_do_mdtmultil
Definition: MdtRawDataValAlg.h:304
DataVector< Trk::Segment >
MdtRawDataValAlg::m_lumiblock
int m_lumiblock
Definition: MdtRawDataValAlg.h:169
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
MdtRawDataValAlg::m_overalladccutPRLumi
TH1 * m_overalladccutPRLumi[4]
Definition: MdtRawDataValAlg.h:230
MdtRawDataValAlg::fillMDTMaskedTubes
virtual StatusCode fillMDTMaskedTubes(IdentifierHash, const std::string &, TH1F_LW *&h)
Definition: MDTRawDataUtils.cxx:1027
ManagedMonitorToolBase::m_environment
AthenaMonManager::Environment_t m_environment
Definition: ManagedMonitorToolBase.h:902
Trk::MeasurementBase::localCovariance
const Amg::MatrixX & localCovariance() const
Interface method to get the localError.
Definition: MeasurementBase.h:138
Trk::Combined
@ Combined
Definition: TrackSummaryTool.h:32
MdtRawDataValAlg::m_mdtchamberstat
TH1 * m_mdtchamberstat
Definition: MdtRawDataValAlg.h:260
Trk::MeasurementBase
Definition: MeasurementBase.h:58
MdtRawDataValAlg::m_do_mdt_effEntries
bool m_do_mdt_effEntries
Definition: MdtRawDataValAlg.h:311
MdtRawDataValAlg::binMdtOccVsLB
virtual StatusCode binMdtOccVsLB(TH2 *&h, int region, int layer)
Definition: MDTRawDataUtils.cxx:1324
MdtRawDataValAlg::binMdtRegional
virtual StatusCode binMdtRegional(TH2 *, std::string_view xAxis)
Definition: MDTRawDataUtils.cxx:379
Muon::MdtPrepData::tdc
int tdc() const
Returns the TDC (typically range is 0 to 2500).
Definition: MdtPrepData.h:161
MdtRawDataValAlg::mezzmdt
int mezzmdt(Identifier)
Definition: MDTRawDataUtils.cxx:1081
MdtRawDataValAlg.h
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
MdtRawDataValAlg::m_overalladc_segm_PR_Lumi
TH1 * m_overalladc_segm_PR_Lumi[4]
Definition: MdtRawDataValAlg.h:228
MdtRawDataValAlg::m_overalltdccutPRLumi_TGCtrig
TH1 * m_overalltdccutPRLumi_TGCtrig[4]
Definition: MdtRawDataValAlg.h:232
MdtRawDataValAlg::m_do_mdttdccut_ML2
bool m_do_mdttdccut_ML2
Definition: MdtRawDataValAlg.h:295
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
MdtRawDataValAlg::m_do_mdttdc
bool m_do_mdttdc
Definition: MdtRawDataValAlg.h:293
IdentifierHash.h
MdtRawDataValAlg::m_mdthitspermultilayerLumi
TH2 * m_mdthitspermultilayerLumi[4][4]
Definition: MdtRawDataValAlg.h:265
Muon::MdtDriftCircleOnTrack
This class represents the corrected MDT measurements, where the corrections include the effects of wi...
Definition: MdtDriftCircleOnTrack.h:37
MuonCalib::MTStraightLine::signDistFrom
double signDistFrom(const MTStraightLine &h) const
get the signed distance of two lines (if both are parallel, dist>0)
Definition: MTStraightLine.cxx:89
MdtRawDataValAlg::m_overalltdcadcPRLumi
TH2 * m_overalltdcadcPRLumi[4]
Definition: MdtRawDataValAlg.h:221
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
MdtRawDataValAlg::m_overalladc_HighOcc
TH1 * m_overalladc_HighOcc
Definition: MdtRawDataValAlg.h:237
MdtRawDataValAlg::bookHistogramsRecurrent
virtual StatusCode bookHistogramsRecurrent()
An inheriting class should either override this function, bookHists() or bookHistograms().
Definition: MdtRawDataValAlg.cxx:223
Muon::MdtPrepData
Class to represent measurements from the Monitored Drift Tubes.
Definition: MdtPrepData.h:37
L1_UNKNOWN
@ L1_UNKNOWN
Definition: MdtRawDataValAlg.h:62
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
ManagedMonitorToolBase::lowStat
@ lowStat
Definition: ManagedMonitorToolBase.h:115
MdtRawDataValAlg::m_do_mdtmezz
bool m_do_mdtmezz
Definition: MdtRawDataValAlg.h:310
MdtRawDataValAlg::m_do_mdtadc_onSegm_ML1
bool m_do_mdtadc_onSegm_ML1
Definition: MdtRawDataValAlg.h:296
MdtRawDataValAlg::m_BMGid
int m_BMGid
Definition: MdtRawDataValAlg.h:325
MdtRawDataValAlg::bookMDTHisto_overview_2D
virtual StatusCode bookMDTHisto_overview_2D(TH2 *&h, TString, TString, TString, int, float, float, int, float, float, MonGroup &)
Definition: MDTRawDataUtils.cxx:981
MdtRawDataValAlg::initialize
StatusCode initialize()
Definition: MdtRawDataValAlg.cxx:121
MdtRawDataValAlg::StoreTriggerType
StatusCode StoreTriggerType()
MdtRawDataValAlg::m_mdtxydet
TH2 * m_mdtxydet[3]
Definition: MdtRawDataValAlg.h:263
Trk::iPhi
@ iPhi
Definition: ParamDefs.h:53
MdtRawDataValAlg::m_do_mdttdccut_ML1
bool m_do_mdttdccut_ML1
Definition: MdtRawDataValAlg.h:294
Trk::Track::measurementsOnTrack
const DataVector< const MeasurementBase > * measurementsOnTrack() const
return a pointer to a vector of MeasurementBase (NOT including any that come from outliers).
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:178
MdtRawDataValAlg::m_mdtoccvslb_summaryPerSector
TH2 * m_mdtoccvslb_summaryPerSector
Definition: MdtRawDataValAlg.h:275
TrackParticle.h
MdtRawDataValAlg::m_eventInfo
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo
Definition: MdtRawDataValAlg.h:207
ManagedMonitorToolBase::run
@ run
Definition: ManagedMonitorToolBase.h:116
MdtRawDataValAlg::m_doMdtESD
bool m_doMdtESD
Definition: MdtRawDataValAlg.h:193
MuonGM::MuonDetectorManager::getMuonStation
const MuonStation * getMuonStation(const std::string &stName, int eta, int phi) const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:137
geoGetIds
void geoGetIds(FUNCTION f, const GeoGraphNode *node, int depthLimit=1)
Template helper for running the visitor.
Definition: GeoGetIds.h:82
MdtRawDataValAlg::m_mdtoccvslb
TH2 * m_mdtoccvslb[4][3]
Definition: MdtRawDataValAlg.h:272
MdtRawDataValAlg::m_mdtglobalhitstime
TH1 * m_mdtglobalhitstime
Definition: MdtRawDataValAlg.h:254
MdtRawDataValAlg::m_chi2_cut
float m_chi2_cut
Definition: MdtRawDataValAlg.h:322
MuonGM::MdtReadoutElement::tubePos
Amg::Vector3D tubePos(const Identifier &id) const
Returns the global position of the given tube.
MdtRawDataValAlg::m_muonKey
SG::ReadHandleKey< xAOD::MuonContainer > m_muonKey
Definition: MdtRawDataValAlg.h:206
MdtRawDataValAlg::m_do_mdt_DRvsDT
bool m_do_mdt_DRvsDT
Definition: MdtRawDataValAlg.h:314
MdtRawDataValAlg::m_MdtNHitsvsRpcNHits
TH2 * m_MdtNHitsvsRpcNHits
Definition: MdtRawDataValAlg.h:247
MdtRawDataValAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MdtRawDataValAlg.h:118
h
TH1F
Definition: rootspy.cxx:320
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
LikeEnum::Medium
@ Medium
Definition: LikelihoodEnums.h:14
MdtRawDataValAlg::m_title
std::string m_title
Definition: MdtRawDataValAlg.h:109
MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:49
MdtRawDataValAlg::fillLumiBlock
StatusCode fillLumiBlock()
Definition: MDTRawDataUtils.cxx:1166
MdtRawDataValAlg::m_tubesperchamber_map
std::map< std::string, float > m_tubesperchamber_map
Definition: MdtRawDataValAlg.h:191
ManagedMonitorToolBase::endOfRunFlag
bool endOfRunFlag() const
Definition: ManagedMonitorToolBase.h:859
MdtRawDataValAlg::m_mdthitsperchamber_InnerMiddleOuterLumi
TH2 * m_mdthitsperchamber_InnerMiddleOuterLumi[2]
Definition: MdtRawDataValAlg.h:267
MdtRawDataValAlg::m_mdthitsperchamber_onSegm_InnerMiddleOuterLumi
TH2 * m_mdthitsperchamber_onSegm_InnerMiddleOuterLumi[2]
Definition: MdtRawDataValAlg.h:269
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TH1
Definition: rootspy.cxx:268
MdtRawDataValAlg::m_overalltdccutPRLumi_RPCtrig
TH1 * m_overalltdccutPRLumi_RPCtrig[4]
Definition: MdtRawDataValAlg.h:231
generate::GetEntries
double GetEntries(TH1D *h, int ilow, int ihi)
Definition: rmsFrac.cxx:20
MdtRawDataValAlg::m_ADCCut
float m_ADCCut
Definition: MdtRawDataValAlg.h:215
MuonGM::MuonReadoutElement::identify
Identifier identify() const override final
Returns the ATLAS Identifier of the MuonReadOutElement.
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:184
MdtRawDataValAlg::m_ADCCut_Bkgrd
float m_ADCCut_Bkgrd
Definition: MdtRawDataValAlg.h:216
MdtRawDataValAlg::m_mdteventscutLumi
TH1 * m_mdteventscutLumi
Definition: MdtRawDataValAlg.h:249
Trk::RIO_OnTrack::identify
virtual Identifier identify() const final
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:155
MuonCalib::MTStraightLine
Definition: MTStraightLine.h:16
MDTChamber::getName
const std::string & getName() const
Definition: MDTChamber.h:67
MuonSegment.h
MdtRawDataValAlg::m_overalladc_Lumi
TH1 * m_overalladc_Lumi
Definition: MdtRawDataValAlg.h:225
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
MdtRawDataValAlg::m_overalltdccutLumi
TH1 * m_overalltdccutLumi
Definition: MdtRawDataValAlg.h:222
SG::VarHandleBase::isPresent
bool isPresent() const
Is the referenced object present in SG?
Definition: StoreGate/src/VarHandleBase.cxx:397
MdtRawDataValAlg::m_overalltdcPR_HighOcc
TH1 * m_overalltdcPR_HighOcc[4]
Definition: MdtRawDataValAlg.h:239
MdtRawDataValAlg::m_mdtchamberstatphislice
TH1 * m_mdtchamberstatphislice[16]
Definition: MdtRawDataValAlg.h:261
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
MdtRawDataValAlg::binMdtGlobal
virtual StatusCode binMdtGlobal(TH2 *, char ecap)
Definition: MDTRawDataUtils.cxx:29
Muon::MuonSegment
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:45
MdtRawDataValAlg::m_time
uint32_t m_time
Definition: MdtRawDataValAlg.h:172
Muon::nsw::STGTPSegments::moduleIDBits::stationEta
constexpr uint8_t stationEta
1 to 3
Definition: NSWSTGTPDecodeBitmaps.h:127
IdentifierHash
Definition: IdentifierHash.h:38
MdtRawDataValAlg::m_do_mdt_effPerTube
bool m_do_mdt_effPerTube
Definition: MdtRawDataValAlg.h:313
MdtIdHelper::maxNTubesPerLayer
static constexpr int maxNTubesPerLayer
The maxNTubesPerLayer represents the absolute maximum of tubes which are built into a single multilay...
Definition: MdtIdHelper.h:68
FitQuality.h
ManagedMonitorToolBase::newLumiBlockFlag
bool newLumiBlockFlag() const
Definition: ManagedMonitorToolBase.h:853
MdtRawDataValAlg::MdtRawDataValAlg
MdtRawDataValAlg(const std::string &type, const std::string &name, const IInterface *parent)
Definition: MdtRawDataValAlg.cxx:64
SG::ExcNoAuxStore
Exception — Aux data requested from object with no store.
Definition: Control/AthContainers/AthContainers/exceptions.h:34
MuonGM::MdtReadoutElement::getNtubesperlayer
int getNtubesperlayer() const
Returns the number of tubes in each tube layer.
MuonStation.h
test_pyathena.counter
counter
Definition: test_pyathena.py:15
MdtRawDataValAlg::m_mdthitsperchamber_InnerMiddleOuter_HighOcc
TH2 * m_mdthitsperchamber_InnerMiddleOuter_HighOcc[2]
Definition: MdtRawDataValAlg.h:268
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
xAOD::numberOfPhiLayers
@ numberOfPhiLayers
layers with a trigger phi hit [unit8_t].
Definition: TrackingPrimitives.h:290
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
MdtRawDataValAlg::m_mdtrzdet
TH2 * m_mdtrzdet[3]
Definition: MdtRawDataValAlg.h:264
MdtRawDataValAlg::m_doChamberHists
bool m_doChamberHists
Definition: MdtRawDataValAlg.h:196
python.compressB64.c
def c
Definition: compressB64.py:93
MdtRawDataValAlg::fillMDTSummaryHistograms
virtual StatusCode fillMDTSummaryHistograms(const Muon::MdtPrepData *, std::set< std::string >, bool &isNoiseBurstCandidate)
Definition: MdtRawDataValAlg.cxx:1512
TrackingPrimitives.h
MdtRawDataValAlg::GetTimingInfo
StatusCode GetTimingInfo()
Definition: MDTRawDataUtils.cxx:1139
MuonFixedId.h
ManagedMonitorToolBase::regHist
virtual StatusCode regHist(TH1 *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical ...
Definition: ManagedMonitorToolBase.cxx:1454
MdtRawDataValAlg::HasTrigBARREL
bool HasTrigBARREL()
Definition: MdtRawDataValAlg.h:161
calibdata.tube
tube
Definition: calibdata.py:31
MdtRawDataValAlg::m_BMGpresent
bool m_BMGpresent
Definition: MdtRawDataValAlg.h:324
TrackParticleContainer.h
MdtRawDataValAlg::initDeadChannels
void initDeadChannels(const MuonGM::MdtReadoutElement *mydetEl)
Definition: MdtRawDataValAlg.cxx:1970
MdtRawDataValAlg::m_do_mdttdccut_TGCtrig_ML2
bool m_do_mdttdccut_TGCtrig_ML2
Definition: MdtRawDataValAlg.h:301
MdtRawDataValAlg::bookMDTHistograms
virtual StatusCode bookMDTHistograms(MDTChamber *chamber, Identifier digcoll_id)
Definition: MdtRawDataValAlg.cxx:706
MdtRawDataValAlg::m_DeadChannels
std::map< Identifier, std::vector< Identifier > > m_DeadChannels
Definition: MdtRawDataValAlg.h:326
MdtRawDataValAlg::m_nb_hits
float m_nb_hits
Definition: MdtRawDataValAlg.h:320
fitman.k
k
Definition: fitman.py:528
MdtRawDataValAlg::m_do_mdttdccut_TGCtrig_ML1
bool m_do_mdttdccut_TGCtrig_ML1
Definition: MdtRawDataValAlg.h:299
NSWL1::PadTriggerAdapter::segment
Muon::NSW_PadTriggerSegment segment(const NSWL1::PadTrigger &data)
Definition: PadTriggerAdapter.cxx:5
ManagedMonitorToolBase::newRunFlag
bool newRunFlag() const
Definition: ManagedMonitorToolBase.h:854
MdtRawDataValAlg::fillMDTOverviewHistograms
virtual StatusCode fillMDTOverviewHistograms(const Muon::MdtPrepData *, bool &isNoiseBurstCandidate)
Definition: MdtRawDataValAlg.cxx:1614
MdtRawDataValAlg::m_overalladc_segm_Lumi
TH1 * m_overalladc_segm_Lumi
Definition: MdtRawDataValAlg.h:224
MdtRawDataValAlg::m_do_mdtchamberstatphislice
bool m_do_mdtchamberstatphislice
Definition: MdtRawDataValAlg.h:290
Generated on Tue Jul 2 2024 21:21:22 for ATLAS Offline Software by   doxygen 1.8.18