ATLAS Offline Software
MuonPhysValMonitoringTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // MuonPhysValMonitoringTool.cxx
6 // Implementation file for class MuonPhysValMonitoringTool
7 // Author: S.Binet<binet@cern.ch>
9 
10 // PhysVal includes
11 #include "MuonPhysValMonitoringTool.h"
12 
13 
14 
15 #include "GaudiKernel/IToolSvc.h"
16 #include "MuonHistUtils/MuonEnumDefs.h"
17 
18 #include "xAODBase/IParticleHelpers.h"
19 #include "xAODCore/ShallowCopy.h"
20 #include "xAODMuon/MuonAuxContainer.h"
21 #include "xAODMuon/MuonContainer.h"
22 #include "xAODMuon/SlowMuonAuxContainer.h"
23 #include "xAODMuon/SlowMuonContainer.h"
24 #include "xAODTrigMuon/L2CombinedMuonContainer.h"
25 #include "xAODTrigMuon/L2StandAloneMuonContainer.h"
26 #include "xAODTrigger/MuonRoI.h"
27 #include "xAODTrigger/MuonRoIContainer.h"
28 #include "AthContainers/ConstAccessor.h"
29 
30 #include "xAODTruth/TruthVertexAuxContainer.h"
31 #include "xAODTruth/TruthVertexContainer.h"
32 #include "FourMomUtils/xAODP4Helpers.h"
33 #include "TruthUtils/HepMCHelpers.h"
34 
35 #include "TString.h"
36 #include <cmath>
37 #include <limits>
38 
39 
40 namespace{
41  using TrackLink = ElementLink<xAOD::TrackParticleContainer>;
42  using MuonLink = ElementLink<xAOD::MuonContainer>;
43  using MuonSegmentLink = ElementLink<xAOD::MuonSegmentContainer>;
44  using TruthLink = ElementLink<xAOD::TruthParticleContainer>;
45 
46  constexpr int comm_bit = (1<<xAOD::Muon::Commissioning);
47 }
48 using namespace xAOD::P4Helpers;
49 
50 namespace MuonPhysValMonitoring {
51 
53  // Public methods:
55 
56  // utilities
57  float getMatchingProbability(const xAOD::TrackParticle& trackParticle) {
58  static const SG::ConstAccessor<float> truthMatchProbabilityAcc("truthMatchProbability");
59  return truthMatchProbabilityAcc.withDefault (trackParticle,
60  std::numeric_limits<float>::quiet_NaN());
61  }
62 
63  // Constructors
65 
66  MuonPhysValMonitoringTool::MuonPhysValMonitoringTool(const std::string& type, const std::string& name, const IInterface* parent) :
67  ManagedMonitorToolBase(type, name, parent),
68  m_counterBits(),
69  m_muonItems(),
70  m_L1Seed() {
71  }
72 
73  // Athena algtool's Hooks
75  StatusCode MuonPhysValMonitoringTool::initialize() {
76  ATH_MSG_INFO("Initializing " << name() << "...");
77  ATH_CHECK(ManagedMonitorToolBase::initialize());
78 
79  if (!m_slowMuonsName.empty()) m_muonsName = m_slowMuonsName;
80 
81  for (unsigned int i = 0; i < m_selectHLTMuonItems.size(); i++) {
82  if (m_selectHLTMuonItems[i][0] == "" || m_selectHLTMuonItems[i][1] == "") continue;
83  m_muonItems.emplace_back(m_selectHLTMuonItems[i][0]);
84  m_L1Seed.emplace_back(m_selectHLTMuonItems[i][1]);
85  }
86 
87  // setup flags
88  if (m_doTrigMuonValidation == false) {
89  m_doTrigMuonL1Validation = false;
90  m_doTrigMuonL2Validation = false;
91  m_doTrigMuonEFValidation = false;
92  }
93  ATH_CHECK(m_trigDec.retrieve(DisableTool{!m_doTrigMuonValidation}));
94 
95  ATH_CHECK(m_eventInfo.initialize());
96  ATH_CHECK(m_muonSelectionTool.retrieve());
97  ATH_CHECK(m_trackSelector.retrieve());
98  ATH_CHECK(m_isoTool.retrieve());
99 
100  return StatusCode::SUCCESS;
101  }
102 
103 
104 
105  StatusCode MuonPhysValMonitoringTool::bookHistograms() {
106  ATH_MSG_INFO("Booking hists " << name() << "...");
107 
108  if (m_selectMuonWPs.size() == 1 && m_selectMuonWPs[0] < 0) m_selectMuonWPs.clear();
109 
110  if (m_selectMuonAuthors.size() == 1 && m_selectMuonAuthors[0] == 0) m_selectMuonAuthors.clear();
111 
112  static const std::map<int,std::string> theMuonCategories = {
113  {ALL, "All"},
114  {PROMPT, "Prompt"},
115  {INFLIGHT, "InFlight"},
116  {NONISO, "NonIsolated"},
117  {REST, "Rest"}
118  };
119 
120  for (const auto& category : m_selectMuonCategories) m_selectMuonCategoriesStr.emplace_back(theMuonCategories.at(category));
121 
122  // no such muons in case of SlowMuon reco
123  bool separateSAFMuons = m_slowMuonsName.empty();
124 
125  std::string muonContainerName = m_muonsName;
126  for (const auto& category : m_selectMuonCategoriesStr) {
127  std::string categoryPath = m_muonsName + "/" + category + "/";
128 
129  m_muonValidationPlots.emplace_back(std::make_unique<MuonValidationPlots>(
130  nullptr, categoryPath, m_selectMuonWPs, m_selectMuonAuthors, m_isData,
131  (category == theMuonCategories.at(ALL) ? false : m_doBinnedResolutionPlots.value()), separateSAFMuons, m_doMuonTree));
132 
133  if (!m_slowMuonsName.empty()) m_slowMuonValidationPlots.emplace_back(std::make_unique<SlowMuonValidationPlots>(nullptr, categoryPath, m_isData));
134  if (m_doTrigMuonValidation) {
135  if (category == "All") {
136  m_TriggerMuonValidationPlots.emplace_back(std::make_unique<TriggerMuonValidationPlots>(
137  nullptr, categoryPath, m_selectMuonAuthors, m_isData, m_doTrigMuonL1Validation, m_doTrigMuonL2Validation,
138  m_doTrigMuonEFValidation, m_selectHLTMuonItems, m_L1MuonItems));
139  }
140  }
141  if (!m_muonTracksName.empty()) {
142  m_muonMSTrackValidationPlots.emplace_back(std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "MSTrackParticles", m_isData));
143  if (!m_isData)
144  m_oUnmatchedRecoMuonTrackPlots = std::make_unique<Muon::RecoMuonTrackPlotOrganizer>(nullptr, muonContainerName + "/UnmatchedRecoMuonTracks/");
145  }
146  if (!m_muonExtrapolatedTracksName.empty())
147  m_muonMETrackValidationPlots.emplace_back(std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "METrackParticles", m_isData));
148  if (!m_muonMSOnlyExtrapolatedTracksName.empty())
149  m_muonMSOnlyMETrackValidationPlots.emplace_back(
150  std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "MSOnlyMETrackParticles", m_isData));
151 
152  if (!m_tracksName.empty()) {
153  m_muonIDTrackValidationPlots.emplace_back(std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "IDTrackParticles", m_isData));
154  m_muonIDSelectedTrackValidationPlots.emplace_back(
155  std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "IDSelectedTrackParticles", m_isData));
156  }
157  if (!m_fwdtracksName.empty())
158  m_muonIDForwardTrackValidationPlots.emplace_back(
159  std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "IDForwardTrackParticles", m_isData));
160 
161  if (!m_muonSegmentsName.empty()) {
162  if (category != theMuonCategories.at(ALL)) continue; // cannot identify the truth origin of segments...
163  m_muonSegmentValidationPlots.emplace_back(std::make_unique<MuonSegmentValidationPlots>(nullptr, categoryPath, m_isData));
164  if (!m_isData)
165  m_oUnmatchedRecoMuonSegmentPlots.reset(
166  new Muon::MuonSegmentPlots(nullptr, Form("%s/UnmatchedRecoMuonSegments/", muonContainerName.c_str())));
167  }
168  }
169 
170  if (!m_isData) {
171  m_oUnmatchedRecoMuonPlots = std::make_unique<Muon::RecoMuonPlotOrganizer>(nullptr, muonContainerName +"/UnmatchedRecoMuons/");
172  m_oUnmatchedTruthMuonPlots = std::make_unique<Muon::TruthMuonPlotOrganizer>(nullptr, muonContainerName +"/UnmatchedTruthMuons/");
173  }
174 
175  for (const auto& plots : m_muonValidationPlots) bookValidationPlots(*plots).ignore();
176  for (const auto& plots : m_slowMuonValidationPlots) bookValidationPlots(*plots).ignore();
177  for (const auto& plots : m_TriggerMuonValidationPlots) bookValidationPlots(*plots).ignore();
178  for (const auto& plots : m_muonIDTrackValidationPlots) bookValidationPlots(*plots).ignore();
179  for (const auto& plots : m_muonIDSelectedTrackValidationPlots) bookValidationPlots(*plots).ignore();
180  for (const auto& plots : m_muonIDForwardTrackValidationPlots) bookValidationPlots(*plots).ignore();
181  for (const auto& plots : m_muonMSTrackValidationPlots) bookValidationPlots(*plots).ignore();
182  for (const auto& plots : m_muonMETrackValidationPlots) bookValidationPlots(*plots).ignore();
183  for (const auto& plots : m_muonMSOnlyMETrackValidationPlots) bookValidationPlots(*plots).ignore();
184  if (!m_isData) {
185  bookValidationPlots(*m_oUnmatchedRecoMuonPlots).ignore();
186  bookValidationPlots(*m_oUnmatchedTruthMuonPlots).ignore();
187  if (m_oUnmatchedRecoMuonTrackPlots) bookValidationPlots(*m_oUnmatchedRecoMuonTrackPlots).ignore();
188  for (const auto& plots : m_muonSegmentValidationPlots) bookValidationPlots(*plots).ignore();
189  if (m_oUnmatchedRecoMuonSegmentPlots) bookValidationPlots(*m_oUnmatchedRecoMuonSegmentPlots).ignore();
190  }
191  // book overview hists
192  m_h_overview_Z_mass = new TH1F(Form("%s_Overview_Z_mass", muonContainerName.c_str()), "", 20, 76, 106);
193  ATH_CHECK(regHist(m_h_overview_Z_mass, Form("%s/Overview", muonContainerName.c_str()), all));
194  m_h_overview_Z_mass_ME = new TH1F(Form("%s_Overview_Z_mass_ME", muonContainerName.c_str()), "", 20, 76, 106);
195  ATH_CHECK(regHist(m_h_overview_Z_mass_ME, Form("%s/Overview", muonContainerName.c_str()), all));
196  m_h_overview_Z_mass_ID = new TH1F(Form("%s_Overview_Z_mass_ID", muonContainerName.c_str()), "", 20, 76, 106);
197  ATH_CHECK(regHist(m_h_overview_Z_mass_ID, Form("%s/Overview", muonContainerName.c_str()), all));
198 
199  m_h_overview_nObjects.clear();
200  m_h_overview_nObjects.emplace_back(new TH1F(Form("%s_Overview_N_perevent_truth_muons", muonContainerName.c_str()),
201  "Number of truth Muons per event", 20, -0.5, 19.5));
202  m_h_overview_nObjects.emplace_back(
203  new TH1F(Form("%s_Overview_N_perevent_muons", muonContainerName.c_str()), "Number of Muons per event", 20, -0.5, 19.5));
204  m_h_overview_nObjects.emplace_back(
205  new TH1F(Form("%s_Overview_N_perevent_tracks", muonContainerName.c_str()), "Number of Tracks per event", 50, -0.5, 49.5));
206  m_h_overview_nObjects.emplace_back(new TH1F(Form("%s_Overview_N_perevent_truth_segments", muonContainerName.c_str()),
207  "Number of truth Segments per event", 200, -0.5, 199.5));
208  m_h_overview_nObjects.emplace_back(
209  new TH1F(Form("%s_Overview_N_perevent_segments", muonContainerName.c_str()), "Number of Segments per event", 200, -0.5, 199.5));
210  for (const auto& hist : m_h_overview_nObjects) {
211  if (hist) ATH_CHECK(regHist(hist, Form("%s/Overview", muonContainerName.c_str()), all));
212  }
213 
214  m_h_overview_reco_category =
215  new TH1F(Form("%s_Overview_reco_category", muonContainerName.c_str()), "", 4, 0, 4); // prompt/in-flight/non-isolated/other
216  for (int i = 1; i < 4; i++) { // skip 'All'
217  m_h_overview_reco_category->GetXaxis()->SetBinLabel(i, theMuonCategories.at(i).c_str());
218  }
219  m_h_overview_reco_category->GetXaxis()->SetBinLabel(4, "Other"); // of some other origin or fakes
220  ATH_CHECK(regHist(m_h_overview_reco_category, Form("%s/Overview", muonContainerName.c_str()), all));
221 
222  int nAuth = xAOD::Muon::NumberOfMuonAuthors;
223  for (int i = 1; i < 4; i++) {
224  m_h_overview_reco_authors.emplace_back(new TH1F((m_muonsName + "_" + theMuonCategories.at(i) + "_reco_authors").c_str(),
225  (muonContainerName + "_" + theMuonCategories.at(i) + "_reco_authors").c_str(),
226  nAuth + 1, -0.5, nAuth + 0.5));
227  }
228  m_h_overview_reco_authors.emplace_back(new TH1F((m_muonsName + "_Overview_Other_reco_authors").c_str(),
229  (muonContainerName + "_Other_reco_authors").c_str(), nAuth + 1, -0.5, nAuth + 0.5));
230 
231  for (const auto& hist : m_h_overview_reco_authors) {
232  if (hist) ATH_CHECK(regHist(hist, Form("%s/Overview", muonContainerName.c_str()), all));
233  }
234 
235  return StatusCode::SUCCESS;
236  }//bookHistograms*/
237 
238  StatusCode MuonPhysValMonitoringTool::bookValidationPlots(PlotBase& valPlots) {
239  valPlots.initialize();
240  std::vector<HistData> hists = valPlots.retrieveBookedHistograms();
241 
242  for (auto& hist : hists) {
243  TString sHistName = hist.first->GetName();
244  ATH_MSG_VERBOSE("Initializing " << hist.first << " " << sHistName << " " << hist.second << "...");
245 
246  // check for histograms that are useless and skip regHist:
247  if (sHistName.Contains("momentumPulls")) {
248  if (sHistName.Contains(Muon::EnumDefs::toString(xAOD::Muon::MuidSA))) continue; // empty for standalone muons
249  if (!(sHistName.Contains("Prompt") && (sHistName.Contains("AllMuons") || sHistName.Contains("SiAssocForward"))))
250  continue; // don't need binned eloss plots for separate muon types, keep only for Prompt AllMuons
251  }
252  if ((sHistName.Contains("resolution") || sHistName.Contains("pulls")) && !sHistName.Contains("Prompt"))
253  continue; // don't need resolution plots except for prompt muons
254  if (sHistName.Contains("trigger") && sHistName.Contains("wrt") && sHistName.Contains("Features")) continue;
255  modifyHistogram(hist.first);
256  ATH_CHECK(regHist(hist.first, hist.second, all));
257  }
258 
259  // register trees
260  std::vector<TreeData> trees = valPlots.retrieveBookedTrees();
261  for (auto& tree : trees) {
262  std::string sTreeName = tree.first->GetName();
263  ATH_MSG_VERBOSE("Initializing " << tree.first << " " << sTreeName << " " << tree.second << "...");
264  ATH_CHECK(regTree(tree.first, tree.second, all));
265  }
266 
267  return StatusCode::SUCCESS;
268  }
269 
270  StatusCode MuonPhysValMonitoringTool::fillHistograms() {
271  ATH_MSG_DEBUG("Filling hists " << name() << "...");
272  m_vMatchedTruthMuons.clear();
273  m_vMatchedMuons.clear();
274  m_vMatchedSlowMuons.clear();
275  m_vMatchedMuonTracks.clear();
276  m_vMatchedMuonSegments.clear();
277  m_vZmumuIDTracks.clear();
278  m_vZmumuMETracks.clear();
279  m_vZmumuMuons.clear();
280  m_vEFMuons.clear();
281  m_vEFMuonsSelected.clear();
282  m_vL2SAMuons.clear();
283  m_vL2SAMuonsSelected.clear();
284  m_vL2CBMuons.clear();
285  m_vL2CBMuonsSelected.clear();
286  m_vRecoMuons.clear();
287  m_vRecoMuons_EffDen.clear();
288  m_vRecoMuons_EffDen_CB.clear();
289  m_vRecoMuons_EffDen_MS.clear();
290 
291  SG::ReadHandle<xAOD::EventInfo> eventInfoHandle(m_eventInfo);
292  if (!eventInfoHandle.isValid()) {
293  ATH_MSG_WARNING("Could not retrieve EventInfo, returning");
294  return StatusCode::SUCCESS;
295  }
296  const xAOD::EventInfo* eventInfo = eventInfoHandle.cptr();
297  m_isData = !eventInfo->eventType(xAOD::EventInfo::IS_SIMULATION);
298  float beamSpotWeight = eventInfo->beamSpotWeight();
299 
300  const xAOD::TruthParticleContainer* TruthMuons(nullptr);
301 
302  if (!m_isData) {
303  TruthMuons = evtStore()->tryConstRetrieve<xAOD::TruthParticleContainer>(m_muonsTruthName);
304  if (!TruthMuons) {
305  ATH_MSG_ERROR("Couldn't retrieve TruthMuons container with key: " << m_muonsTruthName);
306  return StatusCode::FAILURE;
307  }
308  ATH_MSG_DEBUG("Retrieved truth muons " << TruthMuons->size());
309  m_h_overview_nObjects[0]->Fill(TruthMuons->size(), beamSpotWeight);
310  }
311 
312  const xAOD::MuonContainer* Muons = nullptr;
313  const xAOD::SlowMuonContainer* SlowMuons = nullptr;
314  if (!m_slowMuonsName.empty()) {
315  SlowMuons = getContainer<xAOD::SlowMuonContainer>(m_slowMuonsName);
316  if (!SlowMuons) {
317  ATH_MSG_WARNING("Couldn't retrieve SlowMuons container with key: " << m_slowMuonsName);
318  return StatusCode::SUCCESS;
319  }
320  ATH_MSG_DEBUG("Retrieved slow muons " << SlowMuons->size());
321  m_h_overview_nObjects[1]->Fill(SlowMuons->size(), beamSpotWeight);
322  } else {
323  Muons = getContainer<xAOD::MuonContainer>(m_muonsName);
324  if (!Muons) { return StatusCode::SUCCESS; }
325  ATH_MSG_DEBUG("Retrieved muons " << Muons->size());
326  m_h_overview_nObjects[1]->Fill(Muons->size(), beamSpotWeight);
327  }
328 
330  // @@@ Temp hack to get the MuonSpectrometerTrackParticle (@MS Entry, not extrapolated), needed for eloss plots
331  // Remove when the link to the real MuonSpectrometerTrackParticle appears in the xAOD muon
332  if (evtStore()->contains<xAOD::TrackParticleContainer>("MuonSpectrometerTrackParticles")) {
333  m_MSTracks = getContainer<xAOD::TrackParticleContainer>("MuonSpectrometerTrackParticles");
334  if (!m_MSTracks) {
335  ATH_MSG_WARNING("Couldn't retrieve MS Tracks container");
336  return StatusCode::SUCCESS;
337  } else
338  ATH_MSG_DEBUG("Retrieved muon tracks " << m_MSTracks->size());
339  } else
340  ATH_MSG_DEBUG("Couldn't find MS Tracks container");
341 
343 
344  // Do resonance selection
345  std::vector<std::pair<const xAOD::Muon*, const xAOD::Muon*> > pairs;
346  if (Muons) {
347  // Use iterator loop to avoid double counting
348  for (xAOD::MuonContainer::const_iterator mu1_itr = Muons->begin(); mu1_itr != Muons->end(); ++mu1_itr) {
349  const xAOD::Muon* mu1 = (*mu1_itr);
350  if (!m_selectComissioning && mu1->allAuthors() & comm_bit) continue;
351  for (xAOD::MuonContainer::const_iterator mu2_itr = Muons->begin(); mu2_itr != mu1_itr; ++mu2_itr) {
352  const xAOD::Muon* mu2 = (*mu2_itr);
353  if (!m_selectComissioning && mu2->allAuthors() & comm_bit) continue;
354  if (mu1->charge() * mu2->charge() >= 0) continue;
355  pairs.emplace_back(std::make_pair(mu1, mu2));
356  }
357  }
358  }
359 
360  float dMmin {1e10}, mZ{0.};
361  for (std::pair<const xAOD::Muon*, const xAOD::Muon*>& x : pairs) {
362  // select best Z
363  const TLorentzVector mu1{x.first->p4()}, mu2{x.second->p4()};
364  const float M = (mu1 + mu2).M();
365  if (M < 66000. || M > 116000.) continue;
366 
367  // choose the Z candidate closest to the Z pole - if multiple exist
368  float dM = std::abs(M - 91187.);
369  if (dM > dMmin) continue;
370  dMmin = dM;
371  mZ = M;
372 
373  m_vZmumuMuons.clear();
374  m_vZmumuMuons.emplace_back(x.first);
375  m_vZmumuMuons.emplace_back(x.second);
376  }
377 
378  if (m_vZmumuMuons.size() == 2) {
379  m_h_overview_Z_mass->Fill(mZ / 1000., beamSpotWeight);
380 
381  const xAOD::TrackParticle* metr1 = m_vZmumuMuons[0]->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
382  const xAOD::TrackParticle* metr2 = m_vZmumuMuons[1]->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
383  if (metr1 && metr2) {
384  const TLorentzVector mu1ME{metr1->p4()}, mu2ME{metr2->p4()};
385  m_h_overview_Z_mass_ME->Fill((mu1ME + mu2ME).M() / 1000., beamSpotWeight);
386  if (m_isData) {
387  m_vZmumuMETracks.clear();
388  m_vZmumuMETracks.emplace_back(metr1);
389  m_vZmumuMETracks.emplace_back(metr2);
390  }
391  }
392 
393  const xAOD::TrackParticle* tr1 = m_vZmumuMuons[0]->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
394  const xAOD::TrackParticle* tr2 = m_vZmumuMuons[1]->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
395  if (tr1 && tr2) {
396  const TLorentzVector mu1ID{tr1->p4()}, mu2ID{tr2->p4()};
397  m_h_overview_Z_mass_ID->Fill((mu1ID + mu2ID).M() / 1000., beamSpotWeight);
398  if (m_isData) {
399  m_vZmumuIDTracks.clear();
400  m_vZmumuIDTracks.emplace_back(tr1);
401  m_vZmumuIDTracks.emplace_back(tr2);
402  }
403  }
404  }
405 
406  if (!m_isData) {
407  for (const auto truthMu : *TruthMuons) handleTruthMuon(truthMu, beamSpotWeight);
408  }
409 
410  if (SlowMuons) {
411  for (const auto smu : *SlowMuons) {
412  if (!smu) continue;
413  const MuonLink link = smu->muonLink();
414  if (!link.isValid()) continue;
415  handleMuon(*link, smu, beamSpotWeight);
416  }
417  } else if (Muons) {
418  for (const auto mu : *Muons) handleMuon(mu, nullptr, beamSpotWeight);
419  }
420 
421  if (m_doMuonTree) { handleMuonTrees(eventInfo, m_isData); }
422 
423  if (!m_tracksName.empty()) {
424  auto IDTracks = getContainer<xAOD::TrackParticleContainer>(m_tracksName);
425  if (!IDTracks) return StatusCode::FAILURE;
426  ATH_MSG_DEBUG("handling " << IDTracks->size() << " " << m_tracksName);
427  for (const auto tp : *IDTracks) handleMuonTrack(tp, xAOD::Muon::InnerDetectorTrackParticle, beamSpotWeight);
428  }
429  if (!m_fwdtracksName.empty()) {
430  auto FwdIDTracks = getContainer<xAOD::TrackParticleContainer>(m_fwdtracksName);
431  if (!FwdIDTracks) return StatusCode::FAILURE;
432  ATH_MSG_DEBUG("handling " << FwdIDTracks->size() << " " << m_fwdtracksName);
433  for (const auto tp : *FwdIDTracks) handleMuonTrack(tp, xAOD::Muon::InnerDetectorTrackParticle, beamSpotWeight);
434  }
435  if (!m_muonTracksName.empty()) {
436  auto MuonTracks = getContainer<xAOD::TrackParticleContainer>(m_muonTracksName);
437  if (!MuonTracks) return StatusCode::FAILURE;
438  ATH_MSG_DEBUG("handling " << MuonTracks->size() << " " << m_muonTracksName);
439  m_h_overview_nObjects[2]->Fill(MuonTracks->size(), beamSpotWeight);
440  for (const auto tp : *MuonTracks) handleMuonTrack(tp, xAOD::Muon::MuonSpectrometerTrackParticle, beamSpotWeight);
441  }
442  if (!m_muonExtrapolatedTracksName.empty()) {
443  auto MuonExtrapolatedTracks = getContainer<xAOD::TrackParticleContainer>(m_muonExtrapolatedTracksName);
444  if (!MuonExtrapolatedTracks) return StatusCode::FAILURE;
445  ATH_MSG_DEBUG("handling " << MuonExtrapolatedTracks->size() << " " << m_muonExtrapolatedTracksName);
446  for (const auto tp : *MuonExtrapolatedTracks)
447  handleMuonTrack(tp, xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle, beamSpotWeight);
448  }
449 
450  if (!m_muonMSOnlyExtrapolatedTracksName.empty() &&
451  evtStore()->contains<xAOD::TrackParticleContainer>(m_muonMSOnlyExtrapolatedTracksName)) {
452  auto MSOnlyMuonExtrapolatedTracks = getContainer<xAOD::TrackParticleContainer>(m_muonMSOnlyExtrapolatedTracksName);
453  if (!MSOnlyMuonExtrapolatedTracks) return StatusCode::FAILURE;
454  ATH_MSG_DEBUG("handling " << MSOnlyMuonExtrapolatedTracks->size() << " " << m_muonMSOnlyExtrapolatedTracksName);
455  for (const auto tp : *MSOnlyMuonExtrapolatedTracks)
456  handleMuonTrack(tp, xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle, beamSpotWeight);
457  }
458 
459  if (!m_muonSegmentsName.empty()) {
460  const xAOD::MuonSegmentContainer* TruthMuonSegments(nullptr);
461  if (!m_isData) {
462  TruthMuonSegments = getContainer<xAOD::MuonSegmentContainer>(m_muonSegmentsTruthName);
463  if (!TruthMuonSegments) { return StatusCode::SUCCESS; }
464  m_h_overview_nObjects[3]->Fill(TruthMuonSegments->size(), beamSpotWeight);
465  ATH_MSG_DEBUG("handling " << TruthMuonSegments->size() << " " << m_muonSegmentsTruthName);
466  for (const auto truthMuSeg : *TruthMuonSegments) handleTruthMuonSegment(truthMuSeg, TruthMuons, beamSpotWeight);
467  }
468 
469  const xAOD::MuonSegmentContainer* MuonSegments = getContainer<xAOD::MuonSegmentContainer>(m_muonSegmentsName);
470  if (!MuonSegments) { return StatusCode::SUCCESS; }
471  m_h_overview_nObjects[4]->Fill(MuonSegments->size(), beamSpotWeight);
472  ATH_MSG_DEBUG("handling " << MuonSegments->size() << " " << m_muonSegmentsName);
473  for (const auto muSeg : *MuonSegments) handleMuonSegment(muSeg, beamSpotWeight);
474  }
475 
476  //@@@@@@@@@@@@@@@@ TRIGGER MONITORING IMPLEMENTATION @@@@@@@@@@@@@@@@@
477  if (m_doTrigMuonValidation) {
478  auto chainGroups = m_trigDec->getChainGroup("HLT_.*mu.*");
479  for (auto& trig : chainGroups->getListOfTriggers()) {
480  if (m_trigDec->isPassed(trig, TrigDefs::EF_passedRaw)) {
481  ATH_MSG_DEBUG("Chain " << trig << " is passed: YES");
482  } else
483  ATH_MSG_DEBUG("Chain " << trig << " is passed: NO");
484  }
485  auto L1chainGroups = m_trigDec->getChainGroup("L1_MU.*");
486  for (auto& L1trig : L1chainGroups->getListOfTriggers()) {
487  if (m_trigDec->isPassed(L1trig, TrigDefs::EF_passedRaw))
488  ATH_MSG_DEBUG("Chain " << L1trig << " is passed: YES");
489  else
490  ATH_MSG_DEBUG("Chain " << L1trig << " is passed: NO");
491  }
492  for (auto mu : m_vRecoMuons) {
493  if (passesAcceptanceCuts(mu) && std::abs(mu->eta()) < 2.4) {
494  if (mu->author() == 1) {
495  m_vRecoMuons_EffDen_CB.emplace_back(mu);
496  ATH_MSG_DEBUG("##### m_vRecoMuons_EffDen_CB pt:" << mu->pt() << " phi:" << mu->phi() << " eta:" << mu->eta());
497  } else if (mu->author() == 5) {
498  m_vRecoMuons_EffDen_MS.emplace_back(mu);
499  ATH_MSG_DEBUG("##### m_vRecoMuons_EffDen_MS pt:" << mu->pt() << " phi:" << mu->phi() << " eta:" << mu->eta());
500  }
501  }
502  }
503 
504  //@@@@@ L1 @@@@@
505  if (m_doTrigMuonL1Validation) {
506  const xAOD::MuonRoIContainer* L1TrigMuons = getContainer<xAOD::MuonRoIContainer>(m_muonL1TrigName);
507  if (!L1TrigMuons) { return StatusCode::SUCCESS; }
508  ATH_MSG_DEBUG("Retrieved L1 triggered muons " << L1TrigMuons->size());
509  for (const auto TrigL1mu : *L1TrigMuons) handleMuonL1Trigger(TrigL1mu);
510  }
511 
512  //@@@@@ L2 @@@@@
513  if (m_doTrigMuonL2Validation) {
514  //@@@@@ L2SA @@@@@
515  const xAOD::L2StandAloneMuonContainer* L2SAMuons = getContainer<xAOD::L2StandAloneMuonContainer>(m_muonL2SAName);
516  if (!L2SAMuons) { return StatusCode::SUCCESS; }
517  ATH_MSG_DEBUG("Retrieved L2 StandAlone triggered muons " << L2SAMuons->size());
518  if (L2SAMuons->size() != 0) {
519  for (const auto L2SAmu : *L2SAMuons) {
520  ATH_MSG_DEBUG("Muon L2SA Trigger: pt " << L2SAmu->pt() << " phi " << L2SAmu->phi() << " eta " << L2SAmu->eta()
521  << " roiWord " << L2SAmu->roiWord() << " sAddress " << L2SAmu->sAddress());
522  m_vL2SAMuons.emplace_back(L2SAmu);
523  }
524  for (const auto& mu : m_vL2SAMuons) {
525  if (mu->pt() != 0.) {
526  m_vL2SAMuonsSelected.emplace_back(mu);
527  break;
528  }
529  }
530  for (unsigned int i = 0; i < m_vL2SAMuons.size(); i++) {
531  unsigned int cont = 0;
532  for (unsigned int j = 0; j < m_vL2SAMuonsSelected.size(); j++) {
533  if (((m_vL2SAMuons.at(i)->pt()) != 0.) && ((deltaR(m_vL2SAMuonsSelected.at(j), m_vL2SAMuons.at(i))) > 0.1))
534  cont++;
535  if (cont == m_vL2SAMuonsSelected.size()) {
536  m_vL2SAMuonsSelected.emplace_back(m_vL2SAMuons.at(i));
537  break;
538  }
539  }
540  }
541  for (unsigned int i = 0; i < m_vL2SAMuonsSelected.size(); i++) { handleMuonL2Trigger(m_vL2SAMuonsSelected.at(i)); }
542  L2SATriggerResolution();
543  }
544  for (const auto& muonItem : m_muonItems) {
545  std::vector<Trig::Feature<xAOD::L2StandAloneMuonContainer> > vec_muons;
546  TString muonItem_str = (TString)muonItem;
547  if (muonItem_str.Contains("_OR_")) {
548  muonItem_str.ReplaceAll("_OR_", " ");
549  TString delim = " ";
550  std::vector<TString> v_subchains;
551  SplitString(muonItem_str, delim, v_subchains);
552  for (int i = 0; i < (int)v_subchains.size(); i++) {
553  Trig::FeatureContainer fc1 = m_trigDec->features((std::string)v_subchains.at(i));
554  std::vector<Trig::Feature<xAOD::L2StandAloneMuonContainer> > vec_muons_1 =
555  fc1.get<xAOD::L2StandAloneMuonContainer>();
556  for (const auto& mufeat : vec_muons_1) { vec_muons.emplace_back(mufeat); }
557  }
558  } else {
559  Trig::FeatureContainer fc = m_trigDec->features(muonItem);
560  vec_muons = fc.get<xAOD::L2StandAloneMuonContainer>();
561  }
562  ATH_MSG_DEBUG("Size of vector Trig::Feature<xAOD::L2StandAloneMuonContainer> for chain " << muonItem << " = "
563  << vec_muons.size());
564  for (const auto& mufeat : vec_muons) {
565  ATH_MSG_DEBUG(muonItem << " vec_muons.size() = " << vec_muons.size()
566  << " mufeat.cptr()->size() = " << mufeat.cptr()->size());
567  for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
568  ATH_MSG_DEBUG("#####" << muonItem << " L2SA feature pt: " << (*mufeat.cptr())[i]->pt()
569  << " eta: " << (*mufeat.cptr())[i]->eta() << " phi: " << (*mufeat.cptr())[i]->phi());
570  }
571  }
572  }
573 
574  //@@@@@ L2CB @@@@@
575  const xAOD::L2CombinedMuonContainer* L2CBMuons = getContainer<xAOD::L2CombinedMuonContainer>(m_muonL2CBName);
576  if (!L2CBMuons) { return StatusCode::SUCCESS; }
577  ATH_MSG_DEBUG("Retrieved L2 Combined triggered muons " << L2CBMuons->size());
578  if (L2CBMuons->size() != 0) {
579  for (const auto L2CBmu : *L2CBMuons) {
580  ATH_MSG_DEBUG("Muon L2CB Trigger: pt " << L2CBmu->pt() << " phi " << L2CBmu->phi() << " eta " << L2CBmu->eta());
581  m_vL2CBMuons.emplace_back(L2CBmu);
582  }
583  for (unsigned int i = 0; i < m_vL2CBMuons.size(); i++) {
584  if ((m_vL2CBMuons.at(i)->pt()) != 0.) {
585  m_vL2CBMuonsSelected.emplace_back(m_vL2CBMuons.at(i));
586  break;
587  }
588  }
589  for (unsigned int i = 0; i < m_vL2CBMuons.size(); i++) {
590  unsigned int cont = 0;
591  for (unsigned int j = 0; j < m_vL2CBMuonsSelected.size(); j++) {
592  if (((m_vL2CBMuons.at(i)->pt()) != 0.) && ((deltaR(m_vL2CBMuonsSelected.at(j), m_vL2CBMuons.at(i))) > 0.1))
593  cont++;
594  if (cont == m_vL2CBMuonsSelected.size()) {
595  m_vL2CBMuonsSelected.emplace_back(m_vL2CBMuons.at(i));
596  break;
597  }
598  }
599  }
600  for (unsigned int i = 0; i < m_vL2CBMuonsSelected.size(); i++) { handleMuonL2Trigger(m_vL2CBMuonsSelected.at(i)); }
601  L2CBTriggerResolution();
602  }
603  for (const auto& muonItem : m_muonItems) {
604  std::vector<Trig::Feature<xAOD::L2CombinedMuonContainer> > vec_muons;
605  TString muonItem_str = (TString)muonItem;
606  if (muonItem_str.Contains("_OR_")) {
607  muonItem_str.ReplaceAll("_OR_", " ");
608  TString delim = " ";
609  std::vector<TString> v_subchains;
610  SplitString(muonItem_str, delim, v_subchains);
611  for (int i = 0; i < (int)v_subchains.size(); i++) {
612  Trig::FeatureContainer fc1 = m_trigDec->features((std::string)v_subchains.at(i));
613  std::vector<Trig::Feature<xAOD::L2CombinedMuonContainer> > vec_muons_1 =
614  fc1.get<xAOD::L2CombinedMuonContainer>();
615  for (const auto& mufeat : vec_muons_1) { vec_muons.emplace_back(mufeat); }
616  }
617  } else {
618  Trig::FeatureContainer fc = m_trigDec->features(muonItem);
619  vec_muons = fc.get<xAOD::L2CombinedMuonContainer>();
620  }
621  ATH_MSG_DEBUG("Size of vector Trig::Feature<xAOD::L2CombinedMuonContainer> for chain " << muonItem << " = "
622  << vec_muons.size());
623  for (const auto& mufeat : vec_muons) {
624  ATH_MSG_DEBUG(muonItem << " vec_muons.size() = " << vec_muons.size()
625  << " mufeat.cptr()->size() = " << mufeat.cptr()->size());
626  for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
627  ATH_MSG_DEBUG("#####" << muonItem << " L2CB feature pt: " << (*mufeat.cptr())[i]->pt()
628  << " eta: " << (*mufeat.cptr())[i]->eta() << " phi: " << (*mufeat.cptr())[i]->phi());
629  }
630  }
631  }
632  } // close if(m_doTrigMuonL2Validation)
633 
634  //@@@@@ EF @@@@@
635  if (m_doTrigMuonEFValidation) {
636  const xAOD::MuonContainer* EFCombTrigMuons = getContainer<xAOD::MuonContainer>(m_muonEFCombTrigName);
637  const xAOD::MuonRoIContainer* L1TrigMuons = getContainer<xAOD::MuonRoIContainer>(m_muonL1TrigName);
638  if (!EFCombTrigMuons) { return StatusCode::SUCCESS; }
639  ATH_MSG_DEBUG("Retrieved EF triggered muons " << EFCombTrigMuons->size());
640  if (EFCombTrigMuons->size() != 0) {
641  for (const auto Trigmu : *EFCombTrigMuons) {
642  ATH_MSG_DEBUG("Muon EF Trigger: pt " << Trigmu->pt() << " phi " << Trigmu->phi() << " eta " << Trigmu->eta()
643  << " author" << Trigmu->author());
644  m_vEFMuons.emplace_back(Trigmu);
645  }
646  m_vEFMuonsSelected.emplace_back(m_vEFMuons.at(0));
647  for (unsigned int i = 0; i < m_vEFMuons.size(); i++) {
648  unsigned int cont = 0;
649  for (unsigned int j = 0; j < m_vEFMuonsSelected.size(); j++) {
650  if (((deltaR(m_vEFMuonsSelected.at(j), m_vEFMuons.at(i))) > 0.1) ||
651  ((m_vEFMuons.at(i)->author() - m_vEFMuonsSelected.at(j)->author()) != 0))
652  cont++;
653  if (cont == m_vEFMuonsSelected.size()) {
654  m_vEFMuonsSelected.emplace_back(m_vEFMuons.at(i));
655  break;
656  }
657  }
658  }
659  for (unsigned int i = 0; i < m_vEFMuonsSelected.size(); i++) { handleMuonTrigger(m_vEFMuonsSelected.at(i)); }
660  EFTriggerResolution();
661  }
662  if (!m_isData) {
663  for (const auto truthMu : *TruthMuons) {
664  ATH_MSG_DEBUG("TRUTH:: pt=" << truthMu->pt() << " eta=" << truthMu->eta() << " phi=" << truthMu->phi());
665  }
666  }
667  // handleMuonTrigger_ResoWRTTruth(m_vEFMuonsSelected,)
668  //@@@@@ chains efficiency @@@@@
669  for (const auto& muonItem : m_muonItems) {
670  m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_CB;
671  m_SelectedAuthor = 1;
672  if ((muonItem.find("msonly") != std::string::npos)) {
673  m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_MS;
674  m_SelectedAuthor = 5;
675  }
676  std::vector<Trig::Feature<xAOD::MuonContainer> > vec_muons;
677  TString muonItem_str = (TString)muonItem;
678  if (muonItem_str.Contains("_OR_")) {
679  muonItem_str.ReplaceAll("_OR_", " ");
680  TString delim = " ";
681  std::vector<TString> v_subchains;
682  SplitString(muonItem_str, delim, v_subchains);
683  for (int i = 0; i < (int)v_subchains.size(); i++) {
684  Trig::FeatureContainer fc1 = m_trigDec->features((std::string)v_subchains.at(i));
685  std::vector<Trig::Feature<xAOD::MuonContainer> > vec_muons_1 = fc1.get<xAOD::MuonContainer>();
686  for (const auto& mufeat : vec_muons_1) { vec_muons.emplace_back(mufeat); }
687  }
688  } else {
689  Trig::FeatureContainer fc = m_trigDec->features(muonItem);
690  vec_muons = fc.get<xAOD::MuonContainer>();
691  }
692  ATH_MSG_DEBUG("Size of vector Trig::Feature<xAOD::MuonContainer> for chain " << muonItem << " = " << vec_muons.size());
693  for (const auto& mufeat : vec_muons) {
694  ATH_MSG_DEBUG(muonItem << " vec_muons.size() = " << vec_muons.size()
695  << " mufeat.cptr()->size() = " << mufeat.cptr()->size());
696  for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
697  ATH_MSG_DEBUG("#####" << muonItem << " EF feature pt: " << (*mufeat.cptr())[i]->pt()
698  << " eta: " << (*mufeat.cptr())[i]->eta() << " phi: " << (*mufeat.cptr())[i]->phi()
699  << " author: " << (*mufeat.cptr())[i]->author());
700  for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
701  if (m_selectMuonCategories[j] == ALL) {
702  if (((*mufeat.cptr())[i]->author()) == m_SelectedAuthor)
703  m_TriggerMuonValidationPlots[j]->fillFeatPlots(*(*mufeat.cptr())[i], muonItem);
704  } // if categ=ALL
705  } // categories
706  } // mufeat.cptr
707  } // mufeat
708  for (unsigned int k = 0; k < m_vRecoMuons_EffDen.size(); k++) {
709  bool break_flag = false;
710  for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
711  if (m_selectMuonCategories[j] == ALL) {
712  m_TriggerMuonValidationPlots[j]->fillDenEff(*m_vRecoMuons_EffDen.at(k), muonItem);
713  }
714  }
715  for (const auto& mufeat : vec_muons) {
716  for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
717  if ((((*mufeat.cptr())[i]->author()) == m_SelectedAuthor) &&
718  (deltaR((*mufeat.cptr())[i], m_vRecoMuons_EffDen.at(k)) < 0.1)) {
719  break_flag = true;
720  ATH_MSG_DEBUG(" $$$ match Reco_EffDen "
721  << muonItem << " pt: " << m_vRecoMuons_EffDen.at(k)->pt() << " eta: "
722  << m_vRecoMuons_EffDen.at(k)->eta() << " phi: " << m_vRecoMuons_EffDen.at(k)->phi()
723  << " author: " << m_vRecoMuons_EffDen.at(k)->author());
724  ATH_MSG_DEBUG(" $$$ match EF MuidCo feature "
725  << muonItem << " pt: " << (*mufeat.cptr())[i]->pt()
726  << " eta: " << (*mufeat.cptr())[i]->eta() << " phi: " << (*mufeat.cptr())[i]->phi()
727  << " author: " << (*mufeat.cptr())[i]->author() << " rel_p "
728  << (std::abs(((*mufeat.cptr())[i]->pt() - m_vRecoMuons_EffDen.at(k)->pt()) /
729  (m_vRecoMuons_EffDen.at(k)->pt()))));
730  for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
731  if (m_selectMuonCategories[j] == ALL) {
732  m_TriggerMuonValidationPlots[j]->fillNumEff(*m_vRecoMuons_EffDen.at(k), muonItem);
733  // if (muonItem=="HLT_2mu10") m_TriggerMuonValidationPlots[j]->fill(
734  // *(*mufeat.cptr())[i],*m_vRecoMuons_EffDen.at(k));
735 
736  } // if categ=ALL
737  } // categories
738  break;
739  } // if(Delta_R)
740  } // mufeat
741  if (break_flag) break;
742  } // vec_muons
743  } // m_vRecoMuons_EffDen
744  } // m_muonItems
745  //@@@@@ L1 items efficiency @@@@@
746  for (const auto& L1MuonItem : m_L1MuonItems) {
747  m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_CB;
748  m_SelectedAuthor = 1;
749  float threshold = 0.;
750  if (L1MuonItem == "L1_MU4") threshold = 4000;
751  else if (L1MuonItem == "L1_MU6") threshold = 6000;
752  else if (L1MuonItem == "L1_MU10") threshold = 10000;
753  else if (L1MuonItem == "L1_MU11") threshold = 11000;
754  else if (L1MuonItem == "L1_MU15") threshold = 15000;
755  else if (L1MuonItem == "L1_MU20") threshold = 20000;
756  for (const auto TrigL1mu : *L1TrigMuons) {
757  for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
758  if (m_selectMuonCategories[j] == ALL) {
759  if ((TrigL1mu->thrValue()) >= threshold)
760  m_TriggerMuonValidationPlots[j]->fillFeatPlots(*TrigL1mu, L1MuonItem);
761  } // if categ=ALL
762  } // categories
763  } // L1TrigMuons
764  for (unsigned int k = 0; k < m_vRecoMuons_EffDen.size(); k++) {
765  for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
766  if (m_selectMuonCategories[j] == ALL) {
767  m_TriggerMuonValidationPlots[j]->fillDenL1Eff(*m_vRecoMuons_EffDen.at(k), L1MuonItem);
768  }
769  }
770  for (const auto TrigL1mu : *L1TrigMuons) {
771  if (((TrigL1mu->thrValue()) >= threshold) &&
772  (sqrt(pow(m_vRecoMuons_EffDen.at(k)->eta() - TrigL1mu->eta(), 2.) +
773  pow(m_vRecoMuons_EffDen.at(k)->phi() - TrigL1mu->phi(), 2.)) < 0.2)) {
774  ATH_MSG_DEBUG(" $$$ match Reco_EffDen "
775  << L1MuonItem << " pt: " << m_vRecoMuons_EffDen.at(k)->pt() << " eta: "
776  << m_vRecoMuons_EffDen.at(k)->eta() << " phi: " << m_vRecoMuons_EffDen.at(k)->phi()
777  << " author: " << m_vRecoMuons_EffDen.at(k)->author());
778  ATH_MSG_DEBUG(" $$$ L1 feature " << L1MuonItem << " pt: " << TrigL1mu->thrValue()
779  << " eta: " << TrigL1mu->eta() << " phi: " << TrigL1mu->phi());
780  for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
781  if (m_selectMuonCategories[j] == ALL) {
782  m_TriggerMuonValidationPlots[j]->fillNumL1Eff(*m_vRecoMuons_EffDen.at(k), L1MuonItem);
783  } // if categ=ALL
784  } // categories
785  break;
786  } // if(Delta_R)
787  } // L1TrigMuons
788  } // m_vRecoMuons_EffDen
789  }
790  //@@@@@ chains efficiency w.r.t. L1 @@@@@
791  for (unsigned int m = 0; m < m_muonItems.size(); m++) {
792  std::vector<Trig::Feature<xAOD::MuonContainer> > vec_muons;
793  TString muonItem_str = (TString)m_muonItems[m];
794  if (muonItem_str.Contains("_OR_")) {
795  muonItem_str.ReplaceAll("_OR_", " ");
796  TString delim = " ";
797  std::vector<TString> v_subchains;
798  SplitString(muonItem_str, delim, v_subchains);
799  for (int i = 0; i < (int)v_subchains.size(); i++) {
800  Trig::FeatureContainer fc1 = m_trigDec->features((std::string)v_subchains.at(i));
801  std::vector<Trig::Feature<xAOD::MuonContainer> > vec_muons_1 = fc1.get<xAOD::MuonContainer>();
802  for (const auto& mufeat : vec_muons_1) { vec_muons.emplace_back(mufeat); }
803  }
804  } else {
805  Trig::FeatureContainer fc = m_trigDec->features(m_muonItems[m]);
806  vec_muons = fc.get<xAOD::MuonContainer>();
807  }
808  m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_CB;
809  m_SelectedAuthor = 1;
810  if ((m_muonItems[m].find("msonly") != std::string::npos)) {
811  m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_MS;
812  m_SelectedAuthor = 5;
813  }
814  float threshold = 0.;
815  if (m_L1Seed[m] == "L1_MU4") threshold = 4000;
816  if (m_L1Seed[m] == "L1_MU6") threshold = 6000;
817  if (m_L1Seed[m] == "L1_MU10") threshold = 10000;
818  if (m_L1Seed[m] == "L1_MU11") threshold = 11000;
819  if (m_L1Seed[m] == "L1_MU15") threshold = 15000;
820  if (m_L1Seed[m] == "L1_MU20") threshold = 20000;
821  for (unsigned int k = 0; k < m_vRecoMuons_EffDen.size(); k++) {
822  bool break_flag = false;
823  for (const auto TrigL1mu : *L1TrigMuons) {
824  if (((TrigL1mu->thrValue()) >= threshold) &&
825  (sqrt(pow(m_vRecoMuons_EffDen.at(k)->eta() - TrigL1mu->eta(), 2.) +
826  pow(m_vRecoMuons_EffDen.at(k)->phi() - TrigL1mu->phi(), 2.)) < 0.2)) {
827  for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
828  if (m_selectMuonCategories[j] == ALL) {
829  m_TriggerMuonValidationPlots[j]->fillDenRELEff(*m_vRecoMuons_EffDen.at(k), m_muonItems[m]);
830  } // if categ=ALL
831  } // categories
832  for (const auto& mufeat : vec_muons) {
833  for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
834  if ((((*mufeat.cptr())[i]->author()) == m_SelectedAuthor) &&
835  (deltaR((*mufeat.cptr())[i], m_vRecoMuons_EffDen.at(k)) < 0.1)) {
836  break_flag = true;
837  for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
838  if (m_selectMuonCategories[j] == ALL) {
839  m_TriggerMuonValidationPlots[j]->fillNumRELEff(*m_vRecoMuons_EffDen.at(k),
840  m_muonItems[m]);
841  } // if categ=ALL
842  } // categories
843  break;
844  } // if(Delta_R)
845  } // mufeat
846  if (break_flag) break;
847  } // vec_muons
848  break;
849  } // if(Delta_R)
850  } // L1TrigMuons
851  } // m_vRecoMuons_EffDen
852  } // m_muonItems.size()
853  } // m_doTrigMuonEFValidation
854  }
855  return StatusCode::SUCCESS;
856  }//fillHistograms()*/
857 
858  void MuonPhysValMonitoringTool::handleTruthMuonSegment(const xAOD::MuonSegment* truthMuSeg,
859  const xAOD::TruthParticleContainer* /*muonTruthContainer*/, float weight) {
860  const xAOD::MuonSegment* muSeg = findRecoMuonSegment(truthMuSeg);
862 
863  unsigned int thisMuonCategory = ALL; // getMuonSegmentTruthCategory(truthMuSeg, muonTruthContainer) @@@ Does not work...
864 
865  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
866  if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisMuonCategory) {
867  m_muonSegmentValidationPlots[i]->fill(truthMuSeg, muSeg,
868  weight); // if no reco muon segment is found a protection inside
869  // MuonSegmentValidationPlots will ensure, its plots won't be filled
870  }
871  }
872  }
873 
874  void MuonPhysValMonitoringTool::handleMuonSegment(const xAOD::MuonSegment* muSeg, float weight) {
875  if (!muSeg) {
876  ATH_MSG_WARNING("No muon segment found");
877  return;
878  }
879  if (std::find(std::begin(m_vMatchedMuonSegments), std::end(m_vMatchedMuonSegments), muSeg) != std::end(m_vMatchedMuonSegments))
880  return;
881  if (!m_isData) m_oUnmatchedRecoMuonSegmentPlots->fill(*muSeg, weight);
882  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
883  if (m_selectMuonCategories[i] == ALL) {
884  m_muonSegmentValidationPlots[i]->fill(muSeg, weight);
885  break;
886  }
887  }
888  }
889 
890  void MuonPhysValMonitoringTool::handleMuon(const xAOD::Muon* mu, const xAOD::SlowMuon* smu, float weight) {
891  if (!mu) return;
892  if (!m_selectComissioning && mu->allAuthors() & comm_bit) return;
893 
894  if (msgLvl(MSG::DEBUG)) printMuonDebug(mu);
895 
896  // make deep copy of muon and decorate with quality
897  std::unique_ptr<xAOD::Muon> mu_c;
898  try {
899  mu_c = getCorrectedMuon(*mu);
900  } catch (const SG::ExcBadAuxVar&) {
901  ATH_MSG_ERROR("Cannot retrieve aux-item - rejecting muon");
902  return;
903  }
904 
905  if (m_isData) {
906  MUCATEGORY thisMuonCategory = ALL;
907  // for events with a Zmumu candidate, separate Z muons from the rest:
908  if (m_vZmumuMuons.size() > 0) {
909  thisMuonCategory = REST;
910  if (std::find(m_vZmumuMuons.begin(), m_vZmumuMuons.end(), mu) != m_vZmumuMuons.end()) { thisMuonCategory = PROMPT; }
911  }
912  // fill plots
913  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
914  if (m_selectMuonCategories[i] == ALL or m_selectMuonCategories[i] == thisMuonCategory) {
915  if (mu_c){
916  // histos
917  m_muonValidationPlots[i]->fill(*mu_c, weight);
918  if (smu) m_slowMuonValidationPlots[i]->fill(*smu, *mu_c, weight);
919  // tree branches
920  m_muonValidationPlots[i]->fillTreeBranches(*mu_c);
921  }
922  }
923  }
924  }
925 
927  // SELECT MUON MEDIUM QUALITY FOR TRIGGER VALIDATION
928  xAOD::Muon::Quality my_quality = m_muonSelectionTool->getQuality(*mu_c);
929  if (my_quality <= xAOD::Muon::Medium && m_isoTool->accept(*mu_c)) m_vRecoMuons.emplace_back(mu);
931 
932  if (smu) {
933  if (std::find(std::begin(m_vMatchedSlowMuons), std::end(m_vMatchedSlowMuons), smu) != std::end(m_vMatchedSlowMuons)) { return; }
934  } else {
935  if (std::find(std::begin(m_vMatchedMuons), std::end(m_vMatchedMuons), mu) != std::end(m_vMatchedMuons)) { return; }
936  }
937 
938  // unmatched reco muons (not matched with any kind of truth particle, fakes)
939  if (!m_isData) m_oUnmatchedRecoMuonPlots->fill(*mu_c, weight);
940 
941  m_h_overview_reco_category->Fill("Other", weight);
942  m_h_overview_reco_authors[3]->Fill(mu->author(), weight);
943 
944  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
945  if (m_selectMuonCategories[i] == ALL) {
946  if (mu_c){// histos
947  m_muonValidationPlots[i]->fill(*mu_c);
948  if (smu) m_slowMuonValidationPlots[i]->fill(*smu, *mu_c, weight);
949  // tree branches
950  m_muonValidationPlots[i]->fillTreeBranches(*mu_c);
951  break;
952  }
953  }
954  }
955  }
956 
957  void MuonPhysValMonitoringTool::handleTruthMuon(const xAOD::TruthParticle* truthMu, float weight) {
958  const xAOD::SlowMuon* smu = nullptr;
959  const xAOD::Muon* mu = nullptr;
960  if (!m_slowMuonsName.empty()) {
961  smu = findRecoSlowMuon(truthMu);
962  if (smu) {
963  const MuonLink muLink = smu->muonLink();
964  if (muLink.isValid()) mu = *muLink;
965 
966  if (!mu) {
967  ATH_MSG_WARNING("Found SlowMuon without valid muon link");
968  smu = nullptr;
969  }
970  }
971  } else {
972  mu = findRecoMuon(truthMu);
973  }
974 
975  if (msgLvl(MSG::DEBUG)) printTruthMuonDebug(truthMu, mu);
976  if (!passesAcceptanceCuts(truthMu)) return;
977 
978  std::unique_ptr<xAOD::Muon> mu_c;
979  if (mu) {
980  try {
981  mu_c = getCorrectedMuon(*mu);
982  } catch (const SG::ExcBadAuxVar&) {
983  ATH_MSG_ERROR("Cannot retrieve aux-item - rejecting muon");
984  return;
985  }
986  }
987 
988  unsigned int thisMuonCategory = getMuonTruthCategory(truthMu);
989  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
990  if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisMuonCategory) {
991  // histos
992  m_muonValidationPlots[i]->fill(
993  truthMu, mu_c.get(), m_MSTracks,
994  weight); // if no muon is found a protection inside MuonValidationPlots will ensure, its plots won't be filled
995  if (!m_slowMuonsName.empty()) m_slowMuonValidationPlots[i]->fill(truthMu, smu, mu_c.get(), weight);
996  // tree branches
997  m_muonValidationPlots[i]->fillTreeBranches(truthMu, mu_c.get(), m_MSTracks);
998  }
999  }
1000  if (mu_c) {
1001  m_h_overview_reco_category->Fill(thisMuonCategory - 1, weight);
1002  m_h_overview_reco_authors[thisMuonCategory - 1]->Fill(mu_c->author(), weight);
1003  } else if (!m_isData)
1004  m_oUnmatchedTruthMuonPlots->fill(*truthMu, weight);
1005  }
1006 
1007  // This method MUST be called after all muon object (reco, truth) related variables (usually, vectors or arrays of vectors) of branches
1008  // of tree are already initialized. The method fills the event related branches (basic types like int, float, double, etc), fills the
1009  // TTree object and at the end resets all branch variables for the next event.
1010  void MuonPhysValMonitoringTool::handleMuonTrees(const xAOD::EventInfo* eventInfo, bool isData) {
1011  ATH_MSG_DEBUG("Filling MuonTree " << name() << "...");
1012 
1013  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1014  m_muonValidationPlots[i]->fillTree(eventInfo, isData);
1015 
1016  ATH_MSG_DEBUG("MuonTree is filled for muon category = " << m_selectMuonCategories[i] << " with event # "
1017  << eventInfo->eventNumber());
1018  }
1019  }
1020 
1021  void MuonPhysValMonitoringTool::handleMuonTrack(const xAOD::TrackParticle* tp, xAOD::Muon::TrackParticleType type, float weight) {
1022  if (!tp) {
1023  ATH_MSG_WARNING("No track particle found");
1024  return;
1025  }
1026 
1027  // if ID track, check that it passes standard combined mu reco selections
1028  bool passesMuonTrackSel = false;
1029  if (type == xAOD::Muon::InnerDetectorTrackParticle) { passesMuonTrackSel = m_trackSelector->decision(*tp); }
1030 
1031  if (m_isData) {
1032  if (type == xAOD::Muon::InnerDetectorTrackParticle) {
1033  MUCATEGORY thisTrkCategory = ALL;
1034  // for events with a Zmumu candidate, separate Z muon tracks from the rest:
1035  if (m_vZmumuIDTracks.size() > 0) {
1036  thisTrkCategory = REST;
1037  for (const auto& zmu : m_vZmumuIDTracks) {
1038  if (deltaR(zmu, tp) < 0.01) {
1039  thisTrkCategory = PROMPT;
1040  break;
1041  }
1042  }
1043  }
1044 
1045  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1046  if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisTrkCategory) {
1047  m_muonIDTrackValidationPlots[i]->fill(*tp, weight);
1048  if (passesMuonTrackSel) m_muonIDSelectedTrackValidationPlots[i]->fill(*tp, weight);
1049  }
1050  }
1051  } else if (type == xAOD::Muon::MuonSpectrometerTrackParticle)
1052  m_muonMSTrackValidationPlots[ALL]->fill(*tp, weight);
1053  else if (type == xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle)
1054  m_muonMETrackValidationPlots[ALL]->fill(*tp, weight);
1055  else if (type == xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle)
1056  m_muonMSOnlyMETrackValidationPlots[ALL]->fill(*tp, weight);
1057 
1058  return;
1059  }
1060 
1061  static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
1062  TruthLink truthLink = truthParticleLinkAcc.withDefault(*tp, TruthLink());
1063 
1064  if (!truthLink.isValid()) {
1065  ATH_MSG_DEBUG("No truth link available");
1066  if (type == xAOD::Muon::InnerDetectorTrackParticle) return;
1067  if (!passesAcceptanceCuts(tp)) return;
1068 
1069  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1070  if (m_selectMuonCategories[i] == ALL) {
1071  // ID track plots for any track
1072  // if (type==xAOD::Muon::InnerDetectorTrackParticle) {
1073  // m_muonIDTrackValidationPlots[i]->fill(*tp);
1074  // if (passesMuonTrackSel) m_muonIDSelectedTrackValidationPlots[i]->fill(*tp);
1075  // } else
1076  if (type == xAOD::Muon::MuonSpectrometerTrackParticle) {
1077  if (!m_isData) m_oUnmatchedRecoMuonTrackPlots->fill(*tp, weight);
1078  m_muonMSTrackValidationPlots[i]->fill(*tp, weight);
1079  } else if (type == xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle) {
1080  m_muonMETrackValidationPlots[i]->fill(*tp, weight);
1081  } else if (type == xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle) {
1082  m_muonMSOnlyMETrackValidationPlots[i]->fill(*tp, weight);
1083  }
1084  break;
1085  }
1086  }
1087  } // end if no valid truth link
1088  else { // here: valid truth link and truthType
1089 
1090  if (type ==
1091  xAOD::Muon::InnerDetectorTrackParticle) { // don't fill histograms for any ID track, only for muons; buys a lot of time
1092  if ((*truthLink)->absPdgId() != 13 || !MC::isStable(*truthLink)) return; // not a muon
1093  if (HepMC::uniqueID(*truthLink) == HepMC::UNDEFINED_ID || HepMC::is_simulation_particle((*truthLink))) return; // must have valid barcode
1094  }
1095 
1096  if (!passesAcceptanceCuts(*truthLink)) return;
1097  unsigned int thisMuonCategory = getMuonTruthCategory(tp);
1098 
1099  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1100  if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisMuonCategory) {
1101  if (type == xAOD::Muon::InnerDetectorTrackParticle) {
1102  if (!m_fwdtracksName.empty() && std::abs((*truthLink)->eta()) > 2.5)
1103  m_muonIDForwardTrackValidationPlots[i]->fill(*truthLink, tp, weight);
1104  else if (!m_tracksName.empty()) {
1105  m_muonIDTrackValidationPlots[i]->fill(*truthLink, tp, weight);
1106  if (passesMuonTrackSel) m_muonIDSelectedTrackValidationPlots[i]->fill(*truthLink, tp, weight);
1107  }
1108  } else if (type == xAOD::Muon::MuonSpectrometerTrackParticle) {
1109  m_muonMSTrackValidationPlots[i]->fill(*truthLink, tp, weight);
1110  } else if (type == xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle) {
1111  m_muonMETrackValidationPlots[i]->fill(*truthLink, tp, weight);
1112  } else if (type == xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle) {
1113  m_muonMSOnlyMETrackValidationPlots[i]->fill(*truthLink, tp, weight);
1114  }
1115  }
1116  }
1117  }
1118 
1119  return;
1120  }
1121 
1122  void MuonPhysValMonitoringTool::handleMuonL1Trigger(const xAOD::MuonRoI* TrigL1mu) {
1123  ATH_MSG_DEBUG("MuonRoI L1 Trigger: ptThr " << TrigL1mu->thrValue() << " phi " << TrigL1mu->phi() << " eta " << TrigL1mu->eta());
1124  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1125  if (m_selectMuonCategories[i] == ALL) {
1126  m_TriggerMuonValidationPlots[i]->fill(*TrigL1mu);
1127  break;
1128  }
1129  }
1130  }
1131 
1132  void MuonPhysValMonitoringTool::handleMuonL2Trigger(const xAOD::L2StandAloneMuon* L2SAMu) {
1133  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1134  if (m_selectMuonCategories[i] == ALL) {
1135  m_TriggerMuonValidationPlots[i]->fill(*L2SAMu);
1136  break;
1137  }
1138  }
1139  ATH_MSG_DEBUG(" ==> Geometrical selection of Muon L2SA Trigger : pt " << L2SAMu->pt() << " phi " << L2SAMu->phi() << " eta "
1140  << L2SAMu->eta() << " roiWord " << L2SAMu->roiWord()
1141  << " sAddress " << L2SAMu->sAddress());
1142  }
1143 
1144  void MuonPhysValMonitoringTool::L2SATriggerResolution() {
1145  int k_L2SAMu_MinDeltaR = -1;
1146  float MinDeltaR = 0.;
1147  ATH_MSG_DEBUG(" m_vL2SAMuons.size()" << m_vL2SAMuons.size());
1148  for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1149  ATH_MSG_DEBUG(":: TEST: listing all Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta() << " phi="
1150  << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1151  }
1152  for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1153  if ((m_vRecoMuons.at(i)->author() != 1) || (std::abs(m_vRecoMuons.at(i)->eta()) > 2.4)) continue;
1154  ATH_MSG_DEBUG(":::: TEST: Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta()
1155  << " phi=" << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1156  k_L2SAMu_MinDeltaR = -1;
1157  MinDeltaR = 1000;
1158  ATH_MSG_DEBUG("==============>>>> k_L2SAMu_MinDeltaR=" << k_L2SAMu_MinDeltaR << " MinDeltaR" << MinDeltaR);
1159  for (unsigned int k = 0; k < m_vL2SAMuons.size(); k++) {
1160  ATH_MSG_DEBUG(" :::::::: TEST: L2SA pt=" << m_vL2SAMuons.at(k)->pt() << " eta=" << m_vL2SAMuons.at(k)->eta()
1161  << " phi=" << m_vL2SAMuons.at(k)->phi()
1162  << " DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)));
1163  if ((deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)) < 0.1 &&
1164  (deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)) < MinDeltaR))) {
1165  k_L2SAMu_MinDeltaR = k;
1166  MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k));
1167  ATH_MSG_DEBUG("==============>>>> taken!!!! k_L2SAMu_MinDeltaR=" << k_L2SAMu_MinDeltaR << " MinDeltaR"
1168  << MinDeltaR);
1169  }
1170  }
1171  if (k_L2SAMu_MinDeltaR == -1) continue;
1172  for (unsigned int c = 0; c < m_selectMuonCategories.size(); c++) {
1173  if (m_selectMuonCategories[c] == ALL) {
1174  m_TriggerMuonValidationPlots[c]->fill(*m_vL2SAMuons.at(k_L2SAMu_MinDeltaR), *m_vRecoMuons.at(i));
1175  }
1176  }
1177  }
1178  }
1179 
1180  void MuonPhysValMonitoringTool::handleMuonL2Trigger(const xAOD::L2CombinedMuon* L2CBMu) {
1181  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1182  if (m_selectMuonCategories[i] == ALL) {
1183  m_TriggerMuonValidationPlots[i]->fill(*L2CBMu);
1184  break;
1185  }
1186  }
1187  ATH_MSG_DEBUG(" ==> Geometrical selection of Muon L2CB Trigger : pt " << L2CBMu->pt() << " phi " << L2CBMu->phi() << " eta "
1188  << L2CBMu->eta());
1189  }
1190 
1191  void MuonPhysValMonitoringTool::L2CBTriggerResolution() {
1192  int k_L2CBMu_MinDeltaR = -1;
1193  float MinDeltaR = 0.;
1194  ATH_MSG_DEBUG(" m_vL2CBMuons.size()" << m_vL2CBMuons.size());
1195  for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1196  ATH_MSG_DEBUG(":: TEST: listing all Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta() << " phi="
1197  << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1198  }
1199  for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1200  if ((m_vRecoMuons.at(i)->author() != 1) || (std::abs(m_vRecoMuons.at(i)->eta()) > 2.4)) continue;
1201  ATH_MSG_DEBUG(":::: TEST: Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta()
1202  << " phi=" << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1203  k_L2CBMu_MinDeltaR = -1;
1204  MinDeltaR = 1000;
1205  ATH_MSG_DEBUG("==============>>>> k_L2CBMu_MinDeltaR=" << k_L2CBMu_MinDeltaR << " MinDeltaR" << MinDeltaR);
1206  for (unsigned int k = 0; k < m_vL2CBMuons.size(); k++) {
1207  ATH_MSG_DEBUG(" :::::::: TEST: L2CB pt=" << m_vL2CBMuons.at(k)->pt() << " eta=" << m_vL2CBMuons.at(k)->eta()
1208  << " phi=" << m_vL2CBMuons.at(k)->phi()
1209  << " DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k)));
1210  if ((deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k)) < 0.1 &&
1211  (deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k)) < MinDeltaR))) {
1212  k_L2CBMu_MinDeltaR = k;
1213  MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k));
1214  ATH_MSG_DEBUG("==============>>>> taken!!!! k_L2CBMu_MinDeltaR=" << k_L2CBMu_MinDeltaR << " MinDeltaR"
1215  << MinDeltaR);
1216  }
1217  }
1218  if (k_L2CBMu_MinDeltaR == -1) continue;
1219  for (unsigned int c = 0; c < m_selectMuonCategories.size(); c++) {
1220  if (m_selectMuonCategories[c] == ALL) {
1221  m_TriggerMuonValidationPlots[c]->fill(*m_vL2CBMuons.at(k_L2CBMu_MinDeltaR), *m_vRecoMuons.at(i));
1222  }
1223  }
1224  }
1225  }
1226 
1227  void MuonPhysValMonitoringTool::handleMuonTrigger(const xAOD::Muon* EFMu) {
1228  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1229  if (m_selectMuonCategories[i] == ALL) {
1230  m_TriggerMuonValidationPlots[i]->fill(*EFMu);
1231  break;
1232  }
1233  }
1234  ATH_MSG_DEBUG("==> Geometrical selection of EF Trigger muons: pt " << EFMu->pt() << " phi " << EFMu->phi() << " eta " << EFMu->eta()
1235  << " author " << EFMu->author());
1236  }
1237 
1238  void MuonPhysValMonitoringTool::EFTriggerResolution() {
1239  int k_EFMu_MinDeltaR = -1;
1240  float MinDeltaR = 0.;
1241  std::vector<int> vAvailableAuthors;
1242  vAvailableAuthors.clear();
1243  vAvailableAuthors.emplace_back(m_vEFMuons[0]->author());
1244  unsigned int iter = 0;
1245  for (unsigned int k = 0; k < m_vEFMuons.size(); k++) {
1246  iter = 0;
1247  for (unsigned int l = 0; l < vAvailableAuthors.size(); l++) {
1248  if (m_vEFMuons[k]->author() != vAvailableAuthors[l]) iter++;
1249  }
1250  if (iter == vAvailableAuthors.size()) vAvailableAuthors.emplace_back(m_vEFMuons[k]->author());
1251  }
1252  ATH_MSG_DEBUG(" m_vEFMuons.size()" << m_vEFMuons.size());
1253  for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1254  ATH_MSG_DEBUG(":: TEST: listing all Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta() << " phi="
1255  << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1256  }
1257  for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1258  if ((m_vRecoMuons.at(i)->author() != 1) || (std::abs(m_vRecoMuons.at(i)->eta()) > 2.4)) continue;
1259  ATH_MSG_DEBUG(":::: TEST: Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta()
1260  << " phi=" << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1261  for (unsigned int l = 0; l < vAvailableAuthors.size(); l++) {
1262  k_EFMu_MinDeltaR = -1;
1263  MinDeltaR = 1000;
1264  for (unsigned int k = 0; k < m_vEFMuons.size(); k++) {
1265  ATH_MSG_DEBUG(" :::::::: TEST: EF pt=" << m_vEFMuons.at(k)->pt() << " eta=" << m_vEFMuons.at(k)->eta()
1266  << " phi=" << m_vEFMuons.at(k)->phi()
1267  << " DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k))
1268  << " author=" << m_vEFMuons.at(k)->author());
1269  if (m_vEFMuons.at(k)->author() == vAvailableAuthors.at(l) &&
1270  (deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k)) < 0.1 &&
1271  (deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k)) < MinDeltaR))) {
1272  k_EFMu_MinDeltaR = k;
1273  MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k));
1274  }
1275  }
1276  if (k_EFMu_MinDeltaR == -1) continue;
1277  for (unsigned int c = 0; c < m_selectMuonCategories.size(); c++) {
1278  if (m_selectMuonCategories[c] == ALL) {
1279  m_TriggerMuonValidationPlots[c]->fill(*m_vEFMuons.at(k_EFMu_MinDeltaR), *m_vRecoMuons.at(i));
1280  }
1281  }
1282  }
1283  }
1284  }
1285 
1286  void MuonPhysValMonitoringTool::printMuonDebug(const xAOD::Muon* mu) {
1287  const xAOD::TrackParticle* tp = mu->primaryTrackParticle();
1288  static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
1289  TruthLink truthLink;
1290  if (tp) {
1291  truthLink = truthParticleLinkAcc.withDefault(*tp, TruthLink());
1292  }
1293  ATH_MSG_DEBUG("Muon: pt " << mu->pt() << " eta " << mu->eta() << " link " << truthLink.isValid());
1294  }
1295 
1296  const xAOD::Muon* MuonPhysValMonitoringTool::findRecoMuon(const xAOD::TruthParticle* truthMu) {
1297  static const SG::ConstAccessor<MuonLink> acc_muon("recoMuonLink");
1298  if (!acc_muon.isAvailable(*truthMu)) return nullptr;
1299  MuonLink link = acc_muon(*truthMu);
1300  if (!link.isValid()) return nullptr;
1301  const xAOD::Muon* reco_mu = (*link);
1302  if (!m_selectComissioning && reco_mu->allAuthors() & comm_bit) return nullptr;
1303  m_vMatchedMuons.emplace_back(reco_mu);
1304  return reco_mu;
1305  }
1306 
1307  const xAOD::SlowMuon* MuonPhysValMonitoringTool::findRecoSlowMuon(const xAOD::TruthParticle* truthMu) {
1308  if (m_slowMuonsName.empty()) return nullptr;
1309 
1310  const xAOD::SlowMuonContainer* SlowMuons = nullptr;
1311  SlowMuons = getContainer<xAOD::SlowMuonContainer>(m_slowMuonsName);
1312  for (const auto smu : *SlowMuons) {
1313  const MuonLink muLink = smu->muonLink();
1314  if (!muLink.isValid()) continue;
1315  float DR = deltaR(*muLink , truthMu);
1316  if (DR < 0.005) {
1317  m_vMatchedSlowMuons.emplace_back(smu);
1318  return smu;
1319  }
1320  }
1321 
1322  return nullptr;
1323  }
1324 
1325  void MuonPhysValMonitoringTool::printTruthMuonDebug(const xAOD::TruthParticle* truthMu, const xAOD::Muon* mu) {
1326  ATH_MSG_DEBUG("Truth muon: " << truthMu->pt() << " eta " << truthMu->eta());
1327  if (!mu) return;
1328  ATH_MSG_DEBUG("Reco muon: " << mu->pt() << " eta " << mu->eta());
1329  }
1330 
1331  StatusCode MuonPhysValMonitoringTool::procHistograms() {
1332  ATH_MSG_INFO("Finalising hists " << name() << "...");
1333  for (const auto& plots : m_muonValidationPlots) plots->finalize();
1334  for (const auto& plots : m_TriggerMuonValidationPlots) plots->finalize();
1335  if (!m_isData) {
1336  m_oUnmatchedRecoMuonPlots->finalize();
1337  m_oUnmatchedTruthMuonPlots->finalize();
1338  }
1339 
1340  for (const auto& plots : m_muonMSTrackValidationPlots) plots->finalize();
1341  for (const auto& plots : m_muonMETrackValidationPlots) plots->finalize();
1342  for (const auto& plots : m_muonMSOnlyMETrackValidationPlots) plots->finalize();
1343  for (const auto& plots : m_muonIDTrackValidationPlots) plots->finalize();
1344  for (const auto& plots : m_muonIDSelectedTrackValidationPlots) plots->finalize();
1345  for (const auto& plots : m_muonIDForwardTrackValidationPlots) plots->finalize();
1346  if (!m_isData)
1347  if (m_oUnmatchedRecoMuonTrackPlots) m_oUnmatchedRecoMuonTrackPlots->finalize();
1348 
1349  for (const auto& plots : m_muonSegmentValidationPlots) plots->finalize();
1350  if (!m_isData)
1351  if (m_oUnmatchedRecoMuonSegmentPlots) m_oUnmatchedRecoMuonSegmentPlots->finalize();
1352 
1353  if (m_doMuonTree) {
1354  for (const auto& plots : m_muonValidationPlots) {
1355  if (plots->getMuonTree()) { plots->getMuonTree()->getTree()->Write(); }
1356  }
1357  }
1358 
1359  return StatusCode::SUCCESS;
1360  }//procHistograms*/
1361 
1362  const xAOD::MuonSegment* MuonPhysValMonitoringTool::findRecoMuonSegment(const xAOD::MuonSegment* truthMuSeg) {
1363  static const SG::ConstAccessor<MuonSegmentLink> recoSegmentLinkAcc("recoSegmentLink");
1364  if (!recoSegmentLinkAcc.isAvailable(*truthMuSeg)) {
1365  ATH_MSG_DEBUG("recoSegmentLink not found");
1366  return nullptr;
1367  }
1368  MuonSegmentLink link = recoSegmentLinkAcc(*truthMuSeg);
1369  if (!link.isValid()) {
1370  ATH_MSG_DEBUG("recoSegmentLink not valid");
1371  return nullptr;
1372  }
1373  m_vMatchedMuonSegments.emplace_back(*link);
1374  return (*link);
1375  }
1376 
1377  TH1F* MuonPhysValMonitoringTool::findHistogram(const std::vector<HistData>& hists, const std::string& hnameTag,
1378  const std::string& hdirTag, const std::string& hNewName) {
1379  TH1F* h = nullptr;
1380  for (const auto& hist : hists) {
1381  if (hist.second.find(hdirTag) != std::string::npos || hdirTag.empty()) {
1382  std::string histname = hist.first->GetName();
1383  if (histname.find(hnameTag) != std::string::npos) {
1384  h = (TH1F*)hist.first->Clone(hNewName.c_str());
1385  return h;
1386  }
1387  }
1388  }
1389  return h;
1390  }
1391 
1392  MuonPhysValMonitoringTool::MUCATEGORY MuonPhysValMonitoringTool::getMuonSegmentTruthCategory(
1393  const xAOD::MuonSegment* truthMuSeg, const xAOD::TruthParticleContainer* muonTruthContainer) {
1394  static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
1395  TruthLink truthLink;
1396  if (truthParticleLinkAcc.isAvailable(*truthMuSeg)) {
1397  truthLink = truthParticleLinkAcc(*truthMuSeg);
1398  if (truthLink.isValid()) {
1399  const int theUniqueID = HepMC::uniqueID(*truthLink);
1400  if (std::abs((*truthLink)->pdgId()) != 13) return REST;
1401 
1402  for (const auto muTruthPart : *muonTruthContainer) {
1403  if ( HepMC::uniqueID(muTruthPart) == theUniqueID ) { return getMuonTruthCategory(muTruthPart); }
1404  }
1405  }
1406  } else
1407  ATH_MSG_WARNING("No truth link available for muon truth segment");
1408 
1409  return REST;
1410  }
1411 
1412  MuonPhysValMonitoringTool::MUCATEGORY MuonPhysValMonitoringTool::getMuonTruthCategory(const xAOD::IParticle* mu) {
1413  static const SG::ConstAccessor<int> truthTypeAcc("truthType");
1414  static const SG::ConstAccessor<int> truthOriginAcc("truthOrigin");
1415  int truthType = truthTypeAcc(*mu);
1416  if (truthType == 6)
1417  return PROMPT;
1418  else if (truthType == 8 && (truthOriginAcc(*mu) == 34 || truthOriginAcc(*mu) == 35))
1419  return INFLIGHT;
1420  else if (truthType == 7)
1421  return NONISO;
1422  return REST;
1423  }
1424 
1425  std::unique_ptr<xAOD::Muon> MuonPhysValMonitoringTool::getCorrectedMuon(const xAOD::Muon& mu) {
1426  std::unique_ptr<xAOD::Muon> mu_c;
1427  if (mu.m() <= 0) return mu_c;
1428  mu_c = std::make_unique<xAOD::Muon>();
1429  mu_c->makePrivateStore(mu);
1430 
1431  // add decorations too fool the muon selector tool
1432  const xAOD::TrackParticle* idtrk{mu_c->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)};
1433  const xAOD::TrackParticle* metrk{mu_c->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle)};
1434  if (idtrk && metrk) {
1435  const static SG::Decorator<float> InnerDetectorPtDec("InnerDetectorPt");
1436  const static SG::Decorator<float> MuonSpectrometerPtDec("MuonSpectrometerPt");
1437  InnerDetectorPtDec(*mu_c) = idtrk->pt();
1438  MuonSpectrometerPtDec(*mu_c) = metrk->pt();
1439  }
1440  m_muonSelectionTool->setQuality(*mu_c);
1441  m_muonSelectionTool->setPassesIDCuts(*mu_c);
1442  return mu_c;
1443  }
1444 
1445  void MuonPhysValMonitoringTool::modifyHistogram(TH1* hist) {
1446  std::string histname = hist->GetName();
1447 
1448  if(m_muonsName == "Muons"){
1449  if (histname.find("parameters_z0") != std::string::npos) {
1450  hist->GetXaxis()->Set(80, -200., 200.);
1451  }
1452  if (histname.find("parameters_d0") != std::string::npos && histname.find("parameters_d0_small") == std::string::npos) {
1453  hist->GetXaxis()->Set(80, -1., 1.);
1454  hist->GetYaxis()->SetTitle("Entries / 0.025 mm");
1455  }
1456  }
1457 
1458  if(m_muonsName == "MuonsLRT"){
1459  if (histname.find("parameters_d0") != std::string::npos && histname.find("parameters_d0_small") == std::string::npos) {
1460  hist->Rebin(100);
1461  hist->GetYaxis()->SetTitle("Entries / 2.5 mm");
1462  }
1463  }
1464 
1465 
1466  if (histname.find("trigger_L1_pt") != std::string::npos) { // if (histname=="Muons_All_trigger_L1_pt"){
1467  hist->SetTitle("L1Trigger Muons pt threshold");
1468  hist->GetXaxis()->SetTitle("L1Trigger Muons pt threshold [GeV]");
1469  hist->GetXaxis()->Set(30, -0.5, 29.5);
1470  }
1471  if (histname.find("trigger_L1_eta_pt") != std::string::npos) { // if (histname=="Muons_All_trigger_L1_eta_pt") {
1472  hist->SetTitle("L1Trigger Muons pt threshold vs eta");
1473  hist->GetYaxis()->Set(90, -0.5, 29.5);
1474  hist->GetYaxis()->SetTitle("L1Trigger Muons pt threshold [GeV]");
1475  }
1476 
1477  if (histname.find("trigger") != std::string::npos &&
1478  ((histname.find("Denom_pt") != std::string::npos) || (histname.find("Numer_pt") != std::string::npos) ||
1479  (histname.find("Features_pt") != std::string::npos)))
1480  hist->GetXaxis()->Set(200, 0., 200.);
1481 
1482  if (histname.find("hits") != std::string::npos) {
1483  if (histname.find("etaLayer2") != std::string::npos)
1484  hist->GetXaxis()->Set(15, -0.5, 14.5);
1485  else if (histname.find("etaLayer") != std::string::npos)
1486  hist->GetXaxis()->Set(11, -0.5, 10.5);
1487  }
1488 
1490  bool is2D = !(histname.find("_vs_") == std::string::npos);
1492 
1493  if (histname.find("METrackParticles") != std::string::npos) {
1494  if (histname.find("Res_eta") != std::string::npos) {
1495  if (is2D)
1496  hist->GetYaxis()->Set(50, -0.025, 0.025);
1497  else
1498  hist->GetXaxis()->Set(50, -0.025, 0.025);
1499  } else if (histname.find("Res_phi") != std::string::npos) {
1500  if (is2D)
1501  hist->GetYaxis()->Set(50, -0.02, 0.02);
1502  else
1503  hist->GetXaxis()->Set(50, -0.02, 0.02);
1504  }
1505  } else if (histname.find("MSTrackParticles") != std::string::npos) {
1506  if (histname.find("Res_eta") != std::string::npos) {
1507  if (is2D)
1508  hist->GetYaxis()->Set(50, -0.025, 0.025);
1509  else
1510  hist->GetXaxis()->Set(50, -0.025, 0.025);
1511  } else if (histname.find("Res_phi") != std::string::npos) {
1512  if (is2D)
1513  hist->GetYaxis()->Set(50, -0.05, 0.05);
1514  else
1515  hist->GetXaxis()->Set(50, -0.05, 0.05);
1516  }
1517  } else {
1518  if (histname.find("Res_eta") != std::string::npos) {
1519  if (is2D)
1520  hist->GetYaxis()->Set(50, -0.005, 0.005);
1521  else
1522  hist->GetXaxis()->Set(50, -0.005, 0.005);
1523  } else if (histname.find("Res_phi") != std::string::npos) {
1524  if (is2D)
1525  hist->GetYaxis()->Set(50, -0.002, 0.002);
1526  else
1527  hist->GetXaxis()->Set(50, -0.002, 0.002);
1528  }
1529  }
1530 
1531  if (histname.find("trigger") != std::string::npos) {
1532  // RESO EF - MC
1533  if ((!m_isData) && histname.find("MuidCo") != std::string::npos &&
1534  (histname.find("BARREL") != std::string::npos || histname.find("WHOLE_DETECT") != std::string::npos)) {
1535  if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1536  hist->GetXaxis()->Set(100, -0.04, 0.04);
1537  }
1538  if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.04, 0.04); }
1539  if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1540  hist->GetXaxis()->Set(100, -0.0005, 0.0005);
1541  }
1542  if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0005, 0.0005); }
1543 
1544  if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1545  hist->GetXaxis()->Set(100, -0.0002, 0.0002);
1546  }
1547  if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0002, 0.0002); }
1548  }
1549  if ((!m_isData) && histname.find("MuidCo") != std::string::npos && (histname.find("ENDCAPS") != std::string::npos)) {
1550  if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1551  hist->GetXaxis()->Set(100, -0.05, 0.05);
1552  }
1553  if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.05, 0.05); }
1554  if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1555  hist->GetXaxis()->Set(100, -0.001, 0.001);
1556  }
1557  if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.001, 0.001); }
1558 
1559  if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1560  hist->GetXaxis()->Set(100, -0.0003, 0.0003);
1561  }
1562  if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0003, 0.0003); }
1563  }
1564  if ((!m_isData) && histname.find("MuidSA") != std::string::npos) {
1565  if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1566  hist->GetXaxis()->Set(100, -0.03, 0.03);
1567  }
1568  if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
1569 
1570  if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1571  hist->GetXaxis()->Set(100, -0.03, 0.03);
1572  }
1573  if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
1574  }
1575  if ((!m_isData) && histname.find("MuidSA") != std::string::npos && (histname.find("BARREL") != std::string::npos)) {
1576  if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1577  hist->GetXaxis()->Set(100, -0.15, 0.15);
1578  }
1579  if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.15, 0.15); }
1580  }
1581  if ((!m_isData) && histname.find("MuidSA") != std::string::npos &&
1582  (histname.find("ENDCAPS") != std::string::npos || histname.find("WHOLE_DETECT") != std::string::npos)) {
1583  if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1584  hist->GetXaxis()->Set(100, -0.2, 0.2);
1585  }
1586  if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.2, 0.2); }
1587  }
1588 
1589  // RESO EF - DATA
1590  if ((m_isData) && histname.find("MuidCo") != std::string::npos &&
1591  (histname.find("BARREL") != std::string::npos || histname.find("WHOLE_DETECT") != std::string::npos)) {
1592  if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1593  hist->GetXaxis()->Set(100, -0.06, 0.06);
1594  }
1595  if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.06, 0.06); }
1596  if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1597  hist->GetXaxis()->Set(100, -0.001, 0.001);
1598  }
1599  if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.001, 0.001); }
1600 
1601  if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1602  hist->GetXaxis()->Set(100, -0.0005, 0.0005);
1603  }
1604  if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0005, 0.0005); }
1605  }
1606  if ((m_isData) && histname.find("MuidCo") != std::string::npos && (histname.find("ENDCAPS") != std::string::npos)) {
1607  if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1608  hist->GetXaxis()->Set(100, -0.1, 0.1);
1609  }
1610  if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.1, 0.1); }
1611  if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1612  hist->GetXaxis()->Set(100, -0.0015, 0.0015);
1613  }
1614  if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0015, 0.0015); }
1615 
1616  if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1617  hist->GetXaxis()->Set(100, -0.0005, 0.0005);
1618  }
1619  if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0005, 0.0005); }
1620  }
1621  if ((m_isData) && histname.find("MuidSA") != std::string::npos) {
1622  if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1623  hist->GetXaxis()->Set(100, -0.03, 0.03);
1624  }
1625  if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
1626 
1627  if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1628  hist->GetXaxis()->Set(100, -0.03, 0.03);
1629  }
1630  if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
1631  }
1632  if ((m_isData) && histname.find("MuidSA") != std::string::npos && (histname.find("BARREL") != std::string::npos)) {
1633  if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1634  hist->GetXaxis()->Set(100, -0.3, 0.3);
1635  }
1636  if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.3, 0.3); }
1637  }
1638  if ((m_isData) && histname.find("MuidSA") != std::string::npos &&
1639  (histname.find("ENDCAPS") != std::string::npos || histname.find("WHOLE_DETECT") != std::string::npos)) {
1640  if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1641  hist->GetXaxis()->Set(100, -0.5, 0.5);
1642  }
1643  if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.5, 0.5); }
1644  }
1645 
1646  // LEVEL2
1647  if ((histname.find("L2_StandAlone") != std::string::npos)) {
1648  if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1649  hist->GetXaxis()->Set(100, -0.03, 0.03);
1650  }
1651  if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
1652 
1653  if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1654  hist->GetXaxis()->Set(100, -0.03, 0.03);
1655  }
1656  if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
1657  }
1658  if ((histname.find("L2_StandAlone") != std::string::npos) && (histname.find("BARREL") != std::string::npos)) {
1659  if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1660  hist->GetXaxis()->Set(100, -0.3, 0.3);
1661  }
1662  if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.3, 0.3); }
1663  }
1664  if ((histname.find("L2_StandAlone") != std::string::npos) &&
1665  ((histname.find("ENDCAPS") != std::string::npos) || (histname.find("WHOLE_DETECT") != std::string::npos))) {
1666  if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1667  hist->GetXaxis()->Set(100, -0.5, 0.5);
1668  }
1669  if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.5, 0.5); }
1670  }
1671 
1672  if ((histname.find("L2_Combined") != std::string::npos)) {
1673  if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1674  hist->GetXaxis()->Set(100, -0.002, 0.002);
1675  }
1676  if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.002, 0.002); }
1677 
1678  if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1679  hist->GetXaxis()->Set(100, -0.001, 0.001);
1680  }
1681  if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.001, 0.001); }
1682  if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1683  hist->GetXaxis()->Set(100, -0.2, 0.2);
1684  }
1685  if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.2, 0.2); }
1686  }
1687  }
1688  }
1689 
1690  bool MuonPhysValMonitoringTool::passesAcceptanceCuts(const xAOD::IParticle* prt) {
1691  if (prt->pt() < 2000.) return false;
1692  if (std::abs(prt->eta()) > 2.7) return false;
1693  return true;
1694  }
1695 
1696  void MuonPhysValMonitoringTool::SplitString(TString x, const TString& delim, std::vector<TString>& v) {
1697  v.clear();
1698  int stringLength = x.Length();
1699  int delimLength = delim.Length();
1700 
1701  int stop = 1;
1702  TString temp = "---";
1703  while (stop != -1) {
1704  stop = x.First(delim);
1705 
1706  if (stop != -1) {
1707  temp = x(0, stop);
1708  TSubString newString = x(stop + delimLength, stringLength);
1709  x = newString;
1710  stringLength = x.Length();
1711  } else {
1712  stringLength = x.Length();
1713  temp = x(0, stringLength);
1714  }
1715 
1716  v.emplace_back(temp);
1717  }
1718  }
1719 
1720 } // namespace MuonPhysValMonitoring
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonExtrapolatedTracksName
Gaudi::Property< std::string > m_muonExtrapolatedTracksName
Definition: MuonPhysValMonitoringTool.h:125
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vRecoMuons_EffDen_MS
std::vector< const xAOD::Muon * > m_vRecoMuons_EffDen_MS
Definition: MuonPhysValMonitoringTool.h:217
ShallowCopy.h
xAOD::L2CombinedMuon_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleTruthMuonSegment
void handleTruthMuonSegment(const xAOD::MuonSegment *truthMuSeg, const xAOD::TruthParticleContainer *muonTruthContainer, float weight=1.0)
Definition: MuonPhysValMonitoringTool.cxx:858
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonPlots
std::unique_ptr< Muon::RecoMuonPlotOrganizer > m_oUnmatchedRecoMuonPlots
Definition: MuonPhysValMonitoringTool.h:185
temp
Definition: JetEventDict.h:21
MuonPhysValMonitoring::MuonPhysValMonitoringTool::INFLIGHT
@ INFLIGHT
Definition: MuonPhysValMonitoringTool.h:80
xAOD::Muon_v1::allAuthors
uint16_t allAuthors() const
Get all the authors of this Muon.
xAOD::name
name
Definition: TriggerMenuJson_v1.cxx:29
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedTruthMuons
std::vector< const xAOD::TruthParticle * > m_vMatchedTruthMuons
Definition: MuonPhysValMonitoringTool.h:201
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_nObjects
std::vector< TH1F * > m_h_overview_nObjects
Definition: MuonPhysValMonitoringTool.h:193
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vRecoMuons
std::vector< const xAOD::Muon * > m_vRecoMuons
Definition: MuonPhysValMonitoringTool.h:215
xAOD::SlowMuon_v1
Class describing a SlowMuon.
Definition: SlowMuon_v1.h:26
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonL2CBName
Gaudi::Property< std::string > m_muonL2CBName
Definition: MuonPhysValMonitoringTool.h:133
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSegmentsName
Gaudi::Property< std::string > m_muonSegmentsName
Definition: MuonPhysValMonitoringTool.h:129
PlotBase::retrieveBookedTrees
std::vector< TreeData > retrieveBookedTrees()
Retrieve all booked trees.
Definition: PlotBase.cxx:73
PlotBase
Definition: PlotBase.h:34
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSegmentsTruthName
Gaudi::Property< std::string > m_muonSegmentsTruthName
Definition: MuonPhysValMonitoringTool.h:130
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
xAOD::Muon_v1::trackParticle
const TrackParticle * trackParticle(TrackParticleType type) const
Returns a pointer (which can be NULL) to the TrackParticle used in identification of this muon.
Definition: Muon_v1.cxx:486
MuonPhysValMonitoring::MuonPhysValMonitoringTool::printMuonDebug
void printMuonDebug(const xAOD::Muon *mu)
Definition: MuonPhysValMonitoringTool.cxx:1286
ManagedMonitorToolBase
Provides functionality for users to implement and save histograms, ntuples, and summary data,...
Definition: ManagedMonitorToolBase.h:73
MuonPhysValMonitoring::MuonPhysValMonitoringTool::MUCATEGORY
MUCATEGORY
Definition: MuonPhysValMonitoringTool.h:80
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoMuonSegment
const xAOD::MuonSegment * findRecoMuonSegment(const xAOD::MuonSegment *truthMuSeg)
Definition: MuonPhysValMonitoringTool.cxx:1362
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vRecoMuons_EffDen_CB
std::vector< const xAOD::Muon * > m_vRecoMuons_EffDen_CB
Definition: MuonPhysValMonitoringTool.h:216
xAOD::L2StandAloneMuon_v2
Class describing standalone muons reconstructed in the LVL2 trigger.
Definition: L2StandAloneMuon_v2.h:36
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_eventInfo
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo
Definition: MuonPhysValMonitoringTool.h:159
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
xAODP4Helpers.h
MuonRoIContainer.h
ManagedMonitorToolBase::regTree
virtual StatusCode regTree(TTree *t, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TTree to be included in the output stream using logical parameters that describe it.
Definition: ManagedMonitorToolBase.cxx:1547
xAOD::Muon_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doTrigMuonValidation
Gaudi::Property< bool > m_doTrigMuonValidation
Definition: MuonPhysValMonitoringTool.h:152
TruthVertexContainer.h
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonTrees
void handleMuonTrees(const xAOD::EventInfo *eventInfo, bool isData)
Definition: MuonPhysValMonitoringTool.cxx:1010
plotmaker.hist
hist
Definition: plotmaker.py:148
CutsMETMaker::accept
StatusCode accept(const xAOD::Muon *mu)
Definition: CutsMETMaker.cxx:18
L2CombinedMuonContainer.h
TruthLink
ElementLink< xAOD::TruthParticleContainer > TruthLink
Definition: TruthRelatedMuonPlotOrganizer.cxx:12
RTTAlgmain.trees
list trees
Definition: RTTAlgmain.py:40
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
tree
TChain * tree
Definition: tile_monitor.h:30
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vEFMuons
std::vector< const xAOD::Muon * > m_vEFMuons
Definition: MuonPhysValMonitoringTool.h:209
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMETrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMETrackValidationPlots
Definition: MuonPhysValMonitoringTool.h:179
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
xAOD::Muon_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSOnlyMETrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMSOnlyMETrackValidationPlots
Definition: MuonPhysValMonitoringTool.h:180
SlowMuonAuxContainer.h
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vZmumuIDTracks
std::vector< const xAOD::TrackParticle * > m_vZmumuIDTracks
Definition: MuonPhysValMonitoringTool.h:206
xAOD::MuonRoI_v1::eta
float eta() const
The pseudorapidity ( ) of the muon candidate.
xAOD::MuonSegment_v1
Class describing a MuonSegment.
Definition: MuonSegment_v1.h:33
ParticleTest.tp
tp
Definition: ParticleTest.py:25
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
xAOD::MuonRoI_v1::thrValue
float thrValue() const
The highest threshold value (in MeV) passed by the muon candidate.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleTruthMuon
void handleTruthMuon(const xAOD::TruthParticle *truthMu, float weight=1.0)
Definition: MuonPhysValMonitoringTool.cxx:957
L2StandAloneMuonContainer.h
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoMuon
const xAOD::Muon * findRecoMuon(const xAOD::TruthParticle *truthMu)
Definition: MuonPhysValMonitoringTool.cxx:1296
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonValidationPlots
std::vector< std::unique_ptr< MuonValidationPlots > > m_muonValidationPlots
Definition: MuonPhysValMonitoringTool.h:176
PixelModuleFeMask_create_db.stop
int stop
Definition: PixelModuleFeMask_create_db.py:76
xAOD::Muon_v1::author
Author author() const
SG::ConstAccessor< float >
MuonPhysValMonitoring::MuonPhysValMonitoringTool::procHistograms
virtual StatusCode procHistograms() override
An inheriting class should either override this function or finalHists().
Definition: MuonPhysValMonitoringTool.cxx:1331
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2SAMuons
std::vector< const xAOD::L2StandAloneMuon * > m_vL2SAMuons
Definition: MuonPhysValMonitoringTool.h:211
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedMuons
std::vector< const xAOD::Muon * > m_vMatchedMuons
Definition: MuonPhysValMonitoringTool.h:202
MuonPhysValMonitoring::MuonPhysValMonitoringTool::getMuonSegmentTruthCategory
MuonPhysValMonitoringTool::MUCATEGORY getMuonSegmentTruthCategory(const xAOD::MuonSegment *truthMuSeg, const xAOD::TruthParticleContainer *muonTruthContainer)
Definition: MuonPhysValMonitoringTool.cxx:1392
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
xAOD::EventInfo_v1::IS_SIMULATION
@ IS_SIMULATION
true: simulation, false: data
Definition: EventInfo_v1.h:151
x
#define x
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_slowMuonsName
Gaudi::Property< std::string > m_slowMuonsName
Definition: MuonPhysValMonitoringTool.h:122
MuonPhysValMonitoring::MuonPhysValMonitoringTool::fillHistograms
virtual StatusCode fillHistograms() override
An inheriting class should either override this function or fillHists().
Definition: MuonPhysValMonitoringTool.cxx:270
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectHLTMuonItems
Gaudi::Property< std::vector< std::vector< std::string > > > m_selectHLTMuonItems
Definition: MuonPhysValMonitoringTool.h:144
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
xAOD::L2StandAloneMuon_v2::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::EFTriggerResolution
void EFTriggerResolution()
Definition: MuonPhysValMonitoringTool.cxx:1238
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_reco_category
TH1F * m_h_overview_reco_category
Definition: MuonPhysValMonitoringTool.h:194
python.CreateTierZeroArgdict.pairs
pairs
Definition: CreateTierZeroArgdict.py:201
xAOD::L2CombinedMuon_v1
Class describing combined muon reconstructed in the LVL2 trigger.
Definition: L2CombinedMuon_v1.h:41
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDTrackValidationPlots
Definition: MuonPhysValMonitoringTool.h:181
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonL2Trigger
void handleMuonL2Trigger(const xAOD::L2StandAloneMuon *L2SAMu)
Definition: MuonPhysValMonitoringTool.cxx:1132
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:189
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedSlowMuons
std::vector< const xAOD::SlowMuon * > m_vMatchedSlowMuons
Definition: MuonPhysValMonitoringTool.h:203
Trig::FeatureContainer
Definition: FeatureContainer.h:54
xAOD::Muon_v1::charge
float charge() const
MuonAuxContainer.h
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSOnlyExtrapolatedTracksName
Gaudi::Property< std::string > m_muonMSOnlyExtrapolatedTracksName
Definition: MuonPhysValMonitoringTool.h:127
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
xAOD::TrackParticle_v1::p4
virtual FourMom_t p4() const override final
The full 4-momentum of the particle.
Definition: TrackParticle_v1.cxx:129
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonSegment
void handleMuonSegment(const xAOD::MuonSegment *muSeg, float weight=1.0)
Definition: MuonPhysValMonitoringTool.cxx:874
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonTracksName
Gaudi::Property< std::string > m_muonTracksName
Definition: MuonPhysValMonitoringTool.h:124
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_L1MuonItems
Gaudi::Property< std::vector< std::string > > m_L1MuonItems
Definition: MuonPhysValMonitoringTool.h:145
xAOD::L2CombinedMuon_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doTrigMuonEFValidation
Gaudi::Property< bool > m_doTrigMuonEFValidation
Definition: MuonPhysValMonitoringTool.h:155
PlotBase::retrieveBookedHistograms
std::vector< HistData > retrieveBookedHistograms()
Retrieve all booked histograms.
Definition: PlotBase.cxx:63
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
PixelAthClusterMonAlgCfg.histname
histname
Definition: PixelAthClusterMonAlgCfg.py:106
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedMuonSegments
std::vector< const xAOD::MuonSegment * > m_vMatchedMuonSegments
Definition: MuonPhysValMonitoringTool.h:205
SG::ExcBadAuxVar
Exception — Attempt to retrieve nonexistent aux data item.
Definition: Control/AthContainers/AthContainers/exceptions.h:59
MuonPhysValMonitoring::MuonPhysValMonitoringTool::bookHistograms
virtual StatusCode bookHistograms() override
An inheriting class should either override this function or bookHists().
Definition: MuonPhysValMonitoringTool.cxx:105
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonL1TrigName
Gaudi::Property< std::string > m_muonL1TrigName
Definition: MuonPhysValMonitoringTool.h:131
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_L1Seed
std::vector< std::string > m_L1Seed
Definition: MuonPhysValMonitoringTool.h:112
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:617
MuonPhysValMonitoring::getMatchingProbability
float getMatchingProbability(const xAOD::TrackParticle &trackParticle)
Definition: MuonPhysValMonitoringTool.cxx:57
SG::Decorator< float >
HepMC::is_simulation_particle
bool is_simulation_particle(const T &p)
Method to establish if a particle (or barcode) was created during the simulation (TODO update to be s...
Definition: MagicNumbers.h:342
xAOD::L2StandAloneMuon_v2::sAddress
int sAddress() const
Get the station address of the muon.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonEFCombTrigName
Gaudi::Property< std::string > m_muonEFCombTrigName
Definition: MuonPhysValMonitoringTool.h:134
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonTrigger
void handleMuonTrigger(const xAOD::Muon *mu)
Definition: MuonPhysValMonitoringTool.cxx:1227
lumiFormat.i
int i
Definition: lumiFormat.py:85
MuonPhysValMonitoringTool.h
PlotBase::initialize
void initialize()
Definition: PlotBase.cxx:39
h
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_isData
Gaudi::Property< bool > m_isData
Definition: MuonPhysValMonitoringTool.h:157
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDForwardTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDForwardTrackValidationPlots
Definition: MuonPhysValMonitoringTool.h:183
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
extractSporadic.h
list h
Definition: extractSporadic.py:97
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSegmentValidationPlots
std::vector< std::unique_ptr< MuonSegmentValidationPlots > > m_muonSegmentValidationPlots
Definition: MuonPhysValMonitoringTool.h:184
ReweightUtils.category
category
Definition: ReweightUtils.py:15
xAOD::TruthParticle_v1
Class describing a truth particle in the MC record.
Definition: TruthParticle_v1.h:37
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_reco_authors
std::vector< TH1F * > m_h_overview_reco_authors
Definition: MuonPhysValMonitoringTool.h:195
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_TriggerMuonValidationPlots
std::vector< std::unique_ptr< TriggerMuonValidationPlots > > m_TriggerMuonValidationPlots
Definition: MuonPhysValMonitoringTool.h:177
MuonPhysValMonitoring::MuonPhysValMonitoringTool::getMuonTruthCategory
MuonPhysValMonitoringTool::MUCATEGORY getMuonTruthCategory(const xAOD::IParticle *prt)
Definition: MuonPhysValMonitoringTool.cxx:1412
xAOD::L2CombinedMuon_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
xAOD::MuonRoI_v1
Class describing a LVL1 muon region of interest.
Definition: MuonRoI_v1.h:29
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonsName
Gaudi::Property< std::string > m_muonsName
Definition: MuonPhysValMonitoringTool.h:121
HepMC::uniqueID
int uniqueID(const T &p)
Definition: MagicNumbers.h:109
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectComissioning
Gaudi::Property< bool > m_selectComissioning
Flag to tell whether muons with the comissioning author will be selected or not.
Definition: MuonPhysValMonitoringTool.h:143
test_pyathena.parent
parent
Definition: test_pyathena.py:15
MuonPhysValMonitoring::MuonPhysValMonitoringTool::SplitString
void SplitString(TString x, const TString &delim, std::vector< TString > &v)
Definition: MuonPhysValMonitoringTool.cxx:1696
xAOD::Muon_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonAuthors
Gaudi::Property< std::vector< unsigned int > > m_selectMuonAuthors
Definition: MuonPhysValMonitoringTool.h:138
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MakeTH3DFromTH2Ds.hists
hists
Definition: MakeTH3DFromTH2Ds.py:72
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSelectionTool
ToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
Definition: MuonPhysValMonitoringTool.h:162
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_Z_mass_ID
TH1F * m_h_overview_Z_mass_ID
Definition: MuonPhysValMonitoringTool.h:199
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_MSTracks
const xAOD::TrackParticleContainer * m_MSTracks
Definition: MuonPhysValMonitoringTool.h:109
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
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonWPs
Gaudi::Property< std::vector< int > > m_selectMuonWPs
Definition: MuonPhysValMonitoringTool.h:136
MuonPhysValMonitoring::MuonPhysValMonitoringTool::initialize
virtual StatusCode initialize() override
Definition: MuonPhysValMonitoringTool.cxx:75
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doTrigMuonL1Validation
Gaudi::Property< bool > m_doTrigMuonL1Validation
Definition: MuonPhysValMonitoringTool.h:153
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_SelectedAuthor
int m_SelectedAuthor
Definition: MuonPhysValMonitoringTool.h:113
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
MuonParameters::NumberOfMuonAuthors
@ NumberOfMuonAuthors
Definition: MuonParamDefs.h:69
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMSTrackValidationPlots
Definition: MuonPhysValMonitoringTool.h:178
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doTrigMuonL2Validation
Gaudi::Property< bool > m_doTrigMuonL2Validation
Definition: MuonPhysValMonitoringTool.h:154
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
MuonPhysValMonitoring
Definition: MuonPhysValMonitoringTool.cxx:50
HepMC::UNDEFINED_ID
constexpr int UNDEFINED_ID
Definition: MagicNumbers.h:55
SlowMuonContainer.h
xAOD::IParticle::pt
virtual double pt() const =0
The transverse momentum ( ) of the particle.
xAOD::SlowMuon_v1::muonLink
const ElementLink< MuonContainer > & muonLink() const
TruthVertexAuxContainer.h
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedMuonTracks
std::vector< const xAOD::TrackParticle * > m_vMatchedMuonTracks
Definition: MuonPhysValMonitoringTool.h:204
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonCategoriesStr
std::vector< std::string > m_selectMuonCategoriesStr
Definition: MuonPhysValMonitoringTool.h:168
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedTruthMuonPlots
std::unique_ptr< Muon::TruthMuonPlotOrganizer > m_oUnmatchedTruthMuonPlots
Definition: MuonPhysValMonitoringTool.h:186
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
Trig::FeatureContainer::get
const std::vector< Trig::Feature< T > > get(const std::string &label="", unsigned int condition=TrigDefs::Physics, const std::string &teName="") const
returns flattened vector of Features of given type This method is in fact sullied by 3 arguments.
Definition: FeatureContainer.h:151
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonCategories
Gaudi::Property< std::vector< unsigned int > > m_selectMuonCategories
Definition: MuonPhysValMonitoringTool.h:146
threshold
Definition: chainparser.cxx:74
MuonPhysValMonitoring::MuonPhysValMonitoringTool::printTruthMuonDebug
void printTruthMuonDebug(const xAOD::TruthParticle *truthMu, const xAOD::Muon *mu)
Definition: MuonPhysValMonitoringTool.cxx:1325
MuonPhysValMonitoring::MuonPhysValMonitoringTool::PROMPT
@ PROMPT
Definition: MuonPhysValMonitoringTool.h:80
MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2CBTriggerResolution
void L2CBTriggerResolution()
Definition: MuonPhysValMonitoringTool.cxx:1191
MuonPhysValMonitoring::MuonPhysValMonitoringTool::NONISO
@ NONISO
Definition: MuonPhysValMonitoringTool.h:80
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonSegmentPlots
std::unique_ptr< Muon::MuonSegmentPlots > m_oUnmatchedRecoMuonSegmentPlots
Definition: MuonPhysValMonitoringTool.h:188
MuonParameters::MuidSA
@ MuidSA
Definition: MuonParamDefs.h:59
SG::AuxElement::makePrivateStore
void makePrivateStore()
Create a new (empty) private store for this object.
Definition: AuxElement.cxx:172
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonTrack
void handleMuonTrack(const xAOD::TrackParticle *tp, xAOD::Muon::TrackParticleType type, float weight=1.0)
Definition: MuonPhysValMonitoringTool.cxx:1021
MuonPhysValMonitoring::MuonPhysValMonitoringTool::passesAcceptanceCuts
bool passesAcceptanceCuts(const xAOD::IParticle *prt)
Definition: MuonPhysValMonitoringTool.cxx:1690
xAOD::TruthParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TruthParticle_v1.cxx:174
xAOD::L2StandAloneMuon_v2::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_trigDec
ToolHandle< Trig::TrigDecisionTool > m_trigDec
Definition: MuonPhysValMonitoringTool.h:164
MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2SATriggerResolution
void L2SATriggerResolution()
Definition: MuonPhysValMonitoringTool.cxx:1144
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
MuonContainer.h
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2SAMuonsSelected
std::vector< const xAOD::L2StandAloneMuon * > m_vL2SAMuonsSelected
Definition: MuonPhysValMonitoringTool.h:212
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_fwdtracksName
Gaudi::Property< std::string > m_fwdtracksName
Definition: MuonPhysValMonitoringTool.h:120
python.PyAthena.v
v
Definition: PyAthena.py:154
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2CBMuons
std::vector< const xAOD::L2CombinedMuon * > m_vL2CBMuons
Definition: MuonPhysValMonitoringTool.h:213
Muon::MuonSegmentPlots
Definition: MuonSegmentPlots.h:18
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vZmumuMETracks
std::vector< const xAOD::TrackParticle * > m_vZmumuMETracks
Definition: MuonPhysValMonitoringTool.h:207
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doBinnedResolutionPlots
Gaudi::Property< bool > m_doBinnedResolutionPlots
Definition: MuonPhysValMonitoringTool.h:151
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doMuonTree
Gaudi::Property< bool > m_doMuonTree
Definition: MuonPhysValMonitoringTool.h:156
MC::isStable
bool isStable(const T &p)
Identify if the particle is stable, i.e. has not decayed.
Definition: HepMCHelpers.h:45
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_trackSelector
ToolHandle< Trk::ITrackSelectorTool > m_trackSelector
Definition: MuonPhysValMonitoringTool.h:165
MuonPhysValMonitoring::MuonPhysValMonitoringTool::REST
@ REST
Definition: MuonPhysValMonitoringTool.h:80
Muons
Definition: Muons.py:1
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoSlowMuon
const xAOD::SlowMuon * findRecoSlowMuon(const xAOD::TruthParticle *truthMu)
Definition: MuonPhysValMonitoringTool.cxx:1307
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_Z_mass_ME
TH1F * m_h_overview_Z_mass_ME
Definition: MuonPhysValMonitoringTool.h:198
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
xAOD::P4Helpers
Definition: xAODP4Helpers.h:36
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonL2SAName
Gaudi::Property< std::string > m_muonL2SAName
Definition: MuonPhysValMonitoringTool.h:132
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonL1Trigger
void handleMuonL1Trigger(const xAOD::MuonRoI *TrigL1mu)
Definition: MuonPhysValMonitoringTool.cxx:1122
xAOD::IParticle::eta
virtual double eta() const =0
The pseudorapidity ( ) of the particle.
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
MuonRoI.h
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2CBMuonsSelected
std::vector< const xAOD::L2CombinedMuon * > m_vL2CBMuonsSelected
Definition: MuonPhysValMonitoringTool.h:214
DEBUG
#define DEBUG
Definition: page_access.h:11
CaloCondBlobAlgs_fillNoiseFromASCII.author
string author
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:26
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_tracksName
Gaudi::Property< std::string > m_tracksName
Definition: MuonPhysValMonitoringTool.h:119
ManagedMonitorToolBase::all
@ all
Definition: ManagedMonitorToolBase.h:115
MuonPhysValMonitoring::MuonPhysValMonitoringTool::bookValidationPlots
StatusCode bookValidationPlots(PlotBase &valPlots)
Definition: MuonPhysValMonitoringTool.cxx:238
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonTrackPlots
std::unique_ptr< Muon::RecoMuonTrackPlotOrganizer > m_oUnmatchedRecoMuonTrackPlots
Definition: MuonPhysValMonitoringTool.h:187
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonsTruthName
Gaudi::Property< std::string > m_muonsTruthName
Definition: MuonPhysValMonitoringTool.h:123
covarianceTool.plots
plots
Definition: covarianceTool.py:698
xAOD::TruthParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TruthParticle_v1.cxx:166
xAOD::L2StandAloneMuon_v2::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
SG::ConstAccessor::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
IParticleHelpers.h
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vRecoMuons_EffDen
std::vector< const xAOD::Muon * > m_vRecoMuons_EffDen
Definition: MuonPhysValMonitoringTool.h:218
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vZmumuMuons
std::vector< const xAOD::Muon * > m_vZmumuMuons
Definition: MuonPhysValMonitoringTool.h:208
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
xAOD::L2StandAloneMuon_v2::roiWord
uint32_t roiWord() const
Get the RoI ID of the seeding LVL1 muon.
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDSelectedTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDSelectedTrackValidationPlots
Definition: MuonPhysValMonitoringTool.h:182
MuonPhysValMonitoring::MuonPhysValMonitoringTool::modifyHistogram
void modifyHistogram(TH1 *hist)
Definition: MuonPhysValMonitoringTool.cxx:1445
ConstAccessor.h
Helper class to provide constant type-safe access to aux data.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuon
void handleMuon(const xAOD::Muon *mu, const xAOD::SlowMuon *smu=nullptr, float weight=1.0)
Definition: MuonPhysValMonitoringTool.cxx:890
MuonEnumDefs.h
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_slowMuonValidationPlots
std::vector< std::unique_ptr< SlowMuonValidationPlots > > m_slowMuonValidationPlots
Definition: MuonPhysValMonitoringTool.h:190
MuonPhysValMonitoring::MuonPhysValMonitoringTool::ALL
@ ALL
Definition: MuonPhysValMonitoringTool.h:80
makeComparison.deltaR
float deltaR
Definition: makeComparison.py:36
python.compressB64.c
def c
Definition: compressB64.py:93
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonItems
std::vector< std::string > m_muonItems
Definition: MuonPhysValMonitoringTool.h:111
xAOD::EventInfo_v1::beamSpotWeight
float beamSpotWeight() const
Weight for beam spot size reweighting.
Definition: EventInfo_v1.cxx:970
ManagedMonitorToolBase::regHist
virtual StatusCode regHist(TH1 *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical ...
Definition: ManagedMonitorToolBase.cxx:1346
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_Z_mass
TH1F * m_h_overview_Z_mass
Definition: MuonPhysValMonitoringTool.h:197
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findHistogram
TH1F * findHistogram(const std::vector< HistData > &hists, const std::string &hnameTag, const std::string &hdirTag, const std::string &hNewName)
Definition: MuonPhysValMonitoringTool.cxx:1377
HepMCHelpers.h
MuonPhysValMonitoring::MuonPhysValMonitoringTool::getCorrectedMuon
std::unique_ptr< xAOD::Muon > getCorrectedMuon(const xAOD::Muon &mu)
Definition: MuonPhysValMonitoringTool.cxx:1425
fitman.k
k
Definition: fitman.py:528
xAOD::EventInfo_v1::eventType
bool eventType(EventType type) const
Check for one particular bitmask value.
SG::ConstAccessor::withDefault
const_reference_type withDefault(const ELT &e, const T &deflt) const
Fetch the variable for one element, as a const reference, with a default.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vEFMuonsSelected
std::vector< const xAOD::Muon * > m_vEFMuonsSelected
Definition: MuonPhysValMonitoringTool.h:210
xAOD::MuonRoI_v1::phi
float phi() const
The azimuthal angle ( ) of the muon candidate.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_isoTool
ToolHandle< CP::IIsolationSelectionTool > m_isoTool
Definition: MuonPhysValMonitoringTool.h:166
Generated on Thu Nov 7 2024 21:22:12 for ATLAS Offline Software by   doxygen 1.8.18