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 
123  else if (channelType == sTgcIdHelper::sTgcChannelTypes::Strip) {
124  channelName = "strip";
125  int stripNumber = m_idHelperSvc -> stgcIdHelper().channel(id);
126  Identifier idStripQ1 = m_idHelperSvc -> stgcIdHelper().channelID(stationName, 1, stationPhi, multiplet, gasGap, channelType, 1);
127  Identifier idStripQ2 = m_idHelperSvc -> stgcIdHelper().channelID(stationName, 2, stationPhi, multiplet, gasGap, channelType, 1);
128  const MuonGM::sTgcReadoutElement* sTgcReadoutObjectStripQ1 = muonDetectorManagerObject -> getsTgcReadoutElement(idStripQ1);
129  const MuonGM::sTgcReadoutElement* sTgcReadoutObjectStripQ2 = muonDetectorManagerObject -> getsTgcReadoutElement(idStripQ2);
130  int maxStripNumberQ1 = sTgcReadoutObjectStripQ1 -> numberOfStrips(idStripQ1);
131  int maxStripNumberQ2 = sTgcReadoutObjectStripQ2 -> numberOfStrips(idStripQ2);
132 
133  if (stationEtaAbs == 2) stripNumber = stripNumber + maxStripNumberQ1 + 1;
134  else if (stationEtaAbs == 3) stripNumber = stripNumber + maxStripNumberQ1 + maxStripNumberQ2 + 1;
135 
136  auto sectorMon = Monitored::Scalar<int>("sector_layer_" + layerStr, sectorsTotal);
137  auto stripNumberMon = Monitored::Scalar<int>("stripNumber_layer_" + layerStr, stripNumber);
138  fill("Occupancy", sectorMon, stripNumberMon);
139  }
140 
141  else if (channelType == sTgcIdHelper::sTgcChannelTypes::Wire) {
142  channelName = "wire";
143  int wireGroupNumber = m_idHelperSvc -> stgcIdHelper().channel(id);
144  Identifier idWireGroupQ3 = m_idHelperSvc -> stgcIdHelper().channelID("STL", 3, stationPhi, 1, 3, channelType, 1);
145  const MuonGM::sTgcReadoutElement* sTgcReadoutObjectWireGroupQ3 = muonDetectorManagerObject -> getsTgcReadoutElement(idWireGroupQ3);
146  int maxWireGroupNumberQ3 = sTgcReadoutObjectWireGroupQ3 -> numberOfStrips(idWireGroupQ3);
147 
148  auto stationEtaMon = Monitored::Scalar<int>("stationEta_layer_" + layerStr, stationEta);
149  auto wireGroupNumberMon = Monitored::Scalar<int>("wireGroupNumber_layer_" + layerStr, wireGroupNumber + (sector - 1)*maxWireGroupNumberQ3);
150  fill("Occupancy", stationEtaMon, wireGroupNumberMon);
151  }
152 
153  auto layerMon = Monitored::Scalar<int>(channelName+"layer_" + side + sectorStr, layer);
154  auto quadMon = Monitored::Scalar<int>(channelName+"quad_" + side + sectorStr, stationEtaAbs);
155  fill("OccupancyShifter", layerMon, quadMon);
156 
157  auto sectorMon = Monitored::Scalar<int>(channelName+"Sector", sectorsTotal);
158  auto febMon = Monitored::Scalar<int>(channelName+"Feb", getFEBs(stationEta,layer));
159  fill("Overview", sectorMon, febMon);
160 
161 
162  }
163  }
164 
165  ATH_MSG_DEBUG("Off fillsTgcOccupancyHistograms");
166 }
167 
168 void sTgcRawDataMonAlg::fillsTgcLumiblockHistograms(const Muon::sTgcPrepDataContainer* sTgcContainer, int lb) const {
169  ATH_MSG_DEBUG("On fillsTgcLumiblockHistograms");
170  for(const Muon::sTgcPrepDataCollection* coll : *sTgcContainer) {
171  for (const Muon::sTgcPrepData* prd : *coll) {
172  Identifier id = prd -> identify();
173 
174  if(!id.is_valid()) {
175  ATH_MSG_WARNING("Invalid identifier found in Muon::sTgcPrepData");
176  return;
177  }
178 
179  std::string stationName = m_idHelperSvc->stgcIdHelper().stationNameString(m_idHelperSvc->stgcIdHelper().stationName(id));
180  int stationEta = m_idHelperSvc->stgcIdHelper().stationEta(id);
181  int channelType = m_idHelperSvc->stgcIdHelper().channelType(id);
182  int multiplet = m_idHelperSvc->stgcIdHelper().multilayer(id);
183  int gasGap = m_idHelperSvc->stgcIdHelper().gasGap(id);
184  int layer = std::abs(getLayer(multiplet, gasGap));
185  int iside = (stationEta > 0) ? 1 : 0;
186  int feb = getFEBs(stationEta,layer);
187  int sector = m_idHelperSvc -> sector(id);
188 
189 
190  std::string layerStr = std::to_string(layer);
191  std::string side = GeometricSectors::sTgcSide[iside];
192  std::string channelName = "";
193  std::string sectorStr = std::to_string(sector);
194 
195  if (channelType == sTgcIdHelper::sTgcChannelTypes::Pad) channelName = "pad";
196  else if (channelType == sTgcIdHelper::sTgcChannelTypes::Strip) channelName = "strip";
197  else if (channelType == sTgcIdHelper::sTgcChannelTypes::Wire) channelName = "wire";
198 
199  auto febMon = Monitored::Scalar<int>(channelName+"FEBsector"+side+sectorStr, feb);
200  auto lbMon = Monitored::Scalar<int>(channelName+"LBsector"+side+sectorStr, lb);
201 
202  fill("LBShifterGroup", lbMon, febMon);
203  }
204  }
205  ATH_MSG_DEBUG("Off fillsTgcLumiblockHistograms");
206 }
207 
208 void sTgcRawDataMonAlg::fillsTgcClusterFromTrackHistograms(const xAOD::TrackParticleContainer* trkPartCont) const {
209  ATH_MSG_DEBUG("On fillsTgcClusterFromTrackHistograms");
210  for (const xAOD::TrackParticle* meTP : *trkPartCont) {
211  const Trk::Track* meTrack = meTP -> track();
212  if(!meTrack) continue;
213  for (const Trk::TrackStateOnSurface* trkState : *meTrack -> trackStateOnSurfaces()) {
214  std::optional<std::tuple<Identifier, const Trk::RIO_OnTrack*>> status = getRotIdAndRotObject(trkState);
215  if (!status.has_value()) continue;
216  std::tuple<Identifier, const Trk::RIO_OnTrack*> rotIDtuple = status.value();
217 
218  Identifier rot_id = std::get<Identifier>(rotIDtuple);
219 
220  const Muon::sTgcClusterOnTrack* cluster = dynamic_cast<const Muon::sTgcClusterOnTrack*>(std::get<const Trk::RIO_OnTrack*>(rotIDtuple));
221  if(!cluster) continue;
222 
223  const Muon::sTgcPrepData* prd = cluster -> prepRawData();
224  if (!prd) continue;
225 
226  int channelType = m_idHelperSvc -> stgcIdHelper().channelType(rot_id);
227  int stEta = m_idHelperSvc -> stgcIdHelper().stationEta(rot_id);
228  int multi = m_idHelperSvc -> stgcIdHelper().multilayer(rot_id);
229  int gap = m_idHelperSvc -> stgcIdHelper().gasGap(rot_id);
230  int sector = m_idHelperSvc -> sector(rot_id);
231  int sectorsTotal = getSectors(rot_id);
232  int layer = getLayer(multi, gap);
233  int iside = (stEta > 0) ? 1 : 0;
234  std::string side = GeometricSectors::sTgcSide[iside];
235  std::string channelName = "";
236  std::string sectorStr = std::to_string(sector);
237 
238 
239  if (channelType == sTgcIdHelper::sTgcChannelTypes::Pad) {
240  float padCharge = prd -> charge();
241  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);
242  fill("padCharge_" + side + std::to_string(sector) + "_quad_" + std::to_string(std::abs(stEta)), padChargeMon);
243 
244  short int padTiming = prd -> time();
245  auto padSectorSidedMon = Monitored::Scalar<int>("padTrackSectorSided_layer_" + std::to_string(layer), sectorsTotal);
246  auto padTimingMon = Monitored::Scalar<float>("padTrackTiming_layer_" + std::to_string(layer), padTiming);
247  fill("sTgcTiming", padSectorSidedMon, padTimingMon);
248 
249  auto padSectorSidedExpertMon = Monitored::Scalar<int>("padTrackSectorSided_quad_" + std::to_string(std::abs(stEta)) + "_layer_" + std::to_string(layer), sectorsTotal);
250  auto padTimingExpertMon = Monitored::Scalar<float>("padTrackTiming_quad_" + std::to_string(std::abs(stEta)) + "_layer_" + std::to_string(layer), padTiming);
251  fill("padTiming_quad_" + std::to_string(std::abs(stEta)), padSectorSidedExpertMon, padTimingExpertMon);
252 
253  ATH_MSG_DEBUG("Pad Timing: " << padTiming);
254 
255  auto febMon = Monitored::Scalar<int>("padFEB"+ side + sectorStr, getFEBs(stEta,layer));
256  auto timeMon = Monitored::Scalar<int>("padTiming"+ side + sectorStr, padTiming);
257  fill("sTgcTiming", timeMon, febMon);
258  }
259 
260  else if (channelType == sTgcIdHelper::sTgcChannelTypes::Strip) {
261  channelName = "strip";
262  const std::vector<Identifier>& stripIds = prd->rdoList();
263  unsigned int csize = stripIds.size();
264 
265  std::vector<short int> stripTimesVec = prd -> stripTimes();
266  std::vector<int> stripChargesVec = prd -> stripCharges();
267 
268  float stripClusterTimes = 0;
269  float stripClusterCharges = 0;
270 
271  for (unsigned int sIdx = 0; sIdx < csize; ++sIdx) {
272  stripClusterTimes += stripTimesVec.at(sIdx);
273  stripClusterCharges += stripChargesVec.at(sIdx);
274  }
275 
276  stripClusterTimes /= stripTimesVec.size();
277 
278  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);
279  fill("stripCharge_" + side + std::to_string(sector) + "_quad_" + std::to_string(std::abs(stEta)), stripClusterChargesPerSideQuadMon);
280 
281  auto stripClusterSectorSidedMon = Monitored::Scalar<int>("stripTrackSectorSided_layer_" + std::to_string(layer), sectorsTotal);
282  auto stripClusterTimesMon = Monitored::Scalar<float>("stripTrackTiming_layer_" + std::to_string(layer), stripClusterTimes);
283  auto stripClusterSizeMon = Monitored::Scalar<unsigned int>("stripTrackClusterSize_layer_" + std::to_string(layer), csize);
284  fill("sTgcTiming", stripClusterSectorSidedMon, stripClusterTimesMon);
285  fill("padTriggerShifter", stripClusterSectorSidedMon, stripClusterSizeMon);
286 
287  ATH_MSG_DEBUG("Strip Timing: " << stripClusterTimes);
288 
289  auto febMon = Monitored::Scalar<int>("stripFEB"+ side + sectorStr, getFEBs(stEta,layer));
290  auto timeMon = Monitored::Scalar<int>("stripTiming"+ side + sectorStr, stripClusterTimes);
291  fill("sTgcTiming", timeMon, febMon);
292 
293 
294  auto stripSectorSidedExpertMon = Monitored::Scalar<int>("stripTrackSectorSided_quad_" + std::to_string(std::abs(stEta)) + "_layer_" + std::to_string(layer), sectorsTotal);
295  auto stripTimingExpertMon = Monitored::Scalar<float>("stripTrackTiming_quad_" + std::to_string(std::abs(stEta)) + "_layer_" + std::to_string(layer), stripClusterTimes);
296  fill("stripTiming_quad_" + std::to_string(std::abs(stEta)), stripSectorSidedExpertMon, stripTimingExpertMon);
297 
298 
299  std::optional<Trk::ResidualPull> resPull(m_residualPullCalculator -> residualPull(trkState -> measurementOnTrack(), trkState -> trackParameters(), Trk::ResidualPull::ResidualType::Biased));
300 
301  if (resPull) {
302  float residual = resPull -> residual()[Trk::locX];
303  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);
304  fill("sTgcResiduals_" + side + std::to_string(sector) + "_quad_" + std::to_string(std::abs(stEta)), residualMon);
305  }
306  }
307 
308  else if (channelType == sTgcIdHelper::sTgcChannelTypes::Wire) {
309  float wireGroupCharge = prd -> charge();
310  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);
311  fill("wireGroupCharge_" + side + std::to_string(sector) + "_quad_" + std::to_string(std::abs(stEta)), wireGroupChargeMon);
312 
313  short int wireGroupTiming = prd -> time();
314  auto wireGroupSectorSidedMon = Monitored::Scalar<int>("wireGroupTrackSectorSided_layer_" + std::to_string(layer), sectorsTotal);
315  auto wireGroupTimingMon = Monitored::Scalar<float>("wireGroupTrackTiming_layer_" + std::to_string(layer), wireGroupTiming);
316  fill("sTgcTiming", wireGroupSectorSidedMon, wireGroupTimingMon);
317 
318  auto wireSectorSidedExpertMon = Monitored::Scalar<int>("wireTrackSectorSided_quad_" + std::to_string(std::abs(stEta)) + "_layer_" + std::to_string(layer), sectorsTotal);
319  auto wireTimingExpertMon = Monitored::Scalar<float>("wireTrackTiming_quad_" + std::to_string(std::abs(stEta)) + "_layer_" + std::to_string(layer), wireGroupTiming);
320  fill("wireTiming_quad_" + std::to_string(std::abs(stEta)), wireSectorSidedExpertMon, wireTimingExpertMon);
321 
322  ATH_MSG_DEBUG("Wire Timing: " << wireGroupTiming);
323 
324  auto febMon = Monitored::Scalar<int>("wireFEB"+ side + sectorStr, getFEBs(stEta,layer));
325  auto timeMon = Monitored::Scalar<int>("wireTiming"+ side + sectorStr, wireGroupTiming);
326  fill("sTgcTiming", timeMon, febMon);
327  }
328  }
329  }
330  ATH_MSG_DEBUG("Off fillsTgcClusterFromTrackHistograms");
331 }
332 
333 void sTgcRawDataMonAlg::fillsTgcPadTriggerDataHistograms(const xAOD::MuonContainer* muonContainer, const Muon::NSW_PadTriggerDataContainer* NSWpadTriggerObject, int lb) const {
334  ATH_MSG_DEBUG("On fillsTgcPadTriggerDataHistograms");
335  for (const Muon::NSW_PadTriggerData* rdo : *NSWpadTriggerObject) {
336  bool sideA = rdo -> sideA();
337  bool largeSector = rdo -> largeSector();
338 
339  int iside = (sideA) ? 1 : 0;
340  int isize = (largeSector) ? 1 : 0;
341 
342  std::string side = GeometricSectors::sTgcSide[iside];
343  std::string size = GeometricSectors::sTgcSize[isize];
344 
345  size_t numberOfTriggers = rdo -> getNumberOfTriggers();
346  size_t numberOfHits = rdo -> getNumberOfHits();
347 
348  for (size_t trigger = 0; trigger < numberOfTriggers; ++trigger) {
349  int triggerPhiIdsUnsigned = rdo -> getTriggerPhiIds().at(trigger);
350  int triggerBandIds = rdo -> getTriggerBandIds().at(trigger);
351  int triggerRelBCID = rdo -> getTriggerRelBcids().at(trigger);
352  int sourceId = rdo -> getSourceid();
353  int sectorNumber = sourceidToSector(sourceId, sideA);
354 
355  if (triggerPhiIdsUnsigned == m_cutTriggerPhiId || triggerBandIds == m_cutTriggerBandId) continue;
356 
357  int triggerPhiIds = getSignedPhiId(triggerPhiIdsUnsigned);
358 
359  auto phiIdsPerSideSizeMon = Monitored::Scalar<int>("phiIds_" + side + "_" + size, triggerPhiIds);
360  auto bandIdsPerSideSizeMon = Monitored::Scalar<int>("bandIds_" + side + "_" + size, triggerBandIds);
361  fill("padTriggerShifter", phiIdsPerSideSizeMon, bandIdsPerSideSizeMon);
362 
363  auto lbMon = Monitored::Scalar<int>("lb", lb);
364  auto relBCIDMon = Monitored::Scalar<int>("relBCID", triggerRelBCID);
365  auto sectorMon = Monitored::Scalar<int>("sector", sectorNumber);
366  auto numberOfTriggersMon = Monitored::Scalar<int>("numberOfTriggers", numberOfTriggers);
367  fill("padTriggerShifter", lbMon, relBCIDMon, sectorMon, numberOfTriggersMon);
368 
369  auto numberOfTriggersPerSectorMon = Monitored::Scalar<int>("numberOfTriggers_" + side + "_sector_" + std::to_string(std::abs(sectorNumber)), numberOfTriggers);
370  auto phiIdsSidedSizedPerSectorMon = Monitored::Scalar<int>("phiIds_" + side + "_sector_" + std::to_string(std::abs(sectorNumber)), triggerPhiIds);
371  auto bandIdsSidedSizedPerSectorMon = Monitored::Scalar<int>("bandIds_" + side + "_sector_" + std::to_string(std::abs(sectorNumber)), triggerBandIds);
372  auto lbPerSectorMon = Monitored::Scalar<int>("lb_" + side + "_sector_" + std::to_string(std::abs(sectorNumber)), lb);
373  auto relBCIDperSectorMon = Monitored::Scalar<int>("relBCID_" + side + "_sector_" + std::to_string(std::abs(sectorNumber)), triggerRelBCID);
374  fill("padTriggerExpert", numberOfTriggersPerSectorMon, phiIdsSidedSizedPerSectorMon, bandIdsSidedSizedPerSectorMon, lbPerSectorMon, relBCIDperSectorMon);
375 
376  auto RelBCIDPerSectorMon = Monitored::Scalar<int>("relBCID_"+ side + "_sector_" + std::to_string(std::abs(sectorNumber)), triggerRelBCID);
377  auto PhiIDPerSectorMon = Monitored::Scalar<int>("phiIds_" + side + "_sector_" + std::to_string(std::abs(sectorNumber)), triggerPhiIds);
378  auto BandIDPerSectorMon = Monitored::Scalar<int>("bandID_" + side + "_sector_" + std::to_string(std::abs(sectorNumber)), triggerBandIds);
379  fill("padTriggerShifter", RelBCIDPerSectorMon, PhiIDPerSectorMon, BandIDPerSectorMon);
380  } // end Number of triggers loop
381 
382  for (size_t hits = 0; hits < numberOfHits; ++hits){
383  std::optional<Identifier> status = getPadId(rdo->getSourceid(), rdo->getHitPfebs().at(hits), rdo->getHitTdsChannels().at(hits));
384  if (!status.has_value()) continue;
385  Identifier pad_id = status.value();
386 
387  for (const xAOD::Muon* mu : *muonContainer) {
388  if(mu -> pt() < m_cutPt) continue;
389  if(!(mu -> author() == xAOD::Muon::Author::MuidCo || mu -> author() == xAOD::Muon::Author::MuidSA)) continue;
390 
391  const xAOD::TrackParticle* meTP = mu -> trackParticle(xAOD::Muon::TrackParticleType::ExtrapolatedMuonSpectrometerTrackParticle);
392  if(meTP == nullptr) continue;
393 
394  const Trk::Track* meTrack = meTP -> track();
395  if(!meTrack) continue;
396 
397  for(const Trk::TrackStateOnSurface* trkState : *meTrack->trackStateOnSurfaces()) {
398  std::optional<Identifier> status = getRotId(trkState);
399  if (!status.has_value()) continue;
400  Identifier rot_id = status.value();
401 
402  int channelType = m_idHelperSvc -> stgcIdHelper().channelType(rot_id);
403  if (channelType != sTgcIdHelper::sTgcChannelTypes::Pad) continue;
404 
405 
406  if (rot_id != pad_id) continue;
407 
408  int sourceIds = rdo -> getSourceid();
409  int sectorNumbers = sourceidToSector(sourceIds, sideA);
410  int hitRelBCID = rdo -> getHitRelBcids().at(hits);
411  int hitpfebs = rdo -> getHitPfebs().at(hits);
412  int hitTdsChannels = rdo->getHitTdsChannels().at(hits);
413 
414  std::optional<std::tuple<int, int, std::string, std::string, int>> statusPadEtaPhi = getPadEtaPhiTuple(sourceIds, hitpfebs, hitTdsChannels);
415  if (!statusPadEtaPhi.has_value()) continue;
416  std::tuple<int, int, std::string, std::string, int> padEtaPhiTuple = statusPadEtaPhi.value();
417 
418  int padPhi = std::get<0>(padEtaPhiTuple);
419  int padEta = std::get<1>(padEtaPhiTuple);
420  std::string sideName = std::get<2>(padEtaPhiTuple);
421  std::string sizeName = std::get<3>(padEtaPhiTuple);
422  int layer = std::get<4>(padEtaPhiTuple);
423 
424  auto padPhiMon = Monitored::Scalar<int>("padPhi_" + sideName + "_" + sizeName + "_layer_" + std::to_string(layer), padPhi);
425  auto padEtaMon = Monitored::Scalar<int>("padEta_" + sideName + "_" + sizeName + "_layer_" + std::to_string(layer), padEta);
426  fill("padTriggerOccupancy", padPhiMon, padEtaMon);
427 
428  auto hitRelBCIDmon = Monitored::Scalar<int>("hitRelBCID", hitRelBCID);
429  auto hitPfebsMon = Monitored::Scalar<int>("hitPfebs", hitpfebs);
430  auto sectorMon = Monitored::Scalar<int>("sector", sectorNumbers);
431  fill("padTriggerShifter", hitRelBCIDmon, hitPfebsMon, sectorMon);
432 
433  auto hitRelBCIDPerSectorMon = Monitored::Scalar<int>("hitRelBCID_"+side+"_sector_"+std::to_string(std::abs(sectorNumbers)), hitRelBCID);
434  auto hitpfebsPerSectorMon = Monitored::Scalar<int>("hitPfebs_"+side+"_sector_"+std::to_string(std::abs(sectorNumbers)), hitpfebs);
435  fill("padTriggerShifter", hitRelBCIDPerSectorMon, hitpfebsPerSectorMon);
436  } // end TrackStateOnSurface loop
437  } // end Muon loop
438  } // end NSW_PadTriggerData loop
439  }// end Number of Hits loop
440  ATH_MSG_DEBUG("Off fillsTgcPadTriggerDataHistograms");
441 } // end fillsTgcPadTriggerDataHistograms function
442 
443 void sTgcRawDataMonAlg::fillsTgcEfficiencyHistograms(const xAOD::MuonContainer* muonContainer, const MuonGM::MuonDetectorManager* muonDetectorManagerObject) const {
444  ATH_MSG_DEBUG("On fillsTgcEfficiencyHistograms");
445  for (const xAOD::Muon* mu : *muonContainer) {
446  if (mu -> pt() < m_cutPt) continue;
447  if (!(mu -> author() == xAOD::Muon::Author::MuidCo || mu -> author() == xAOD::Muon::Author::MuidSA)) continue;
448 
449  struct sTGCeff {
450  std::array<int, 8> quadMultiplet{};
451  std::array<int, 8> layerMultiplet{};
452  std::array<float, 8> xPosMultiplet{};
453  std::array<float, 8> yPosMultiplet{};
454  std::array<float, 8> zPosMultiplet{};
455  };
456 
457  std::array<std::array<sTGCeff, 16>, 2> effPlots; // Store active layers per side (2) and sectors (16)
458 
459  const xAOD::TrackParticle* meTP = mu -> trackParticle(xAOD::Muon::TrackParticleType::ExtrapolatedMuonSpectrometerTrackParticle);
460  if(meTP == nullptr) continue;
461 
462  const Trk::Track* meTrack = meTP -> track();
463  if(!meTrack) continue;
464 
465  for(const Trk::TrackStateOnSurface* trkState : *meTrack->trackStateOnSurfaces()) {
466  std::optional<Identifier> status = getRotId(trkState);
467  if (!status.has_value()) continue;
468 
469  Identifier rot_id = status.value();
470 
471  int channelType = m_idHelperSvc -> stgcIdHelper().channelType(rot_id);
472  if (channelType != sTgcIdHelper::sTgcChannelTypes::Strip) continue;
473 
474  int stEta = m_idHelperSvc -> stgcIdHelper().stationEta(rot_id);
475  int iside = (stEta > 0) ? 1 : 0;
476  int sector = m_idHelperSvc -> sector(rot_id);
477  int multi = m_idHelperSvc -> stgcIdHelper().multilayer(rot_id);
478  int gap = m_idHelperSvc -> stgcIdHelper().gasGap(rot_id);
479  int layer = getLayer(multi, gap);
480 
481  const Amg::Vector2D& positionsMultiplet = (trkState) -> trackParameters() -> localPosition();
482  float xPosStripInMultipletLocal = positionsMultiplet.x();
483  float yPosStripInMultipletLocal = positionsMultiplet.y();
484 
485  Amg::Vector2D localPos(xPosStripInMultipletLocal, yPosStripInMultipletLocal);
486  Amg::Vector3D globalPos(Amg::Vector3D::Zero());
487  const MuonGM::sTgcReadoutElement* sTgcReadoutObjectStrip = muonDetectorManagerObject -> getsTgcReadoutElement(rot_id);
488  sTgcReadoutObjectStrip -> surface(rot_id).localToGlobal(localPos, Amg::Vector3D::Zero(), globalPos);
489  float xPosStripInMultiplet = globalPos.x();
490  float yPosStripInMultiplet = globalPos.y();
491 
492  Amg::Vector3D posStripGlobal{Amg::Vector3D::Zero()};
493  (muonDetectorManagerObject -> getsTgcReadoutElement(rot_id)) -> stripGlobalPosition(rot_id, posStripGlobal);
494  float zPosStripInMultiplet = posStripGlobal.z();
495 
496  auto& sTGCelements = effPlots[iside][sector - 1];
497 
498  sTGCelements.quadMultiplet.at(layer - 1) = stEta;
499  sTGCelements.layerMultiplet.at(layer - 1) = layer;
500  sTGCelements.xPosMultiplet.at(layer - 1) = xPosStripInMultiplet;
501  sTGCelements.yPosMultiplet.at(layer - 1) = yPosStripInMultiplet;
502  sTGCelements.zPosMultiplet.at(layer - 1) = zPosStripInMultiplet;
503  } // end track state loop
504 
505  for (unsigned int isideIndex = 0; isideIndex <= 1; ++isideIndex) {
506  for (unsigned int sectorIndex = 1; sectorIndex <= 16; ++sectorIndex) {
507  auto& sTGCelements = effPlots[isideIndex][sectorIndex - 1];
508  bool fourOutEight = std::count_if(sTGCelements.layerMultiplet.begin(), sTGCelements.layerMultiplet.end(), [](int i) { return i != 0; }) >= 4;
509  bool oneRefLayer = std::count_if(sTGCelements.layerMultiplet.begin(), sTGCelements.layerMultiplet.end(), [](int i) { return i != 0; }) >= 1;
510 
511  if (fourOutEight) {
512  for (auto layerIndex = static_cast<std::array<int, 8>::size_type>(1); layerIndex <= sTGCelements.layerMultiplet.size(); ++layerIndex) {
513  if (sTGCelements.layerMultiplet.at(layerIndex - 1) == 0) continue;
514 
515  float xPos = sTGCelements.xPosMultiplet.at(layerIndex - 1);
516  float yPos = sTGCelements.yPosMultiplet.at(layerIndex - 1);
517  float rPos = std::hypot(xPos, yPos);
518 
519  std::string side = GeometricSectors::sTgcSide[isideIndex];
520 
521  auto effQuestionMon = Monitored::Scalar<bool>("hitLayer", true);
522 
523  auto rPosStripMon = Monitored::Scalar<float>("rPosStrip_" + side + "_sector_" + std::to_string(sectorIndex) + "_layer_" + std::to_string(layerIndex), rPos);
524  fill("rPosStrip_" + side + std::to_string(sectorIndex), rPosStripMon, effQuestionMon);
525 
526  auto xPosStripmon = Monitored::Scalar<float>("xPosStrip_" + side + "_layer_" + std::to_string(layerIndex), xPos);
527  auto yPosStripmon = Monitored::Scalar<float>("yPosStrip_" + side + "_layer_" + std::to_string(layerIndex), yPos);
528  fill("padTriggerShifter", xPosStripmon, yPosStripmon, effQuestionMon);
529  } // End of loop over efficient layers
530  } // End of efficient case
531 
532  else if (!fourOutEight && oneRefLayer) {
533  auto refLayerIndex = std::distance(sTGCelements.layerMultiplet.begin(), std::find_if(sTGCelements.layerMultiplet.begin(), sTGCelements.layerMultiplet.end(), [](int i) {return i != 0;}));
534 
535  for (auto layerIndex = static_cast<std::array<int, 8>::size_type>(1); layerIndex <= sTGCelements.layerMultiplet.size(); ++layerIndex) {
536  if (sTGCelements.layerMultiplet.at(layerIndex - 1) != 0) continue;
537  int quad = sTGCelements.quadMultiplet.at(refLayerIndex);
538  int multi = (layerIndex <= static_cast<std::array<int, 8>::size_type>(m_idHelperSvc->stgcIdHelper().gasGapMax())) ? m_idHelperSvc->stgcIdHelper().multilayerMin() : m_idHelperSvc->stgcIdHelper().multilayerMax();
539  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());
540 
541  bool isValid = false;
542  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);
543 
544  if (!isValid) {
545  ATH_MSG_WARNING("Identifier of probe layer is invalid");
546  continue;
547  }
548 
549  Amg::Vector3D posProbe{Amg::Vector3D::Zero()};
550  (muonDetectorManagerObject -> getsTgcReadoutElement(idProbe)) -> stripGlobalPosition(idProbe, posProbe);
551  float posZprobe = posProbe.z();
552 
553  float xSlope = sTGCelements.xPosMultiplet.at(refLayerIndex)/sTGCelements.zPosMultiplet.at(refLayerIndex);
554  float ySlope = sTGCelements.yPosMultiplet.at(refLayerIndex)/sTGCelements.zPosMultiplet.at(refLayerIndex);
555 
556  float xPos = sTGCelements.xPosMultiplet.at(refLayerIndex) + xSlope*(posZprobe - sTGCelements.zPosMultiplet.at(refLayerIndex));
557  float yPos = sTGCelements.yPosMultiplet.at(refLayerIndex) + ySlope*(posZprobe - sTGCelements.zPosMultiplet.at(refLayerIndex));
558  float rPos = std::hypot(xPos, yPos);
559 
560  std::string side = GeometricSectors::sTgcSide[isideIndex];
561 
562  auto effQuestionMon = Monitored::Scalar<bool>("hitLayer", false);
563 
564  auto rPosStripProbemon = Monitored::Scalar<float>("rPosStrip_" + side + "_sector_" + std::to_string(sectorIndex) + "_layer_" + std::to_string(layerIndex), rPos);
565  fill("rPosStrip_" + side + std::to_string(sectorIndex), rPosStripProbemon, effQuestionMon);
566 
567  auto xPosStripProbemon = Monitored::Scalar<float>("xPosStrip_" + side + "_layer_" + std::to_string(layerIndex), xPos);
568  auto yPosStripProbemon = Monitored::Scalar<float>("yPosStrip_" + side + "_layer_" + std::to_string(layerIndex), yPos);
569  fill("padTriggerShifter", xPosStripProbemon, yPosStripProbemon, effQuestionMon);
570  } // End of loop over probe layers
571  } // End of non-efficient case
572  } // End of sector loop
573  } // End of iside loop
574  } // End muon container loop
575  ATH_MSG_DEBUG("Off fillsTgcClusterFromTrackHistograms");
576 } // end stgc strip function
577 
578 void sTgcRawDataMonAlg::fillsTgcPadTriggerEfficiencyHistograms(const xAOD::MuonContainer* muonContainer, const Muon::NSW_PadTriggerDataContainer* NSWpadTriggerObject, const MuonGM::MuonDetectorManager* muonDetectorManagerObject) const {
579  ATH_MSG_DEBUG("On fillsTgcPadTriggerEfficiencyHistograms");
580  for (const xAOD::Muon* mu : *muonContainer) {
581  if (!(mu -> author() == xAOD::Muon::Author::MuidCo || mu -> author() == xAOD::Muon::Author::MuidSA)) continue;
582  if (mu -> pt() < m_cutPt) continue;
583  if (std::abs(mu -> eta()) < m_cutEtaDown || std::abs(mu -> eta()) > m_cutEtaUp) continue;
584 
585  double recoMuonEta = mu -> eta();
586  double recoMuonPhi = mu -> phi();
587 
588  std::string sideRecoMuon = GeometricSectors::sTgcSide[recoMuonEta > 0];
589 
590  std::string minSideRecoMuon = "", minSideTrigger = "";
591 
592  double minTriggerEta = 999., minTriggerPhi = 999.,
593  minRecoEta = 999., minRecoPhi = 999., minDeltaR = 999.;
594 
595  auto minDeltaRtrigIt = -1;
596 
597  for (const Muon::NSW_PadTriggerData* rdo : *NSWpadTriggerObject) {
598  bool sideA = rdo -> sideA();
599  bool largeSector = rdo -> largeSector();
600  std::string sideTrigger = GeometricSectors::sTgcSide[sideA];
601  size_t numberOfTriggers = rdo -> getNumberOfTriggers();
602 
603  for (size_t trigger = 0; trigger < numberOfTriggers; ++trigger) {
604  int triggerPhiIdsUnsigned = rdo -> getTriggerPhiIds().at(trigger);
605  int triggerBandIds = rdo -> getTriggerBandIds().at(trigger);
606  int sourceId = rdo -> getSourceid();
607 
608  if (triggerPhiIdsUnsigned == m_cutTriggerPhiId || triggerBandIds == m_cutTriggerBandId) continue;
609 
610  int triggerPhiIds = getSignedPhiId(triggerPhiIdsUnsigned);
611  std::optional<double> status = bandId2eta(triggerBandIds, largeSector, sideA, muonDetectorManagerObject);
612  if (!status.has_value()) continue;
613  double triggerBandIdToEta = status.value();
614  double triggerPhiIDtoPhi = triggersectorphiid2phi(sourceId, triggerPhiIds);
615  double deltaR = xAOD::P4Helpers::deltaR(recoMuonEta, recoMuonPhi, triggerBandIdToEta, triggerPhiIDtoPhi);
616 
617  if (std::abs(triggerBandIdToEta) < m_cutEtaDown || std::abs(triggerBandIdToEta) > m_cutEtaUp) continue;
618 
619  if (sideRecoMuon == sideTrigger) {
620  if (deltaR < minDeltaR) {
621  minSideRecoMuon = sideRecoMuon;
622  minSideTrigger = sideTrigger;
623  minTriggerEta = triggerBandIdToEta;
624  minTriggerPhi = triggerPhiIDtoPhi;
625  minRecoEta = recoMuonEta;
626  minRecoPhi = recoMuonPhi;
627  minDeltaR = deltaR;
628  minDeltaRtrigIt = trigger;
629  }
630  }
631  } // end number of triggers loop
632  } // end pad trigger data container loop
633 
634  bool muonRecoTriggerMatch = false;
635 
636  if (minDeltaRtrigIt != -1) {
637  if (minDeltaR < m_minDeltaR) {
638  muonRecoTriggerMatch = true;
639  }
640  }
641 
642  auto deltaRmon = Monitored::Scalar<double>("deltaR", minDeltaR);
643  fill("Overview", deltaRmon);
644 
645  auto etaRecoMuonMon = Monitored::Scalar<double>("etaRecoMuon", minRecoEta);
646  auto phiRecoMuonMon = Monitored::Scalar<double>("phiRecoMuon", minRecoPhi);
647  fill("Overview", etaRecoMuonMon, phiRecoMuonMon);
648 
649  auto etaPadTriggerMon = Monitored::Scalar<double>("etaPadTrigger", minTriggerEta);
650  auto phiPadTriggerMon = Monitored::Scalar<double>("phiPadTrigger", minTriggerPhi);
651  fill("Overview", etaPadTriggerMon, phiPadTriggerMon);
652 
653  auto phiRecoMuonSidedMon = Monitored::Scalar<double>("phiRecoMuon_" + minSideRecoMuon, minRecoPhi);
654  auto phiPadTriggerSidedMon = Monitored::Scalar<double>("phiPadTrigger_" + minSideTrigger, minTriggerPhi);
655  fill("Overview", phiRecoMuonSidedMon, phiPadTriggerSidedMon);
656 
657  auto muonRecoTriggerMatchMon = Monitored::Scalar<bool>("muonRecoTriggerMatch", muonRecoTriggerMatch);
658  auto etaRecoMuonEffMon = Monitored::Scalar<double>("etaRecoMuonEff", minRecoEta);
659  auto phiRecoMuonEffMon = Monitored::Scalar<double>("phiRecoMuonEff", minRecoPhi);
660  fill("Overview", muonRecoTriggerMatchMon, etaRecoMuonEffMon, phiRecoMuonEffMon);
661 
662  } // end muon container loop
663  ATH_MSG_DEBUG("Off fillsTgcPadTriggerEfficiencyHistograms");
664 }
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:443
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:578
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:333
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:867
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:208
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:986
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:168
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 2 2025 21:21:26 for ATLAS Offline Software by   doxygen 1.8.18