ATLAS Offline Software
StgcRawDataMonAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // Package : sTgcRawDataMonAlg
7 // Author: Sebastian Fuenzalida Garrido
8 // Local supervisor: Edson Carquin Lopez
9 // Technical supervisor: Gerardo Vasquez
10 //
11 // DESCRIPTION:
12 // Subject: sTgc --> sTgc raw data monitoring
14 
15 #include "StgcRawDataMonitoring/StgcRawDataMonAlg.h"
16 
18 // *********************************************************************
19 // Public Methods
20 // *********************************************************************
22 
23 sTgcRawDataMonAlg::sTgcRawDataMonAlg(const std::string& name, ISvcLocator* pSvcLocator) : AthMonitorAlgorithm(name, pSvcLocator) {
24  //Declare the property
25 }
26 
27 StatusCode sTgcRawDataMonAlg::initialize() {
28  ATH_CHECK(AthMonitorAlgorithm::initialize());
29  ATH_CHECK(m_idHelperSvc.retrieve());
30  ATH_CHECK(m_sTgcContainerKey.initialize());
31  ATH_CHECK(m_detectorManagerKey.initialize());
32  ATH_CHECK(m_meTrkKey.initialize());
33  ATH_CHECK(m_residualPullCalculator.retrieve());
34  ATH_CHECK(m_muonKey.initialize());
35  ATH_CHECK(m_rdoKey.initialize(SG::AllowEmpty));
36 
37  return StatusCode::SUCCESS;
38 }
39 
40 StatusCode sTgcRawDataMonAlg::fillHistograms(const EventContext& ctx) const {
41  const int lumiblock = GetEventInfo(ctx) -> lumiBlock();
42 
43  SG::ReadHandle<Muon::sTgcPrepDataContainer> sTgcContainer(m_sTgcContainerKey, ctx);
44  SG::ReadCondHandle<MuonGM::MuonDetectorManager> detectorManagerKey(m_detectorManagerKey, ctx);
45  SG::ReadHandle<xAOD::TrackParticleContainer> meTPContainer(m_meTrkKey, ctx);
46  SG::ReadHandle<xAOD::MuonContainer> muonContainer(m_muonKey, ctx);
47 
48  if (!meTPContainer.isValid()) {
49  ATH_MSG_FATAL("Could not get track particle container: " << m_meTrkKey.fullKey());
50  return StatusCode::FAILURE;
51  }
52 
53  if (!muonContainer.isValid()) {
54  ATH_MSG_FATAL("Could not get muon container: " << m_muonKey.fullKey());
55  return StatusCode::FAILURE;
56  }
57 
58  if(!m_rdoKey.key().empty()){
59  SG::ReadHandle<Muon::NSW_PadTriggerDataContainer> NSWpadTriggerContainer(m_rdoKey, ctx);
60  if (!NSWpadTriggerContainer.isValid()) {
61  ATH_MSG_FATAL("Could not get pad trigger data container: " << m_rdoKey.fullKey());
62  return StatusCode::FAILURE;
63  }
64  fillsTgcPadTriggerDataHistograms(muonContainer.cptr(), NSWpadTriggerContainer.cptr(), lumiblock);
65  fillsTgcPadTriggerEfficiencyHistograms(muonContainer.cptr(), NSWpadTriggerContainer.cptr(), detectorManagerKey.cptr());
66  }
67 
68  ATH_MSG_DEBUG("Lumiblock: " << lumiblock);
69 
70  fillsTgcClusterFromTrackHistograms(meTPContainer.cptr());
71  fillsTgcEfficiencyHistograms(muonContainer.cptr(), detectorManagerKey.cptr());
72  fillsTgcOccupancyHistograms(sTgcContainer.cptr(), detectorManagerKey.cptr());
73  fillsTgcLumiblockHistograms(sTgcContainer.cptr(), lumiblock);
74 
75  return StatusCode::SUCCESS;
76 }
77 
78 void sTgcRawDataMonAlg::fillsTgcOccupancyHistograms(const Muon::sTgcPrepDataContainer* sTgcContainer, const MuonGM::MuonDetectorManager* muonDetectorManagerObject) const {
79  ATH_MSG_DEBUG("ON fillsTgcOccupancyHistograms");
80  for(const Muon::sTgcPrepDataCollection* coll : *sTgcContainer) {
81  for (const Muon::sTgcPrepData* prd : *coll) {
82  Identifier id = prd -> identify();
83 
84  if(!id.is_valid()) {
85  ATH_MSG_WARNING("Invalid identifier found in Muon::sTgcPrepData");
86  return;
87  }
88 
89  std::string stationName = m_idHelperSvc -> stgcIdHelper().stationNameString(m_idHelperSvc -> stgcIdHelper().stationName(id));
90  int stationEta = m_idHelperSvc -> stgcIdHelper().stationEta(id);
91  int stationPhi = m_idHelperSvc -> stgcIdHelper().stationPhi(id);
92  int multiplet = m_idHelperSvc -> stgcIdHelper().multilayer(id);
93  int gasGap = m_idHelperSvc -> stgcIdHelper().gasGap(id);
94  int channelType = m_idHelperSvc -> stgcIdHelper().channelType(id);
95  int sector = m_idHelperSvc -> sector(id);
96  std::string sectorStr = std::to_string(sector);
97  int sectorsTotal = getSectors(id);
98  int layer = getLayer(multiplet, gasGap);
99  int stationEtaAbs = std::abs(stationEta);
100  std::string layerStr = std::to_string(layer);
101  int iside = (stationEta > 0) ? 1 : 0;
102  std::string side = GeometricSectors::sTgcSide[iside];
103  std::string channelName = "";
104 
105  if (channelType == sTgcIdHelper::sTgcChannelTypes::Pad) {
106  channelName = "pad";
107  int padNumber = m_idHelperSvc -> stgcIdHelper().channel(id);
108  Identifier idPadQ1 = m_idHelperSvc -> stgcIdHelper().channelID(stationName, 1, stationPhi, multiplet, gasGap, channelType, 1);
109  Identifier idPadQ2 = m_idHelperSvc -> stgcIdHelper().channelID(stationName, 2, stationPhi, multiplet, gasGap, channelType, 1);
110  const MuonGM::sTgcReadoutElement* sTgcReadoutObjectPadQ1 = muonDetectorManagerObject -> getsTgcReadoutElement(idPadQ1);
111  const MuonGM::sTgcReadoutElement* sTgcReadoutObjectPadQ2 = muonDetectorManagerObject -> getsTgcReadoutElement(idPadQ2);
112  int maxPadNumberQ1 = sTgcReadoutObjectPadQ1 -> maxPadNumber(idPadQ1);
113  int maxPadNumberQ2 = sTgcReadoutObjectPadQ2 -> maxPadNumber(idPadQ2);
114 
115  if (stationEtaAbs == 2) padNumber = padNumber + maxPadNumberQ1;
116  else if (stationEtaAbs == 3) padNumber = padNumber + maxPadNumberQ1 + maxPadNumberQ2;
117 
118  auto sectorMon = Monitored::Scalar<int>("sector_layer_" + layerStr, sectorsTotal);
119  auto padNumberMon = Monitored::Scalar<int>("padNumber_layer_" + layerStr, padNumber);
120  fill("Occupancy", sectorMon, padNumberMon);
121 
122  auto layerMon = Monitored::Scalar<int>(channelName+"layer_" + side + sectorStr, layer);
123  auto quadMon = Monitored::Scalar<int>(channelName+"quad_" + side + sectorStr, stationEtaAbs);
124  fill("Occupancy", layerMon, quadMon);
125  }
126 
127  else if (channelType == sTgcIdHelper::sTgcChannelTypes::Strip) {
128  channelName = "strip";
129  int stripNumber = m_idHelperSvc -> stgcIdHelper().channel(id);
130  Identifier idStripQ1 = m_idHelperSvc -> stgcIdHelper().channelID(stationName, 1, stationPhi, multiplet, gasGap, channelType, 1);
131  Identifier idStripQ2 = m_idHelperSvc -> stgcIdHelper().channelID(stationName, 2, stationPhi, multiplet, gasGap, channelType, 1);
132  const MuonGM::sTgcReadoutElement* sTgcReadoutObjectStripQ1 = muonDetectorManagerObject -> getsTgcReadoutElement(idStripQ1);
133  const MuonGM::sTgcReadoutElement* sTgcReadoutObjectStripQ2 = muonDetectorManagerObject -> getsTgcReadoutElement(idStripQ2);
134  int maxStripNumberQ1 = sTgcReadoutObjectStripQ1 -> numberOfStrips(idStripQ1);
135  int maxStripNumberQ2 = sTgcReadoutObjectStripQ2 -> numberOfStrips(idStripQ2);
136 
137  if (stationEtaAbs == 2) stripNumber = stripNumber + maxStripNumberQ1 + 1;
138  else if (stationEtaAbs == 3) stripNumber = stripNumber + maxStripNumberQ1 + maxStripNumberQ2 + 1;
139 
140  auto sectorMon = Monitored::Scalar<int>("sector_layer_" + layerStr, sectorsTotal);
141  auto stripNumberMon = Monitored::Scalar<int>("stripNumber_layer_" + layerStr, stripNumber);
142  fill("Occupancy", sectorMon, stripNumberMon);
143 
144  auto layerMon = Monitored::Scalar<int>(channelName+"layer_" + side + sectorStr, layer);
145  auto quadMon = Monitored::Scalar<int>(channelName+"quad_" + side + sectorStr, stationEtaAbs);
146  fill("Occupancy", layerMon, quadMon);
147  }
148 
149  else if (channelType == sTgcIdHelper::sTgcChannelTypes::Wire) {
150  channelName = "wire";
151  int wireGroupNumber = m_idHelperSvc -> stgcIdHelper().channel(id);
152  Identifier idWireGroupQ3 = m_idHelperSvc -> stgcIdHelper().channelID("STL", 3, stationPhi, 1, 3, channelType, 1);
153  const MuonGM::sTgcReadoutElement* sTgcReadoutObjectWireGroupQ3 = muonDetectorManagerObject -> getsTgcReadoutElement(idWireGroupQ3);
154  int maxWireGroupNumberQ3 = sTgcReadoutObjectWireGroupQ3 -> numberOfStrips(idWireGroupQ3);
155 
156  auto stationEtaMon = Monitored::Scalar<int>("stationEta_layer_" + layerStr, stationEta);
157  auto wireGroupNumberMon = Monitored::Scalar<int>("wireGroupNumber_layer_" + layerStr, wireGroupNumber + (sector - 1)*maxWireGroupNumberQ3);
158  fill("Occupancy", stationEtaMon, wireGroupNumberMon);
159 
160  auto layerMon = Monitored::Scalar<int>(channelName+"layer_" + side + sectorStr, layer);
161  auto quadMon = Monitored::Scalar<int>(channelName+"quad_" + side + sectorStr, stationEtaAbs);
162  fill("Occupancy", layerMon, quadMon);
163  }
164 
165  auto sectorMon = Monitored::Scalar<int>(channelName+"Sector", sectorsTotal);
166  auto febMon = Monitored::Scalar<int>(channelName+"Feb", getFEBs(stationEta,layer));
167  fill("Overview", sectorMon, febMon);
168 
169  }
170  }
171 
172  ATH_MSG_DEBUG("Off fillsTgcOccupancyHistograms");
173 }
174 
175 void sTgcRawDataMonAlg::fillsTgcLumiblockHistograms(const Muon::sTgcPrepDataContainer* sTgcContainer, int lb) const {
176  ATH_MSG_DEBUG("On fillsTgcLumiblockHistograms");
177  for(const Muon::sTgcPrepDataCollection* coll : *sTgcContainer) {
178  for (const Muon::sTgcPrepData* prd : *coll) {
179  Identifier id = prd -> identify();
180 
181  if(!id.is_valid()) {
182  ATH_MSG_WARNING("Invalid identifier found in Muon::sTgcPrepData");
183  return;
184  }
185 
186  std::string stationName = m_idHelperSvc->stgcIdHelper().stationNameString(m_idHelperSvc->stgcIdHelper().stationName(id));
187  int stationEta = m_idHelperSvc->stgcIdHelper().stationEta(id);
188  int channelType = m_idHelperSvc->stgcIdHelper().channelType(id);
189  int multiplet = m_idHelperSvc->stgcIdHelper().multilayer(id);
190  int gasGap = m_idHelperSvc->stgcIdHelper().gasGap(id);
191  int layer = std::abs(getLayer(multiplet, gasGap));
192  int iside = (stationEta > 0) ? 1 : 0;
193  int feb = getFEBs(stationEta,layer);
194  int sector = m_idHelperSvc -> sector(id);
195 
196 
197  std::string layerStr = std::to_string(layer);
198  std::string side = GeometricSectors::sTgcSide[iside];
199  std::string channelName = "";
200  std::string sectorStr = std::to_string(sector);
201 
202  if (channelType == sTgcIdHelper::sTgcChannelTypes::Pad) channelName = "pad";
203  else if (channelType == sTgcIdHelper::sTgcChannelTypes::Strip) channelName = "strip";
204  else if (channelType == sTgcIdHelper::sTgcChannelTypes::Wire) channelName = "wire";
205 
206  auto febMon = Monitored::Scalar<int>(channelName+"FEBsector"+side+sectorStr, feb);
207  auto lbMon = Monitored::Scalar<int>(channelName+"LBsector"+side+sectorStr, lb);
208 
209  fill("LBShifterGroup", lbMon, febMon);
210  }
211  }
212  ATH_MSG_DEBUG("Off fillsTgcLumiblockHistograms");
213 }
214 
215 void sTgcRawDataMonAlg::fillsTgcClusterFromTrackHistograms(const xAOD::TrackParticleContainer* trkPartCont) const {
216  ATH_MSG_DEBUG("On fillsTgcClusterFromTrackHistograms");
217  for (const xAOD::TrackParticle* meTP : *trkPartCont) {
218  const Trk::Track* meTrack = meTP -> track();
219  if(!meTrack) continue;
220  for (const Trk::TrackStateOnSurface* trkState : *meTrack -> trackStateOnSurfaces()) {
221  std::optional<std::tuple<Identifier, const Trk::RIO_OnTrack*>> status = getRotIdAndRotObject(trkState);
222  if (!status.has_value()) continue;
223  std::tuple<Identifier, const Trk::RIO_OnTrack*> rotIDtuple = status.value();
224 
225  Identifier rot_id = std::get<Identifier>(rotIDtuple);
226 
227  const Muon::sTgcClusterOnTrack* cluster = dynamic_cast<const Muon::sTgcClusterOnTrack*>(std::get<const Trk::RIO_OnTrack*>(rotIDtuple));
228  if(!cluster) continue;
229 
230  const Muon::sTgcPrepData* prd = cluster -> prepRawData();
231  if (!prd) continue;
232 
233  int channelType = m_idHelperSvc -> stgcIdHelper().channelType(rot_id);
234  int stEta = m_idHelperSvc -> stgcIdHelper().stationEta(rot_id);
235  int multi = m_idHelperSvc -> stgcIdHelper().multilayer(rot_id);
236  int gap = m_idHelperSvc -> stgcIdHelper().gasGap(rot_id);
237  int sector = m_idHelperSvc -> sector(rot_id);
238  int sectorsTotal = getSectors(rot_id);
239  int layer = getLayer(multi, gap);
240  int iside = (stEta > 0) ? 1 : 0;
241  std::string side = GeometricSectors::sTgcSide[iside];
242  std::string channelName = "";
243  std::string sectorStr = std::to_string(sector);
244 
245 
246  if (channelType == sTgcIdHelper::sTgcChannelTypes::Pad) {
247  float padCharge = prd -> charge();
248  auto padChargeMon = Monitored::Scalar<float>("padTrackCharge_" + side + "_quad_" + std::to_string(std::abs(stEta)) + "_sector_" + std::to_string(sector) + "_layer_" + std::to_string(layer), padCharge);
249  fill("padCharge_" + side + std::to_string(sector) + "_quad_" + std::to_string(std::abs(stEta)), padChargeMon);
250 
251  short int padTiming = prd -> time();
252  auto padSectorSidedMon = Monitored::Scalar<int>("padTrackSectorSided_layer_" + std::to_string(layer), sectorsTotal);
253  auto padTimingMon = Monitored::Scalar<float>("padTrackTiming_layer_" + std::to_string(layer), padTiming);
254  fill("sTgcTiming", padSectorSidedMon, padTimingMon);
255 
256  auto padSectorSidedExpertMon = Monitored::Scalar<int>("padTrackSectorSided_quad_" + std::to_string(std::abs(stEta)) + "_layer_" + std::to_string(layer), sectorsTotal);
257  auto padTimingExpertMon = Monitored::Scalar<float>("padTrackTiming_quad_" + std::to_string(std::abs(stEta)) + "_layer_" + std::to_string(layer), padTiming);
258  fill("padTiming_quad_" + std::to_string(std::abs(stEta)), padSectorSidedExpertMon, padTimingExpertMon);
259 
260  ATH_MSG_DEBUG("Pad Timing: " << padTiming);
261 
262  auto febMon = Monitored::Scalar<int>("padFEB"+ side + sectorStr, getFEBs(stEta,layer));
263  auto timeMon = Monitored::Scalar<int>("padTiming"+ side + sectorStr, padTiming);
264  fill("sTgcTiming", timeMon, febMon);
265  }
266 
267  else if (channelType == sTgcIdHelper::sTgcChannelTypes::Strip) {
268  channelName = "strip";
269  const std::vector<Identifier>& stripIds = prd->rdoList();
270  unsigned int csize = stripIds.size();
271 
272  std::vector<short int> stripTimesVec = prd -> stripTimes();
273  std::vector<int> stripChargesVec = prd -> stripCharges();
274 
275  float stripClusterTimes = 0;
276  float stripClusterCharges = 0;
277 
278  for (unsigned int sIdx = 0; sIdx < csize; ++sIdx) {
279  stripClusterTimes += stripTimesVec.at(sIdx);
280  stripClusterCharges += stripChargesVec.at(sIdx);
281  }
282 
283  stripClusterTimes /= stripTimesVec.size();
284 
285  auto stripClusterChargesPerSideQuadMon = Monitored::Scalar<float>("stripTrackCharge_" + side + "_quad_" + std::to_string(std::abs(stEta)) + "_sector_" + std::to_string(sector) + "_layer_" + std::to_string(layer), stripClusterCharges);
286  fill("stripCharge_" + side + std::to_string(sector) + "_quad_" + std::to_string(std::abs(stEta)), stripClusterChargesPerSideQuadMon);
287 
288  auto stripClusterSectorSidedMon = Monitored::Scalar<int>("stripTrackSectorSided_layer_" + std::to_string(layer), sectorsTotal);
289  auto stripClusterTimesMon = Monitored::Scalar<float>("stripTrackTiming_layer_" + std::to_string(layer), stripClusterTimes);
290  auto stripClusterSizeMon = Monitored::Scalar<unsigned int>("stripTrackClusterSize_layer_" + std::to_string(layer), csize);
291  fill("sTgcTiming", stripClusterSectorSidedMon, stripClusterTimesMon);
292  fill("padTriggerExpert", stripClusterSectorSidedMon, stripClusterSizeMon);
293 
294  ATH_MSG_DEBUG("Strip Timing: " << stripClusterTimes);
295 
296  auto febMon = Monitored::Scalar<int>("stripFEB"+ side + sectorStr, getFEBs(stEta,layer));
297  auto timeMon = Monitored::Scalar<int>("stripTiming"+ side + sectorStr, stripClusterTimes);
298  fill("sTgcTiming", timeMon, febMon);
299 
300 
301  auto stripSectorSidedExpertMon = Monitored::Scalar<int>("stripTrackSectorSided_quad_" + std::to_string(std::abs(stEta)) + "_layer_" + std::to_string(layer), sectorsTotal);
302  auto stripTimingExpertMon = Monitored::Scalar<float>("stripTrackTiming_quad_" + std::to_string(std::abs(stEta)) + "_layer_" + std::to_string(layer), stripClusterTimes);
303  fill("stripTiming_quad_" + std::to_string(std::abs(stEta)), stripSectorSidedExpertMon, stripTimingExpertMon);
304 
305 
306  std::optional<Trk::ResidualPull> resPull(m_residualPullCalculator -> residualPull(trkState -> measurementOnTrack(), trkState -> trackParameters(), Trk::ResidualPull::ResidualType::Biased));
307 
308  if (resPull) {
309  float residual = resPull -> residual()[Trk::locX];
310  auto residualMon = Monitored::Scalar<float>("residual_" + side + "_quad_" + std::to_string(std::abs(stEta)) + "_sector_" + std::to_string(sector) + "_layer_" + std::to_string(layer), residual);
311  fill("sTgcResiduals_" + side + std::to_string(sector) + "_quad_" + std::to_string(std::abs(stEta)), residualMon);
312  }
313  }
314 
315  else if (channelType == sTgcIdHelper::sTgcChannelTypes::Wire) {
316  float wireGroupCharge = prd -> charge();
317  auto wireGroupChargeMon = Monitored::Scalar<float>("wireGroupTrackCharge_" + side + "_quad_" + std::to_string(std::abs(stEta)) + "_sector_" + std::to_string(sector) + "_layer_" + std::to_string(layer), wireGroupCharge);
318  fill("wireGroupCharge_" + side + std::to_string(sector) + "_quad_" + std::to_string(std::abs(stEta)), wireGroupChargeMon);
319 
320  short int wireGroupTiming = prd -> time();
321  auto wireGroupSectorSidedMon = Monitored::Scalar<int>("wireGroupTrackSectorSided_layer_" + std::to_string(layer), sectorsTotal);
322  auto wireGroupTimingMon = Monitored::Scalar<float>("wireGroupTrackTiming_layer_" + std::to_string(layer), wireGroupTiming);
323  fill("sTgcTiming", wireGroupSectorSidedMon, wireGroupTimingMon);
324 
325  auto wireSectorSidedExpertMon = Monitored::Scalar<int>("wireTrackSectorSided_quad_" + std::to_string(std::abs(stEta)) + "_layer_" + std::to_string(layer), sectorsTotal);
326  auto wireTimingExpertMon = Monitored::Scalar<float>("wireTrackTiming_quad_" + std::to_string(std::abs(stEta)) + "_layer_" + std::to_string(layer), wireGroupTiming);
327  fill("wireTiming_quad_" + std::to_string(std::abs(stEta)), wireSectorSidedExpertMon, wireTimingExpertMon);
328 
329  ATH_MSG_DEBUG("Wire Timing: " << wireGroupTiming);
330 
331  auto febMon = Monitored::Scalar<int>("wireFEB"+ side + sectorStr, getFEBs(stEta,layer));
332  auto timeMon = Monitored::Scalar<int>("wireTiming"+ side + sectorStr, wireGroupTiming);
333  fill("sTgcTiming", timeMon, febMon);
334  }
335  }
336  }
337  ATH_MSG_DEBUG("Off fillsTgcClusterFromTrackHistograms");
338 }
339 
340 void sTgcRawDataMonAlg::fillsTgcPadTriggerDataHistograms(const xAOD::MuonContainer* muonContainer, const Muon::NSW_PadTriggerDataContainer* NSWpadTriggerObject, int lb) const {
341  ATH_MSG_DEBUG("On fillsTgcPadTriggerDataHistograms");
342  for (const Muon::NSW_PadTriggerData* rdo : *NSWpadTriggerObject) {
343  bool sideA = rdo -> sideA();
344  bool largeSector = rdo -> largeSector();
345 
346  int iside = (sideA) ? 1 : 0;
347  int isize = (largeSector) ? 1 : 0;
348 
349  std::string side = GeometricSectors::sTgcSide[iside];
350  std::string size = GeometricSectors::sTgcSize[isize];
351 
352  size_t numberOfTriggers = rdo -> getNumberOfTriggers();
353  size_t numberOfHits = rdo -> getNumberOfHits();
354 
355  for (size_t trigger = 0; trigger < numberOfTriggers; ++trigger) {
356  int triggerPhiIdsUnsigned = rdo -> getTriggerPhiIds().at(trigger);
357  int triggerBandIds = rdo -> getTriggerBandIds().at(trigger);
358  int triggerRelBCID = rdo -> getTriggerRelBcids().at(trigger);
359  int sourceId = rdo -> getSourceid();
360  int sectorNumber = sourceidToSector(sourceId, sideA);
361 
362  if (triggerPhiIdsUnsigned == m_cutTriggerPhiId || triggerBandIds == m_cutTriggerBandId) continue;
363 
364  int triggerPhiIds = getSignedPhiId(triggerPhiIdsUnsigned);
365 
366  auto phiIdsPerSideSizeMon = Monitored::Scalar<int>("phiIds_" + side + "_" + size, triggerPhiIds);
367  auto bandIdsPerSideSizeMon = Monitored::Scalar<int>("bandIds_" + side + "_" + size, triggerBandIds);
368  fill("padTriggerShifter", phiIdsPerSideSizeMon, bandIdsPerSideSizeMon);
369 
370  auto lbMon = Monitored::Scalar<int>("lb", lb);
371  auto relBCIDMon = Monitored::Scalar<int>("relBCID", triggerRelBCID);
372  auto sectorMon = Monitored::Scalar<int>("sector", sectorNumber);
373  auto numberOfTriggersMon = Monitored::Scalar<int>("numberOfTriggers", numberOfTriggers);
374  fill("padTriggerShifter", lbMon, relBCIDMon, sectorMon, numberOfTriggersMon);
375 
376  auto numberOfTriggersPerSectorMon = Monitored::Scalar<int>("numberOfTriggers_" + side + "_sector_" + std::to_string(std::abs(sectorNumber)), numberOfTriggers);
377  auto phiIdsSidedSizedPerSectorMon = Monitored::Scalar<int>("phiIds_" + side + "_sector_" + std::to_string(std::abs(sectorNumber)), triggerPhiIds);
378  auto bandIdsSidedSizedPerSectorMon = Monitored::Scalar<int>("bandIds_" + side + "_sector_" + std::to_string(std::abs(sectorNumber)), triggerBandIds);
379  auto lbPerSectorMon = Monitored::Scalar<int>("lb_" + side + "_sector_" + std::to_string(std::abs(sectorNumber)), lb);
380  auto relBCIDperSectorMon = Monitored::Scalar<int>("relBCID_" + side + "_sector_" + std::to_string(std::abs(sectorNumber)), triggerRelBCID);
381  fill("padTriggerExpert", numberOfTriggersPerSectorMon, phiIdsSidedSizedPerSectorMon, bandIdsSidedSizedPerSectorMon, lbPerSectorMon, relBCIDperSectorMon);
382 
383  auto RelBCIDPerSectorMon = Monitored::Scalar<int>("relBCID_"+ side + "_sector_" + std::to_string(std::abs(sectorNumber)), triggerRelBCID);
384  auto PhiIDPerSectorMon = Monitored::Scalar<int>("phiIds_" + side + "_sector_" + std::to_string(std::abs(sectorNumber)), triggerPhiIds);
385  auto BandIDPerSectorMon = Monitored::Scalar<int>("bandID_" + side + "_sector_" + std::to_string(std::abs(sectorNumber)), triggerBandIds);
386  fill("padTriggerExpert", RelBCIDPerSectorMon, PhiIDPerSectorMon, BandIDPerSectorMon);
387  } // end Number of triggers loop
388 
389  for (size_t hits = 0; hits < numberOfHits; ++hits){
390  std::optional<Identifier> status = getPadId(rdo->getSourceid(), rdo->getHitPfebs().at(hits), rdo->getHitTdsChannels().at(hits));
391  if (!status.has_value()) continue;
392  Identifier pad_id = status.value();
393 
394  for (const xAOD::Muon* mu : *muonContainer) {
395  if(mu -> pt() < m_cutPt) continue;
396  if(!(mu -> author() == xAOD::Muon::Author::MuidCo || mu -> author() == xAOD::Muon::Author::MuidSA)) continue;
397 
398  const xAOD::TrackParticle* meTP = mu -> trackParticle(xAOD::Muon::TrackParticleType::ExtrapolatedMuonSpectrometerTrackParticle);
399  if(meTP == nullptr) continue;
400 
401  const Trk::Track* meTrack = meTP -> track();
402  if(!meTrack) continue;
403 
404  for(const Trk::TrackStateOnSurface* trkState : *meTrack->trackStateOnSurfaces()) {
405  std::optional<Identifier> status = getRotId(trkState);
406  if (!status.has_value()) continue;
407  Identifier rot_id = status.value();
408 
409  int channelType = m_idHelperSvc -> stgcIdHelper().channelType(rot_id);
410  if (channelType != sTgcIdHelper::sTgcChannelTypes::Pad) continue;
411 
412 
413  if (rot_id != pad_id) continue;
414 
415  int sourceIds = rdo -> getSourceid();
416  int sectorNumbers = sourceidToSector(sourceIds, sideA);
417  int hitRelBCID = rdo -> getHitRelBcids().at(hits);
418  int hitpfebs = rdo -> getHitPfebs().at(hits);
419  int hitTdsChannels = rdo->getHitTdsChannels().at(hits);
420 
421  std::optional<std::tuple<int, int, std::string, std::string, int>> statusPadEtaPhi = getPadEtaPhiTuple(sourceIds, hitpfebs, hitTdsChannels);
422  if (!statusPadEtaPhi.has_value()) continue;
423  std::tuple<int, int, std::string, std::string, int> padEtaPhiTuple = statusPadEtaPhi.value();
424 
425  int padPhi = std::get<0>(padEtaPhiTuple);
426  int padEta = std::get<1>(padEtaPhiTuple);
427  std::string sideName = std::get<2>(padEtaPhiTuple);
428  std::string sizeName = std::get<3>(padEtaPhiTuple);
429  int layer = std::get<4>(padEtaPhiTuple);
430 
431  auto padPhiMon = Monitored::Scalar<int>("padPhi_" + sideName + "_" + sizeName + "_layer_" + std::to_string(layer), padPhi);
432  auto padEtaMon = Monitored::Scalar<int>("padEta_" + sideName + "_" + sizeName + "_layer_" + std::to_string(layer), padEta);
433  fill("padTriggerOccupancy", padPhiMon, padEtaMon);
434 
435  auto hitRelBCIDmon = Monitored::Scalar<int>("hitRelBCID", hitRelBCID);
436  auto hitPfebsMon = Monitored::Scalar<int>("hitPfebs", hitpfebs);
437  auto sectorMon = Monitored::Scalar<int>("sector", sectorNumbers);
438  fill("padTriggerShifter", hitRelBCIDmon, hitPfebsMon, sectorMon);
439 
440  auto hitRelBCIDPerSectorMon = Monitored::Scalar<int>("hitRelBCID_"+side+"_sector_"+std::to_string(std::abs(sectorNumbers)), hitRelBCID);
441  auto hitpfebsPerSectorMon = Monitored::Scalar<int>("hitPfebs_"+side+"_sector_"+std::to_string(std::abs(sectorNumbers)), hitpfebs);
442  fill("padTriggerExpert", hitRelBCIDPerSectorMon, hitpfebsPerSectorMon);
443  } // end TrackStateOnSurface loop
444  } // end Muon loop
445  } // end NSW_PadTriggerData loop
446  }// end Number of Hits loop
447  ATH_MSG_DEBUG("Off fillsTgcPadTriggerDataHistograms");
448 } // end fillsTgcPadTriggerDataHistograms function
449 
450 void sTgcRawDataMonAlg::fillsTgcEfficiencyHistograms(const xAOD::MuonContainer* muonContainer, const MuonGM::MuonDetectorManager* muonDetectorManagerObject) const {
451  ATH_MSG_DEBUG("On fillsTgcEfficiencyHistograms");
452  for (const xAOD::Muon* mu : *muonContainer) {
453  if (mu -> pt() < m_cutPt) continue;
454  if (!(mu -> author() == xAOD::Muon::Author::MuidCo || mu -> author() == xAOD::Muon::Author::MuidSA)) continue;
455 
456  struct sTGCeff {
457  std::array<int, 8> quadMultiplet{};
458  std::array<int, 8> layerMultiplet{};
459  std::array<float, 8> xPosMultiplet{};
460  std::array<float, 8> yPosMultiplet{};
461  std::array<float, 8> zPosMultiplet{};
462  };
463 
464  std::array<std::array<sTGCeff, 16>, 2> effPlots; // Store active layers per side (2) and sectors (16)
465 
466  const xAOD::TrackParticle* meTP = mu -> trackParticle(xAOD::Muon::TrackParticleType::ExtrapolatedMuonSpectrometerTrackParticle);
467  if(meTP == nullptr) continue;
468 
469  const Trk::Track* meTrack = meTP -> track();
470  if(!meTrack) continue;
471 
472  for(const Trk::TrackStateOnSurface* trkState : *meTrack->trackStateOnSurfaces()) {
473  std::optional<Identifier> status = getRotId(trkState);
474  if (!status.has_value()) continue;
475 
476  Identifier rot_id = status.value();
477 
478  int channelType = m_idHelperSvc -> stgcIdHelper().channelType(rot_id);
479  if (channelType != sTgcIdHelper::sTgcChannelTypes::Strip) continue;
480 
481  int stEta = m_idHelperSvc -> stgcIdHelper().stationEta(rot_id);
482  int iside = (stEta > 0) ? 1 : 0;
483  int sector = m_idHelperSvc -> sector(rot_id);
484  int multi = m_idHelperSvc -> stgcIdHelper().multilayer(rot_id);
485  int gap = m_idHelperSvc -> stgcIdHelper().gasGap(rot_id);
486  int layer = getLayer(multi, gap);
487 
488  const Amg::Vector2D& positionsMultiplet = (trkState) -> trackParameters() -> localPosition();
489  float xPosStripInMultipletLocal = positionsMultiplet.x();
490  float yPosStripInMultipletLocal = positionsMultiplet.y();
491 
492  Amg::Vector2D localPos(xPosStripInMultipletLocal, yPosStripInMultipletLocal);
493  Amg::Vector3D globalPos(Amg::Vector3D::Zero());
494  const MuonGM::sTgcReadoutElement* sTgcReadoutObjectStrip = muonDetectorManagerObject -> getsTgcReadoutElement(rot_id);
495  sTgcReadoutObjectStrip -> surface(rot_id).localToGlobal(localPos, Amg::Vector3D::Zero(), globalPos);
496  float xPosStripInMultiplet = globalPos.x();
497  float yPosStripInMultiplet = globalPos.y();
498 
499  Amg::Vector3D posStripGlobal{Amg::Vector3D::Zero()};
500  (muonDetectorManagerObject -> getsTgcReadoutElement(rot_id)) -> stripGlobalPosition(rot_id, posStripGlobal);
501  float zPosStripInMultiplet = posStripGlobal.z();
502 
503  auto& sTGCelements = effPlots[iside][sector - 1];
504 
505  sTGCelements.quadMultiplet.at(layer - 1) = stEta;
506  sTGCelements.layerMultiplet.at(layer - 1) = layer;
507  sTGCelements.xPosMultiplet.at(layer - 1) = xPosStripInMultiplet;
508  sTGCelements.yPosMultiplet.at(layer - 1) = yPosStripInMultiplet;
509  sTGCelements.zPosMultiplet.at(layer - 1) = zPosStripInMultiplet;
510  } // end track state loop
511 
512  for (unsigned int isideIndex = 0; isideIndex <= 1; ++isideIndex) {
513  for (unsigned int sectorIndex = 1; sectorIndex <= 16; ++sectorIndex) {
514  auto& sTGCelements = effPlots[isideIndex][sectorIndex - 1];
515  bool fourOutEight = std::count_if(sTGCelements.layerMultiplet.begin(), sTGCelements.layerMultiplet.end(), [](int i) { return i != 0; }) >= 4;
516  bool oneRefLayer = std::count_if(sTGCelements.layerMultiplet.begin(), sTGCelements.layerMultiplet.end(), [](int i) { return i != 0; }) >= 1;
517 
518  if (fourOutEight) {
519  for (auto layerIndex = static_cast<std::array<int, 8>::size_type>(1); layerIndex <= sTGCelements.layerMultiplet.size(); ++layerIndex) {
520  if (sTGCelements.layerMultiplet.at(layerIndex - 1) == 0) continue;
521 
522  float xPos = sTGCelements.xPosMultiplet.at(layerIndex - 1);
523  float yPos = sTGCelements.yPosMultiplet.at(layerIndex - 1);
524  float rPos = std::hypot(xPos, yPos);
525 
526  std::string side = GeometricSectors::sTgcSide[isideIndex];
527 
528  auto effQuestionMon = Monitored::Scalar<bool>("hitLayer", true);
529  auto rPosStripMon = Monitored::Scalar<float>("rPosStrip_" + side + "_sector_" + std::to_string(sectorIndex) + "_layer_" + std::to_string(layerIndex), rPos);
530  fill("rPosStrip_" + side + std::to_string(sectorIndex), rPosStripMon, effQuestionMon);
531  //GlobalRGroup
532 
533  auto xPosStripmon = Monitored::Scalar<float>("xPosStrip_" + side + "_layer_" + std::to_string(layerIndex), xPos);
534  auto yPosStripmon = Monitored::Scalar<float>("yPosStrip_" + side + "_layer_" + std::to_string(layerIndex), yPos);
535  fill("padTriggerShifter", xPosStripmon, yPosStripmon, effQuestionMon);
536  //StripEfficiency
537  } // End of loop over efficient layers
538  } // End of efficient case
539 
540  else if (!fourOutEight && oneRefLayer) {
541  auto refLayerIndex = std::distance(sTGCelements.layerMultiplet.begin(), std::find_if(sTGCelements.layerMultiplet.begin(), sTGCelements.layerMultiplet.end(), [](int i) {return i != 0;}));
542 
543  for (auto layerIndex = static_cast<std::array<int, 8>::size_type>(1); layerIndex <= sTGCelements.layerMultiplet.size(); ++layerIndex) {
544  if (sTGCelements.layerMultiplet.at(layerIndex - 1) != 0) continue;
545  int quad = sTGCelements.quadMultiplet.at(refLayerIndex);
546  int multi = (layerIndex <= static_cast<std::array<int, 8>::size_type>(m_idHelperSvc->stgcIdHelper().gasGapMax())) ? m_idHelperSvc->stgcIdHelper().multilayerMin() : m_idHelperSvc->stgcIdHelper().multilayerMax();
547  int gap = (layerIndex <= static_cast<std::array<int, 8>::size_type>(m_idHelperSvc->stgcIdHelper().gasGapMax())) ? layerIndex : layerIndex - static_cast<std::array<int, 8>::size_type>(m_idHelperSvc->stgcIdHelper().gasGapMax());
548 
549  bool isValid = false;
550  const Identifier idProbe = m_idHelperSvc -> stgcIdHelper().channelID((sectorIndex % 2 == 0) ? "STS" : "STL", quad, (sectorIndex % 2 == 0) ? sectorIndex/2 : (sectorIndex + 1)/2, multi, gap, sTgcIdHelper::sTgcChannelTypes::Strip, 1, isValid);
551 
552  if (!isValid) {
553  ATH_MSG_WARNING("Identifier of probe layer is invalid");
554  continue;
555  }
556 
557  Amg::Vector3D posProbe{Amg::Vector3D::Zero()};
558  (muonDetectorManagerObject -> getsTgcReadoutElement(idProbe)) -> stripGlobalPosition(idProbe, posProbe);
559  float posZprobe = posProbe.z();
560 
561  float xSlope = sTGCelements.xPosMultiplet.at(refLayerIndex)/sTGCelements.zPosMultiplet.at(refLayerIndex);
562  float ySlope = sTGCelements.yPosMultiplet.at(refLayerIndex)/sTGCelements.zPosMultiplet.at(refLayerIndex);
563 
564  float xPos = sTGCelements.xPosMultiplet.at(refLayerIndex) + xSlope*(posZprobe - sTGCelements.zPosMultiplet.at(refLayerIndex));
565  float yPos = sTGCelements.yPosMultiplet.at(refLayerIndex) + ySlope*(posZprobe - sTGCelements.zPosMultiplet.at(refLayerIndex));
566  float rPos = std::hypot(xPos, yPos);
567 
568  std::string side = GeometricSectors::sTgcSide[isideIndex];
569 
570  auto effQuestionMon = Monitored::Scalar<bool>("hitLayer", false);
571 
572  auto rPosStripProbemon = Monitored::Scalar<float>("rPosStrip_" + side + "_sector_" + std::to_string(sectorIndex) + "_layer_" + std::to_string(layerIndex), rPos);
573  fill("rPosStrip_" + side + std::to_string(sectorIndex), rPosStripProbemon, effQuestionMon);
574 
575  auto xPosStripProbemon = Monitored::Scalar<float>("xPosStrip_" + side + "_layer_" + std::to_string(layerIndex), xPos);
576  auto yPosStripProbemon = Monitored::Scalar<float>("yPosStrip_" + side + "_layer_" + std::to_string(layerIndex), yPos);
577  fill("padTriggerShifter", xPosStripProbemon, yPosStripProbemon, effQuestionMon);
578  } // End of loop over probe layers
579  } // End of non-efficient case
580  } // End of sector loop
581  } // End of iside loop
582  } // End muon container loop
583  ATH_MSG_DEBUG("Off fillsTgcClusterFromTrackHistograms");
584 } // end stgc strip function
585 
586 void sTgcRawDataMonAlg::fillsTgcPadTriggerEfficiencyHistograms(const xAOD::MuonContainer* muonContainer, const Muon::NSW_PadTriggerDataContainer* NSWpadTriggerObject, const MuonGM::MuonDetectorManager* muonDetectorManagerObject) const {
587  ATH_MSG_DEBUG("On fillsTgcPadTriggerEfficiencyHistograms");
588  for (const xAOD::Muon* mu : *muonContainer) {
589  if (!(mu -> author() == xAOD::Muon::Author::MuidCo || mu -> author() == xAOD::Muon::Author::MuidSA)) continue;
590  if (mu -> pt() < m_cutPt) continue;
591  if (std::abs(mu -> eta()) < m_cutEtaDown || std::abs(mu -> eta()) > m_cutEtaUp) continue;
592 
593  double recoMuonEta = mu -> eta();
594  double recoMuonPhi = mu -> phi();
595 
596  std::string sideRecoMuon = GeometricSectors::sTgcSide[recoMuonEta > 0];
597 
598  std::string minSideRecoMuon = "", minSideTrigger = "";
599 
600  double minTriggerEta = 999., minTriggerPhi = 999.,
601  minRecoEta = 999., minRecoPhi = 999., minDeltaR = 999.;
602 
603  auto minDeltaRtrigIt = -1;
604 
605  for (const Muon::NSW_PadTriggerData* rdo : *NSWpadTriggerObject) {
606  bool sideA = rdo -> sideA();
607  bool largeSector = rdo -> largeSector();
608  std::string sideTrigger = GeometricSectors::sTgcSide[sideA];
609  size_t numberOfTriggers = rdo -> getNumberOfTriggers();
610 
611  for (size_t trigger = 0; trigger < numberOfTriggers; ++trigger) {
612  int triggerPhiIdsUnsigned = rdo -> getTriggerPhiIds().at(trigger);
613  int triggerBandIds = rdo -> getTriggerBandIds().at(trigger);
614  int sourceId = rdo -> getSourceid();
615 
616  if (triggerPhiIdsUnsigned == m_cutTriggerPhiId || triggerBandIds == m_cutTriggerBandId) continue;
617 
618  int triggerPhiIds = getSignedPhiId(triggerPhiIdsUnsigned);
619  std::optional<double> status = bandId2eta(triggerBandIds, largeSector, sideA, muonDetectorManagerObject);
620  if (!status.has_value()) continue;
621  double triggerBandIdToEta = status.value();
622  double triggerPhiIDtoPhi = triggersectorphiid2phi(sourceId, triggerPhiIds);
623  double deltaR = xAOD::P4Helpers::deltaR(recoMuonEta, recoMuonPhi, triggerBandIdToEta, triggerPhiIDtoPhi);
624 
625  if (std::abs(triggerBandIdToEta) < m_cutEtaDown || std::abs(triggerBandIdToEta) > m_cutEtaUp) continue;
626 
627  if (sideRecoMuon == sideTrigger) {
628  if (deltaR < minDeltaR) {
629  minSideRecoMuon = sideRecoMuon;
630  minSideTrigger = sideTrigger;
631  minTriggerEta = triggerBandIdToEta;
632  minTriggerPhi = triggerPhiIDtoPhi;
633  minRecoEta = recoMuonEta;
634  minRecoPhi = recoMuonPhi;
635  minDeltaR = deltaR;
636  minDeltaRtrigIt = trigger;
637  }
638  }
639  } // end number of triggers loop
640  } // end pad trigger data container loop
641 
642  bool muonRecoTriggerMatch = false;
643 
644  if (minDeltaRtrigIt != -1) {
645  if (minDeltaR < m_minDeltaR) {
646  muonRecoTriggerMatch = true;
647  }
648  }
649 
650  auto deltaRmon = Monitored::Scalar<double>("deltaR", minDeltaR);
651  fill("Overview", deltaRmon);
652 
653  auto etaRecoMuonMon = Monitored::Scalar<double>("etaRecoMuon", minRecoEta);
654  auto phiRecoMuonMon = Monitored::Scalar<double>("phiRecoMuon", minRecoPhi);
655  fill("Overview", etaRecoMuonMon, phiRecoMuonMon);
656 
657  auto etaPadTriggerMon = Monitored::Scalar<double>("etaPadTrigger", minTriggerEta);
658  auto phiPadTriggerMon = Monitored::Scalar<double>("phiPadTrigger", minTriggerPhi);
659  fill("Overview", etaPadTriggerMon, phiPadTriggerMon);
660 
661  auto phiRecoMuonSidedMon = Monitored::Scalar<double>("phiRecoMuon_" + minSideRecoMuon, minRecoPhi);
662  auto phiPadTriggerSidedMon = Monitored::Scalar<double>("phiPadTrigger_" + minSideTrigger, minTriggerPhi);
663  fill("Overview", phiRecoMuonSidedMon, phiPadTriggerSidedMon);
664 
665  auto muonRecoTriggerMatchMon = Monitored::Scalar<bool>("muonRecoTriggerMatch", muonRecoTriggerMatch);
666  auto etaRecoMuonEffMon = Monitored::Scalar<double>("etaRecoMuonEff", minRecoEta);
667  auto phiRecoMuonEffMon = Monitored::Scalar<double>("phiRecoMuonEff", minRecoPhi);
668  fill("Overview", muonRecoTriggerMatchMon, etaRecoMuonEffMon, phiRecoMuonEffMon);
669 
670  } // end muon container loop
671  ATH_MSG_DEBUG("Off fillsTgcPadTriggerEfficiencyHistograms");
672 }
muonContainer
xAOD::MuonContainer * muonContainer
Definition: TrigGlobEffCorrValidation.cxx:188
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:161
Muon::MuonPrepDataContainer
Template for Muon PRD containers (which are basically collections of MuonPrepDataCollections).
Definition: MuonPrepDataContainer.h:42
xAOD::identify
const Identifier & identify(const UncalibratedMeasurement *meas)
Returns the associated identifier from the muon measurement.
Definition: MuonSpectrometer/MuonPhaseII/Event/xAOD/xAODMuonPrepData/Root/UtilFunctions.cxx:82
dumpTgcDigiDeadChambers.gasGap
list gasGap
Definition: dumpTgcDigiDeadChambers.py:33
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
sTgcRawDataMonAlg::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override
adds event to the monitoring histograms
Definition: StgcRawDataMonAlg.cxx:40
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
sTgcRawDataMonAlg::m_sTgcContainerKey
SG::ReadHandleKey< Muon::sTgcPrepDataContainer > m_sTgcContainerKey
Definition: StgcRawDataMonAlg.h:91
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
sTgcRawDataMonAlg::fillsTgcEfficiencyHistograms
void fillsTgcEfficiencyHistograms(const xAOD::MuonContainer *, const MuonGM::MuonDetectorManager *) const
Definition: StgcRawDataMonAlg.cxx:450
sTgcRawDataMonAlg::m_cutTriggerPhiId
Gaudi::Property< int > m_cutTriggerPhiId
Definition: StgcRawDataMonAlg.h:101
Trk::locX
@ locX
Definition: ParamDefs.h:37
sTgcRawDataMonAlg::fillsTgcPadTriggerEfficiencyHistograms
void fillsTgcPadTriggerEfficiencyHistograms(const xAOD::MuonContainer *, const Muon::NSW_PadTriggerDataContainer *, const MuonGM::MuonDetectorManager *muonDetectorManagerObject) const
Definition: StgcRawDataMonAlg.cxx:586
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
python.MagFieldUtils.lumiblock
lumiblock
Definition: MagFieldUtils.py:187
dumpTgcDigiDeadChambers.stationName
dictionary stationName
Definition: dumpTgcDigiDeadChambers.py:30
ClusterSeg::residual
@ residual
Definition: ClusterNtuple.h:20
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
Trk::Track::trackStateOnSurfaces
const Trk::TrackStates * trackStateOnSurfaces() const
return a pointer to a const DataVector of const TrackStateOnSurfaces.
sTgcRawDataMonAlg::m_meTrkKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_meTrkKey
Definition: StgcRawDataMonAlg.h:93
Muon::NSW_PadTriggerDataContainer
Definition: NSW_PadTriggerDataContainer.h:15
test_pyathena.pt
pt
Definition: test_pyathena.py:11
Trk::PrepRawData::rdoList
const std::vector< Identifier > & rdoList() const
return the List of rdo identifiers (pointers)
sTgcRawDataMonAlg::fillsTgcPadTriggerDataHistograms
void fillsTgcPadTriggerDataHistograms(const xAOD::MuonContainer *, const Muon::NSW_PadTriggerDataContainer *, const int lb) const
Definition: StgcRawDataMonAlg.cxx:340
PlotCalibFromCool.multi
multi
Definition: PlotCalibFromCool.py:99
isValid
bool isValid(const T &p)
Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
Definition: AtlasPID.h:872
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
CaloSwCorrections.gap
def gap(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:212
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
StgcRawDataMonAlg.h
sTgcRawDataMonAlg::getSectors
int getSectors(const Identifier &id) const
Definition: StgcRawDataUtils.cxx:23
TRT::Hit::side
@ side
Definition: HitInfo.h:83
AthMonitorAlgorithm
Base class for Athena Monitoring Algorithms.
Definition: AthMonitorAlgorithm.h:36
sTgcRawDataMonAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: StgcRawDataMonAlg.h:66
sTgcRawDataMonAlg::m_residualPullCalculator
ToolHandle< Trk::IResidualPullCalculator > m_residualPullCalculator
Definition: StgcRawDataMonAlg.h:67
sTgcRawDataMonAlg::getLayer
int getLayer(const int multiplet, const int gasGap) const
Definition: StgcRawDataUtils.cxx:27
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
sTgcRawDataMonAlg::m_muonKey
SG::ReadHandleKey< xAOD::MuonContainer > m_muonKey
Definition: StgcRawDataMonAlg.h:95
sTgcRawDataMonAlg::sourceidToSector
int32_t sourceidToSector(uint32_t sourceid, bool isSideA) const
Definition: StgcRawDataUtils.cxx:31
python.BunchSpacingUtils.lb
lb
Definition: BunchSpacingUtils.py:86
lumiFormat.i
int i
Definition: lumiFormat.py:85
sTgcRawDataMonAlg::m_minDeltaR
Gaudi::Property< double > m_minDeltaR
Definition: StgcRawDataMonAlg.h:100
xAOD::P4Helpers::deltaR
double deltaR(double rapidity1, double phi1, double rapidity2, double phi2)
from bare bare rapidity,phi
Definition: xAODP4Helpers.h:150
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
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
MuonGM::sTgcReadoutElement
An sTgcReadoutElement corresponds to a single STGC module; therefore typicaly a barrel muon station c...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/sTgcReadoutElement.h:30
sTgcRawDataMonAlg::m_cutTriggerBandId
Gaudi::Property< int > m_cutTriggerBandId
Definition: StgcRawDataMonAlg.h:102
sTgcRawDataMonAlg::triggersectorphiid2phi
double triggersectorphiid2phi(uint32_t sourceid, int trigger_phiid) const
Definition: StgcRawDataUtils.cxx:187
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Muon::NSW_PadTriggerData
Definition: NSW_PadTriggerData.h:19
sTgcRawDataMonAlg::getPadId
std::optional< Identifier > getPadId(uint32_t sourceid, uint32_t pfeb, uint32_t tdschan) const
Definition: StgcRawDataUtils.cxx:43
sTgcRawDataMonAlg::getFEBs
int getFEBs(int eta, int layers) const
Definition: StgcRawDataUtils.cxx:13
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
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
sTgcRawDataMonAlg::m_detectorManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_detectorManagerKey
Definition: StgcRawDataMonAlg.h:92
Muon::MuonPrepDataCollection
Template to hold collections of MuonPrepRawData objects.
Definition: MuonPrepDataCollection.h:46
AthMonitorAlgorithm::GetEventInfo
SG::ReadHandle< xAOD::EventInfo > GetEventInfo(const EventContext &) const
Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)
Definition: AthMonitorAlgorithm.cxx:107
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
sTgcRawDataMonAlg::getSignedPhiId
int getSignedPhiId(const uint32_t phiid) const
Definition: StgcRawDataUtils.cxx:36
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
Muon::sTgcClusterOnTrack
Class to represent calibrated clusters formed from TGC strips.
Definition: sTgcClusterOnTrack.h:30
sTgcRawDataMonAlg::m_cutEtaDown
Gaudi::Property< double > m_cutEtaDown
Definition: StgcRawDataMonAlg.h:98
RPDUtils::sideA
unsigned constexpr int sideA
Definition: RPDUtils.h:16
sTgcRawDataMonAlg::m_cutEtaUp
Gaudi::Property< double > m_cutEtaUp
Definition: StgcRawDataMonAlg.h:99
sTgcRawDataMonAlg::fillsTgcClusterFromTrackHistograms
void fillsTgcClusterFromTrackHistograms(const xAOD::TrackParticleContainer *) const
Definition: StgcRawDataMonAlg.cxx:215
Trk::TrackStateOnSurface
represents the track state (measurement, material, fit parameters and quality) at a surface.
Definition: TrackStateOnSurface.h:71
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
sTgcRawDataMonAlg::getRotId
std::optional< Identifier > getRotId(const Trk::TrackStateOnSurface *trkState) const
Definition: StgcRawDataUtils.cxx:88
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
sTgcRawDataMonAlg::m_cutPt
Gaudi::Property< double > m_cutPt
Definition: StgcRawDataMonAlg.h:97
charge
double charge(const T &p)
Definition: AtlasPID.h:991
MuonParameters::MuidSA
@ MuidSA
Definition: MuonParamDefs.h:59
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
sTgcRawDataMonAlg::sTgcRawDataMonAlg
sTgcRawDataMonAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: StgcRawDataMonAlg.cxx:23
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
MuonParameters::MuidCo
@ MuidCo
Definition: MuonParamDefs.h:60
sTgcRawDataMonAlg::fillsTgcLumiblockHistograms
void fillsTgcLumiblockHistograms(const Muon::sTgcPrepDataContainer *, const int lb) const
Definition: StgcRawDataMonAlg.cxx:175
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:51
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
sTgcRawDataMonAlg::fillsTgcOccupancyHistograms
void fillsTgcOccupancyHistograms(const Muon::sTgcPrepDataContainer *, const MuonGM::MuonDetectorManager *) const
Definition: StgcRawDataMonAlg.cxx:78
CaloCondBlobAlgs_fillNoiseFromASCII.author
string author
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:25
merge.status
status
Definition: merge.py:16
sTgcRawDataMonAlg::m_rdoKey
SG::ReadHandleKey< Muon::NSW_PadTriggerDataContainer > m_rdoKey
Definition: StgcRawDataMonAlg.h:94
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
sTgcRawDataMonAlg::initialize
virtual StatusCode initialize() override
initialize
Definition: StgcRawDataMonAlg.cxx:27
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
Muon::nsw::STGTPSegments::moduleIDBits::stationEta
constexpr uint8_t stationEta
1 to 3
Definition: NSWSTGTPDecodeBitmaps.h:159
xAOD::lumiBlock
setTeId lumiBlock
Definition: L2StandAloneMuon_v1.cxx:328
sTgcRawDataMonAlg::getRotIdAndRotObject
std::optional< std::tuple< Identifier, const Trk::RIO_OnTrack * > > getRotIdAndRotObject(const Trk::TrackStateOnSurface *trkState) const
Definition: StgcRawDataUtils.cxx:66
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:51
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
Muon::sTgcPrepData
Class to represent sTgc measurements.
Definition: sTgcPrepData.h:20
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
makeComparison.deltaR
float deltaR
Definition: makeComparison.py:36
sTgcRawDataMonAlg::bandId2eta
std::optional< double > bandId2eta(int bandid, bool isLarge, bool isA, const MuonGM::MuonDetectorManager *muonDetectorManagerObject) const
Definition: StgcRawDataUtils.cxx:178
sTgcRawDataMonAlg::getPadEtaPhiTuple
std::optional< std::tuple< int, int, std::string, std::string, int > > getPadEtaPhiTuple(uint32_t sourceid, uint32_t pfeb, uint32_t tdschan) const
Definition: StgcRawDataUtils.cxx:96
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
SG::ReadCondHandle::cptr
const_pointer_type cptr()
Definition: ReadCondHandle.h:71
dumpNswErrorDb.quad
def quad
Definition: dumpNswErrorDb.py:30
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Tue Sep 30 2025 21:18:22 for ATLAS Offline Software by   doxygen 1.8.18