ATLAS Offline Software
MuonTrackMonitorAlgorithm.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3  2020 Matthias Schott - Uni Mainz
4 */
5 
6 #include "MuonTrackMonitoring/MuonTrackMonitorAlgorithm.h"
7 #include "TrigDecisionTool/TrigDecisionTool.h"
8 #include "xAODTracking/TrackParticlexAODHelpers.h"
9 #include "xAODEventInfo/EventInfo.h"
10 
11 
12 namespace{
13  constexpr double MeVtoGeV = 1.e-3;
14 }
15 
16 
17 MuonTrackMonitorAlgorithm::MuonTrackMonitorAlgorithm (const std::string& name, ISvcLocator* pSvcLocator)
18  :AthMonitorAlgorithm(name,pSvcLocator){}
19 
20 
21 StatusCode MuonTrackMonitorAlgorithm::initialize()
22 {
23  ATH_CHECK(AthMonitorAlgorithm::initialize());
24  ATH_CHECK(m_MuonContainerKey.initialize());
25  ATH_CHECK(m_MuonIsoDecorKey.initialize());
26  ATH_CHECK(m_VertexContainerKey.initialize(!m_VertexContainerKey.empty()));
27  ATH_CHECK(m_derEventInfoKey.initialize());
29  ATH_CHECK(m_beamSpotKey.initialize(m_useBeamSpot));
30  return StatusCode::SUCCESS;
31 }
32 
33 
34 //========================================================================================================
35 StatusCode MuonTrackMonitorAlgorithm::FillTrackInformation(const std::string& sIdentifier, const xAOD::Muon* muon, const xAOD::Vertex *pvtx, const std::string& sTrack, const xAOD::EventInfo &evt) const
36 {
37 
38 
39  const double beamPosSigmaX = m_useBeamSpot ? evt.beamPosSigmaX() : -1.;
40  const double beamPosSigmaY = m_useBeamSpot ? evt.beamPosSigmaY() : -1.;
41  const double beamPosSigmaXY = m_useBeamSpot ? evt.beamPosSigmaXY() : -1.;
42 
44  using namespace Monitored;
45  auto tool = getGroup("MuonTrackMonitorAlgorithm");
46  auto Author = Monitored::Scalar<float>((sIdentifier+sTrack+"Author").c_str(), -1);
47  auto Quality = Monitored::Scalar<float>((sIdentifier+sTrack+"Quality").c_str(), -1);
48  auto Type = Monitored::Scalar<float>((sIdentifier+sTrack+"Quality").c_str(), -1);
49  auto Eta = Monitored::Scalar<float>((sIdentifier+sTrack+"Eta").c_str(), -9);
50  auto Phi = Monitored::Scalar<float>((sIdentifier+sTrack+"Phi").c_str(), -9);
51  auto Pt = Monitored::Scalar<float>((sIdentifier+sTrack+"Pt").c_str(), -9);
52  auto D0 = Monitored::Scalar<float>((sIdentifier+sTrack+"D0").c_str(), -9);
53  auto Z0 = Monitored::Scalar<float>((sIdentifier+sTrack+"Z0").c_str(), -9);
54  auto deltaZ0 = Monitored::Scalar<float>((sIdentifier+sTrack+"deltaZ0").c_str(), -9);
55  auto D0sig = Monitored::Scalar<float>((sIdentifier+sTrack+"D0sig").c_str(), -9);
56  auto chi2ndof = Monitored::Scalar<float>((sIdentifier+sTrack+"chi2ndof").c_str(), -9);
57 
58  Author = muon->author();
59  Quality = muon->quality();
60  Type = muon->type();
61 
62  // fill track particle hists
63  const xAOD::TrackParticle *tp = nullptr;
64  if (sTrack == "ME") {
65  tp = muon->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
66  }
67  if (sTrack == "MS") {
68  tp = muon->trackParticle(xAOD::Muon::MuonSpectrometerTrackParticle);
69  }
70  if (tp) {
71  Eta = tp->eta();
72  Phi = tp->phi();
73  Pt = tp->pt() * MeVtoGeV;
74  D0 = tp->d0();
75  Z0 = tp->z0();
76  chi2ndof = tp->chiSquared()/std::max(1.f,tp->numberDoF());
77 
78  if (pvtx) {
79  deltaZ0 = tp->z0() + tp->vz() - pvtx->z();
80  }
81 
82  D0sig = m_useBeamSpot ? xAOD::TrackingHelpers::d0significance( tp, beamPosSigmaX, beamPosSigmaY, beamPosSigmaXY ) : -1.;
83 
84  fill(tool, Author, Quality, Type, Eta, Phi, Pt, D0, Z0, chi2ndof, deltaZ0, D0sig);
85  }
86  return StatusCode::SUCCESS;
87 }
88 
89 
90 //========================================================================================================
91 StatusCode MuonTrackMonitorAlgorithm::FillMuonInformation(const std::string& sIdentifier, std::vector<const xAOD::Muon*> &vecMuons, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const
92 {
94  using namespace Monitored;
95  auto tool = getGroup("MuonTrackMonitorAlgorithm");
96  auto MuonEta = Monitored::Scalar<float>((sIdentifier+"MuonEta").c_str(), 0);
97  auto MuonPhi = Monitored::Scalar<float>((sIdentifier+"MuonPhi").c_str(), 0);
98  auto MuonEtaTight = Monitored::Scalar<float>((sIdentifier+"MuonEtaTight").c_str(), 0);
99  auto MuonPhiTight = Monitored::Scalar<float>((sIdentifier+"MuonPhiTight").c_str(), 0);
100  auto MuonEtaMedium = Monitored::Scalar<float>((sIdentifier+"MuonEtaMedium").c_str(), 0);
101  auto MuonPhiMedium = Monitored::Scalar<float>((sIdentifier+"MuonPhiMedium").c_str(), 0);
102  auto MuonD0 = Monitored::Scalar<float>((sIdentifier+"MuonD0").c_str(), 0);
103  auto MuonZ0 = Monitored::Scalar<float>((sIdentifier+"MuonZ0").c_str(), 0);
104  auto MuonPt = Monitored::Scalar<float>((sIdentifier+"MuonPt").c_str(), 0);
105  auto MuonDPTIDME = Monitored::Scalar<float>((sIdentifier+"MuonDPTIDME").c_str(), 0);
106  auto MuonDPTIDMS = Monitored::Scalar<float>((sIdentifier+"MuonDPTIDMS").c_str(), 0);
107  auto MuonDPTIDMECB = Monitored::Scalar<float>((sIdentifier+"MuonDPTIDMECB").c_str(), 0);
108  auto MuonDPTCBME = Monitored::Scalar<float>((sIdentifier+"MuonDPTCBME").c_str(), 0);
109  auto MuonsNBHits = Monitored::Scalar<float>((sIdentifier+"MuonNBHits").c_str(), 0);
110  auto MuonsNPixHits = Monitored::Scalar<float>((sIdentifier+"MuonNPixHits").c_str(), 0);
111  auto MuonsNSCTHits = Monitored::Scalar<float>((sIdentifier+"MuonNSCTHits").c_str(), 0);
112  auto MuonsNTRTHits = Monitored::Scalar<float>((sIdentifier+"MuonNTRTHits").c_str(), 0);
113  auto MuonsNBHitsAvg = Monitored::Scalar<float>((sIdentifier+"MuonNBHitsAvg").c_str(), 0);
114  auto MuonsNPixHitsAvg = Monitored::Scalar<float>((sIdentifier+"MuonNPixHitsAvg").c_str(), 0);
115  auto MuonsNSCTHitsAvg = Monitored::Scalar<float>((sIdentifier+"MuonNSCTHitsAvg").c_str(), 0);
116  auto MuonsNTRTHitsAvg = Monitored::Scalar<float>((sIdentifier+"MuonNTRTHitsAvg").c_str(), 0);
117  auto MuonsIDchi2ndof = Monitored::Scalar<float>((sIdentifier+"MuonIDchi2ndof").c_str(), 0);
118  auto MuonsMEchi2ndof = Monitored::Scalar<float>((sIdentifier+"MuonMEchi2ndof").c_str(), 0);
119  auto MuonsEtaHitsLayer1 = Monitored::Scalar<float>((sIdentifier+"MuonsEtaHitsLayer1").c_str(), 0);
120  auto MuonsEtaHitsLayer2 = Monitored::Scalar<float>((sIdentifier+"MuonsEtaHitsLayer2").c_str(), 0);
121  auto MuonsEtaHitsLayer3 = Monitored::Scalar<float>((sIdentifier+"MuonsEtaHitsLayer3").c_str(), 0);
122  auto MuonsEtaHitsLayer4 = Monitored::Scalar<float>((sIdentifier+"MuonsEtaHitsLayer4").c_str(), 0);
123  auto MuonsPhiHitsLayer1 = Monitored::Scalar<float>((sIdentifier+"MuonsPhiHitsLayer1").c_str(), 0);
124  auto MuonsPhiHitsLayer2 = Monitored::Scalar<float>((sIdentifier+"MuonsPhiHitsLayer2").c_str(), 0);
125  auto MuonsPhiHitsLayer3 = Monitored::Scalar<float>((sIdentifier+"MuonsPhiHitsLayer3").c_str(), 0);
126  auto MuonsPhiHitsLayer4 = Monitored::Scalar<float>((sIdentifier+"MuonsPhiHitsLayer4").c_str(), 0);
127 
128  auto LumiBlock = Monitored::Scalar<float>("LumiBlock", 0);
129  auto LumiBlockTrackCategory = Monitored::Scalar<float>("LumiBlockTrackCategory", 0);
130 
131  uint32_t lumiBlockID = evt.lumiBlock();
132  LumiBlock = lumiBlockID;
133  LumiBlockTrackCategory = getTrackCategoryID(sIdentifier);
134 
136  for(unsigned int n=0; n<vecMuons.size(); n++) {
137  const xAOD::Muon* muon = vecMuons[n];
138  xAOD::Muon::MuonType muonType = muon->muonType();
139  xAOD::Muon::Quality muonQuality = muon->quality();
140 
142  ATH_CHECK ( FillTrackInformation(sIdentifier, muon, pvtx, "ME", evt) );
143 
145  MuonEta = muon->eta();
146  MuonPhi = muon->phi();
147  MuonPt = muon->pt() * MeVtoGeV;
148 
149  const xAOD::TrackParticle *metp = muon->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
150  const xAOD::TrackParticle *idtp = muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
151  const xAOD::TrackParticle *mstp = muon->trackParticle(xAOD::Muon::MuonSpectrometerTrackParticle);
152 
153  fill(tool, LumiBlock, LumiBlockTrackCategory);
154 
155  if (muonType==xAOD::Muon::Combined) {
156  const xAOD::TrackParticle *cbtp = muon->trackParticle(xAOD::Muon::CombinedTrackParticle);
157 
158  if (cbtp) {
159  uint8_t hitval_numberOfBLayerHits, hitval_numberOfPixelHits, hitval_numberOfSCTHits, hitval_numberOfTRTHits;
160  cbtp->summaryValue(hitval_numberOfBLayerHits, xAOD::SummaryType::numberOfInnermostPixelLayerHits);
161  cbtp->summaryValue(hitval_numberOfPixelHits, xAOD::SummaryType::numberOfPixelHits);
162  cbtp->summaryValue(hitval_numberOfSCTHits, xAOD::SummaryType::numberOfSCTHits);
163  cbtp->summaryValue(hitval_numberOfTRTHits, xAOD::SummaryType::numberOfTRTHits);
164 
165  MuonZ0 = cbtp->z0();
166  MuonD0 = cbtp->d0();
167 
168  fill(tool, MuonEta, MuonPhi, MuonPt, MuonZ0, MuonD0);
169 
171  MuonsNBHits = static_cast<unsigned int>(hitval_numberOfBLayerHits);
172  MuonsNPixHits = static_cast<unsigned int>(hitval_numberOfPixelHits);
173  MuonsNSCTHits = static_cast<unsigned int>(hitval_numberOfSCTHits);
174  MuonsNTRTHits = static_cast<unsigned int>(hitval_numberOfTRTHits);
175  fill(tool, MuonsNBHits, MuonsNPixHits, MuonsNSCTHits, MuonsNTRTHits);
176  MuonsNBHitsAvg = hitval_numberOfBLayerHits / vecMuons.size();
177  MuonsNPixHitsAvg = hitval_numberOfPixelHits / vecMuons.size();
178  MuonsNSCTHitsAvg = hitval_numberOfSCTHits / vecMuons.size();
179  MuonsNTRTHitsAvg = hitval_numberOfTRTHits / vecMuons.size();
180  fill(tool, MuonsNBHitsAvg, MuonsNPixHitsAvg, MuonsNSCTHitsAvg, MuonsNTRTHitsAvg);
181 
183  uint8_t hitval_nEtaLayer1{0}, hitval_nEtaLayer2{0}, hitval_nEtaLayer3{0}, hitval_nEtaLayer4{0};
184  uint8_t hitval_nPhiLayer1{0}, hitval_nPhiLayer2{0}, hitval_nPhiLayer3{0}, hitval_nPhiLayer4{0};
185  muon->summaryValue(hitval_nEtaLayer1, xAOD::MuonSummaryType::etaLayer1Hits);
186  muon->summaryValue(hitval_nEtaLayer2, xAOD::MuonSummaryType::etaLayer2Hits);
187  muon->summaryValue(hitval_nEtaLayer3, xAOD::MuonSummaryType::etaLayer3Hits);
188  muon->summaryValue(hitval_nEtaLayer4, xAOD::MuonSummaryType::etaLayer4Hits);
189  muon->summaryValue(hitval_nPhiLayer1, xAOD::MuonSummaryType::phiLayer1Hits);
190  muon->summaryValue(hitval_nPhiLayer2, xAOD::MuonSummaryType::phiLayer2Hits);
191  muon->summaryValue(hitval_nPhiLayer3, xAOD::MuonSummaryType::phiLayer3Hits);
192  muon->summaryValue(hitval_nPhiLayer4, xAOD::MuonSummaryType::phiLayer4Hits);
193  MuonsEtaHitsLayer1 = static_cast<unsigned int>(hitval_nEtaLayer1);
194  MuonsEtaHitsLayer2 = static_cast<unsigned int>(hitval_nEtaLayer2);
195  MuonsEtaHitsLayer3 = static_cast<unsigned int>(hitval_nEtaLayer3);
196  MuonsEtaHitsLayer4 = static_cast<unsigned int>(hitval_nEtaLayer4);
197  MuonsPhiHitsLayer1 = static_cast<unsigned int>(hitval_nPhiLayer1);
198  MuonsPhiHitsLayer2 = static_cast<unsigned int>(hitval_nPhiLayer2);
199  MuonsPhiHitsLayer3 = static_cast<unsigned int>(hitval_nPhiLayer3);
200  MuonsPhiHitsLayer4 = static_cast<unsigned int>(hitval_nPhiLayer4);
201  fill(tool, MuonsEtaHitsLayer1, MuonsEtaHitsLayer2, MuonsEtaHitsLayer3, MuonsEtaHitsLayer4, MuonsPhiHitsLayer1, MuonsPhiHitsLayer2, MuonsPhiHitsLayer3, MuonsPhiHitsLayer4);
202 
205  if (muonQuality==xAOD::Muon::Medium) {
206  MuonEtaMedium = cbtp->eta();
207  MuonPhiMedium = cbtp->phi();
208  fill(tool, MuonEtaMedium, MuonPhiMedium);
209  }
210  if (muonQuality==xAOD::Muon::Tight) {
211  MuonEtaTight = cbtp->eta();
212  MuonPhiTight = cbtp->phi();
213  fill(tool, MuonEtaTight, MuonPhiTight);
214  }
216  if (idtp && metp) {
217  MuonDPTIDME = (idtp->pt() - metp->pt()) / idtp->pt();
218  MuonDPTCBME = (cbtp->pt() - metp->pt()) / cbtp->pt();
219  MuonDPTIDMECB = (idtp->pt() - metp->pt()) / cbtp->pt();
220  MuonsIDchi2ndof = idtp->chiSquared()/std::max(1.f,idtp->numberDoF());
221  MuonsMEchi2ndof = metp->chiSquared()/std::max(1.f,metp->numberDoF());
222  fill(tool, MuonDPTIDME, MuonsIDchi2ndof, MuonsMEchi2ndof);
223  }
224  }
225  }
226  else {
227  const xAOD::TrackParticle *ptp = muon->primaryTrackParticle();
228  if (ptp) {
229  MuonZ0 = ptp->z0();
230  MuonD0 = ptp->d0();
231 
232  fill(tool, MuonEta, MuonPhi, MuonPt, MuonZ0, MuonD0);
233 
234  // Information on hits in each layer
235  uint8_t hitval_numberOfBLayerHits{0}, hitval_numberOfPixelHits{0}, hitval_numberOfSCTHits{0}, hitval_numberOfTRTHits{0};
236  ptp->summaryValue(hitval_numberOfBLayerHits, xAOD::SummaryType::numberOfInnermostPixelLayerHits);
237  ptp->summaryValue(hitval_numberOfPixelHits, xAOD::SummaryType::numberOfPixelHits);
238  ptp->summaryValue(hitval_numberOfSCTHits, xAOD::SummaryType::numberOfSCTHits);
239  ptp->summaryValue(hitval_numberOfTRTHits, xAOD::SummaryType::numberOfTRTHits);
240  MuonsNBHits = static_cast<unsigned int>(hitval_numberOfBLayerHits);
241  MuonsNPixHits = static_cast<unsigned int>(hitval_numberOfPixelHits);
242  MuonsNSCTHits = static_cast<unsigned int>(hitval_numberOfSCTHits);
243  MuonsNTRTHits = static_cast<unsigned int>(hitval_numberOfTRTHits);
244  fill(tool, MuonsNBHits, MuonsNPixHits, MuonsNSCTHits, MuonsNTRTHits);
245 
247  if (idtp && metp) {
248  MuonDPTIDME = (idtp->pt() - metp->pt()) / idtp->pt();
249  MuonsIDchi2ndof = idtp->chiSquared()/idtp->numberDoF();
250  MuonsMEchi2ndof = metp->chiSquared()/metp->numberDoF();
251  fill(tool, MuonDPTIDME, MuonsIDchi2ndof, MuonsMEchi2ndof);
252  }
253  }
254  }
255 
257  auto muonEta = muon->eta();
258  if (mstp) {
259  if (muonEta > 1.05) {
260  LumiBlockTrackCategory = getTrackCategoryID("MS_EA");
261  } else if (muonEta > 0) {
262  LumiBlockTrackCategory = getTrackCategoryID("MS_BA");
263  } else if (muonEta > -1.05) {
264  LumiBlockTrackCategory = getTrackCategoryID("MS_BC");
265  } else if (muonEta <= -1.05) {
266  LumiBlockTrackCategory = getTrackCategoryID("MS_EC");
267  }
268  fill(tool, LumiBlock, LumiBlockTrackCategory);
269  }
270  if (idtp) {
271  auto muonEta = muon->eta();
272  if (muonEta > 1.05) {
273  LumiBlockTrackCategory = getTrackCategoryID("ID_EA");
274  } else if (muonEta > 0) {
275  LumiBlockTrackCategory = getTrackCategoryID("ID_BA");
276  } else if (muonEta > -1.05) {
277  LumiBlockTrackCategory = getTrackCategoryID("ID_BC");
278  } else if (muonEta <= -1.05) {
279  LumiBlockTrackCategory = getTrackCategoryID("ID_EC");
280  }
281  fill(tool, LumiBlock, LumiBlockTrackCategory);
282  }
283  if (metp) {
284  auto muonEta = muon->eta();
285  if (muonEta > 1.05) {
286  LumiBlockTrackCategory = getTrackCategoryID("ME_EA");
287  } else if (muonEta > 0) {
288  LumiBlockTrackCategory = getTrackCategoryID("ME_BA");
289  } else if (muonEta > -1.05) {
290  LumiBlockTrackCategory = getTrackCategoryID("ME_BC");
291  } else if (muonEta <= -1.05) {
292  LumiBlockTrackCategory = getTrackCategoryID("ME_EC");
293  }
294  fill(tool, LumiBlock, LumiBlockTrackCategory);
295  }
296  }
297  return StatusCode::SUCCESS;
298 }
299 
300 //========================================================================================================
301 StatusCode MuonTrackMonitorAlgorithm::analyseLowLevelMuonFeatures(const std::string& sIdentifier, std::vector<const xAOD::Muon*> &Muons, const xAOD::EventInfo &evt) const
302 {
303  uint32_t lumiBlockID = evt.lumiBlock();
304 
305  using namespace Monitored;
306 
308  auto tool = getGroup("MuonTrackMonitorAlgorithm");
309  auto MuonAuthor = Monitored::Scalar<float>((sIdentifier+"MuonAuthor").c_str(), 0);
310  auto MuonQuality = Monitored::Scalar<float>((sIdentifier+"MuonQuality").c_str(), 0);
311  auto MuonType = Monitored::Scalar<float>((sIdentifier+"MuonType").c_str(), 0);
312  auto MuonLargeSectorR = Monitored::Scalar<float>((sIdentifier+"MuonLargeSectorR").c_str(), 0);
313  auto MuonLargeSectorZ = Monitored::Scalar<float>((sIdentifier+"MuonLargeSectorZ").c_str(), 0);
314  auto MuonSmallSectorR = Monitored::Scalar<float>((sIdentifier+"MuonSmallSectorR").c_str(), 0);
315  auto MuonSmallSectorZ = Monitored::Scalar<float>((sIdentifier+"MuonSmallSectorZ").c_str(), 0);
316  auto MuonEta = Monitored::Scalar<float>((sIdentifier+"MuonEta").c_str(), 0);
317  auto MuonPhi = Monitored::Scalar<float>((sIdentifier+"MuonPhi").c_str(), 0);
318  auto MuonPt = Monitored::Scalar<float>((sIdentifier+"MuonPt").c_str(), 0);
319  auto MuonEtaHi = Monitored::Scalar<float>((sIdentifier+"MuonEtaHi").c_str(), 0);
320  auto MuonPhiHi = Monitored::Scalar<float>((sIdentifier+"MuonPhiHi").c_str(), 0);
321  auto MuonPtHi = Monitored::Scalar<float>((sIdentifier+"MuonPtHi").c_str(), 0);
322  auto MuonSector = Monitored::Scalar<float>((sIdentifier+"MuonSector").c_str(), 0);
323  auto MuonCIndex = Monitored::Scalar<float>((sIdentifier+"MuonCIndex").c_str(), 0);
324  auto MuonEta1 = Monitored::Scalar<float>((sIdentifier+"MuonEta1All").c_str(), 0);
325  auto MuonPhi1 = Monitored::Scalar<float>((sIdentifier+"MuonPhi1All").c_str(), 0);
326  auto MuonLumiBlock = Monitored::Scalar<float>((sIdentifier+"MuonLumiBlock").c_str(), 0);
327  auto SegmentXPosBarrel = Monitored::Scalar<float>((sIdentifier+"SegmentXPosBarrel").c_str(), 0);
328  auto SegmentYPosBarrel = Monitored::Scalar<float>((sIdentifier+"SegmentYPosBarrel").c_str(), 0);
329  auto SegmentXPosEndcap = Monitored::Scalar<float>((sIdentifier+"SegmentXPosEndcap").c_str(), 0);
330  auto SegmentYPosEndcap = Monitored::Scalar<float>((sIdentifier+"SegmentYPosEndcap").c_str(), 0);
331 
333  for(const auto muon : Muons) {
334  xAOD::Muon::Quality muonQuality = muon->quality();
335  xAOD::Muon::MuonType muonType = muon->muonType();
336  xAOD::Muon::Author muonAuthor = muon->author();
337  MuonLumiBlock = lumiBlockID;
338  fill(tool, MuonLumiBlock);
339 
341  MuonAuthor = muonAuthor;
342  MuonQuality = muonQuality;
343  MuonType = muonType;
344  MuonEta = muon->eta();
345  MuonPhi = muon->phi();
346  MuonPt = muon->pt() * MeVtoGeV;
347  fill(tool, MuonAuthor, MuonQuality, MuonType, MuonEta, MuonPhi, MuonPt);
348 
349  // Fill high pT plots
350  if (muon->pt() > m_CBmuons_minPt) {
351  MuonEtaHi = muon->eta();
352  MuonPhiHi = muon->phi();
353  MuonPtHi = muon->pt() * MeVtoGeV;
354  fill(tool, MuonEtaHi, MuonPhiHi, MuonPtHi);
355  }
356 
358  for (size_t nSeg=0; nSeg < muon->nMuonSegments(); nSeg++) {
359  const xAOD::MuonSegment* muonSegment = muon->muonSegment(nSeg);
360  if (!muonSegment) {
361  continue;
362  }
363  using namespace Muon::MuonStationIndex;
364  MuonSmallSectorR = MuonLargeSectorR = std::hypot(muonSegment->x(), muonSegment->y());
365  MuonSmallSectorZ = MuonLargeSectorZ = muonSegment->z();
366  MuonSector = muonSegment->sector();
367  MuonCIndex = toInt(muonSegment->chamberIndex());
368  int sector = muonSegment->sector();
369  if(sector % 2 == 0) {
370  fill(tool, MuonLargeSectorZ, MuonLargeSectorR, MuonSector, MuonCIndex);
371  } else {
372  fill(tool, MuonSmallSectorZ, MuonSmallSectorR, MuonSector, MuonCIndex);
373  }
374  const double muonSegmentEta = Amg::Vector3D(muonSegment->px(), muonSegment->py(), muonSegment->pz()).eta();
375  if (std::abs(muonSegmentEta) > 1.05) {
376  SegmentXPosEndcap = muonSegment->x();
377  SegmentYPosEndcap = muonSegment->y();
378  fill(tool, SegmentXPosEndcap, SegmentYPosEndcap);
379  } else {
380  SegmentXPosBarrel = muonSegment->x();
381  SegmentYPosBarrel = muonSegment->y();
382  fill(tool, SegmentXPosBarrel, SegmentYPosBarrel);
383  }
384  }
385  }
386 
387  return StatusCode::SUCCESS;
388 }
389 
390 
391 
392 //========================================================================================================
393 StatusCode MuonTrackMonitorAlgorithm::analyseCombinedTracks(const xAOD::MuonContainer& Muons, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const {
394  using namespace Monitored;
395 
397  auto tool = getGroup("MuonTrackMonitorAlgorithm");
398  auto MuonPrefix = Monitored::Scalar<const char*>("MuonPrefix", "");
399  auto NMuons = Monitored::Scalar<int>("NMuons", 0);
400  auto NMuonsTrig = Monitored::Scalar<int>("NMuonsTrig", 0);
401  auto NMuonsTrigCB = Monitored::Scalar<int>("NMuonsTrigCB", 0);
402  auto NMuonsTrigNonCB = Monitored::Scalar<int>("NMuonsTrigNonCB", 0);
403  auto NMuonsNoTrigCB = Monitored::Scalar<int>("NMuonsNoTrigCB", 0);
404  auto NMuonsNoTrigNonCB = Monitored::Scalar<int>("NMuonsNoTrigNonCB", 0);
405  auto LumiBlockNumberOfMuonTracks = Monitored::Scalar<float>("MSLumiBlockNumberOfMuonTracks", 0);
406  auto LumiBlockNumberOfSegments = Monitored::Scalar<float>("MSLumiBlockNumberOfSegments", 0);
407 
409  std::vector<const xAOD::Muon*> vecAllCombinedMuons;
410  std::vector<const xAOD::Muon*> vecCombinedMuons;
411  std::vector<const xAOD::Muon*> vecNoTrigCombinedMuons;
412 
414  std::vector<const xAOD::Muon*> vecAllNonCombinedMuons;
415  std::vector<const xAOD::Muon*> vecNonCombinedMuons;
416  std::vector<const xAOD::Muon*> vecNoTrigNonCombinedMuons;
417 
418  uint32_t n_muons = 0;
419  uint32_t n_muons_trig = 0;
420  uint32_t n_muons_trig_cb = 0;
421  uint32_t n_muons_trig_noncb = 0;
422  uint32_t n_muons_no_trig_cb = 0;
423  uint32_t n_muons_no_trig_noncb = 0;
424  for(const auto muon : Muons) {
425  n_muons++;
426  bool isTriggered = false;
427  for(const auto& chain : m_hltchainList){
428  if(!getTrigDecisionTool().empty() && getTrigDecisionTool()->isPassed( chain ) ){
429  isTriggered = true;
430  }
431  }
432 
434  if (isTriggered) {
435  ATH_CHECK ( FillTrackInformation("Container", muon, pvtx, "MS", evt) );
436  }
437  else {
438  ATH_CHECK ( FillTrackInformation("ContainerNoTrig", muon, pvtx, "MS", evt) );
439  }
440 
441  xAOD::Muon::MuonType muonType = muon->muonType();
442  if (muonType==xAOD::Muon::Combined) {
443  vecAllCombinedMuons.push_back(muon);
444  if (isTriggered) {
445  vecCombinedMuons.push_back(muon);
446  n_muons_trig++;
447  n_muons_trig_cb++;
448  MuonPrefix = "TrigCB";
449  }
450  else {
451  vecNoTrigCombinedMuons.push_back(muon);
452  MuonPrefix = "NoTrigCB";
453  n_muons_no_trig_cb++;
454  }
455  }
456  else {
457  vecAllNonCombinedMuons.push_back(muon);
458  if (isTriggered) {
459  vecNonCombinedMuons.push_back(muon);
460  n_muons_trig++;
461  n_muons_trig_noncb++;
462  MuonPrefix = "TrigNonCB";
463  }
464  else {
465  vecNoTrigNonCombinedMuons.push_back(muon);
466  MuonPrefix = "NoTrigNonCB";
467  n_muons_no_trig_noncb++;
468  }
469  }
470  fill(tool, MuonPrefix);
471  for (size_t nSeg=0; nSeg < muon->nMuonSegments(); nSeg++) {
472  LumiBlockNumberOfSegments = evt.lumiBlock();
473  fill(tool, LumiBlockNumberOfSegments);
474  }
475  }
476  NMuons = n_muons;
477  NMuonsTrig = n_muons_trig;
478  NMuonsTrigCB = n_muons_trig_cb;
479  NMuonsTrigNonCB = n_muons_trig_noncb;
480  NMuonsNoTrigCB = n_muons_no_trig_cb;
481  NMuonsNoTrigNonCB = n_muons_no_trig_noncb;
482  fill(tool, NMuons, NMuonsTrig, NMuonsTrigCB, NMuonsTrigNonCB, NMuonsNoTrigCB, NMuonsNoTrigNonCB);
483 
484  LumiBlockNumberOfMuonTracks = evt.lumiBlock();
485  fill(tool, LumiBlockNumberOfMuonTracks);
486 
488  ATH_CHECK (analyseLowLevelMuonFeatures("AllCB", vecAllCombinedMuons, evt) );
489  ATH_CHECK (analyseLowLevelMuonFeatures("AllNonCB", vecAllNonCombinedMuons, evt) );
490  ATH_CHECK (analyseLowLevelMuonFeatures("CB", vecCombinedMuons, evt) );
491  ATH_CHECK (analyseLowLevelMuonFeatures("NonCB", vecNonCombinedMuons, evt) );
492  ATH_CHECK (analyseLowLevelMuonFeatures("NoTrigCB", vecNoTrigCombinedMuons, evt) );
493  ATH_CHECK (analyseLowLevelMuonFeatures("NoTrigNonCB", vecNoTrigNonCombinedMuons, evt) );
494 
496  ATH_CHECK (FillMuonInformation("AllCB", vecAllCombinedMuons, pvtx, evt) );
497  ATH_CHECK (FillMuonInformation("AllNonCB", vecAllNonCombinedMuons, pvtx, evt) );
498  ATH_CHECK (FillMuonInformation("CB", vecCombinedMuons, pvtx, evt) );
499  ATH_CHECK (FillMuonInformation("NonCB", vecNonCombinedMuons, pvtx, evt) );
500  ATH_CHECK (FillMuonInformation("NoTrigCB", vecNoTrigCombinedMuons, pvtx, evt) );
501  ATH_CHECK (FillMuonInformation("NoTrigNonCB", vecNoTrigNonCombinedMuons, pvtx, evt) );
502 
503  return StatusCode::SUCCESS;
504 }
505 
506 
507 //========================================================================================================
508 StatusCode MuonTrackMonitorAlgorithm::plotResonanceCandidates(const std::string& resonanceName, std::vector<const xAOD::Muon*>& muonCandidates, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const {
509 
510  uint32_t lumiBlockID = evt.lumiBlock();
511 
512  using namespace Monitored;
513 
515  auto tool = getGroup("MuonTrackMonitorAlgorithm");
516  auto Eta = Monitored::Scalar<float>((resonanceName+"Eta").c_str(), 0);
517  auto Mass = Monitored::Scalar<float>((resonanceName+"Mass").c_str(), 0);
518  auto MuonLumiBlock = Monitored::Scalar<float>((resonanceName+"MuonLumiBlock").c_str(), 0);
519  auto muMinusEta = Monitored::Scalar<float>((resonanceName+"muMinusEta").c_str(), -9);
520  auto muPlusEta = Monitored::Scalar<float>((resonanceName+"muPlusEta").c_str(), -9);
521  auto Eta2D = Monitored::Scalar<const char*>((resonanceName+"Eta2D").c_str(), "outside");
522  auto Eta2 = Monitored::Scalar<int>((resonanceName+"Eta2").c_str(), -8);
523 
525  std::map<int, int> mapTagged_Resonance;
526  std::vector<const xAOD::Muon*> vecMuons;
527  for (unsigned int n=0; n<muonCandidates.size(); n++)
528  mapTagged_Resonance[n]=0;
529  for (unsigned int n=0; n<muonCandidates.size(); n++){
530  const TLorentzVector& tVec1 = muonCandidates[n]->p4();
531  for (unsigned int m=n+1; m<muonCandidates.size(); m++) {
532  const TLorentzVector& tVec2 = muonCandidates[m]->p4();
533  const TLorentzVector candidate = tVec1 + tVec2;
534  const float resonance_Mass = candidate.M() * MeVtoGeV;
535  const float resonance_Eta = candidate.Eta();
536  if (muonCandidates[n]->charge()==muonCandidates[m]->charge()) continue;
537  if ((candidate.M() < m_ZBosonSelection_minMass)&&(resonanceName=="Z")) continue;
538  if ((candidate.M() > m_ZBosonSelection_maxMass)&&(resonanceName=="Z")) continue;
539  if ((candidate.M() < m_JpsiSelection_minMass)&&(resonanceName=="Jpsi")) continue;
540  if ((candidate.M() > m_JpsiSelection_maxMass)&&(resonanceName=="Jpsi")) continue;
541 
542  if (mapTagged_Resonance[n]!=1) vecMuons.push_back(muonCandidates[n]);
543  mapTagged_Resonance[n]=1;
544  if (mapTagged_Resonance[m]!=1) vecMuons.push_back(muonCandidates[m]);
545  mapTagged_Resonance[m]=1;
546 
547  if (muonCandidates[n]->charge()<0){
548  muMinusEta = tVec1.Eta();
549  muPlusEta = tVec2.Eta();
550  }
551  else{
552  muMinusEta = tVec2.Eta();
553  muPlusEta = tVec1.Eta();
554  }
555  const char* EtaReg = "";
556  int EtaRegio = -9;
557  if ((muMinusEta>1.05)&&(muPlusEta>1.05)){
558  EtaReg = "EA_EA";
559  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
560  Mass2D = resonance_Mass;
561  fill(tool, Mass2D);
562  } else if ((muMinusEta>1.05)&&(muPlusEta>0.)&&(muPlusEta<1.05)){
563  EtaReg = "EA_BA";
564  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
565  Mass2D = resonance_Mass;
566  fill(tool, Mass2D);
567  } else if ((muMinusEta>1.05)&&(muPlusEta>-1.05)&&(muPlusEta<0.)){
568  EtaReg = "EA_BC";
569  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
570  Mass2D = resonance_Mass;
571  fill(tool, Mass2D);
572  } else if ((muMinusEta>1.05)&&(muPlusEta<-1.05)){
573  EtaReg = "EA_EC";
574  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
575  Mass2D = resonance_Mass;
576  fill(tool, Mass2D);
577  } else if ((muMinusEta>0.)&&(muMinusEta<1.05)&&(muPlusEta>1.05)){
578  EtaReg = "BA_EA";
579  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
580  Mass2D = resonance_Mass;
581  fill(tool, Mass2D);
582  } else if ((muMinusEta>0.)&&(muMinusEta<1.05)&&(muPlusEta>0.)&&(muPlusEta<1.05)){
583  EtaReg = "BA_BA";
584  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
585  Mass2D = resonance_Mass;
586  fill(tool, Mass2D);
587  } else if ((muMinusEta>0.)&&(muMinusEta<1.05)&&(muPlusEta>-1.05)&&(muPlusEta<0.)){
588  EtaReg = "BA_BC";
589  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
590  Mass2D = resonance_Mass;
591  fill(tool, Mass2D);
592  } else if ((muMinusEta>0.)&&(muMinusEta<1.05)&&(muPlusEta<-1.05)){
593  EtaReg = "BA_EC";
594  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
595  Mass2D = resonance_Mass;
596  fill(tool, Mass2D);
597  } else if ((muMinusEta>-1.05)&&(muMinusEta<0.)&&(muPlusEta>1.05)){
598  EtaReg = "BC_EA";
599  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
600  Mass2D = resonance_Mass;
601  fill(tool, Mass2D);
602  } else if ((muMinusEta>-1.05)&&(muMinusEta<0.)&&(muPlusEta>0.)&&(muPlusEta<1.05)){
603  EtaReg = "BC_BA";
604  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
605  Mass2D = resonance_Mass;
606  fill(tool, Mass2D);
607  } else if ((muMinusEta>-1.05)&&(muMinusEta<0.)&&(muPlusEta>-1.05)&&(muPlusEta<0.)){
608  EtaReg = "BC_BC";
609  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
610  Mass2D = resonance_Mass;
611  fill(tool, Mass2D);
612  } else if ((muMinusEta>-1.05)&&(muMinusEta<0.)&&(muPlusEta<-1.05)){
613  EtaReg = "BC_EC";
614  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
615  Mass2D = resonance_Mass;
616  fill(tool, Mass2D);
617  } else if ((muMinusEta<-1.05)&&(muPlusEta>1.05)){
618  EtaReg = "EC_EA";
619  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
620  Mass2D = resonance_Mass;
621  fill(tool, Mass2D);
622  } else if ((muMinusEta<-1.05)&&(muPlusEta>0.)&&(muPlusEta<1.05)){
623  EtaReg = "EC_BA";
624  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
625  Mass2D = resonance_Mass;
626  fill(tool, Mass2D);
627  } else if ((muMinusEta<-1.05)&&(muPlusEta>-1.05)&&(muPlusEta<0.)){
628  EtaReg = "EC_BC";
629  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
630  Mass2D = resonance_Mass;
631  fill(tool, Mass2D);
632  } else if ((muMinusEta<-1.05)&&(muPlusEta<-1.05)){
633  EtaReg = "EC_EC";
634  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
635  Mass2D = resonance_Mass;
636  fill(tool, Mass2D);
637  } else {
638  EtaReg = "out";
639  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
640  }
641  Mass = resonance_Mass;
642  Eta = resonance_Eta;
643  Eta2D = EtaReg;
644  Eta2 = EtaRegio;
645  fill(tool, Mass, Eta, Eta2, Eta2D, muMinusEta, muPlusEta);
646 
647  MuonLumiBlock = lumiBlockID;
648  fill(tool, MuonLumiBlock);
649  }
650  }
651 
653  ATH_CHECK( FillMuonInformation(resonanceName, vecMuons, pvtx, evt) );
654 
655  return StatusCode::SUCCESS;
656 }
657 
658 
659 //========================================================================================================
660 StatusCode MuonTrackMonitorAlgorithm::analyseResonanceCandidates(const xAOD::MuonContainer& Muons, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const {
661 
662  std::vector<const xAOD::Muon*> vecMuons_ZBoson_Candidates;
663  std::vector<const xAOD::Muon*> vecMuons_Jpsi_Candidates;
664 
666  for(const auto muon : Muons) {
667  xAOD::Muon::MuonType muonType = muon->muonType();
668  if (muonType==xAOD::Muon::Combined) {
669  const xAOD::TrackParticle *cbtp = nullptr;
670  ElementLink<xAOD::TrackParticleContainer> cbtpLink = muon->combinedTrackParticleLink();
671  if (cbtpLink.isValid()) cbtp = *cbtpLink;
672 
674  if (cbtp) {
675  float trkiso = muon->isolation(xAOD::Iso::ptcone30)/muon->pt();
676  if (muonType==xAOD::Muon::Combined &&
677  cbtp &&
678  muon->pt()>m_ZBosonSelection_minPt &&
679  std::abs(muon->eta())<m_ZBosonSelection_maxEta &&
680  trkiso<m_ZBosonSelection_trkIsolation &&
681  std::abs(cbtp->z0())<m_ZBosonSelection_Z0Cut &&
682  std::abs(cbtp->d0())<m_ZBosonSelection_D0Cut )
683  vecMuons_ZBoson_Candidates.push_back(muon);
684  if (muonType==xAOD::Muon::Combined &&
685  cbtp &&
686  muon->pt()>m_JpsiSelection_minPt &&
687  std::abs(muon->eta())<m_JpsiSelection_maxEta &&
688  trkiso<m_JpsiSelection_trkIsolation &&
689  std::abs(cbtp->z0())<m_JpsiSelection_Z0Cut &&
690  std::abs(cbtp->d0())<m_JpsiSelection_D0Cut )
691  vecMuons_Jpsi_Candidates.push_back(muon);
692  }
693  }
694  }
695 
696  ATH_CHECK( plotResonanceCandidates("Z", vecMuons_ZBoson_Candidates, pvtx, evt) );
697  ATH_CHECK( plotResonanceCandidates("Jpsi", vecMuons_Jpsi_Candidates, pvtx, evt) );
698 
699  return StatusCode::SUCCESS;
700 }
701 
702 
703 //========================================================================================================
704 StatusCode MuonTrackMonitorAlgorithm::fillHistograms(const EventContext& ctx) const
705 {
706  using namespace Monitored;
707 
709  if ((!m_derEventInfoKey.empty()) && (!m_MuonContainerKey.empty()) && (!m_VertexContainerKey.empty())) {
710  SG::ReadHandle<xAOD::EventInfo> EventInfo{m_derEventInfoKey, ctx};
711  if (ATH_UNLIKELY(! EventInfo.isValid())) {
712  ATH_MSG_ERROR("Unable to retrieve Event Info " << m_MuonContainerKey);
713  return StatusCode::FAILURE;
714  }
715 
716  const xAOD::Vertex *pvtx = nullptr;
717  SG::ReadHandle<xAOD::VertexContainer> Vertices{m_VertexContainerKey, ctx};
718  if (!Vertices.isValid()) {
719  ATH_MSG_ERROR("Unable to retrieve Vertex container" << m_VertexContainerKey);
720  return StatusCode::FAILURE;
721  }
722  else {
723  pvtx = getPrimaryVertex(*Vertices);
724  }
725 
726  SG::ReadHandle<xAOD::MuonContainer> Muons{m_MuonContainerKey, ctx};
727  if (ATH_UNLIKELY(! Muons.isValid())) {
728  ATH_MSG_ERROR("Unable to retrieve muon container " << m_MuonContainerKey);
729  return StatusCode::FAILURE;
730  }
731 
732  ATH_CHECK( analyseCombinedTracks(*Muons, pvtx, *EventInfo) );
733  ATH_CHECK( analyseResonanceCandidates(*Muons, pvtx, *EventInfo) );
734 
735  }
736 
737  return StatusCode::SUCCESS;
738 }
739 
740 
741 //========================================================================================================
742 const xAOD::Vertex* MuonTrackMonitorAlgorithm::getPrimaryVertex(const xAOD::VertexContainer& Vertices) const
743 {
744  const xAOD::Vertex *pvtx = nullptr;
745  for(const auto vertex : Vertices){
746  if (vertex->vertexType() == xAOD::VxType::PriVtx) {
747  pvtx = vertex;
748  }
749  }
750  return pvtx;
751 }
752 
753 //========================================================================================================
754 int MuonTrackMonitorAlgorithm::getTrackCategoryID(const std::string& sIdentifier) const
755 {
756  int trackCategoryID = -1;
757 
758  if (sIdentifier == "NoTrigNonCB") trackCategoryID = 1;
759  else if (sIdentifier == "NoTrigCB") trackCategoryID = 2;
760  else if (sIdentifier == "NonCB") trackCategoryID = 3;
761  else if (sIdentifier == "CB") trackCategoryID = 4;
762  else if (sIdentifier == "AllNonCB") trackCategoryID = 5;
763  else if (sIdentifier == "AllCB") trackCategoryID = 6;
764  // --------------------
765  else if (sIdentifier == "Z") trackCategoryID = 8;
766  else if (sIdentifier == "Jpsi") trackCategoryID = 9;
767  // --------------------
768  else if (sIdentifier == "ME_EC") trackCategoryID = 11;
769  else if (sIdentifier == "ME_BC") trackCategoryID = 12;
770  else if (sIdentifier == "ME_BA") trackCategoryID = 13;
771  else if (sIdentifier == "ME_EA") trackCategoryID = 14;
772  // --------------------
773  else if (sIdentifier == "MS_EC") trackCategoryID = 16;
774  else if (sIdentifier == "MS_BC") trackCategoryID = 17;
775  else if (sIdentifier == "MS_BA") trackCategoryID = 18;
776  else if (sIdentifier == "MS_EA") trackCategoryID = 19;
777  // --------------------
778  else if (sIdentifier == "ID_EC") trackCategoryID = 21;
779  else if (sIdentifier == "ID_BC") trackCategoryID = 22;
780  else if (sIdentifier == "ID_BA") trackCategoryID = 23;
781  else if (sIdentifier == "ID_EA") trackCategoryID = 24;
782 
783  return trackCategoryID;
784 }
xAOD::phiLayer1Hits
@ phiLayer1Hits
number of phi hits in the first trigger layer (BML1 ot T4)
Definition: TrackingPrimitives.h:349
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:75
MuonTrackMonitorAlgorithm::m_MuonIsoDecorKey
SG::ReadDecorHandleKey< xAOD::MuonContainer > m_MuonIsoDecorKey
Definition: MuonTrackMonitorAlgorithm.h:35
LArL1Calo_ComputeHVCorr.LumiBlock
LumiBlock
Definition: LArL1Calo_ComputeHVCorr.py:38
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:196
xAOD::etaLayer1Hits
@ etaLayer1Hits
number of eta hits in the first trigger layer (BML1 ot T4)
Definition: TrackingPrimitives.h:354
MuonTrackMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override
adds event to the monitoring histograms
Definition: MuonTrackMonitorAlgorithm.cxx:704
xAOD::MuonSegment_v1::x
float x() const
xAOD::phiLayer3Hits
@ phiLayer3Hits
number of phi hits in the third trigger layer (BOL1 ot T2)
Definition: TrackingPrimitives.h:351
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
TrackParticlexAODHelpers.h
xAOD::phiLayer4Hits
@ phiLayer4Hits
number of phi hits in the fourth trigger layer (T3)
Definition: TrackingPrimitives.h:352
MuonTrackMonitorAlgorithm::m_JpsiSelection_minMass
Gaudi::Property< float > m_JpsiSelection_minMass
Definition: MuonTrackMonitorAlgorithm.h:88
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:553
Muon::MuonStationIndex
Definition: MuonStationIndex.h:13
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
MuonTrackMonitorAlgorithm::analyseCombinedTracks
StatusCode analyseCombinedTracks(const xAOD::MuonContainer &Muons, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const
Function to create performance plots for all combined muons.
Definition: MuonTrackMonitorAlgorithm.cxx:393
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:79
MuonTrackMonitorAlgorithm::MuonTrackMonitorAlgorithm
MuonTrackMonitorAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Definition: MuonTrackMonitorAlgorithm.cxx:17
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:666
MuonTrackMonitorAlgorithm::m_ZBosonSelection_minPt
Gaudi::Property< float > m_ZBosonSelection_minPt
Definition: MuonTrackMonitorAlgorithm.h:75
xAOD::TrackingHelpers::d0significance
double d0significance(const xAOD::TrackParticle *tp, double d0_uncert_beam_spot_2)
Definition: TrackParticlexAODHelpers.cxx:42
MuonTrackMonitorAlgorithm::m_MuonContainerKey
SG::ReadHandleKey< xAOD::MuonContainer > m_MuonContainerKey
Definition: MuonTrackMonitorAlgorithm.h:34
AthMonitorAlgorithm::getTrigDecisionTool
const ToolHandle< Trig::TrigDecisionTool > & getTrigDecisionTool() const
Get the trigger decision tool member.
Definition: AthMonitorAlgorithm.cxx:194
MuonTrackMonitorAlgorithm::m_JpsiSelection_trkIsolation
Gaudi::Property< float > m_JpsiSelection_trkIsolation
Definition: MuonTrackMonitorAlgorithm.h:85
xAOD::Iso::ptcone30
@ ptcone30
Definition: IsolationType.h:41
CP::MeVtoGeV
constexpr float MeVtoGeV
Definition: IsolationCloseByCorrectionTool.cxx:38
xAOD::TrackParticle_v1::z0
float z0() const
Returns the parameter.
xAOD::TrackParticle_v1::chiSquared
float chiSquared() const
Returns the of the overall track fit.
MuonTrackMonitorAlgorithm::m_JpsiSelection_maxMass
Gaudi::Property< float > m_JpsiSelection_maxMass
Definition: MuonTrackMonitorAlgorithm.h:89
xAOD::MuonSegment_v1
Class describing a MuonSegment.
Definition: MuonSegment_v1.h:33
ParticleTest.tp
tp
Definition: ParticleTest.py:25
xAOD::MuonSegment_v1::pz
float pz() const
Returns the pz.
xAOD::MuonSegment_v1::px
float px() const
TrigDecisionTool.h
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:260
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:276
Phi
@ Phi
Definition: RPCdef.h:8
ATH_UNLIKELY
#define ATH_UNLIKELY(x)
Definition: AthUnlikelyMacros.h:17
MuonTrackMonitorAlgorithm::analyseResonanceCandidates
StatusCode analyseResonanceCandidates(const xAOD::MuonContainer &Muons, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const
Function to create performance plots for all combined muons that lead to a Z Boson Candidate event.
Definition: MuonTrackMonitorAlgorithm.cxx:660
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
MuonPt
float MuonPt(0)
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
MuonTrackMonitorAlgorithm::getTrackCategoryID
int getTrackCategoryID(const std::string &sIdentifier) const
Function to get the track category ID for the given identifier.
Definition: MuonTrackMonitorAlgorithm.cxx:754
Trk::Z0
@ Z0
Definition: ParameterType.h:18
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
xAOD::TrackParticle_v1::d0
float d0() const
Returns the parameter.
MuonEta
float MuonEta(0)
MuonTrackMonitorAlgorithm::m_VertexContainerKey
SG::ReadHandleKey< xAOD::VertexContainer > m_VertexContainerKey
Definition: MuonTrackMonitorAlgorithm.h:36
xAOD::etaLayer3Hits
@ etaLayer3Hits
number of eta hits in the third trigger layer (BOL1 ot T2)
Definition: TrackingPrimitives.h:356
AthMonitorAlgorithm
Base class for Athena Monitoring Algorithms.
Definition: AthMonitorAlgorithm.h:36
MuonTrackMonitorAlgorithm::m_ZBosonSelection_maxMass
Gaudi::Property< float > m_ZBosonSelection_maxMass
Definition: MuonTrackMonitorAlgorithm.h:81
xAOD::phiLayer2Hits
@ phiLayer2Hits
number of phi hits in the second trigger layer (BML2 ot T1)
Definition: TrackingPrimitives.h:350
MuonTrackMonitorAlgorithm::getPrimaryVertex
const xAOD::Vertex * getPrimaryVertex(const xAOD::VertexContainer &Vertices) const
Function to get the primary vertex.
Definition: MuonTrackMonitorAlgorithm.cxx:742
xAOD::etaLayer2Hits
@ etaLayer2Hits
number of eta hits in the second trigger layer (BML2 ot T1)
Definition: TrackingPrimitives.h:355
MuonTrackMonitorAlgorithm::m_beamSpotKey
SG::ReadDecorHandleKeyArray< xAOD::EventInfo > m_beamSpotKey
Definition: MuonTrackMonitorAlgorithm.h:38
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:28
beamspotman.n
n
Definition: beamspotman.py:727
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
xAOD::MuonSegment_v1::py
float py() const
Returns the py.
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:572
MuonTrackMonitorAlgorithm::m_JpsiSelection_minPt
Gaudi::Property< float > m_JpsiSelection_minPt
Definition: MuonTrackMonitorAlgorithm.h:83
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
hist_file_dump.f
f
Definition: hist_file_dump.py:140
xAOD::Vertex_v1::z
float z() const
Returns the z position.
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
xAODType
Definition: ObjectType.h:13
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
MuonTrackMonitorAlgorithm::m_JpsiSelection_maxEta
Gaudi::Property< float > m_JpsiSelection_maxEta
Definition: MuonTrackMonitorAlgorithm.h:84
MuonTrackMonitorAlgorithm::m_JpsiSelection_D0Cut
Gaudi::Property< float > m_JpsiSelection_D0Cut
Definition: MuonTrackMonitorAlgorithm.h:86
Trk::Combined
@ Combined
Definition: Tracking/TrkTools/TrkTrackSummaryTool/TrkTrackSummaryTool/TrackSummaryTool.h:32
LikeEnum::Tight
@ Tight
Definition: LikelihoodEnums.h:15
MuonTrackMonitorAlgorithm.h
MuonTrackMonitorAlgorithm::m_ZBosonSelection_maxEta
Gaudi::Property< float > m_ZBosonSelection_maxEta
Definition: MuonTrackMonitorAlgorithm.h:76
MuonTrackMonitorAlgorithm::m_ZBosonSelection_trkIsolation
Gaudi::Property< float > m_ZBosonSelection_trkIsolation
Definition: MuonTrackMonitorAlgorithm.h:77
MuonTrackMonitorAlgorithm::plotResonanceCandidates
StatusCode plotResonanceCandidates(const std::string &resonanceName, std::vector< const xAOD::Muon * > &muonCandidates, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const
Function to create performance plots for all combined muons that lead to a Jpsi Meson Candidate event...
Definition: MuonTrackMonitorAlgorithm.cxx:508
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
MuonTrackMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: MuonTrackMonitorAlgorithm.cxx:21
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:452
MuonTrackMonitorAlgorithm::m_ZBosonSelection_Z0Cut
Gaudi::Property< float > m_ZBosonSelection_Z0Cut
Definition: MuonTrackMonitorAlgorithm.h:79
charge
double charge(const T &p)
Definition: AtlasPID.h:997
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
MuonTrackMonitorAlgorithm::FillMuonInformation
StatusCode FillMuonInformation(const std::string &sIdentifier, std::vector< const xAOD::Muon * > &vecMuons, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const
Fills data-quality information (e.g.
Definition: MuonTrackMonitorAlgorithm.cxx:91
EventInfo.h
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
xAOD::MuonSegment_v1::z
float z() const
Returns the y position.
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
Prompt::Def::Pt
@ Pt
Definition: VarHolder.h:76
xAOD::MuonSegment_v1::sector
int sector() const
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
xAOD::MuonSegment_v1::y
float y() const
Returns the x position.
Muons
Definition: Muons.py:1
LikeEnum::Medium
@ Medium
Definition: LikelihoodEnums.h:14
MuonTrackMonitorAlgorithm::m_ZBosonSelection_D0Cut
Gaudi::Property< float > m_ZBosonSelection_D0Cut
Definition: MuonTrackMonitorAlgorithm.h:78
MuonTrackMonitorAlgorithm::m_JpsiSelection_Z0Cut
Gaudi::Property< float > m_JpsiSelection_Z0Cut
Definition: MuonTrackMonitorAlgorithm.h:87
MuonTrackMonitorAlgorithm::m_useBeamSpot
Gaudi::Property< bool > m_useBeamSpot
Definition: MuonTrackMonitorAlgorithm.h:40
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:269
xAOD::TrackParticle_v1::numberDoF
float numberDoF() const
Returns the number of degrees of freedom of the overall track or vertex fit as float.
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:44
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
MuonTrackMonitorAlgorithm::m_derEventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_derEventInfoKey
Definition: MuonTrackMonitorAlgorithm.h:37
MuonTrackMonitorAlgorithm::analyseLowLevelMuonFeatures
StatusCode analyseLowLevelMuonFeatures(const std::string &sIdentifier, std::vector< const xAOD::Muon * > &Muons, const xAOD::EventInfo &evt) const
Function to create performance plots for muon standalone tracks with some detailed informatiom.
Definition: MuonTrackMonitorAlgorithm.cxx:301
ParticleJetParams::Author
Author
Definition: ParticleJetParamDefs.h:33
EventInfo
Definition: EventInfo.py:1
xAOD::MuonSegment_v1::chamberIndex
::Muon::MuonStationIndex::ChIndex chamberIndex() const
Returns the chamber index.
MuonTrackMonitorAlgorithm::m_CBmuons_minPt
Gaudi::Property< float > m_CBmuons_minPt
Definition: MuonTrackMonitorAlgorithm.h:73
AthMonitorAlgorithm::getGroup
const ToolHandle< GenericMonitoringTool > & getGroup(const std::string &name) const
Get a specific monitoring tool from the tool handle array.
Definition: AthMonitorAlgorithm.cxx:164
xAOD::etaLayer4Hits
@ etaLayer4Hits
number of eta hits in the fourth trigger layer (T3)
Definition: TrackingPrimitives.h:357
Eta
@ Eta
Definition: RPCdef.h:8
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:238
MuonTrackMonitorAlgorithm::m_hltchainList
Gaudi::Property< std::vector< std::string > > m_hltchainList
Definition: MuonTrackMonitorAlgorithm.h:71
python.SystemOfUnits.m
float m
Definition: SystemOfUnits.py:106
Muon::MuonStationIndex::toInt
constexpr int toInt(const EnumType enumVal)
Definition: MuonStationIndex.h:61
MuonTrackMonitorAlgorithm::m_ZBosonSelection_minMass
Gaudi::Property< float > m_ZBosonSelection_minMass
Definition: MuonTrackMonitorAlgorithm.h:80
MuonTrackMonitorAlgorithm::FillTrackInformation
StatusCode FillTrackInformation(const std::string &sIdentifier, const xAOD::Muon *muon, const xAOD::Vertex *pvtx, const std::string &sTrack, const xAOD::EventInfo &evt) const
Function to fill low level Track information.
Definition: MuonTrackMonitorAlgorithm.cxx:35
Generated on Fri Nov 7 2025 21:16:20 for ATLAS Offline Software by   doxygen 1.8.18