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