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 
132  for(unsigned int n=0; n<vecMuons.size(); n++) {
133  const xAOD::Muon* muon = vecMuons[n];
134  xAOD::Muon::MuonType muonType = muon->muonType();
135  xAOD::Muon::Quality muonQuality = muon->quality();
136 
138  ATH_CHECK ( FillTrackInformation(sIdentifier, muon, pvtx, "ME", evt) );
139 
141  MuonEta = muon->eta();
142  MuonPhi = muon->phi();
143  MuonPt = muon->pt() * MeVtoGeV;
144 
145  const xAOD::TrackParticle *metp = muon->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
146  const xAOD::TrackParticle *idtp = nullptr;
147  idtp = muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
148 
149  if (muonType==xAOD::Muon::Combined) {
150  const xAOD::TrackParticle *cbtp = muon->trackParticle(xAOD::Muon::CombinedTrackParticle);
151 
152  if (cbtp) {
153  uint8_t hitval_numberOfBLayerHits, hitval_numberOfPixelHits, hitval_numberOfSCTHits, hitval_numberOfTRTHits;
154  cbtp->summaryValue(hitval_numberOfBLayerHits, xAOD::SummaryType::numberOfInnermostPixelLayerHits);
155  cbtp->summaryValue(hitval_numberOfPixelHits, xAOD::SummaryType::numberOfPixelHits);
156  cbtp->summaryValue(hitval_numberOfSCTHits, xAOD::SummaryType::numberOfSCTHits);
157  cbtp->summaryValue(hitval_numberOfTRTHits, xAOD::SummaryType::numberOfTRTHits);
158 
159  MuonZ0 = cbtp->z0();
160  MuonD0 = cbtp->d0();
161 
162  fill(tool, MuonEta, MuonPhi, MuonPt, MuonZ0, MuonD0);
163 
165  MuonsNBHits = static_cast<unsigned int>(hitval_numberOfBLayerHits);
166  MuonsNPixHits = static_cast<unsigned int>(hitval_numberOfPixelHits);
167  MuonsNSCTHits = static_cast<unsigned int>(hitval_numberOfSCTHits);
168  MuonsNTRTHits = static_cast<unsigned int>(hitval_numberOfTRTHits);
169  fill(tool, MuonsNBHits, MuonsNPixHits, MuonsNSCTHits, MuonsNTRTHits);
170  MuonsNBHitsAvg = hitval_numberOfBLayerHits / vecMuons.size();
171  MuonsNPixHitsAvg = hitval_numberOfPixelHits / vecMuons.size();
172  MuonsNSCTHitsAvg = hitval_numberOfSCTHits / vecMuons.size();
173  MuonsNTRTHitsAvg = hitval_numberOfTRTHits / vecMuons.size();
174  fill(tool, MuonsNBHitsAvg, MuonsNPixHitsAvg, MuonsNSCTHitsAvg, MuonsNTRTHitsAvg);
175 
177  uint8_t hitval_nEtaLayer1{0}, hitval_nEtaLayer2{0}, hitval_nEtaLayer3{0}, hitval_nEtaLayer4{0};
178  uint8_t hitval_nPhiLayer1{0}, hitval_nPhiLayer2{0}, hitval_nPhiLayer3{0}, hitval_nPhiLayer4{0};
179  muon->summaryValue(hitval_nEtaLayer1, xAOD::MuonSummaryType::etaLayer1Hits);
180  muon->summaryValue(hitval_nEtaLayer2, xAOD::MuonSummaryType::etaLayer2Hits);
181  muon->summaryValue(hitval_nEtaLayer3, xAOD::MuonSummaryType::etaLayer3Hits);
182  muon->summaryValue(hitval_nEtaLayer4, xAOD::MuonSummaryType::etaLayer4Hits);
183  muon->summaryValue(hitval_nPhiLayer1, xAOD::MuonSummaryType::phiLayer1Hits);
184  muon->summaryValue(hitval_nPhiLayer2, xAOD::MuonSummaryType::phiLayer2Hits);
185  muon->summaryValue(hitval_nPhiLayer3, xAOD::MuonSummaryType::phiLayer3Hits);
186  muon->summaryValue(hitval_nPhiLayer4, xAOD::MuonSummaryType::phiLayer4Hits);
187  MuonsEtaHitsLayer1 = static_cast<unsigned int>(hitval_nEtaLayer1);
188  MuonsEtaHitsLayer2 = static_cast<unsigned int>(hitval_nEtaLayer2);
189  MuonsEtaHitsLayer3 = static_cast<unsigned int>(hitval_nEtaLayer3);
190  MuonsEtaHitsLayer4 = static_cast<unsigned int>(hitval_nEtaLayer4);
191  MuonsPhiHitsLayer1 = static_cast<unsigned int>(hitval_nPhiLayer1);
192  MuonsPhiHitsLayer2 = static_cast<unsigned int>(hitval_nPhiLayer2);
193  MuonsPhiHitsLayer3 = static_cast<unsigned int>(hitval_nPhiLayer3);
194  MuonsPhiHitsLayer4 = static_cast<unsigned int>(hitval_nPhiLayer4);
195  fill(tool, MuonsEtaHitsLayer1, MuonsEtaHitsLayer2, MuonsEtaHitsLayer3, MuonsEtaHitsLayer4, MuonsPhiHitsLayer1, MuonsPhiHitsLayer2, MuonsPhiHitsLayer3, MuonsPhiHitsLayer4);
196 
199  if (muonQuality==xAOD::Muon::Medium) {
200  MuonEtaMedium = cbtp->eta();
201  MuonPhiMedium = cbtp->phi();
202  fill(tool, MuonEtaMedium, MuonPhiMedium);
203  }
204  if (muonQuality==xAOD::Muon::Tight) {
205  MuonEtaTight = cbtp->eta();
206  MuonPhiTight = cbtp->phi();
207  fill(tool, MuonEtaTight, MuonPhiTight);
208  }
210  if (idtp && metp) {
211  MuonDPTIDME = (idtp->pt() - metp->pt()) / idtp->pt();
212  MuonDPTCBME = (cbtp->pt() - metp->pt()) / cbtp->pt();
213  MuonDPTIDMECB = (idtp->pt() - metp->pt()) / cbtp->pt();
214  MuonsIDchi2ndof = idtp->chiSquared()/std::max(1.f,idtp->numberDoF());
215  MuonsMEchi2ndof = metp->chiSquared()/std::max(1.f,metp->numberDoF());
216  fill(tool, MuonDPTIDME, MuonsIDchi2ndof, MuonsMEchi2ndof);
217  }
218 
219  }
220  }
221  else {
222  const xAOD::TrackParticle *ptp = muon->primaryTrackParticle();
223  if (ptp) {
224  MuonZ0 = ptp->z0();
225  MuonD0 = ptp->d0();
226 
227  fill(tool, MuonEta, MuonPhi, MuonPt, MuonZ0, MuonD0);
228 
229  // Information on hits in each layer
230  uint8_t hitval_numberOfBLayerHits{0}, hitval_numberOfPixelHits{0}, hitval_numberOfSCTHits{0}, hitval_numberOfTRTHits{0};
231  ptp->summaryValue(hitval_numberOfBLayerHits, xAOD::SummaryType::numberOfInnermostPixelLayerHits);
232  ptp->summaryValue(hitval_numberOfPixelHits, xAOD::SummaryType::numberOfPixelHits);
233  ptp->summaryValue(hitval_numberOfSCTHits, xAOD::SummaryType::numberOfSCTHits);
234  ptp->summaryValue(hitval_numberOfTRTHits, xAOD::SummaryType::numberOfTRTHits);
235  MuonsNBHits = static_cast<unsigned int>(hitval_numberOfBLayerHits);
236  MuonsNPixHits = static_cast<unsigned int>(hitval_numberOfPixelHits);
237  MuonsNSCTHits = static_cast<unsigned int>(hitval_numberOfSCTHits);
238  MuonsNTRTHits = static_cast<unsigned int>(hitval_numberOfTRTHits);
239  fill(tool, MuonsNBHits, MuonsNPixHits, MuonsNSCTHits, MuonsNTRTHits);
240 
242  if (idtp && metp) {
243  MuonDPTIDME = (idtp->pt() - metp->pt()) / idtp->pt();
244  MuonsIDchi2ndof = idtp->chiSquared()/idtp->numberDoF();
245  MuonsMEchi2ndof = metp->chiSquared()/metp->numberDoF();
246  fill(tool, MuonDPTIDME, MuonsIDchi2ndof, MuonsMEchi2ndof);
247  }
248  }
249  }
250  }
251  return StatusCode::SUCCESS;
252 }
253 
254 //========================================================================================================
255 StatusCode MuonTrackMonitorAlgorithm::analyseLowLevelMuonFeatures(const std::string& sIdentifier, std::vector<const xAOD::Muon*> &Muons, const xAOD::EventInfo &evt) const
256 {
257  uint32_t lumiBlockID = evt.lumiBlock();
258 
259  using namespace Monitored;
260 
262  auto tool = getGroup("MuonTrackMonitorAlgorithm");
263  auto MuonAuthor = Monitored::Scalar<float>((sIdentifier+"MuonAuthor").c_str(), 0);
264  auto MuonQuality = Monitored::Scalar<float>((sIdentifier+"MuonQuality").c_str(), 0);
265  auto MuonType = Monitored::Scalar<float>((sIdentifier+"MuonType").c_str(), 0);
266  auto MuonLargeSectorR = Monitored::Scalar<float>((sIdentifier+"MuonLargeSectorR").c_str(), 0);
267  auto MuonLargeSectorZ = Monitored::Scalar<float>((sIdentifier+"MuonLargeSectorZ").c_str(), 0);
268  auto MuonSmallSectorR = Monitored::Scalar<float>((sIdentifier+"MuonSmallSectorR").c_str(), 0);
269  auto MuonSmallSectorZ = Monitored::Scalar<float>((sIdentifier+"MuonSmallSectorZ").c_str(), 0);
270  auto MuonEta = Monitored::Scalar<float>((sIdentifier+"MuonEta").c_str(), 0);
271  auto MuonPhi = Monitored::Scalar<float>((sIdentifier+"MuonPhi").c_str(), 0);
272  auto MuonPt = Monitored::Scalar<float>((sIdentifier+"MuonPt").c_str(), 0);
273  auto MuonEtaHi = Monitored::Scalar<float>((sIdentifier+"MuonEtaHi").c_str(), 0);
274  auto MuonPhiHi = Monitored::Scalar<float>((sIdentifier+"MuonPhiHi").c_str(), 0);
275  auto MuonPtHi = Monitored::Scalar<float>((sIdentifier+"MuonPtHi").c_str(), 0);
276  auto MuonSector = Monitored::Scalar<float>((sIdentifier+"MuonSector").c_str(), 0);
277  auto MuonCIndex = Monitored::Scalar<float>((sIdentifier+"MuonCIndex").c_str(), 0);
278  auto MuonEta1 = Monitored::Scalar<float>((sIdentifier+"MuonEta1All").c_str(), 0);
279  auto MuonPhi1 = Monitored::Scalar<float>((sIdentifier+"MuonPhi1All").c_str(), 0);
280  auto MuonLumiBlock = Monitored::Scalar<float>((sIdentifier+"MuonLumiBlock").c_str(), 0);
281  auto SegmentXPosBarrel = Monitored::Scalar<float>((sIdentifier+"SegmentXPosBarrel").c_str(), 0);
282  auto SegmentYPosBarrel = Monitored::Scalar<float>((sIdentifier+"SegmentYPosBarrel").c_str(), 0);
283  auto SegmentXPosEndcap = Monitored::Scalar<float>((sIdentifier+"SegmentXPosEndcap").c_str(), 0);
284  auto SegmentYPosEndcap = Monitored::Scalar<float>((sIdentifier+"SegmentYPosEndcap").c_str(), 0);
285 
287  for(const auto muon : Muons) {
288  xAOD::Muon::Quality muonQuality = muon->quality();
289  xAOD::Muon::MuonType muonType = muon->muonType();
290  xAOD::Muon::Author muonAuthor = muon->author();
291  MuonLumiBlock = lumiBlockID;
292  fill(tool, MuonLumiBlock);
293 
295  MuonAuthor = muonAuthor;
296  MuonQuality = muonQuality;
297  MuonType = muonType;
298  MuonEta = muon->eta();
299  MuonPhi = muon->phi();
300  MuonPt = muon->pt() * MeVtoGeV;
301  fill(tool, MuonAuthor, MuonQuality, MuonType, MuonEta, MuonPhi, MuonPt);
302 
303  // Fill high pT plots
304  if (muon->pt() > m_CBmuons_minPt) {
305  MuonEtaHi = muon->eta();
306  MuonPhiHi = muon->phi();
307  MuonPtHi = muon->pt() * MeVtoGeV;
308  fill(tool, MuonEtaHi, MuonPhiHi, MuonPtHi);
309  }
310 
312  for (size_t nSeg=0; nSeg < muon->nMuonSegments(); nSeg++) {
313  const xAOD::MuonSegment* muonSegment = muon->muonSegment(nSeg);
314  if (!muonSegment) {
315  continue;
316  }
317  MuonSmallSectorR = MuonLargeSectorR = std::hypot(muonSegment->x(), muonSegment->y());
318  MuonSmallSectorZ = MuonLargeSectorZ = muonSegment->z();
319  MuonSector = muonSegment->sector();
320  MuonCIndex = muonSegment->chamberIndex();
321  int sector = muonSegment->sector();
322  if(sector % 2 == 0) {
323  fill(tool, MuonLargeSectorZ, MuonLargeSectorR, MuonSector, MuonCIndex);
324  } else {
325  fill(tool, MuonSmallSectorZ, MuonSmallSectorR, MuonSector, MuonCIndex);
326  }
327  const double muonSegmentEta = Amg::Vector3D(muonSegment->px(), muonSegment->py(), muonSegment->pz()).eta();
328  if (std::abs(muonSegmentEta) > 1.05) {
329  SegmentXPosEndcap = muonSegment->x();
330  SegmentYPosEndcap = muonSegment->y();
331  fill(tool, SegmentXPosEndcap, SegmentYPosEndcap);
332  } else {
333  SegmentXPosBarrel = muonSegment->x();
334  SegmentYPosBarrel = muonSegment->y();
335  fill(tool, SegmentXPosBarrel, SegmentYPosBarrel);
336  }
337  }
338  }
339 
340  return StatusCode::SUCCESS;
341 }
342 
343 
344 
345 //========================================================================================================
346 StatusCode MuonTrackMonitorAlgorithm::analyseCombinedTracks(const xAOD::MuonContainer& Muons, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const {
347  using namespace Monitored;
348 
350  auto tool = getGroup("MuonTrackMonitorAlgorithm");
351  auto MuonPrefix = Monitored::Scalar<const char*>("MuonPrefix", "");
352  auto NMuons = Monitored::Scalar<int>("NMuons", 0);
353  auto NMuonsTrig = Monitored::Scalar<int>("NMuonsTrig", 0);
354  auto NMuonsTrigCB = Monitored::Scalar<int>("NMuonsTrigCB", 0);
355  auto NMuonsTrigNonCB = Monitored::Scalar<int>("NMuonsTrigNonCB", 0);
356  auto NMuonsNoTrigCB = Monitored::Scalar<int>("NMuonsNoTrigCB", 0);
357  auto NMuonsNoTrigNonCB = Monitored::Scalar<int>("NMuonsNoTrigNonCB", 0);
358  auto LumiBlockNumberOfMuonTracks = Monitored::Scalar<float>("MSLumiBlockNumberOfMuonTracks", 0);
359  auto LumiBlockNumberOfSegments = Monitored::Scalar<float>("MSLumiBlockNumberOfSegments", 0);
360 
362  std::vector<const xAOD::Muon*> vecAllCombinedMuons;
363  std::vector<const xAOD::Muon*> vecCombinedMuons;
364  std::vector<const xAOD::Muon*> vecNoTrigCombinedMuons;
365 
367  std::vector<const xAOD::Muon*> vecAllNonCombinedMuons;
368  std::vector<const xAOD::Muon*> vecNonCombinedMuons;
369  std::vector<const xAOD::Muon*> vecNoTrigNonCombinedMuons;
370 
371  uint32_t n_muons = 0;
372  uint32_t n_muons_trig = 0;
373  uint32_t n_muons_trig_cb = 0;
374  uint32_t n_muons_trig_noncb = 0;
375  uint32_t n_muons_no_trig_cb = 0;
376  uint32_t n_muons_no_trig_noncb = 0;
377  for(const auto muon : Muons) {
378  n_muons++;
379  bool isTriggered = false;
380  for(const auto& chain : m_hltchainList){
381  if(!getTrigDecisionTool().empty() && getTrigDecisionTool()->isPassed( chain ) ){
382  isTriggered = true;
383  }
384  }
385 
387  if (isTriggered) {
388  ATH_CHECK ( FillTrackInformation("Container", muon, pvtx, "MS", evt) );
389  }
390  else {
391  ATH_CHECK ( FillTrackInformation("ContainerNoTrig", muon, pvtx, "MS", evt) );
392  }
393 
394  xAOD::Muon::MuonType muonType = muon->muonType();
395  if (muonType==xAOD::Muon::Combined) {
396  vecAllCombinedMuons.push_back(muon);
397  if (isTriggered) {
398  vecCombinedMuons.push_back(muon);
399  n_muons_trig++;
400  n_muons_trig_cb++;
401  MuonPrefix = "TrigCB";
402  }
403  else {
404  vecNoTrigCombinedMuons.push_back(muon);
405  MuonPrefix = "NoTrigCB";
406  n_muons_no_trig_cb++;
407  }
408  }
409  else {
410  vecAllNonCombinedMuons.push_back(muon);
411  if (isTriggered) {
412  vecNonCombinedMuons.push_back(muon);
413  n_muons_trig++;
414  n_muons_trig_noncb++;
415  MuonPrefix = "TrigNonCB";
416  }
417  else {
418  vecNoTrigNonCombinedMuons.push_back(muon);
419  MuonPrefix = "NoTrigNonCB";
420  n_muons_no_trig_noncb++;
421  }
422  }
423  fill(tool, MuonPrefix);
424  for (size_t nSeg=0; nSeg < muon->nMuonSegments(); nSeg++) {
425  LumiBlockNumberOfSegments = evt.lumiBlock();
426  fill(tool, LumiBlockNumberOfSegments);
427  }
428  }
429  NMuons = n_muons;
430  NMuonsTrig = n_muons_trig;
431  NMuonsTrigCB = n_muons_trig_cb;
432  NMuonsTrigNonCB = n_muons_trig_noncb;
433  NMuonsNoTrigCB = n_muons_no_trig_cb;
434  NMuonsNoTrigNonCB = n_muons_no_trig_noncb;
435  fill(tool, NMuons, NMuonsTrig, NMuonsTrigCB, NMuonsTrigNonCB, NMuonsNoTrigCB, NMuonsNoTrigNonCB);
436 
437  LumiBlockNumberOfMuonTracks = evt.lumiBlock();
438  fill(tool, LumiBlockNumberOfMuonTracks);
439 
441  ATH_CHECK (analyseLowLevelMuonFeatures("AllCB", vecAllCombinedMuons, evt) );
442  ATH_CHECK (analyseLowLevelMuonFeatures("AllNonCB", vecAllNonCombinedMuons, evt) );
443  ATH_CHECK (analyseLowLevelMuonFeatures("CB", vecCombinedMuons, evt) );
444  ATH_CHECK (analyseLowLevelMuonFeatures("NonCB", vecNonCombinedMuons, evt) );
445  ATH_CHECK (analyseLowLevelMuonFeatures("NoTrigCB", vecNoTrigCombinedMuons, evt) );
446  ATH_CHECK (analyseLowLevelMuonFeatures("NoTrigNonCB", vecNoTrigNonCombinedMuons, evt) );
447 
449  ATH_CHECK (FillMuonInformation("AllCB", vecAllCombinedMuons, pvtx, evt) );
450  ATH_CHECK (FillMuonInformation("AllNonCB", vecAllNonCombinedMuons, pvtx, evt) );
451  ATH_CHECK (FillMuonInformation("CB", vecCombinedMuons, pvtx, evt) );
452  ATH_CHECK (FillMuonInformation("NonCB", vecNonCombinedMuons, pvtx, evt) );
453  ATH_CHECK (FillMuonInformation("NoTrigCB", vecNoTrigCombinedMuons, pvtx, evt) );
454  ATH_CHECK (FillMuonInformation("NoTrigNonCB", vecNoTrigNonCombinedMuons, pvtx, evt) );
455 
456  return StatusCode::SUCCESS;
457 }
458 
459 
460 //========================================================================================================
461 StatusCode MuonTrackMonitorAlgorithm::plotResonanceCandidates(const std::string& resonanceName, std::vector<const xAOD::Muon*>& muonCandidates, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const {
462 
463  uint32_t lumiBlockID = evt.lumiBlock();
464 
465  using namespace Monitored;
466 
468  auto tool = getGroup("MuonTrackMonitorAlgorithm");
469  auto Eta = Monitored::Scalar<float>((resonanceName+"Eta").c_str(), 0);
470  auto Mass = Monitored::Scalar<float>((resonanceName+"Mass").c_str(), 0);
471  auto MuonLumiBlock = Monitored::Scalar<float>((resonanceName+"MuonLumiBlock").c_str(), 0);
472  auto muMinusEta = Monitored::Scalar<float>((resonanceName+"muMinusEta").c_str(), -9);
473  auto muPlusEta = Monitored::Scalar<float>((resonanceName+"muPlusEta").c_str(), -9);
474  auto Eta2D = Monitored::Scalar<const char*>((resonanceName+"Eta2D").c_str(), "outside");
475  auto Eta2 = Monitored::Scalar<int>((resonanceName+"Eta2").c_str(), -8);
476 
478  std::map<int, int> mapTagged_Resonance;
479  std::vector<const xAOD::Muon*> vecMuons;
480  for (unsigned int n=0; n<muonCandidates.size(); n++)
481  mapTagged_Resonance[n]=0;
482  for (unsigned int n=0; n<muonCandidates.size(); n++){
483  const TLorentzVector& tVec1 = muonCandidates[n]->p4();
484  for (unsigned int m=n+1; m<muonCandidates.size(); m++) {
485  const TLorentzVector& tVec2 = muonCandidates[m]->p4();
486  const TLorentzVector candidate = tVec1 + tVec2;
487  const float resonance_Mass = candidate.M() * MeVtoGeV;
488  const float resonance_Eta = candidate.Eta();
489  if (muonCandidates[n]->charge()==muonCandidates[m]->charge()) continue;
490  if ((candidate.M() < m_ZBosonSelection_minMass)&&(resonanceName=="Z")) continue;
491  if ((candidate.M() > m_ZBosonSelection_maxMass)&&(resonanceName=="Z")) continue;
492  if ((candidate.M() < m_JpsiSelection_minMass)&&(resonanceName=="Jpsi")) continue;
493  if ((candidate.M() > m_JpsiSelection_maxMass)&&(resonanceName=="Jpsi")) continue;
494 
495  if (mapTagged_Resonance[n]!=1) vecMuons.push_back(muonCandidates[n]);
496  mapTagged_Resonance[n]=1;
497  if (mapTagged_Resonance[m]!=1) vecMuons.push_back(muonCandidates[m]);
498  mapTagged_Resonance[m]=1;
499 
500  if (muonCandidates[n]->charge()<0){
501  muMinusEta = tVec1.Eta();
502  muPlusEta = tVec2.Eta();
503  }
504  else{
505  muMinusEta = tVec2.Eta();
506  muPlusEta = tVec1.Eta();
507  }
508  const char* EtaReg = "";
509  int EtaRegio = -9;
510  if ((muMinusEta>1.05)&&(muPlusEta>1.05)){
511  EtaReg = "EA_EA";
512  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
513  Mass2D = resonance_Mass;
514  fill(tool, Mass2D);
515  } else if ((muMinusEta>1.05)&&(muPlusEta>0.)&&(muPlusEta<1.05)){
516  EtaReg = "EA_BA";
517  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
518  Mass2D = resonance_Mass;
519  fill(tool, Mass2D);
520  } else if ((muMinusEta>1.05)&&(muPlusEta>-1.05)&&(muPlusEta<0.)){
521  EtaReg = "EA_BC";
522  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
523  Mass2D = resonance_Mass;
524  fill(tool, Mass2D);
525  } else if ((muMinusEta>1.05)&&(muPlusEta<-1.05)){
526  EtaReg = "EA_EC";
527  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
528  Mass2D = resonance_Mass;
529  fill(tool, Mass2D);
530  } else if ((muMinusEta>0.)&&(muMinusEta<1.05)&&(muPlusEta>1.05)){
531  EtaReg = "BA_EA";
532  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
533  Mass2D = resonance_Mass;
534  fill(tool, Mass2D);
535  } else if ((muMinusEta>0.)&&(muMinusEta<1.05)&&(muPlusEta>0.)&&(muPlusEta<1.05)){
536  EtaReg = "BA_BA";
537  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
538  Mass2D = resonance_Mass;
539  fill(tool, Mass2D);
540  } else if ((muMinusEta>0.)&&(muMinusEta<1.05)&&(muPlusEta>-1.05)&&(muPlusEta<0.)){
541  EtaReg = "BA_BC";
542  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
543  Mass2D = resonance_Mass;
544  fill(tool, Mass2D);
545  } else if ((muMinusEta>0.)&&(muMinusEta<1.05)&&(muPlusEta<-1.05)){
546  EtaReg = "BA_EC";
547  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
548  Mass2D = resonance_Mass;
549  fill(tool, Mass2D);
550  } else if ((muMinusEta>-1.05)&&(muMinusEta<0.)&&(muPlusEta>1.05)){
551  EtaReg = "BC_EA";
552  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
553  Mass2D = resonance_Mass;
554  fill(tool, Mass2D);
555  } else if ((muMinusEta>-1.05)&&(muMinusEta<0.)&&(muPlusEta>0.)&&(muPlusEta<1.05)){
556  EtaReg = "BC_BA";
557  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
558  Mass2D = resonance_Mass;
559  fill(tool, Mass2D);
560  } else if ((muMinusEta>-1.05)&&(muMinusEta<0.)&&(muPlusEta>-1.05)&&(muPlusEta<0.)){
561  EtaReg = "BC_BC";
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)&&(muMinusEta<0.)&&(muPlusEta<-1.05)){
566  EtaReg = "BC_EC";
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)){
571  EtaReg = "EC_EA";
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>0.)&&(muPlusEta<1.05)){
576  EtaReg = "EC_BA";
577  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
578  Mass2D = resonance_Mass;
579  fill(tool, Mass2D);
580  } else if ((muMinusEta<-1.05)&&(muPlusEta>-1.05)&&(muPlusEta<0.)){
581  EtaReg = "EC_BC";
582  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
583  Mass2D = resonance_Mass;
584  fill(tool, Mass2D);
585  } else if ((muMinusEta<-1.05)&&(muPlusEta<-1.05)){
586  EtaReg = "EC_EC";
587  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
588  Mass2D = resonance_Mass;
589  fill(tool, Mass2D);
590  } else {
591  EtaReg = "out";
592  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
593  }
594  Mass = resonance_Mass;
595  Eta = resonance_Eta;
596  Eta2D = EtaReg;
597  Eta2 = EtaRegio;
598  fill(tool, Mass, Eta, Eta2, Eta2D, muMinusEta, muPlusEta);
599 
600  MuonLumiBlock = lumiBlockID;
601  fill(tool, MuonLumiBlock);
602  }
603  }
604 
606  ATH_CHECK( FillMuonInformation(resonanceName, vecMuons, pvtx, evt) );
607 
608  return StatusCode::SUCCESS;
609 }
610 
611 
612 //========================================================================================================
613 StatusCode MuonTrackMonitorAlgorithm::analyseResonanceCandidates(const xAOD::MuonContainer& Muons, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const {
614 
615  std::vector<const xAOD::Muon*> vecMuons_ZBoson_Candidates;
616  std::vector<const xAOD::Muon*> vecMuons_Jpsi_Candidates;
617 
619  for(const auto muon : Muons) {
620  xAOD::Muon::MuonType muonType = muon->muonType();
621  if (muonType==xAOD::Muon::Combined) {
622  const xAOD::TrackParticle *cbtp = nullptr;
623  ElementLink<xAOD::TrackParticleContainer> cbtpLink = muon->combinedTrackParticleLink();
624  if (cbtpLink.isValid()) cbtp = *cbtpLink;
625 
627  if (cbtp) {
628  float trkiso = muon->isolation(xAOD::Iso::ptcone30)/muon->pt();
629  if (muonType==xAOD::Muon::Combined &&
630  cbtp &&
631  muon->pt()>m_ZBosonSelection_minPt &&
632  std::abs(muon->eta())<m_ZBosonSelection_maxEta &&
633  trkiso<m_ZBosonSelection_trkIsolation &&
634  std::abs(cbtp->z0())<m_ZBosonSelection_Z0Cut &&
635  std::abs(cbtp->d0())<m_ZBosonSelection_D0Cut )
636  vecMuons_ZBoson_Candidates.push_back(muon);
637  if (muonType==xAOD::Muon::Combined &&
638  cbtp &&
639  muon->pt()>m_JpsiSelection_minPt &&
640  std::abs(muon->eta())<m_JpsiSelection_maxEta &&
641  trkiso<m_JpsiSelection_trkIsolation &&
642  std::abs(cbtp->z0())<m_JpsiSelection_Z0Cut &&
643  std::abs(cbtp->d0())<m_JpsiSelection_D0Cut )
644  vecMuons_Jpsi_Candidates.push_back(muon);
645  }
646  }
647  }
648 
649  ATH_CHECK( plotResonanceCandidates("Z", vecMuons_ZBoson_Candidates, pvtx, evt) );
650  ATH_CHECK( plotResonanceCandidates("Jpsi", vecMuons_Jpsi_Candidates, pvtx, evt) );
651 
652  return StatusCode::SUCCESS;
653 }
654 
655 
656 //========================================================================================================
657 StatusCode MuonTrackMonitorAlgorithm::fillHistograms(const EventContext& ctx) const
658 {
659  using namespace Monitored;
660 
662  if ((!m_derEventInfoKey.empty()) && (!m_MuonContainerKey.empty()) && (!m_VertexContainerKey.empty())) {
663  SG::ReadHandle<xAOD::EventInfo> EventInfo{m_derEventInfoKey, ctx};
664  if (ATH_UNLIKELY(! EventInfo.isValid())) {
665  ATH_MSG_ERROR("Unable to retrieve Event Info " << m_MuonContainerKey);
666  return StatusCode::FAILURE;
667  }
668 
669  const xAOD::Vertex *pvtx = nullptr;
670  SG::ReadHandle<xAOD::VertexContainer> Vertices{m_VertexContainerKey, ctx};
671  if (!Vertices.isValid()) {
672  ATH_MSG_ERROR("Unable to retrieve Vertex container" << m_VertexContainerKey);
673  return StatusCode::FAILURE;
674  }
675  else {
676  pvtx = getPrimaryVertex(*Vertices);
677  }
678 
679  SG::ReadHandle<xAOD::MuonContainer> Muons{m_MuonContainerKey, ctx};
680  if (ATH_UNLIKELY(! Muons.isValid())) {
681  ATH_MSG_ERROR("Unable to retrieve muon container " << m_MuonContainerKey);
682  return StatusCode::FAILURE;
683  }
684 
685  ATH_CHECK( analyseCombinedTracks(*Muons, pvtx, *EventInfo) );
686  ATH_CHECK( analyseResonanceCandidates(*Muons, pvtx, *EventInfo) );
687 
688  }
689 
690  return StatusCode::SUCCESS;
691 }
692 
693 
694 //========================================================================================================
695 const xAOD::Vertex* MuonTrackMonitorAlgorithm::getPrimaryVertex(const xAOD::VertexContainer& Vertices) const
696 {
697  const xAOD::Vertex *pvtx = nullptr;
698  for(const auto vertex : Vertices){
699  if (vertex->vertexType() == xAOD::VxType::PriVtx) {
700  pvtx = vertex;
701  }
702  }
703  return pvtx;
704 }
xAOD::phiLayer1Hits
@ phiLayer1Hits
number of phi hits in the first trigger layer (BML1 ot T4)
Definition: TrackingPrimitives.h:348
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
MuonTrackMonitorAlgorithm::m_MuonIsoDecorKey
SG::ReadDecorHandleKey< xAOD::MuonContainer > m_MuonIsoDecorKey
Definition: MuonTrackMonitorAlgorithm.h:35
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
xAOD::etaLayer1Hits
@ etaLayer1Hits
number of eta hits in the first trigger layer (BML1 ot T4)
Definition: TrackingPrimitives.h:353
MuonTrackMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override
adds event to the monitoring histograms
Definition: MuonTrackMonitorAlgorithm.cxx:657
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:350
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
max
#define max(a, b)
Definition: cfImp.cxx:41
TrackParticlexAODHelpers.h
xAOD::phiLayer4Hits
@ phiLayer4Hits
number of phi hits in the fourth trigger layer (T3)
Definition: TrackingPrimitives.h:351
MuonTrackMonitorAlgorithm::m_JpsiSelection_minMass
Gaudi::Property< float > m_JpsiSelection_minMass
Definition: MuonTrackMonitorAlgorithm.h:85
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
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:346
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
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:736
MuonTrackMonitorAlgorithm::m_ZBosonSelection_minPt
Gaudi::Property< float > m_ZBosonSelection_minPt
Definition: MuonTrackMonitorAlgorithm.h:72
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:189
MuonTrackMonitorAlgorithm::m_JpsiSelection_trkIsolation
Gaudi::Property< float > m_JpsiSelection_trkIsolation
Definition: MuonTrackMonitorAlgorithm.h:82
xAOD::Iso::ptcone30
@ ptcone30
Definition: IsolationType.h:41
CP::MeVtoGeV
constexpr float MeVtoGeV
Definition: IsolationCloseByCorrectionTool.cxx:33
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:86
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:259
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:275
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:613
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
Trk::Z0
@ Z0
Definition: ParameterType.h:18
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
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:355
AthMonitorAlgorithm
Base class for Athena Monitoring Algorithms.
Definition: AthMonitorAlgorithm.h:36
MuonTrackMonitorAlgorithm::m_ZBosonSelection_maxMass
Gaudi::Property< float > m_ZBosonSelection_maxMass
Definition: MuonTrackMonitorAlgorithm.h:78
xAOD::phiLayer2Hits
@ phiLayer2Hits
number of phi hits in the second trigger layer (BML2 ot T1)
Definition: TrackingPrimitives.h:349
MuonTrackMonitorAlgorithm::getPrimaryVertex
const xAOD::Vertex * getPrimaryVertex(const xAOD::VertexContainer &Vertices) const
Function to get the primary vertex.
Definition: MuonTrackMonitorAlgorithm.cxx:695
xAOD::etaLayer2Hits
@ etaLayer2Hits
number of eta hits in the second trigger layer (BML2 ot T1)
Definition: TrackingPrimitives.h:354
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:30
beamspotman.n
n
Definition: beamspotman.py:731
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:571
MuonTrackMonitorAlgorithm::m_JpsiSelection_minPt
Gaudi::Property< float > m_JpsiSelection_minPt
Definition: MuonTrackMonitorAlgorithm.h:80
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
hist_file_dump.f
f
Definition: hist_file_dump.py:135
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:581
MuonTrackMonitorAlgorithm::m_JpsiSelection_maxEta
Gaudi::Property< float > m_JpsiSelection_maxEta
Definition: MuonTrackMonitorAlgorithm.h:81
MuonTrackMonitorAlgorithm::m_JpsiSelection_D0Cut
Gaudi::Property< float > m_JpsiSelection_D0Cut
Definition: MuonTrackMonitorAlgorithm.h:83
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:73
MuonTrackMonitorAlgorithm::m_ZBosonSelection_trkIsolation
Gaudi::Property< float > m_ZBosonSelection_trkIsolation
Definition: MuonTrackMonitorAlgorithm.h:74
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:461
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
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:453
MuonTrackMonitorAlgorithm::m_ZBosonSelection_Z0Cut
Gaudi::Property< float > m_ZBosonSelection_Z0Cut
Definition: MuonTrackMonitorAlgorithm.h:76
charge
double charge(const T &p)
Definition: AtlasPID.h:538
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:75
MuonTrackMonitorAlgorithm::m_JpsiSelection_Z0Cut
Gaudi::Property< float > m_JpsiSelection_Z0Cut
Definition: MuonTrackMonitorAlgorithm.h:84
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:268
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:255
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:70
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:356
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:237
MuonTrackMonitorAlgorithm::m_hltchainList
Gaudi::Property< std::vector< std::string > > m_hltchainList
Definition: MuonTrackMonitorAlgorithm.h:68
MuonTrackMonitorAlgorithm::m_ZBosonSelection_minMass
Gaudi::Property< float > m_ZBosonSelection_minMass
Definition: MuonTrackMonitorAlgorithm.h:77
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 Thu Nov 7 2024 21:22:30 for ATLAS Offline Software by   doxygen 1.8.18