ATLAS Offline Software
IDPerfMonZmumu.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 //==================================================================================
6 // Include files...
7 //==================================================================================
8 // This files header
9 #include "InDetPerformanceMonitoring/IDPerfMonZmumu.h"
10 // Standard headers
11 #include "TTree.h"
12 #include "TLorentzVector.h"
13 
14 #include "InDetPerformanceMonitoring/PerfMonServices.h"
15 #include "InDetPerformanceMonitoring/ZmumuEvent.h"
16 #include "InDetPerformanceMonitoring/FourMuonEvent.h"
17 
18 #include "egammaInterfaces/IegammaTrkRefitterTool.h"
19 #include "EventPrimitives/EventPrimitivesHelpers.h"
20 
21 // ATLAS headers
22 #include "GaudiKernel/IInterface.h"
23 #include "StoreGate/StoreGateSvc.h"
24 
25 #include "TrkTruthData/TrackTruthCollection.h"
26 #include "TrkTruthData/TrackTruthKey.h"
27 
29 #include "TrkVertexFitterInterfaces/ITrackToVertexIPEstimator.h"
30 
31 #include "TrigConfxAOD/xAODConfigTool.h"
32 #include "TrigDecisionTool/TrigDecisionTool.h"
33 #include "TriggerMatchingTool/MatchingTool.h"
34 #include "TrigDecisionTool/ChainGroup.h"
35 
36 #include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
37 #include "MuonAnalysisInterfaces/IMuonSelectionTool.h"
38 
40 #include "xAODMissingET/MissingET.h"
41 #include "xAODMissingET/MissingETContainer.h"
42 #include "AthContainers/ConstAccessor.h"
43 
44 //==================================================================================
45 // Public Methods
46 //==================================================================================
47 IDPerfMonZmumu::IDPerfMonZmumu(const std::string& name,
48  ISvcLocator* pSvcLocator):
49  AthAlgorithm(name, pSvcLocator),
50  m_isMC(false),
51  m_doRefit(false),
52  m_TrackRefitter1(""),
53  m_TrackRefitter2(""),
54  m_trackToVertexTool("Reco::TrackToVertex"),
55  m_triggerDecision("Trig::TrigDecisionTool/TrigDecisionTool"),
56  m_triggerMatching("Trig::MatchingTool/MatchingTool"),
57  m_selTool( "InDet::InDetTrackSelectionTool/TrackSelectionTool"),
58  m_trackToVertexIPEstimator("Trk::TrackToVertexIPEstimator"),
59  m_extrapolator("Trk::Extrapolator/AtlasExtrapolator"),
60  m_muonSelector("CP::MuonSelectionTool/MuonSelectionTool"),
61  m_validationMode(true),
62 
63  m_commonTreeName ("commonTree"),
64  m_defaultTreeName("Default_Particle"),
65  m_IDTreeName ("ID_InDetTrackParticle"),
66  m_refit1TreeName ("Refit1_SiAndTRT"),
67  m_refit2TreeName ("Refit2_SiOnly"),
68  m_truthTreeName ("TruthParams"),
69  m_combTreeName ("CombinedTrackParticle"),
70  m_MSTreeName ("MS_TrackParticle"),
71  m_FourMuTreeName ("FourMu"),
72 
73  m_ValidationTreeDescription("Small Tree for Zmumu fits"),
74 
75  m_commonTreeFolder ("/ZmumuValidation/common"),
76  m_defaultTreeFolder("/ZmumuValidation/default"),
77  m_IDTreeFolder ("/ZmumuValidation/ID"),
78  m_refit1TreeFolder ("/ZmumuValidation/refit1"),
79  m_refit2TreeFolder ("/ZmumuValidation/refit2"),
80  m_truthTreeFolder ("/ZmumuValidation/truth"),
81  m_combTreeFolder ("/ZmumuValidation/comb"),
82  m_MSTreeFolder ("/ZmumuValidation/ms"),
83  m_FourMuTreeFolder ("/ZmumuValidation/fourmu"),
84 
85  m_commonTree (nullptr),
86  m_defaultTree(nullptr),
87  m_IDTree(nullptr),
88  m_refit1Tree(nullptr),
89  m_refit2Tree(nullptr),
90  m_truthTree(nullptr),
91  m_combTree(nullptr),
92  m_MSTree(nullptr),
93  m_FourMuTree(nullptr),
94  m_doRemoval(true),
95  m_doDebug(false),
96  m_Trk2VtxAssociationTool("CP::TrackVertexAssociationTool", this)
97 {
98  // Properties that are set from the python scripts.
99 
100  declareProperty("UseTrigger" , m_UseTrigger = true);
101  declareProperty("doIsoSelection", m_doIsoSelection = true );
102  declareProperty("doIPSelection", m_doIPSelection = true );
103  declareProperty("doMCPSelection", m_doMCPSelection = true );
104  declareProperty("isMC", m_isMC = false);
105  declareProperty("doRefit", m_doRefit = false);
106  declareProperty("doIPextrToPV", m_doIP = false);
107  declareProperty("Extrapolator", m_extrapolator );
108  declareProperty("MassWindowLow", m_MassWindowLow = 60.0, "Lower cut in mu+mu- invariant mass" );
109  declareProperty("MassWindowHigh", m_MassWindowHigh = 120.0, "Upper cut in mu+mu- invariant mass" );
110  declareProperty("OpeningAngle", m_OpeningAngleCut = 0.2, "Opening angle between the two muons (in radians)");
111  declareProperty("OutputTracksName", m_outputTracksName = "ZmumuTracks");
112  declareProperty("PtLeadingMuon", m_LeadingMuonPtCut = 20., "Pt cut on the leading muon");
113  declareProperty("PtSecondMuon", m_SecondMuonPtCut = 15., "Pt cut on the second muon");
114  declareProperty("ReFitterTool1", m_TrackRefitter1, "ToolHandle for track fitter implementation");
115  declareProperty("ReFitterTool2", m_TrackRefitter2, "ToolHandle for track fitter implementation");
116  declareProperty("TrackToVertexTool", m_trackToVertexTool);
117  declareProperty("TrackTruthName", m_truthName="TrackTruthCollection");
118  declareProperty("TrackParticleName", m_trackParticleName="CombinedTrackParticle");
119  declareProperty("triggerChainName", m_sTriggerChainName);
120  declareProperty("ValidationMode", m_validationMode);
121  declareProperty("xAODTruthLinkVector", m_truthLinkVecName="xAODTruthLinks");
122  declareProperty("Z0Gap", m_Z0GapCut = 5.0, "maximum gap between the z0 of both muons (in mm)");
123  declareProperty("TrackSelectionTool", m_selTool );
124  declareProperty("UseTrackSelectionTool", m_useTrackSelectionTool = false);
125  declareProperty("TrackToVertexIPEstimator", m_trackToVertexIPEstimator);
126 
127 
128  declareProperty("commonTreeFolder", m_commonTreeFolder, "/ZmumuValidationUserSel/common" );
129  declareProperty("defaultTreeFolder", m_defaultTreeFolder );
130  declareProperty("IDTreeFolder", m_IDTreeFolder );
131  declareProperty("refit1TreeFolder", m_refit1TreeFolder );
132  declareProperty("refit2TreeFolder", m_refit2TreeFolder );
133  declareProperty("truthTreeFolder", m_truthTreeFolder );
134  declareProperty("combTreeFolder", m_combTreeFolder );
135  declareProperty("MSTreeFolder", m_MSTreeFolder, "/ZmumuValidationUserSel/ms" );
136 
137  declareProperty("UnbiasVertex", m_doRemoval);
138 
139  declareProperty("commonTree", m_commonTreeName, "CommonTree" );
140  declareProperty("DefaultTree", m_defaultTreeName );
141  declareProperty("IDTree", m_IDTreeName );
142  declareProperty("CBTree", m_combTreeName );
143  declareProperty("Refit1Tree", m_refit1TreeName );
144  declareProperty("Refit2Tree", m_refit2TreeName );
145  declareProperty("MSTree", m_MSTreeName );
146 
147  declareProperty("doFourMuAnalysis", m_doFourMuAnalysis = false);
148  declareProperty("FourMuTreeFolder", m_FourMuTreeFolder);
149 
150  declareProperty("StoreZmumuNtuple", m_storeZmumuNtuple = true);
151  declareProperty("doZmumuEventDebug", m_doDebug);
152  declareProperty("MuonQuality", m_MuonQualityName = "Medium");
153  declareProperty("skipMS", m_skipMS = false);
154  declareProperty("useCustomMuonSelector", m_useCustomMuonSelector = false );
155  declareProperty("MuonSelector", m_muonSelector );
156 
157  declareProperty( "MinLumiBlock", m_minGoodLumiBlock = 0, "minimum lumiblock number to be accepted");
158  declareProperty( "MaxLumiBlock", m_maxGoodLumiBlock = 0, "maximum lumiblock number to be accepted");
159 
160  return;
161 }
162 
163 
164 //==================================================================================
165 IDPerfMonZmumu::~IDPerfMonZmumu()
166 {}
167 
168 
169 //==================================================================================
170 StatusCode IDPerfMonZmumu::initialize()
171 {
172  ATH_MSG_DEBUG ("** IDPerfMonZmumu::Initialize ** START **");
173  // Setup the services
174  ISvcLocator* pxServiceLocator = serviceLocator();
175  if ( pxServiceLocator != nullptr ) {
176  StatusCode xSC = PerfMonServices::InitialiseServices( pxServiceLocator );
177  if ( xSC == StatusCode::FAILURE ) {
178  ATH_MSG_FATAL("Problem Initializing PerfMonServices");
179  return StatusCode::FAILURE;
180  }
181  else {
182  ATH_MSG_DEBUG("PerfMonServices::InitialiseServices( pxServiceLocator ); SUCCESS ");
183  }
184  }
185 
186  // Retrieve Track fitter and track to vertex
187  if (m_doRefit) { // only if track refit is requested
188  if (m_TrackRefitter1.retrieve().isSuccess()) {
189  ATH_MSG_INFO("Retrieved tool m_TrackRefitter1: " << m_TrackRefitter1 << " SUCCESS ");
190  }
191  else {
192  ATH_MSG_FATAL("Unable to retrieve m_TrackRefitter1 " << m_TrackRefitter1 << " FAILURE ");
193  return StatusCode::FAILURE;
194  }
195 
196  // Retrieve the second fitter
197  if (m_TrackRefitter2.retrieve().isSuccess()) {
198  ATH_MSG_INFO("Retrieved tool m_TrackRefitter2: " << m_TrackRefitter2 << " SUCCESS ");
199  }
200  else {
201  ATH_MSG_FATAL("Unable to retrieve m_TrackRefitter2 " << m_TrackRefitter2 << " FAILURE ");
202  return StatusCode::FAILURE;
203  }
204 
205  if (m_trackToVertexTool.retrieve().isSuccess()) {
206  ATH_MSG_INFO("Retrieved tool m_trackToVertexTool " << m_trackToVertexTool << " SUCCESS ");
207  }
208  else {
209  ATH_MSG_FATAL("Unable to retrieve m_trackToVertexTool " << m_trackToVertexTool << " FAILURE ");
210  return StatusCode::FAILURE;
211  }
212  }
213 
214  if(m_useTrackSelectionTool){
215  // ATH_CHECK( m_selTool.retrieve() );
216  if (m_selTool.retrieve().isSuccess()){
217  ATH_MSG_INFO("Retrieved tool (track selection tool) m_selTool " << m_selTool << " SUCCESS ");
218  }
219  else {
220  ATH_MSG_FATAL("Unable to retrieve (track selection tool) m_selTool " << m_selTool << " FAILURE ");
221  return StatusCode::FAILURE;
222  }
223  }
224 
225  // initializing the eventInfo "accessor"
226  ATH_CHECK( m_EventInfoKey.initialize() );
227 
228  if (m_doIP) {
229  ATH_MSG_DEBUG("Retrieving tool (trackToVertexIPEstimator)");
230  ATH_CHECK (m_trackToVertexIPEstimator.retrieve());
231  }
232 
233 
234  ATH_CHECK (m_EventInfoKey.initialize()); // initializing the eventInfo "accessor"
235 
236  if (m_isMC) ATH_CHECK (m_extrapolator.retrieve()); // this is only used for the truth particles
237 
238  ATH_CHECK (m_vertexKey.initialize());
239 
240  ATH_CHECK (m_trackContainerName.initialize());
241 
242  ATH_MSG_INFO(" -- IDPerfMonZmumu::initialize() -- m_vertexKey: " << m_vertexKey);
243 
244  ATH_MSG_INFO(" -- IDPerfMonZmumu::initialize() -- init m_beamSpotKey ");
245  ATH_CHECK(m_beamSpotKey.initialize());
246 
247  // START new place for initilization of params
248  m_xZmm.setContainer (PerfMonServices::MUON_COLLECTION);
249  m_xZmm.doIsoSelection (m_doIsoSelection);
250  m_xZmm.doIPSelection (m_doIPSelection);
251  m_xZmm.doMCPSelection (m_doMCPSelection);
252  m_xZmm.SetMassWindowLow (m_MassWindowLow);
253  m_xZmm.SetMassWindowHigh (m_MassWindowHigh);
254  m_xZmm.SetLeadingMuonPtCut(m_LeadingMuonPtCut);
255  m_xZmm.SetSecondMuonPtCut (m_SecondMuonPtCut);
256  m_xZmm.SetOpeningAngleCut (m_OpeningAngleCut);
257  m_xZmm.SetZ0GapCut (m_Z0GapCut);
258  m_xZmm.setDebugMode (m_doDebug);
259  m_xZmm.SetMuonQuality (m_MuonQualityName);
260  m_xZmm.SetSkipMSCheck (m_skipMS);
261  m_xZmm.SetMinLumiBlock (m_minGoodLumiBlock);
262  m_xZmm.SetMaxLumiBlock (m_maxGoodLumiBlock);
263 
264  if (m_useCustomMuonSelector) {
265  m_xZmm.SetMuonSelectionTool (m_muonSelector);
266  }
267  // END new place for initialization of params
268 
269  if (m_doFourMuAnalysis) {
270  m_4mu.Init();
271  m_4mu.setDebugMode(true);
272  if (m_useCustomMuonSelector) m_4mu.SetMuonSelectionTool (m_muonSelector);
273  ATH_MSG_DEBUG(" IDPerfMonZmumu FourMuonAnalysis initialization completed " << m_Trk2VtxAssociationTool);
274  }
275 
276  // m_Trk2VtxAssociationTool = std::make_unique<CP::TrackVertexAssociationTool>("Loose");
277  if ( m_Trk2VtxAssociationTool.retrieve().isSuccess() ) {
278  ATH_MSG_DEBUG(" IDPerfMonZmumu Success retrieving tool " << m_Trk2VtxAssociationTool);
279  }
280  else { // is Failure
281  ATH_MSG_FATAL("IDPerfMonZmumu Failed to retrieve tool m_Trk2VtxAssociationTool " << m_Trk2VtxAssociationTool);
282  return StatusCode::FAILURE;
283  }
284 
285  ATH_CHECK ( this->bookTrees() );
286 
287  if (m_UseTrigger) { // load trigger decission and matching under user request
288  if (m_triggerDecision.retrieve().isFailure()) {
289  ATH_MSG_FATAL("Unable to retrieve " << m_triggerDecision << " turn it off");
290  return StatusCode::FAILURE;
291  }
292  else {
293  ATH_MSG_DEBUG("retrieved tool: " << m_triggerDecision );
294  }
295 
296  if(m_triggerMatching.retrieve().isFailure()) {
297  ATH_MSG_FATAL("Unable to retrieve " << m_triggerMatching << " turn it off");
298  return StatusCode::FAILURE;
299  }
300  else {
301  ATH_MSG_INFO("retrieved tool: " << m_triggerDecision );
302  }
303  }
304 
305  ATH_MSG_DEBUG("** IDPerfMonZmumu::Initialize ** Completed **");
306  return StatusCode::SUCCESS;
307 }
308 
309 
310 
311 //==================================================================================
312 StatusCode IDPerfMonZmumu::bookTrees()
313 {
314  m_h_cutflow = new TH1F("h_cutflow","cut flow histogram",11, -0.5, 9.5);
315 
316  ATH_MSG_DEBUG("initialize() ** bookTrees() ** m_commonTree name: " << m_commonTreeName.c_str());
317  ATH_MSG_DEBUG(" m_defaultTree name: " << m_defaultTreeName.c_str());
318  ATH_MSG_DEBUG(" m_IDTree name: " << m_IDTreeName.c_str());
319 
320  if (!m_commonTree) {
321  ATH_MSG_INFO("initialize() ** defining m_commonTree with name: " << m_commonTreeName.c_str());
322  m_commonTree = new TTree((m_commonTreeName).c_str(), m_ValidationTreeDescription.c_str());
323 
324  m_commonTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
325  m_commonTree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
326  m_commonTree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
327  m_commonTree->Branch("mu" , &m_event_mu, "mu/I");
328  m_commonTree->Branch("IDTrack_pt" , &m_IDTrack_pt);
329  m_commonTree->Branch("IDTrack_eta" , &m_IDTrack_eta);
330  m_commonTree->Branch("IDTrack_phi" , &m_IDTrack_phi);
331  m_commonTree->Branch("IDTrack_d0" , &m_IDTrack_d0);
332  m_commonTree->Branch("IDTrack_z0" , &m_IDTrack_z0);
333  m_commonTree->Branch("IDTrack_qoverp" , &m_IDTrack_qoverp);
334  m_commonTree->Branch("IDTrack_sigma_pt" , &m_IDTrack_sigma_pt);
335  m_commonTree->Branch("IDTrack_sigma_d0" , &m_IDTrack_sigma_d0);
336  m_commonTree->Branch("IDTrack_sigma_z0" , &m_IDTrack_sigma_z0);
337  m_commonTree->Branch("IDTrack_sigma_qoverp", &m_IDTrack_sigma_qoverp);
338  m_commonTree->Branch("CBTrack_pt" , &m_CBTrack_pt);
339  m_commonTree->Branch("CBTrack_eta" , &m_CBTrack_eta);
340  m_commonTree->Branch("CBTrack_phi" , &m_CBTrack_phi);
341  m_commonTree->Branch("CBTrack_d0" , &m_CBTrack_d0);
342  m_commonTree->Branch("CBTrack_z0" , &m_CBTrack_z0);
343  m_commonTree->Branch("CBTrack_qoverp" , &m_CBTrack_qoverp);
344  m_commonTree->Branch("CBTrack_sigma_pt" , &m_CBTrack_sigma_pt);
345  m_commonTree->Branch("CBTrack_sigma_d0" , &m_CBTrack_sigma_d0);
346  m_commonTree->Branch("CBTrack_sigma_z0" , &m_CBTrack_sigma_z0);
347  m_commonTree->Branch("CBTrack_sigma_qoverp", &m_CBTrack_sigma_qoverp);
348  m_commonTree->Branch("Refit1_pt" , &m_Refit1_pt);
349  m_commonTree->Branch("Refit1_eta" , &m_Refit1_eta);
350  m_commonTree->Branch("Refit1_phi" , &m_Refit1_phi);
351  m_commonTree->Branch("Refit1_d0" , &m_Refit1_d0);
352  m_commonTree->Branch("Refit1_z0" , &m_Refit1_z0);
353  m_commonTree->Branch("Refit1_qoverp" , &m_Refit1_qoverp);
354  m_commonTree->Branch("Refit1_sigma_pt" , &m_Refit1_sigma_pt);
355  m_commonTree->Branch("Refit1_sigma_d0" , &m_Refit1_sigma_d0);
356  m_commonTree->Branch("Refit1_sigma_z0" , &m_Refit1_sigma_z0);
357  m_commonTree->Branch("Refit1_sigma_qoverp" , &m_Refit1_sigma_qoverp);
358  m_commonTree->Branch("Refit2_pt" , &m_Refit2_pt);
359  m_commonTree->Branch("Refit2_eta" , &m_Refit2_eta);
360  m_commonTree->Branch("Refit2_phi" , &m_Refit2_phi);
361  m_commonTree->Branch("Refit2_d0" , &m_Refit2_d0);
362  m_commonTree->Branch("Refit2_z0" , &m_Refit2_z0);
363  m_commonTree->Branch("Refit2_qoverp" , &m_Refit2_qoverp);
364  m_commonTree->Branch("Refit2_sigma_pt" , &m_Refit2_sigma_pt);
365  m_commonTree->Branch("Refit2_sigma_d0" , &m_Refit2_sigma_d0);
366  m_commonTree->Branch("Refit2_sigma_z0" , &m_Refit2_sigma_z0);
367  m_commonTree->Branch("Refit2_sigma_qoverp" , &m_Refit2_sigma_qoverp);
368  m_commonTree->Branch("Truth_pt" , &m_Truth_pt);
369  m_commonTree->Branch("Truth_eta" , &m_Truth_eta);
370  m_commonTree->Branch("Truth_phi" , &m_Truth_phi);
371  m_commonTree->Branch("Truth_d0" , &m_Truth_d0);
372  m_commonTree->Branch("Truth_z0" , &m_Truth_z0);
373  m_commonTree->Branch("Truth_qoverp" , &m_Truth_qoverp);
374  m_commonTree->Branch("Truth_parent" , &m_Truth_parent);
375  m_commonTree->Branch("numberOfBLayerHits" , &m_nBLhits);
376  m_commonTree->Branch("numberOfPixelHits" , &m_nPIXhits);
377  m_commonTree->Branch("numberOfSCTHits" , &m_nSCThits);
378  m_commonTree->Branch("numberOfTRTHits" , &m_nTRThits);
379  }
380 
381  if ( !m_defaultTree){
382  ATH_MSG_INFO("initialize() ** defining m_defaultTree with name: " << m_defaultTreeName.c_str());
383  m_defaultTree = new TTree((m_defaultTreeName).c_str(), m_ValidationTreeDescription.c_str());
384 
385  m_defaultTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
386  m_defaultTree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
387  m_defaultTree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
388  m_defaultTree->Branch("mu" , &m_event_mu, "mu/I");
389 
390  m_defaultTree->Branch("Negative_Px", &m_negative_px, "Negative_Px/D");
391  m_defaultTree->Branch("Negative_Py", &m_negative_py, "Negative_Py/D");
392  m_defaultTree->Branch("Negative_Pt", &m_negative_pt, "Negative_Pt/D");
393  m_defaultTree->Branch("Negative_Pz", &m_negative_pz, "Negative_Pz/D");
394  m_defaultTree->Branch("Negative_Phi", &m_negative_phi, "Negative_Phi/D");
395  m_defaultTree->Branch("Negative_eta", &m_negative_eta, "Negative_Eta/D");
396  m_defaultTree->Branch("Negative_z0", &m_negative_z0, "Negative_z0/D");
397  m_defaultTree->Branch("Negative_d0", &m_negative_d0, "Negative_d0/D");
398  m_defaultTree->Branch("Negative_z0_err", &m_negative_z0_err, "Negative_z0_err/D");
399  m_defaultTree->Branch("Negative_d0_err", &m_negative_d0_err, "Negative_d0_err/D");
400  m_defaultTree->Branch("Negative_sigma_pt", &m_negative_sigma_pt, "Negative_sigma_pt/D");
401 
402  m_defaultTree->Branch("Positive_Px", &m_positive_px, "Positive_Px/D");
403  m_defaultTree->Branch("Positive_Py", &m_positive_py, "Positive_Py/D");
404  m_defaultTree->Branch("Positive_Pt", &m_positive_pt, "Positive_Pt/D");
405  m_defaultTree->Branch("Positive_Pz", &m_positive_pz, "Positive_Pz/D");
406  m_defaultTree->Branch("Positive_Phi", &m_positive_phi, "Positive_Phi/D");
407  m_defaultTree->Branch("Positive_eta", &m_positive_eta, "Positive_Eta/D");
408  m_defaultTree->Branch("Positive_z0", &m_positive_z0, "Positive_z0/D");
409  m_defaultTree->Branch("Positive_d0", &m_positive_d0, "Positive_d0/D");
410  m_defaultTree->Branch("Positive_z0_err", &m_positive_z0_err, "Positive_z0_err/D");
411  m_defaultTree->Branch("Positive_d0_err", &m_positive_d0_err, "Positive_d0_err/D");
412  m_defaultTree->Branch("Positive_sigma_pt", &m_positive_sigma_pt, "Positive_sigma_pt/D");
413 
414  if (m_doIP) {
415  m_defaultTree->Branch("Negative_d0_PV", &m_negative_d0_PV , "Negative_d0_PV/D");
416  m_defaultTree->Branch("Negative_z0_PV", &m_negative_z0_PV , "Negative_z0_PV/D");
417  m_defaultTree->Branch("Positive_z0_PV", &m_positive_z0_PV, "Positive_z0_PV/D");
418  m_defaultTree->Branch("Positive_d0_PV", &m_positive_d0_PV, "Positive_d0_PV/D");
419 
420  m_defaultTree->Branch("Negative_d0_PVerr", &m_negative_d0_PVerr, "Negative_d0_PVerr/D");
421  m_defaultTree->Branch("Negative_z0_PVerr", &m_negative_z0_PVerr, "Negative_z0_PVerr/D");
422  m_defaultTree->Branch("Positive_z0_PVerr", &m_positive_z0_PVerr, "Positive_z0_PVerr/D");
423  m_defaultTree->Branch("Positive_d0_PVerr", &m_positive_d0_PVerr, "Positive_d0_PVerr/D");
424 
425  m_defaultTree->Branch("pv_x", &m_pv_x , "pv_x/D");
426  m_defaultTree->Branch("pv_y", &m_pv_y , "pv_y/D");
427  m_defaultTree->Branch("pv_z", &m_pv_z , "pv_z/D");
428  m_defaultTree->Branch("nTrkInVtx", &m_nTrkInVtx, "nTrkInVtx/I");
429  }
430  }
431 
432  bool isTreeNone = false;
433  if (m_IDTreeName.find("none") != std::string::npos) isTreeNone = true;
434  if ( !m_IDTree and !isTreeNone ){
435  ATH_MSG_INFO("initialize() ** defining IDPerfMonZmumu m_IDTree with name: " << m_IDTreeName.c_str());
436  m_IDTree = new TTree((m_IDTreeName).c_str(), m_ValidationTreeDescription.c_str());
437 
438  m_IDTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
439  m_IDTree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
440  m_IDTree->Branch("lumi_bLock" , &m_lumi_block, "lumi_block/I");
441  m_IDTree->Branch("mu" , &m_event_mu, "mu/I");
442 
443  m_IDTree->Branch("Negative_Px", &m_negative_px, "Negative_Px/D");
444  m_IDTree->Branch("Negative_Py", &m_negative_py, "Negative_Py/D");
445  m_IDTree->Branch("Negative_Pt", &m_negative_pt, "Negative_Pt/D");
446  m_IDTree->Branch("Negative_Pz", &m_negative_pz, "Negative_Pz/D");
447  m_IDTree->Branch("Negative_Phi", &m_negative_phi, "Negative_Phi/D");
448  m_IDTree->Branch("Negative_Eta", &m_negative_eta, "Negative_Eta/D");
449  m_IDTree->Branch("Negative_z0", &m_negative_z0, "Negative_z0/D");
450  m_IDTree->Branch("Negative_d0", &m_negative_d0, "Negative_d0/D");
451  m_IDTree->Branch("Negative_z0_err", &m_negative_z0_err, "Negative_z0_err/D");
452  m_IDTree->Branch("Negative_d0_err", &m_negative_d0_err, "Negative_d0_err/D");
453  m_IDTree->Branch("Negative_sigma_pt", &m_negative_sigma_pt, "Negative_sigma_pt/D");
454 
455  m_IDTree->Branch("Positive_Px", &m_positive_px, "Positive_Px/D");
456  m_IDTree->Branch("Positive_Py", &m_positive_py, "Positive_Py/D");
457  m_IDTree->Branch("Positive_Pt", &m_positive_pt, "Positive_Pt/D");
458  m_IDTree->Branch("Positive_Pz", &m_positive_pz, "Positive_Pz/D");
459  m_IDTree->Branch("Positive_Phi", &m_positive_phi, "Positive_Phi/D");
460  m_IDTree->Branch("Positive_Eta", &m_positive_eta, "Positive_Eta/D");
461  m_IDTree->Branch("Positive_z0", &m_positive_z0, "Positive_z0/D");
462  m_IDTree->Branch("Positive_d0", &m_positive_d0, "Positive_d0/D");
463  m_IDTree->Branch("Positive_z0_err", &m_positive_z0_err, "Positive_z0_err/D");
464  m_IDTree->Branch("Positive_d0_err", &m_positive_d0_err, "Positive_d0_err/D");
465  m_IDTree->Branch("Positive_sigma_pt", &m_positive_sigma_pt, "Positive_sigma_pt/D");
466 
467  if(m_doIP){
468  m_IDTree->Branch("Negative_d0_PV", &m_negative_d0_PV , "Negative_d0_PV/D");
469  m_IDTree->Branch("Negative_z0_PV", &m_negative_z0_PV , "Negative_z0_PV/D");
470  m_IDTree->Branch("Positive_z0_PV", &m_positive_z0_PV, "Positive_z0_PV/D");
471  m_IDTree->Branch("Positive_d0_PV", &m_positive_d0_PV, "Positive_d0_PV/D");
472 
473  m_IDTree->Branch("Negative_d0_PVerr", &m_negative_d0_PVerr, "Negative_d0_PVerr/D");
474  m_IDTree->Branch("Negative_z0_PVerr", &m_negative_z0_PVerr, "Negative_z0_PVerr/D");
475  m_IDTree->Branch("Positive_z0_PVerr", &m_positive_z0_PVerr, "Positive_z0_PVerr/D");
476  m_IDTree->Branch("Positive_d0_PVerr", &m_positive_d0_PVerr, "Positive_d0_PVerr/D");
477 
478  m_IDTree->Branch("pv_x", &m_pv_x , "pv_x/D");
479  m_IDTree->Branch("pv_y", &m_pv_y , "pv_y/D");
480  m_IDTree->Branch("pv_z", &m_pv_z , "pv_z/D");
481  m_IDTree->Branch("nTrkInVtx", &m_nTrkInVtx, "nTrkInVtx/I");
482  }
483  }
484 
485  // dealing with tree for Refit1 tracks
486  isTreeNone = false;
487  if (m_refit1TreeName.find("none") != std::string::npos) isTreeNone = true;
488  if ( m_doRefit && !m_refit1Tree && !isTreeNone ){
489  ATH_MSG_INFO("initialize() ** defining IDPerfMonZmumu m_refit1Tree with name: " << m_refit1TreeName.c_str());
490  m_refit1Tree = new TTree((m_refit1TreeName).c_str(), m_ValidationTreeDescription.c_str());
491 
492  m_refit1Tree->Branch("runNumber" , &m_runNumber, "runNumber/I");
493  m_refit1Tree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
494  m_refit1Tree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
495  m_refit1Tree->Branch("mu" , &m_event_mu, "mu/I");
496  m_refit1Tree->Branch("preScale" , &m_triggerPrescale, "preScale/I");
497 
498  m_refit1Tree->Branch("Negative_Px", &m_negative_px, "Negative_Px/D");
499  m_refit1Tree->Branch("Negative_Py", &m_negative_py, "Negative_Py/D");
500  m_refit1Tree->Branch("Negative_Pt", &m_negative_pt, "Negative_Pt/D");
501  m_refit1Tree->Branch("Negative_Pz", &m_negative_pz, "Negative_Pz/D");
502  m_refit1Tree->Branch("Negative_Phi", &m_negative_phi, "Negative_Phi/D");
503  m_refit1Tree->Branch("Negative_Eta", &m_negative_eta, "Negative_Eta/D");
504  m_refit1Tree->Branch("Negative_z0", &m_negative_z0, "Negative_z0/D");
505  m_refit1Tree->Branch("Negative_d0", &m_negative_d0, "Negative_d0/D");
506  m_refit1Tree->Branch("Negative_z0_manualBS", &m_positive_z0_manualBS, "Negative_z0_manualBS/D");
507  m_refit1Tree->Branch("Negative_d0_manualBS", &m_positive_d0_manualBS, "Negative_d0_manualBS/D");
508  m_refit1Tree->Branch("Negative_z0_err", &m_negative_z0_err, "Negative_z0_err/D");
509  m_refit1Tree->Branch("Negative_d0_err", &m_negative_d0_err, "Negative_d0_err/D");
510  m_refit1Tree->Branch("Negative_sigma_pt", &m_negative_sigma_pt, "Negative_sigma_pt/D");
511 
512  m_refit1Tree->Branch("Positive_Px", &m_positive_px, "Positive_Px/D");
513  m_refit1Tree->Branch("Positive_Py", &m_positive_py, "Positive_Py/D");
514  m_refit1Tree->Branch("Positive_Pt", &m_positive_pt, "Positive_Pt/D");
515  m_refit1Tree->Branch("Positive_Pz", &m_positive_pz, "Positive_Pz/D");
516  m_refit1Tree->Branch("Positive_Phi", &m_positive_phi, "Positive_Phi/D");
517  m_refit1Tree->Branch("Positive_eta", &m_positive_eta, "Positive_Eta/D");
518  m_refit1Tree->Branch("Positive_z0", &m_positive_z0, "Positive_z0/D");
519  m_refit1Tree->Branch("Positive_d0", &m_positive_d0, "Positive_d0/D");
520  m_refit1Tree->Branch("Positive_z0_manualBS", &m_positive_z0_manualBS, "Positive_z0_manualBS/D");
521  m_refit1Tree->Branch("Positive_d0_manualBS", &m_positive_d0_manualBS, "Positive_d0_manualBS/D");
522  m_refit1Tree->Branch("Positive_z0_err", &m_positive_z0_err, "Positive_z0_err/D");
523  m_refit1Tree->Branch("Positive_d0_err", &m_positive_d0_err, "Positive_d0_err/D");
524  m_refit1Tree->Branch("Positive_sigma_pt", &m_positive_sigma_pt, "Positive_sigma_pt/D");
525 
526  if(m_doIP){
527  m_refit1Tree->Branch("Negative_d0_PV", &m_negative_d0_PV , "Negative_d0_PV/D");
528  m_refit1Tree->Branch("Negative_z0_PV", &m_negative_z0_PV , "Negative_z0_PV/D");
529  m_refit1Tree->Branch("Positive_z0_PV", &m_positive_z0_PV, "Positive_z0_PV/D");
530  m_refit1Tree->Branch("Positive_d0_PV", &m_positive_d0_PV, "Positive_d0_PV/D");
531 
532  m_refit1Tree->Branch("Negative_d0_PVerr", &m_negative_d0_PVerr , "Negative_d0_PVerr/D");
533  m_refit1Tree->Branch("Negative_z0_PVerr", &m_negative_z0_PVerr , "Negative_z0_PVerr/D");
534  m_refit1Tree->Branch("Positive_z0_PVerr", &m_positive_z0_PVerr, "Positive_z0_PVerr/D");
535  m_refit1Tree->Branch("Positive_d0_PVerr", &m_positive_d0_PVerr, "Positive_d0_PVerr/D");
536 
537  m_refit1Tree->Branch("pv_x", &m_pv_x , "pv_x/D");
538  m_refit1Tree->Branch("pv_y", &m_pv_y , "pv_y/D");
539  m_refit1Tree->Branch("pv_z", &m_pv_z , "pv_z/D");
540  m_refit1Tree->Branch("nTrkInVtx", &m_nTrkInVtx, "nTrkInVtx/I");
541  }
542  }
543 
544  // dealing with tree for Refit2 tracks
545  isTreeNone = false;
546  if (m_refit2TreeName.find("none") != std::string::npos) isTreeNone = true;
547  if ( m_doRefit && !m_refit2Tree && !isTreeNone){
548  ATH_MSG_INFO("initialize() ** defining m_refit2Tree with name: " << m_refit2TreeName.c_str());
549  m_refit2Tree = new TTree((m_refit2TreeName).c_str(), m_ValidationTreeDescription.c_str());
550 
551  m_refit2Tree->Branch("runNumber" , &m_runNumber, "runNumber/I");
552  m_refit2Tree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
553  m_refit2Tree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
554  m_refit2Tree->Branch("mu" , &m_event_mu, "mu/I");
555  m_refit2Tree->Branch("preScale" , &m_triggerPrescale, "preScale/I");
556 
557  m_refit2Tree->Branch("Negative_Px", &m_negative_px, "Negative_Px/D");
558  m_refit2Tree->Branch("Negative_Py", &m_negative_py, "Negative_Py/D");
559  m_refit2Tree->Branch("Negative_Pt", &m_negative_pt, "Negative_Pt/D");
560  m_refit2Tree->Branch("Negative_Pz", &m_negative_pz, "Negative_Pz/D");
561  m_refit2Tree->Branch("Negative_Phi", &m_negative_phi, "Negative_Phi/D");
562  m_refit2Tree->Branch("Negative_Eta", &m_negative_eta, "Negative_Eta/D");
563  m_refit2Tree->Branch("Negative_z0", &m_negative_z0, "Negative_z0/D");
564  m_refit2Tree->Branch("Negative_d0", &m_negative_d0, "Negative_d0/D");
565  m_refit2Tree->Branch("Negative_z0_manualBS", &m_positive_z0_manualBS, "Negative_z0_manualBS/D");
566  m_refit2Tree->Branch("Negative_d0_manualBS", &m_positive_d0_manualBS, "Negative_d0_manualBS/D");
567  m_refit2Tree->Branch("Negative_z0_err", &m_negative_z0_err, "Negative_z0_err/D");
568  m_refit2Tree->Branch("Negative_d0_err", &m_negative_d0_err, "Negative_d0_err/D");
569  m_refit2Tree->Branch("Negative_sigma_pt", &m_negative_sigma_pt, "Negative_sigma_pt/D");
570 
571  m_refit2Tree->Branch("Positive_Px", &m_positive_px, "Positive_Px/D");
572  m_refit2Tree->Branch("Positive_Py", &m_positive_py, "Positive_Py/D");
573  m_refit2Tree->Branch("Positive_Pt", &m_positive_pt, "Positive_Pt/D");
574  m_refit2Tree->Branch("Positive_Pz", &m_positive_pz, "Positive_Pz/D");
575  m_refit2Tree->Branch("Positive_Phi", &m_positive_phi, "Positive_Phi/D");
576  m_refit2Tree->Branch("Positive_Eta", &m_positive_eta, "Positive_Eta/D");
577  m_refit2Tree->Branch("Positive_z0", &m_positive_z0, "Positive_z0/D");
578  m_refit2Tree->Branch("Positive_d0", &m_positive_d0, "Positive_d0/D");
579  m_refit2Tree->Branch("Positive_z0_manualBS", &m_positive_z0_manualBS, "Positive_z0_manualBS/D");
580  m_refit2Tree->Branch("Positive_d0_manualBS", &m_positive_d0_manualBS, "Positive_d0_manualBS/D");
581  m_refit2Tree->Branch("Positive_z0_err", &m_positive_z0_err, "Positive_z0_err/D");
582  m_refit2Tree->Branch("Positive_d0_err", &m_positive_d0_err, "Positive_d0_err/D");
583  m_refit2Tree->Branch("Positive_sigma_pt", &m_positive_sigma_pt, "Positive_sigma_pt/D");
584 
585 
586  if(m_doIP){
587  m_refit2Tree->Branch("Negative_d0_PV", &m_negative_d0_PV , "Negative_d0_PV/D");
588  m_refit2Tree->Branch("Negative_z0_PV", &m_negative_z0_PV , "Negative_z0_PV/D");
589  m_refit2Tree->Branch("Positive_d0_PV", &m_positive_d0_PV , "Positive_d0_PV/D");
590  m_refit2Tree->Branch("Positive_z0_PV", &m_positive_z0_PV , "Positive_z0_PV/D");
591 
592 
593  m_refit2Tree->Branch("Negative_z0_PVerr", &m_negative_z0_PVerr, "Negative_z0_PVerr/D");
594  m_refit2Tree->Branch("Negative_d0_PVerr", &m_negative_d0_PVerr, "Negative_d0_PVerr/D");
595  m_refit2Tree->Branch("Positive_z0_PVerr", &m_positive_z0_PVerr, "Positive_z0_PVerr/D");
596  m_refit2Tree->Branch("Positive_d0_PVerr", &m_positive_d0_PVerr, "Positive_d0_PVerr/D");
597 
598  m_refit2Tree->Branch("pv_x", &m_pv_x , "pv_x/D");
599  m_refit2Tree->Branch("pv_y", &m_pv_y , "pv_y/D");
600  m_refit2Tree->Branch("pv_z", &m_pv_z , "pv_z/D");
601 
602  m_refit2Tree->Branch("nTrkInVtx", &m_nTrkInVtx, "nTrkInVtx/I");
603  }
604  }
605 
606  isTreeNone = false;
607  if (m_combTreeName.find("none") != std::string::npos) isTreeNone = true;
608  if( !m_combTree && !m_skipMS && !isTreeNone){
609  ATH_MSG_INFO("initialize() ** defining IDPerfMonZmumu m_combTree with name: " << m_combTreeName.c_str());
610  m_combTree = new TTree((m_combTreeName).c_str(), m_ValidationTreeDescription.c_str());
611 
612  m_combTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
613  m_combTree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
614  m_combTree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
615  m_combTree->Branch("mu" , &m_event_mu, "mu/I");
616  m_combTree->Branch("preScale" , &m_triggerPrescale, "preScale/I");
617 
618  m_combTree->Branch("Negative_Px", &m_negative_px, "Negative_Px/D");
619  m_combTree->Branch("Negative_Py", &m_negative_py, "Negative_Py/D");
620  m_combTree->Branch("Negative_Pt", &m_negative_pt, "Negative_Pt/D");
621  m_combTree->Branch("Negative_Pz", &m_negative_pz, "Negative_Pz/D");
622  m_combTree->Branch("Negative_Phi", &m_negative_phi, "Negative_Phi/D");
623  m_combTree->Branch("Negative_eta", &m_negative_eta, "Negative_eta/D");
624  m_combTree->Branch("Negative_z0", &m_negative_z0, "Negative_z0/D");
625  m_combTree->Branch("Negative_d0", &m_negative_d0, "Negative_d0/D");
626  m_combTree->Branch("Negative_z0_err", &m_negative_z0_err, "Negative_z0_err/D");
627  m_combTree->Branch("Negative_d0_err", &m_negative_d0_err, "Negative_d0_err/D");
628  m_combTree->Branch("Negative_sigma_pt", &m_negative_sigma_pt, "Negative_sigma_pt/D");
629 
630  m_combTree->Branch("Positive_Px", &m_positive_px, "Positive_Px/D");
631  m_combTree->Branch("Positive_Py", &m_positive_py, "Positive_Py/D");
632  m_combTree->Branch("Positive_Pt", &m_positive_pt, "Positive_Pt/D");
633  m_combTree->Branch("Positive_Pz", &m_positive_pz, "Positive_Pz/D");
634  m_combTree->Branch("Positive_Phi", &m_positive_phi, "Positive_Phi/D");
635  m_combTree->Branch("Positive_eta", &m_positive_eta, "Positive_Eta/D");
636  m_combTree->Branch("Positive_z0", &m_positive_z0, "Positive_z0/D");
637  m_combTree->Branch("Positive_d0", &m_positive_d0, "Positive_d0/D");
638  m_combTree->Branch("Positive_z0_err", &m_positive_z0_err, "Positive_z0_err/D");
639  m_combTree->Branch("Positive_d0_err", &m_positive_d0_err, "Positive_d0_err/D");
640  m_combTree->Branch("Positive_sigma_pt", &m_positive_sigma_pt, "Positive_sigma_pt/D");
641 
642  if(m_doIP){
643  m_combTree->Branch("Negative_z0_PV", &m_negative_z0_PV, "Negative_z0_PV/D");
644  m_combTree->Branch("Negative_d0_PV", &m_negative_d0_PV, "Negative_d0_PV/D");
645  m_combTree->Branch("Positive_z0_PV", &m_positive_z0_PV, "Positive_z0_PV/D");
646  m_combTree->Branch("Positive_d0_PV", &m_positive_d0_PV, "Positive_d0_PV/D");
647 
648  m_combTree->Branch("Negative_z0_PVerr", &m_negative_z0_PVerr, "Negative_z0_PVerr/D");
649  m_combTree->Branch("Negative_d0_PVerr", &m_negative_d0_PVerr, "Negative_d0_PVerr/D");
650  m_combTree->Branch("Positive_z0_PVerr", &m_positive_z0_PVerr, "Positive_z0_PVerr/D");
651  m_combTree->Branch("Positive_d0_PVerr", &m_positive_d0_PVerr, "Positive_d0_PVerr/D");
652 
653  m_combTree->Branch("pv_x", &m_pv_x , "pv_x/D");
654  m_combTree->Branch("pv_y", &m_pv_y , "pv_y/D");
655  m_combTree->Branch("pv_z", &m_pv_z , "pv_z/D");
656 
657  m_combTree->Branch("nTrkInVtx", &m_nTrkInVtx, "nTrkInVtx/I");
658  }
659  }
660 
661 
662  isTreeNone = false;
663  if (m_MSTreeName.find("none") != std::string::npos) isTreeNone = true;
664  if( !m_MSTree && !m_skipMS && !isTreeNone){
665  ATH_MSG_INFO("initialize() ** defining IDPerfMon MSTree ");
666 
667  m_MSTree = new TTree(m_MSTreeName.c_str(), m_ValidationTreeDescription.c_str());
668 
669  m_MSTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
670  m_MSTree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
671  m_MSTree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
672  m_MSTree->Branch("preScale" , &m_triggerPrescale, "preScale/I");
673 
674  m_MSTree->Branch("Negative_Px", &m_negative_px, "Negative_Px/D");
675  m_MSTree->Branch("Negative_Py", &m_negative_py, "Negative_Py/D");
676  m_MSTree->Branch("Negative_Pt", &m_negative_pt, "Negative_Pt/D");
677  m_MSTree->Branch("Negative_Pz", &m_negative_pz, "Negative_Pz/D");
678  m_MSTree->Branch("Negative_Phi", &m_negative_phi, "Negative_Phi/D");
679  m_MSTree->Branch("Negative_Eta", &m_negative_eta, "Negative_Eta/D");
680  m_MSTree->Branch("Negative_z0", &m_negative_z0, "Negative_z0/D");
681  m_MSTree->Branch("Negative_d0", &m_negative_d0, "Negative_d0/D");
682  m_MSTree->Branch("Negative_z0_err", &m_negative_z0_err, "Negative_z0_err/D");
683  m_MSTree->Branch("Negative_d0_err", &m_negative_d0_err, "Negative_d0_err/D");
684  m_MSTree->Branch("Negative_sigma_pt", &m_negative_sigma_pt, "Negative_sigma_pt/D");
685 
686  m_MSTree->Branch("Positive_Px", &m_positive_px, "Positive_Px/D");
687  m_MSTree->Branch("Positive_Py", &m_positive_py, "Positive_Py/D");
688  m_MSTree->Branch("Positive_Pt", &m_positive_pt, "Positive_Pt/D");
689  m_MSTree->Branch("Positive_Pz", &m_positive_pz, "Positive_Pz/D");
690  m_MSTree->Branch("Positive_Phi", &m_positive_phi, "Positive_Phi/D");
691  m_MSTree->Branch("Positive_Eta", &m_positive_eta, "Positive_Eta/D");
692  m_MSTree->Branch("Positive_z0", &m_positive_z0, "Positive_z0/D");
693  m_MSTree->Branch("Positive_d0", &m_positive_d0, "Positive_d0/D");
694  m_MSTree->Branch("Positive_z0_err", &m_positive_z0_err, "Positive_z0_err/D");
695  m_MSTree->Branch("Positive_d0_err", &m_positive_d0_err, "Positive_d0_err/D");
696  m_MSTree->Branch("Positive_sigma_pt", &m_positive_sigma_pt, "Positive_sigma_pt/D");
697  }
698 
699  if( m_isMC && !m_truthTree ){
700  m_truthTree = new TTree(m_truthTreeName.c_str(), m_ValidationTreeDescription.c_str());
701 
702  m_truthTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
703  m_truthTree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
704  m_truthTree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
705  m_truthTree->Branch("preScale" , &m_triggerPrescale, "preScale/I");
706 
707  m_truthTree->Branch("Negative_Px", &m_negative_px, "Negative_Px/D");
708  m_truthTree->Branch("Negative_Py", &m_negative_py, "Negative_Py/D");
709  m_truthTree->Branch("Negative_Pt", &m_negative_pt, "Negative_Pt/D");
710  m_truthTree->Branch("Negative_Pz", &m_negative_pz, "Negative_Pz/D");
711  m_truthTree->Branch("Negative_Phi", &m_negative_phi, "Negative_Phi/D");
712  m_truthTree->Branch("Negative_Eta", &m_negative_eta, "Negative_Eta/D");
713  m_truthTree->Branch("Negative_z0", &m_negative_z0, "Negative_z0/D");
714  m_truthTree->Branch("Negative_d0", &m_negative_d0, "Negative_d0/D");
715  m_truthTree->Branch("Negative_z0_err", &m_negative_z0_err, "Negative_z0_err/D");
716  m_truthTree->Branch("Negative_d0_err", &m_negative_d0_err, "Negative_d0_err/D");
717  m_truthTree->Branch("Negative_parent", &m_negative_parent, "Negative_parent/I");
718 
719  m_truthTree->Branch("Positive_Px", &m_positive_px, "Positive_Px/D");
720  m_truthTree->Branch("Positive_Py", &m_positive_py, "Positive_Py/D");
721  m_truthTree->Branch("Positive_Pt", &m_positive_pt, "Positive_Pt/D");
722  m_truthTree->Branch("Positive_Pz", &m_positive_pz, "Positive_Pz/D");
723  m_truthTree->Branch("Positive_Phi", &m_positive_phi, "Positive_Phi/D");
724  m_truthTree->Branch("Positive_Eta", &m_positive_eta, "Positive_Eta/D");
725  m_truthTree->Branch("Positive_z0", &m_positive_z0, "Positive_z0/D");
726  m_truthTree->Branch("Positive_d0", &m_positive_d0, "Positive_d0/D");
727  m_truthTree->Branch("Positive_z0_err", &m_positive_z0_err, "Positive_z0_err/D");
728  m_truthTree->Branch("Positive_d0_err", &m_positive_d0_err, "Positive_d0_err/D");
729  m_truthTree->Branch("Positive_parent", &m_positive_parent, "Positive_parent/I");
730  }
731 
732  if (m_doFourMuAnalysis && !m_FourMuTree) {
733  ATH_MSG_INFO("initialize() ** defining m_FourMuTree ");
734  m_FourMuTree = new TTree((m_FourMuTreeName).c_str(), "Four Muon monitoring");
735 
736  m_FourMuTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
737  m_FourMuTree->Branch("eventNumber", &m_evtNumber, "eventNumber/I");
738  m_FourMuTree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
739  m_FourMuTree->Branch("mu" , &m_event_mu, "mu/I");
740  m_FourMuTree->Branch("preScale" , &m_triggerPrescale, "preScale/I");
741  m_FourMuTree->Branch("nVertex" , &m_nVertex, "nVertex/I");
742 
743  m_FourMuTree->Branch("Negative_1_Px", &m_negative_px, "Negative_1_Px/D");
744  m_FourMuTree->Branch("Negative_1_Py", &m_negative_py, "Negative_1_Py/D");
745  m_FourMuTree->Branch("Negative_1_Pz", &m_negative_pz, "Negative_1_Pz/D");
746  m_FourMuTree->Branch("Negative_1_z0", &m_negative_z0, "Negative_1_z0/D");
747  m_FourMuTree->Branch("Negative_1_d0", &m_negative_d0, "Negative_1_d0/D");
748  m_FourMuTree->Branch("Negative_1_z0_err", &m_negative_z0_err, "Negative_1_z0_err/D");
749  m_FourMuTree->Branch("Negative_1_d0_err", &m_negative_d0_err, "Negative_1_d0_err/D");
750  m_FourMuTree->Branch("Negative_1_vtx", &m_negative_1_vtx, "Negative_1_vtx/I"); // vertex identifier
751 
752  m_FourMuTree->Branch("Negative_2_Px", &m_negative_2_px, "Negative_2_Px/D");
753  m_FourMuTree->Branch("Negative_2_Py", &m_negative_2_py, "Negative_2_Py/D");
754  m_FourMuTree->Branch("Negative_2_Pz", &m_negative_2_pz, "Negative_2_Pz/D");
755  m_FourMuTree->Branch("Negative_2_z0", &m_negative_2_z0, "Negative_2_z0/D");
756  m_FourMuTree->Branch("Negative_2_d0", &m_negative_2_d0, "Negative_2_d0/D");
757  m_FourMuTree->Branch("Negative_2_z0_err", &m_negative_2_z0_err, "Negative_2_z0_err/D");
758  m_FourMuTree->Branch("Negative_2_d0_err", &m_negative_2_d0_err, "Negative_2_d0_err/D");
759  m_FourMuTree->Branch("Negative_2_vtx", &m_negative_2_vtx, "Negative_2_vtx/I");
760 
761  m_FourMuTree->Branch("Positive_1_Px", &m_positive_px, "Positive_1_Px/D");
762  m_FourMuTree->Branch("Positive_1_Py", &m_positive_py, "Positive_1_Py/D");
763  m_FourMuTree->Branch("Positive_1_Pz", &m_positive_pz, "Positive_1_Pz/D");
764  m_FourMuTree->Branch("Positive_1_z0", &m_positive_z0, "Positive_1_z0/D");
765  m_FourMuTree->Branch("Positive_1_d0", &m_positive_d0, "Positive_1_d0/D");
766  m_FourMuTree->Branch("Positive_1_z0_err", &m_positive_z0_err, "Positive_1_z0_err/D");
767  m_FourMuTree->Branch("Positive_1_d0_err", &m_positive_d0_err, "Positive_1_d0_err/D");
768  m_FourMuTree->Branch("Positive_1_vtx", &m_positive_1_vtx, "Positive_1_vtx/I");
769 
770  m_FourMuTree->Branch("Positive_2_Px", &m_positive_2_px, "Positive_1_Px/D");
771  m_FourMuTree->Branch("Positive_2_Py", &m_positive_2_py, "Positive_1_Py/D");
772  m_FourMuTree->Branch("Positive_2_Pz", &m_positive_2_pz, "Positive_1_Pz/D");
773  m_FourMuTree->Branch("Positive_2_z0", &m_positive_2_z0, "Positive_1_z0/D");
774  m_FourMuTree->Branch("Positive_2_d0", &m_positive_2_d0, "Positive_1_d0/D");
775  m_FourMuTree->Branch("Positive_2_z0_err", &m_positive_2_z0_err,"Positive_1_z0_err/D");
776  m_FourMuTree->Branch("Positive_2_d0_err", &m_positive_2_d0_err,"Positive_1_d0_err/D");
777  m_FourMuTree->Branch("Positive_2_vtx", &m_positive_2_vtx, "Positive_2_vtx/I");
778 
779  // electrons
780  m_FourMuTree->Branch("ElNegative_1_Px", &m_el_negative1_px, "ElNegative_1_Px/D");
781  m_FourMuTree->Branch("ElNegative_1_Py", &m_el_negative1_py, "ElNegative_1_Py/D");
782  m_FourMuTree->Branch("ElNegative_1_Pz", &m_el_negative1_pz, "ElNegative_1_Pz/D");
783  m_FourMuTree->Branch("ElNegative_1_z0", &m_el_negative1_z0, "ElNegative_1_z0/D");
784  m_FourMuTree->Branch("ElNegative_1_d0", &m_el_negative1_d0, "ElNegative_1_d0/D");
785  m_FourMuTree->Branch("ElNegative_1_z0_err", &m_el_negative1_z0_err, "ElNegative_1_z0_err/D");
786  m_FourMuTree->Branch("ElNegative_1_d0_err", &m_el_negative1_d0_err, "ElNegative_1_d0_err/D");
787  m_FourMuTree->Branch("ElNegative_1_vtx", &m_el_negative1_vtx, "ElNegative_1_vtx/I"); // vertex identifier
788 
789  m_FourMuTree->Branch("ElNegative_2_Px", &m_el_negative2_px, "ElNegative_2_Px/D");
790  m_FourMuTree->Branch("ElNegative_2_Py", &m_el_negative2_py, "ElNegative_2_Py/D");
791  m_FourMuTree->Branch("ElNegative_2_Pz", &m_el_negative2_pz, "ElNegative_2_Pz/D");
792  m_FourMuTree->Branch("ElNegative_2_z0", &m_el_negative2_z0, "ElNegative_2_z0/D");
793  m_FourMuTree->Branch("ElNegative_2_d0", &m_el_negative2_d0, "ElNegative_2_d0/D");
794  m_FourMuTree->Branch("ElNegative_2_z0_err", &m_el_negative2_z0_err, "ElNegative_2_z0_err/D");
795  m_FourMuTree->Branch("ElNegative_2_d0_err", &m_el_negative2_d0_err, "ElNegative_2_d0_err/D");
796  m_FourMuTree->Branch("ElNegative_2_vtx", &m_el_negative2_vtx, "ElNegative_2_vtx/I"); // vertex identifier
797 
798  m_FourMuTree->Branch("ElPositive_1_Px", &m_el_positive1_px, "ElPositive_1_Px/D");
799  m_FourMuTree->Branch("ElPositive_1_Py", &m_el_positive1_py, "ElPositive_1_Py/D");
800  m_FourMuTree->Branch("ElPositive_1_Pz", &m_el_positive1_pz, "ElPositive_1_Pz/D");
801  m_FourMuTree->Branch("ElPositive_1_z0", &m_el_positive1_z0, "ElPositive_1_z0/D");
802  m_FourMuTree->Branch("ElPositive_1_d0", &m_el_positive1_d0, "ElPositive_1_d0/D");
803  m_FourMuTree->Branch("ElPositive_1_z0_err", &m_el_positive1_z0_err, "ElPositive_1_z0_err/D");
804  m_FourMuTree->Branch("ElPositive_1_d0_err", &m_el_positive1_d0_err, "ElPositive_1_d0_err/D");
805  m_FourMuTree->Branch("ElPositive_1_vtx", &m_el_positive1_vtx, "ElPositive_1_vtx/I"); // vertex identifier
806 
807  m_FourMuTree->Branch("ElPositive_2_Px", &m_el_positive2_px, "ElPositive_2_Px/D");
808  m_FourMuTree->Branch("ElPositive_2_Py", &m_el_positive2_py, "ElPositive_2_Py/D");
809  m_FourMuTree->Branch("ElPositive_2_Pz", &m_el_positive2_pz, "ElPositive_2_Pz/D");
810  m_FourMuTree->Branch("ElPositive_2_z0", &m_el_positive2_z0, "ElPositive_2_z0/D");
811  m_FourMuTree->Branch("ElPositive_2_d0", &m_el_positive2_d0, "ElPositive_2_d0/D");
812  m_FourMuTree->Branch("ElPositive_2_z0_err", &m_el_positive2_z0_err, "ElPositive_2_z0_err/D");
813  m_FourMuTree->Branch("ElPositive_2_d0_err", &m_el_positive2_d0_err, "ElPositive_2_d0_err/D");
814  m_FourMuTree->Branch("ElPositive_2_vtx", &m_el_positive2_vtx, "ElPositive_2_vtx/I"); // vertex identifier
815 
816  // other quantities
817  m_FourMuTree->Branch("minv4mu", &m_4mu_minv, "minv4mu/D");
818  m_FourMuTree->Branch("pv_x", &m_pv_x , "pv_x/D");
819  m_FourMuTree->Branch("pv_y", &m_pv_y , "pv_y/D");
820  m_FourMuTree->Branch("pv_z", &m_pv_z , "pv_z/D");
821  m_FourMuTree->Branch("nTrkInVtx", &m_nTrkInVtx, "nTrkInVtx/I");
822 
823  m_FourMuTree->Branch("met", &m_met, "met/D");
824  m_FourMuTree->Branch("metphi", &m_metphi, "metphi/D");
825  }
826 
827  // now register the Trees
828  ATH_MSG_INFO("initialize() Going to register the mu+mu- trees");
829  ITHistSvc* tHistSvc = nullptr;
830  if (service("THistSvc",tHistSvc).isFailure()){
831  ATH_MSG_ERROR("initialize() Could not find Hist Service -> Switching ValidationMode Off !");
832  m_validationMode = false;
833  }
834 
835  if (m_commonTree) {
836  if ((tHistSvc->regTree(m_commonTreeFolder, m_commonTree)).isSuccess() ) {
837  ATH_MSG_INFO("initialize() commonTree succesfully registered!");
838  }
839  else {
840  ATH_MSG_ERROR("initialize() Could not register the validation commonTree -> Switching ValidationMode Off !");
841  delete m_commonTree; m_commonTree = nullptr;
842  m_validationMode = false;
843  }
844  }
845 
846  if (m_IDTree) {
847  if ((tHistSvc->regTree(m_IDTreeFolder, m_IDTree)).isSuccess() ) {
848  ATH_MSG_INFO("initialize() IDTree succesfully registered!");
849  }
850  else {
851  ATH_MSG_ERROR("initialize() Could not register the validation IDTree -> Switching ValidationMode Off !");
852  delete m_IDTree; m_IDTree = nullptr;
853  m_validationMode = false;
854  }
855  }
856 
857  if ( m_skipMS ) {
858  ATH_MSG_INFO("CBtree has to be skipped: flag ON");
859  delete m_combTree; m_combTree = nullptr;
860  }
861  else {
862  if (m_combTree) {
863  if ((tHistSvc->regTree(m_combTreeFolder, m_combTree)).isSuccess() ) {
864  ATH_MSG_INFO("initialize() CBTree succesfully registered!");
865  }
866  else {
867  ATH_MSG_ERROR("initialize() Could not register the validation CBTree -> Switching ValidationMode Off !");
868  delete m_combTree; m_combTree = nullptr;
869  m_validationMode = false;
870  }
871  }
872  }
873 
874  if ( m_skipMS ) {
875  ATH_MSG_INFO("MStree has to be skipped: flag ON");
876  delete m_MSTree; m_MSTree = nullptr;
877  }
878  else {
879  if (m_MSTree) {
880  if ( (tHistSvc->regTree(m_MSTreeFolder, m_MSTree)).isSuccess() ){
881  ATH_MSG_INFO("initialize() MSTree succesfully registered!");
882  }
883  else {
884  ATH_MSG_ERROR("initialize() Could not register the validation MSTree -> Switching ValidationMode Off !");
885  delete m_MSTree; m_MSTree = nullptr;
886  m_validationMode = false;
887  }
888  }
889  }
890 
891  if( m_doRefit ){
892  if (m_refit1Tree) {
893  if ((tHistSvc->regTree(m_refit1TreeFolder, m_refit1Tree)).isSuccess() ) {
894  ATH_MSG_INFO("initialize() Refit1 Tree succesfully registered!");
895  }
896  else{
897  ATH_MSG_ERROR("initialize() Could not register the validation Tree -> Switching ValidationMode Off !");
898  delete m_refit1Tree; m_refit1Tree = nullptr;
899  m_validationMode = false;
900  }
901  }
902 
903  if (m_refit2Tree) {
904  if ((tHistSvc->regTree(m_refit2TreeFolder, m_refit2Tree)).isSuccess() ) {
905  ATH_MSG_INFO("initialize() Refit2 Tree succesfully registered!");
906  }
907  else {
908  ATH_MSG_ERROR("initialize() Could not register the validation Tree -> Switching ValidationMode Off !");
909  delete m_refit2Tree; m_refit2Tree = nullptr;
910  m_validationMode = false;
911  }
912  }
913  }
914 
915  if (m_isMC) {
916  if ((tHistSvc->regTree(m_truthTreeFolder, m_truthTree)).isSuccess() ) {
917  ATH_MSG_INFO("initialize() truthTree Tree succesfully registered!");
918  }
919  else {
920  ATH_MSG_ERROR("initialize() Could not register the validation truth Tree -> Switching ValidationMode Off !");
921  delete m_truthTree; m_truthTree = nullptr;
922  m_validationMode = false;
923  }
924  }
925 
926  if (m_doFourMuAnalysis) {
927  if ((tHistSvc->regTree(m_FourMuTreeFolder, m_FourMuTree)).isSuccess() ) {
928  ATH_MSG_INFO("initialize() FourMu Tree succesfully registered!");
929  }
930  else {
931  ATH_MSG_ERROR("initialize() Could not register the validation FourMu Tree -> Switching ValidationMode Off !");
932  delete m_FourMuTree; m_FourMuTree = nullptr;
933  m_validationMode = false;
934  }
935  }
936 
937  return StatusCode::SUCCESS;
938 }
939 
940 
941 //==================================================================================
942 void IDPerfMonZmumu::RegisterHistograms()
943 {
944  return;
945 }
946 
947 
948 //==================================================================================
949 StatusCode IDPerfMonZmumu::execute()
950 {
951  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** START **");
952 
953  SG::ReadHandle<xAOD::EventInfo> eventInfo (m_EventInfoKey, getContext());
954  if(eventInfo.isValid()) {
955  m_runNumber = eventInfo->runNumber();
956  m_evtNumber = eventInfo->eventNumber();
957  m_lumi_block = eventInfo->lumiBlock();
958  m_event_mu = eventInfo->actualInteractionsPerCrossing();
959  ATH_MSG_DEBUG(" Execute() starting on --> Run: " << m_runNumber << " event: " << m_evtNumber << " Lumiblock: " << m_lumi_block);
960  }
961  else {
962  ATH_MSG_DEBUG(" IDPerfMonZmumu::execute evtStore->retrieve (eventInfo) failed .. trying another strategy.. ");
963  SG::ReadHandle<xAOD::EventInfo> eventInfo2(m_EventInfoKey);
964  if (eventInfo2.isValid()) {
965  m_runNumber = eventInfo2->runNumber();
966  m_evtNumber = eventInfo2->eventNumber();
967  m_lumi_block = eventInfo2->lumiBlock();
968  m_event_mu = eventInfo2->actualInteractionsPerCrossing();
969  ATH_MSG_DEBUG(" Execute() starting on --> Run: " << m_runNumber << " event: " << m_evtNumber << " Lumiblock: " << m_lumi_block);
970  }
971 
972  else{
973  ATH_MSG_ERROR("** IDPerfMonZmumu::execute ** Could not retrieve event info.");
974  }
975  }
976 
978  if (m_doFourMuAnalysis) {
979  ATH_MSG_DEBUG(" ** IDPerfMonZmumu::execute ** calling FourLeptonAnalysis()...");
980  StatusCode fourLeptAnaStatus = this->RunFourLeptonAnalysis();
981  if (fourLeptAnaStatus.isSuccess()) ATH_MSG_INFO (" ** IDPerfMonZmumu::execute ** RunFourLeptonAnalysis() SUCCESS -> found a new event");
982  }
984 
985 
986  // check if the muon-pair passed the resonance selection cuts:
987  ATH_MSG_DEBUG(" ** IDPerfMonZmumu::execute ** calling dimuon analysis m_xZmm.Reco()...");
988  if( m_xZmm.Reco( m_lumi_block ) ){
989  ATH_MSG_INFO( " Run: " << m_runNumber
990  << " event: " << m_evtNumber
991  << " Lumiblock: " << m_lumi_block
992  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ** SUCCESS **");
993  }
994  else {
995  ATH_MSG_DEBUG( " Run: " << m_runNumber
996  << " event: " << m_evtNumber
997  << " Lumiblock: " << m_lumi_block
998  << " Failed dimuon reconstruction. m_xZmm.Reco() returned FALSE ");
999  return StatusCode::SUCCESS;
1000  }
1001 
1002  //
1003  // If this point is reached -> there is a good mu+mu- pair that stisfies all selection cuts
1004  //
1005 
1006  if (m_UseTrigger) {
1007  StatusCode isTriggerPassed = CheckTriggerStatusAndPrescale ();
1008  if (isTriggerPassed == StatusCode::SUCCESS) {
1009  ATH_MSG_DEBUG("Trigger passed -> accept event");
1010  }
1011  else{
1012  ATH_MSG_DEBUG("Trigger Failed -> reject event --> leave event");
1013  return StatusCode::SUCCESS;
1014  }
1015  }
1016 
1017  // std::cout << " ** IDPerfMonZmumu ** extracting muon_pos and muon_neg... " << std::endl;
1018  const xAOD::Muon* muon_pos = m_xZmm.getCombMuon(m_xZmm.getPosMuon(ZmumuEvent::CB));
1019  const xAOD::Muon* muon_neg = m_xZmm.getCombMuon(m_xZmm.getNegMuon(ZmumuEvent::CB));
1020 
1021  const xAOD::TrackParticle* ppos_comb = nullptr; const xAOD::Vertex* ppos_comb_v = nullptr;
1022  const xAOD::TrackParticle* pneg_comb = nullptr; const xAOD::Vertex* pneg_comb_v = nullptr;
1023 
1024  //To protect against failures of the estimation
1025  StatusCode success_pos = StatusCode::FAILURE;
1026  StatusCode success_neg = StatusCode::FAILURE;
1027 
1028  if (muon_pos && muon_neg) { // if both combined muons exist and were sucessfully retrieved
1029  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** combined muons exist ** retrieving their m_trackparticleName: " << m_trackParticleName.c_str());
1030 
1031  if (m_trackParticleName.find("InnerDetectorTrackParticles") != std::string::npos) {
1032  ATH_MSG_INFO("** IDPerfMonZmumu::execute ** Retrieving InnerDetectorTrackParticles of the accepted muons");
1033  ppos_comb = muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
1034  pneg_comb = muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
1035 
1036  if (!ppos_comb || !pneg_comb) {
1037  ATH_MSG_WARNING("** IDPerfMonZmumu::execute ** InnerDetectorTrackParticles are requested but they are not present. Exiting event.");
1038  return StatusCode::SUCCESS;
1039  }
1040  } // InnerDetectorTrackParticles
1041  if (m_trackParticleName.find("CombinedTrackParticle") != std::string::npos) {
1042  //
1043  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Retrieving CombinedTrackParticles of the accepted muons");
1044  ppos_comb = muon_pos->trackParticle(xAOD::Muon::CombinedTrackParticle);
1045  pneg_comb = muon_neg->trackParticle(xAOD::Muon::CombinedTrackParticle);
1046 
1047  if (!ppos_comb || !pneg_comb){
1048  ATH_MSG_WARNING( "** IDPerfMonZmumu::execute ** CombinedTrackParticles are requested but they are not present. Exiting event.");
1049  return StatusCode::SUCCESS;
1050  }
1051  } // combined tracks
1052 
1053 
1054  // double check
1055  if (ppos_comb && pneg_comb) {
1056  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** successfull retrieval of muons as " << m_trackParticleName << ". ppos_comb & pneg_comb both exist");
1057  }
1058  else {
1059  ATH_MSG_WARNING("** IDPerfMonZmumu::execute ** problems retrieving muons as " << m_trackParticleName <<". ppos_comb or pneg_comb are not available");
1060  }
1061 
1062 
1063  // vertex
1064  const EventContext& ctx = Gaudi::Hive::currentContext();
1065  SG::ReadHandle<xAOD::VertexContainer> vertices { m_vertexKey, ctx };
1066  for (const auto V : *vertices) {
1067  if (V->vertexType() == xAOD::VxType::VertexType::PriVtx) {
1068  // primaryVertex =V;
1069  ppos_comb_v = V;
1070  pneg_comb_v = V;
1071  break;
1072  }
1073  } // vertex
1074 
1075  // before continuing check both particles have vertex
1076  if (!ppos_comb_v || !pneg_comb_v){
1077  ATH_MSG_WARNING( "Some or all of the requested particles have no vertex. Exiting event");
1078  return StatusCode::SUCCESS;
1079  }
1080  } // if (muon_pos && muon_neg)
1081  else { // this is the else of --> if (muon_pos && muon_neg)
1082  ATH_MSG_WARNING("** IDPerfMonZmumu::execute ** Could not find CombinedMuon pos/neg in event"
1083  << " Run: " << m_runNumber
1084  << " event: " << m_evtNumber
1085  << " Lumiblock: " << m_lumi_block );
1086  return StatusCode::SUCCESS;
1087  }
1088 
1089  //
1090  // If this point is reached -> there is a good mu+mu- pair and the muons have been associated to a vertex
1091  // So, ntuple can be filled
1092  //
1093  if ( m_xZmm.AcceptEvent() ) {
1094  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Going to fill ntuples for Run: " << m_runNumber
1095  << " event: " << m_evtNumber
1096  << " Lumiblock: " << m_lumi_block
1097  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ** some preliminaries are due though...");
1098 
1099  if (m_useTrackSelectionTool) {
1100  // The track selection is applied to the InnerDetectorTrackParticle of the muons
1101  if ( !m_selTool->accept(muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)) ) {
1102  ATH_MSG_DEBUG("Exiting because the ID segment of muon_pos do not pass the TrackSelection");
1103  return StatusCode::SUCCESS;
1104  }
1105  if ( !m_selTool->accept(muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)) ) {
1106  ATH_MSG_DEBUG("Exiting because the ID segment of muon_neg do not pass the TrackSelection");
1107  return StatusCode::SUCCESS;
1108  }
1109  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Good news ** pos and neg muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle) pass the trackSelection :)");
1110  }
1111  else {
1112  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track selection is not in use ");
1113  }
1114 
1115  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** >> before fill rec with default: " << m_trackParticleName << " tracks << ");
1116 
1117  if (m_storeZmumuNtuple) {
1118  // reset vectors
1119  this->ResetCommonNtupleVectors();
1120 
1121  // Fill Inner Detector Tree
1122  ATH_MSG_DEBUG("-- >> going to fill ID muons params << --");
1123  success_pos = FillRecParametersTP (muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1124  muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1125  muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)->charge(),
1126  ppos_comb_v);
1127  success_neg = FillRecParametersTP (muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1128  muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1129  muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)->charge(),
1130  pneg_comb_v);
1131 
1132  if (success_pos && success_neg) {
1133  // before filling the ntuple, extract the hits information. This is filled once and it is used for all track collections
1134  this->ExtractIDHitsInformation(muon_pos, muon_neg);
1135 
1136  // Fill ntuple
1137  if (m_IDTree != nullptr) {
1138  ATH_MSG_DEBUG("-- Filling m_IDTree ntuple " << m_IDTree->GetName() << " entry " << m_IDTree->GetEntries()
1139  << " for run: " << m_runNumber
1140  << " event: " << m_evtNumber
1141  << " Lumiblock: " << m_lumi_block
1142  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ");
1143  }
1144  ATH_MSG_DEBUG("mu+ --> pxyz " << m_positive_px
1145  << ", " << m_positive_py
1146  << ", " << m_positive_pz
1147  << " pt: " << muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)->pt()
1148  << " d0: " << m_positive_d0
1149  << " z0: " << m_positive_z0
1150  << " d0unc: " << m_positive_d0_err
1151  << " sigma_pt: " << m_positive_sigma_pt);
1152  ATH_MSG_DEBUG("mu- --> pxyz: " << m_negative_px
1153  << ", " << m_negative_py
1154  << ", " << m_negative_pz
1155  << " pt: " << muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)->pt()
1156  << " d0: " << m_negative_d0
1157  << " z0: " << m_negative_z0
1158  << " d0unc: " << m_negative_d0_err
1159  << " sigma_pt: " << m_negative_sigma_pt);
1160  // ntuple variables have been filled in FillRecParametersTP
1161  if (m_IDTree) m_IDTree->Fill();
1162 
1163  // Fill vectors for common ntuple
1164  m_IDTrack_pt.push_back(m_positive_pt);
1165  m_IDTrack_pt.push_back(m_negative_pt);
1166  m_IDTrack_eta.push_back(m_positive_eta);
1167  m_IDTrack_eta.push_back(m_negative_eta);
1168  m_IDTrack_phi.push_back(m_positive_phi);
1169  m_IDTrack_phi.push_back(m_negative_phi);
1170  m_IDTrack_d0.push_back(m_positive_d0);
1171  m_IDTrack_d0.push_back(m_negative_d0);
1172  m_IDTrack_z0.push_back(m_positive_z0);
1173  m_IDTrack_z0.push_back(m_negative_z0);
1174  m_IDTrack_qoverp.push_back(m_positive_qoverp);
1175  m_IDTrack_qoverp.push_back(m_negative_qoverp);
1176 
1177  m_IDTrack_sigma_pt.push_back(m_positive_sigma_pt);
1178  m_IDTrack_sigma_pt.push_back(m_negative_sigma_pt);
1179  m_IDTrack_sigma_d0.push_back(m_positive_d0_err);
1180  m_IDTrack_sigma_d0.push_back(m_negative_d0_err);
1181  m_IDTrack_sigma_z0.push_back(m_positive_z0_err);
1182  m_IDTrack_sigma_z0.push_back(m_negative_z0_err);
1183  m_IDTrack_sigma_qoverp.push_back(m_positive_sigma_qoverp);
1184  m_IDTrack_sigma_qoverp.push_back(m_negative_sigma_qoverp);
1185  }
1186  else {
1187  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** not filling IDTracks in combTree due to problems with muon_xxx->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)");
1188  }
1189  // End of fill ID Tree
1190 
1191  //
1192  // combined muons ntuple
1193  if ((!m_skipMS && m_combTree) || m_commonTree ) { // if skipMS -> no combined muons
1194  success_pos = FillRecParametersTP(muon_pos->trackParticle(xAOD::Muon::CombinedTrackParticle),
1195  muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1196  ppos_comb->charge(),
1197  ppos_comb_v);
1198  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** success_pos TP pt: " << m_positive_pt << " GeV");
1199  success_neg = FillRecParametersTP(muon_neg->trackParticle(xAOD::Muon::CombinedTrackParticle),
1200  muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1201  pneg_comb->charge(),
1202  pneg_comb_v);
1203  ATH_MSG_DEBUG("** IDPerfMonZmumu::excute ** success_neg TP pt: " << m_negative_pt << " GeV");
1204 
1205  if (success_pos && success_neg) {
1206  if (m_combTree != nullptr) {
1207  ATH_MSG_DEBUG("-- Filling m_combTree ntuple " << m_combTree->GetName() << " entry " << m_combTree->GetEntries()
1208  << " run: " << m_runNumber
1209  << " event: " << m_evtNumber
1210  << " Lumiblock: " << m_lumi_block
1211  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ");
1212  }
1213  ATH_MSG_DEBUG("mu+ --> pxyz " << m_positive_px
1214  << ", " << m_positive_py
1215  << ", " << m_positive_pz
1216  << " pt: " << m_positive_pt
1217  << " d0: " << m_positive_d0
1218  << " z0: " << m_positive_z0
1219  << " d0unc: " << m_positive_d0_err);
1220  ATH_MSG_DEBUG("mu- --> pxyz: " << m_negative_px
1221  << ", " << m_negative_py
1222  << ", " << m_negative_pz
1223  << " pt: " << m_negative_pt
1224  << " d0: " << m_negative_d0
1225  << " z0: " << m_negative_z0
1226  << " d0unc: " << m_negative_d0_err);
1227  // ntuple variables have been filled in FillRecParameters
1228  if (m_combTree) m_combTree->Fill();
1229  }
1230  // Fill vectors for common ntuple
1231  m_CBTrack_pt.push_back(m_positive_pt);
1232  m_CBTrack_pt.push_back(m_negative_pt);
1233  m_CBTrack_eta.push_back(m_positive_eta);
1234  m_CBTrack_eta.push_back(m_negative_eta);
1235  m_CBTrack_phi.push_back(m_positive_phi);
1236  m_CBTrack_phi.push_back(m_negative_phi);
1237  m_CBTrack_d0.push_back(m_positive_d0);
1238  m_CBTrack_d0.push_back(m_negative_d0);
1239  m_CBTrack_z0.push_back(m_positive_z0);
1240  m_CBTrack_z0.push_back(m_negative_z0);
1241  m_CBTrack_qoverp.push_back(m_positive_qoverp);
1242  m_CBTrack_qoverp.push_back(m_negative_qoverp);
1243 
1244  m_CBTrack_sigma_pt.push_back(m_positive_sigma_pt);
1245  m_CBTrack_sigma_pt.push_back(m_negative_sigma_pt);
1246  m_CBTrack_sigma_d0.push_back(m_positive_d0_err);
1247  m_CBTrack_sigma_d0.push_back(m_negative_d0_err);
1248  m_CBTrack_sigma_z0.push_back(m_positive_z0_err);
1249  m_CBTrack_sigma_z0.push_back(m_negative_z0_err);
1250  m_CBTrack_sigma_qoverp.push_back(m_positive_sigma_qoverp);
1251  m_CBTrack_sigma_qoverp.push_back(m_negative_sigma_qoverp);
1252  } // if skipMS -> no combined muons
1253 
1254 
1255 
1256  // MS ntuple
1257  if (!m_skipMS && m_MSTree) { // if skipMS -> no MS tracks
1258  ATH_MSG_DEBUG("-- >> going to fill MS muons params << --");
1259  success_pos = FillRecParametersTP(m_xZmm.getMSTrack(m_xZmm.getPosMuon(ZmumuEvent::CB)),
1260  muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1261  ppos_comb->charge(),
1262  ppos_comb_v);
1263 
1264  success_neg = FillRecParametersTP(m_xZmm.getMSTrack(m_xZmm.getNegMuon(ZmumuEvent::CB)),
1265  muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1266  pneg_comb->charge(),
1267  pneg_comb_v);
1268  if (success_pos && success_neg) {
1269  if (m_MSTree != nullptr) ATH_MSG_DEBUG("-- Filling m_MSTree " << m_MSTree->GetName() << " entry " << m_MSTree->GetEntries()
1270  << " run: " << m_runNumber
1271  << " event: " << m_evtNumber
1272  << " Lumiblock: " << m_lumi_block
1273  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ");
1274  ATH_MSG_DEBUG("mu+ --> pxyz " << m_positive_px
1275  << ", " << m_positive_py
1276  << " pt: " << m_xZmm.getMSTrack(m_xZmm.getPosMuon(ZmumuEvent::CB))->pt()
1277  << " d0: " << m_positive_d0
1278  << " z0: " << m_positive_z0
1279  << " d0unc: " << m_positive_d0_err);
1280  ATH_MSG_DEBUG("mu- --> pxyz: " << m_negative_px
1281  << ", " << m_negative_py
1282  << " pt: " << m_xZmm.getMSTrack(m_xZmm.getNegMuon(ZmumuEvent::CB))->pt()
1283  << " d0: " << m_negative_d0
1284  << " z0: " << m_negative_z0
1285  << " d0unc: " << m_negative_d0_err);
1286  // ntuple variables have been filled in FillRecParametersTP
1287  if (m_MSTree) m_MSTree->Fill();
1288  }
1289  else {
1290  ATH_MSG_INFO("FAILED filling m_MSTree "
1291  << " for run: " << m_runNumber
1292  << " event: " << m_evtNumber
1293  << " Lumiblock: " << m_lumi_block);
1294  }
1295  // MS ntuple
1296  }
1297  } // if store Zmumu ntuple
1298 
1299  // changed refitting to combined particles since run II DESDM_ZMUMU did not store InDetTrackParticles
1300  if( m_doRefit ) {
1301  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Going to build TrackCollections: muonTrks, muonTrksRefit1 and muonTrksRefit2");
1302  TrackCollection* muonTrks = new TrackCollection(SG::OWN_ELEMENTS);
1303  TrackCollection* muonTrksRefit1 = new TrackCollection(SG::OWN_ELEMENTS);
1304  TrackCollection* muonTrksRefit2 = new TrackCollection(SG::OWN_ELEMENTS);
1305 
1306  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Going to refit and store the track parameters ");
1307  Trk::Track* defaultMuonTrk1{};
1308  Trk::Track* defaultMuonTrk2{};
1309  Trk::Track* refit1MuonTrk1{};
1310  Trk::Track* refit2MuonTrk1{};
1311  Trk::Track* refit1MuonTrk2{};
1312  Trk::Track* refit2MuonTrk2{};
1313 
1314  StatusCode fitStatus;
1315  //save default and refit track parameters
1316  const EventContext& ctx = Gaudi::Hive::currentContext();
1317  if( ppos_comb->track() ) {
1318  defaultMuonTrk1 = new Trk::Track(*ppos_comb->track());
1319 
1320  IegammaTrkRefitterTool::Cache fitResult{};
1321  fitStatus = m_TrackRefitter1->refitTrack( ctx, ppos_comb->track(), fitResult );
1322  if (fitStatus.isFailure()) {
1323  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track Refit1 Failed for ppos_comb->track(). Skipping Event");
1324  return StatusCode::SUCCESS;
1325  } else {
1326  refit1MuonTrk1 = fitResult.refittedTrack.release();
1327  muonTrksRefit1->push_back(refit1MuonTrk1);
1328  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track Refit1 Success of ppos_comb->track()."
1329  << " Original pt: " << ppos_comb->track()->perigeeParameters()->pT()
1330  << " track refit pt: " << refit1MuonTrk1->perigeeParameters()->pT() );
1331  }
1332 
1333 
1334  fitStatus = m_TrackRefitter2->refitTrack( ctx, ppos_comb->track(), fitResult );
1335  if (fitStatus.isFailure()) {
1336  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track Refit2 Failed for ppos_comb->track(). Skipping Event");
1337  return StatusCode::SUCCESS;
1338  } else {
1339  refit2MuonTrk1 = fitResult.refittedTrack.release();
1340  muonTrksRefit2->push_back(refit2MuonTrk1);
1341  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track Refit2 Success of ppos_comb->track()."
1342  << " Original pt: " << ppos_comb->track()->perigeeParameters()->pT()
1343  << " track refit pt: " << refit1MuonTrk1->perigeeParameters()->pT() );
1344  }
1345  }
1346 
1347  if( pneg_comb->track() ) {
1348  defaultMuonTrk2 = new Trk::Track(*pneg_comb->track());
1349 
1350  IegammaTrkRefitterTool::Cache fitResult {};
1351  fitStatus = m_TrackRefitter1->refitTrack( ctx, pneg_comb->track(), fitResult);
1352  if (fitStatus.isFailure()) {
1353  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track Refit1 Failed. Skipping Event");
1354  return StatusCode::SUCCESS;
1355  } else {
1356  refit1MuonTrk2 = fitResult.refittedTrack.release();
1357  muonTrksRefit1->push_back(refit1MuonTrk2);
1358  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track Refit1 Success of pneg_comb->track()."
1359  << " Original pt: " << pneg_comb->track()->perigeeParameters()->pT()
1360  << " track refit pt: " << refit1MuonTrk2->perigeeParameters()->pT() );
1361  }
1362 
1363 
1364  fitStatus = m_TrackRefitter2->refitTrack( ctx, pneg_comb->track(), fitResult );
1365  if (fitStatus.isFailure()) {
1366  ATH_MSG_DEBUG("Track Refit2 Failed. Skipping Event");
1367  return StatusCode::SUCCESS;
1368  } else {
1369  refit2MuonTrk2 = fitResult.refittedTrack.release();
1370  muonTrksRefit2->push_back(refit2MuonTrk2);
1371  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track Refit2 Success of pneg_comb->track()."
1372  << " Original pt: " << pneg_comb->track()->perigeeParameters()->pT()
1373  << " track refit pt: " << refit2MuonTrk2->perigeeParameters()->pT() );
1374  }
1375 
1376  if (muonTrksRefit1->size() != 2) ATH_MSG_WARNING("** IDPerfMonZmumu::execute ** WARNING ** size of muonTrksRefit1: " << muonTrksRefit1->size());
1377  if (muonTrksRefit2->size() != 2) ATH_MSG_WARNING("** IDPerfMonZmumu::execute ** WARNING ** size of muonTrksRefit2: " << muonTrksRefit2->size());
1378  }
1379 
1380  //save tracks to storegrate, they can be used by InDetAlignmentMonitoring
1381  muonTrks->push_back(defaultMuonTrk1);
1382  muonTrks->push_back(defaultMuonTrk2);
1383 
1384  StatusCode sc = evtStore()->record(muonTrks, m_outputTracksName);
1385  if (sc.isSuccess()) {
1386  ATH_MSG_DEBUG ("Stored "<< muonTrks->size() << " " << m_outputTracksName <<" into StoreGate");
1387  }
1388  else{
1389  ATH_MSG_WARNING ("Failed storing " << m_outputTracksName);
1390  }
1391 
1392  if (muonTrksRefit1->size() > 1) { // keep track collection if at least 2 muons were found
1393  sc = evtStore()->record(muonTrksRefit1, m_outputTracksName + "Refit1");
1394  if (sc.isSuccess()) {
1395  ATH_MSG_DEBUG ("Stored "<< muonTrksRefit1->size() << " " << m_outputTracksName + "Refit1" << " into StoreGate");
1396  } else {
1397  ATH_MSG_WARNING ("Failed storing " << m_outputTracksName + "Refit1");
1398  }
1399  }
1400 
1401  if (muonTrksRefit2->size() > 1) { // keep track collection if at least 2 muons were found
1402  sc = evtStore()->record(muonTrksRefit2, m_outputTracksName + "Refit2");
1403  if (sc.isSuccess()) {
1404  ATH_MSG_DEBUG ("Stored "<< muonTrksRefit2->size() << " " << m_outputTracksName + "Refit2" << " into StoreGate");
1405  } else {
1406  ATH_MSG_WARNING ("Failed storing " << m_outputTracksName + "Refit2");
1407  }
1408  }
1409 
1410 
1411  //fill refit1 ID parameters
1412  if (muonTrksRefit1->size()<2) {
1413  ATH_MSG_WARNING("** IDPerfMonZmumu::execute ** Refit1 muon tracks are missing!");
1414  }
1415  else {
1416  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** going to fill refit1tree ");
1417  success_pos = FillRecParametersSimple (refit1MuonTrk1, ppos_comb->charge(), ppos_comb_v);
1418  success_neg = FillRecParametersSimple (refit1MuonTrk2, pneg_comb->charge(), pneg_comb_v);
1419 
1420  if (m_storeZmumuNtuple) {
1421  if (success_pos && success_neg) {
1422  if (m_refit1Tree) {
1423  ATH_MSG_DEBUG("-- Filling ntuple " << m_refit1Tree->GetName() << " entry " << m_refit1Tree->GetEntries()
1424  << " for run: " << m_runNumber
1425  << " event: " << m_evtNumber
1426  << " Lumiblock: " << m_lumi_block
1427  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ");
1428  }
1429  ATH_MSG_DEBUG("Negative p: (" << m_negative_px << ", "
1430  << m_negative_py << ", "
1431  << m_negative_pz << ") "
1432  << " d0: " << m_negative_d0
1433  << " z0: " << m_negative_z0
1434  << " sigma_pt: " << m_positive_sigma_pt);
1435  ATH_MSG_DEBUG("Positive p: (" << m_positive_px << ","
1436  << m_positive_py << ","
1437  << m_positive_pz << ") "
1438  << " d0: " << m_positive_d0
1439  << " z0: " << m_positive_z0
1440  << " sigma_pt: " << m_negative_sigma_pt);
1441  if (m_refit1Tree) {
1442  m_refit1Tree->Fill();
1443  }
1444  // Fill vectors for common ntuple
1445  m_Refit1_pt.push_back(m_positive_pt);
1446  m_Refit1_pt.push_back(m_negative_pt);
1447  m_Refit1_eta.push_back(m_positive_eta);
1448  m_Refit1_eta.push_back(m_negative_eta);
1449  m_Refit1_phi.push_back(m_positive_phi);
1450  m_Refit1_phi.push_back(m_negative_phi);
1451  m_Refit1_d0.push_back(m_positive_d0);
1452  m_Refit1_d0.push_back(m_negative_d0);
1453  m_Refit1_z0.push_back(m_positive_z0);
1454  m_Refit1_z0.push_back(m_negative_z0);
1455 
1456  m_Refit1_sigma_pt.push_back(m_positive_sigma_pt);
1457  m_Refit1_sigma_pt.push_back(m_negative_sigma_pt);
1458  m_Refit1_sigma_d0.push_back(m_positive_d0_err);
1459  m_Refit1_sigma_d0.push_back(m_negative_d0_err);
1460  m_Refit1_sigma_z0.push_back(m_positive_z0_err);
1461  m_Refit1_sigma_z0.push_back(m_negative_z0_err);
1462  } // if (success_pos && success_neg)
1463  } // if (m_storeZmumuNtuple)
1464  } // enough refit1 tracks
1465 
1466  //fill refit2 ID parameters
1467  if (muonTrksRefit2->size()<2) {
1468  ATH_MSG_WARNING("** IDPerfMonZmumu::execute ** Refit2 muon tracks are missing!");
1469  }
1470  else{
1471  ATH_MSG_DEBUG("-- >> going to fill refit2params << --");
1472  success_pos = FillRecParametersSimple (refit2MuonTrk1, ppos_comb->charge(), ppos_comb_v);
1473  success_neg = FillRecParametersSimple (refit2MuonTrk2, pneg_comb->charge(), pneg_comb_v);
1474 
1475  if (m_storeZmumuNtuple) {
1476  if (success_pos && success_neg) {
1477  if (m_refit2Tree) {
1478  ATH_MSG_DEBUG("-- Filling " << m_refit2Tree->GetName() << " entry " << m_refit2Tree->GetEntries()
1479  << " run: " << m_runNumber
1480  << " event: " << m_evtNumber
1481  << " Lumiblock: " << m_lumi_block
1482  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ");
1483  }
1484  ATH_MSG_DEBUG("Negative p: (" << m_negative_px << ", "
1485  << m_negative_py << ", "
1486  << m_negative_pz << ") "
1487  << " d0: " << m_negative_d0
1488  << " z0: " << m_negative_z0
1489  << " sigma_pt: " << m_positive_sigma_pt);
1490  ATH_MSG_DEBUG("Positive p: (" << m_positive_px << ","
1491  << m_positive_py << ","
1492  << m_positive_pz << ") "
1493  << " d0: " << m_positive_d0
1494  << " z0: " << m_positive_z0
1495  << " sigma_pt: " << m_negative_sigma_pt);
1496  if (m_refit2Tree) {
1497  m_refit2Tree->Fill();
1498  }
1499  // Fill vectors for common ntuple
1500  m_Refit2_pt.push_back(m_positive_pt);
1501  m_Refit2_pt.push_back(m_negative_pt);
1502  m_Refit2_eta.push_back(m_positive_eta);
1503  m_Refit2_eta.push_back(m_negative_eta);
1504  m_Refit2_phi.push_back(m_positive_phi);
1505  m_Refit2_phi.push_back(m_negative_phi);
1506  m_Refit2_d0.push_back(m_positive_d0);
1507  m_Refit2_d0.push_back(m_negative_d0);
1508  m_Refit2_z0.push_back(m_positive_z0);
1509  m_Refit2_z0.push_back(m_negative_z0);
1510 
1511  m_Refit2_sigma_pt.push_back(m_positive_sigma_pt);
1512  m_Refit2_sigma_pt.push_back(m_negative_sigma_pt);
1513  m_Refit2_sigma_d0.push_back(m_positive_d0_err);
1514  m_Refit2_sigma_d0.push_back(m_negative_d0_err);
1515  m_Refit2_sigma_z0.push_back(m_positive_z0_err);
1516  m_Refit2_sigma_z0.push_back(m_negative_z0_err);
1517  } // if (success_pos && success_neg)
1518  } // if (m_storeZmumuNtuple)
1519  } // enough refit2 tracks
1520 
1521  ATH_MSG_DEBUG("Execute() All NTUPLES filled Run: " << m_runNumber << " event: " << m_evtNumber << " mass: " << m_xZmm.GetInvMass() << " GeV ");
1522  }
1523  } // closing -> if ( m_xZmm.AcceptEvent() )
1524 
1525  if ( !m_xZmm.AcceptEvent() ) {
1526  // no good muon pair found
1527  //failed cuts, continue to next event
1528  ATH_MSG_DEBUG ("** IDPerfMonZmumu::execute ** No good muon pair found. Leaving Execute(). Run: " << m_runNumber << " event: " << m_evtNumber);
1529  return StatusCode::SUCCESS;
1530  }
1531 
1532  //
1533  // fill truth event iformation even when the reco event has not passed
1534  //
1535  if (m_isMC) {
1536  bool truthStatusIsGood = true;
1537  if (FillTruthParameters(ppos_comb).isFailure()){
1538  truthStatusIsGood = false;
1539  ATH_MSG_WARNING("Failed to fill truth parameters - skipping event");
1540  }
1541  if (FillTruthParameters(pneg_comb).isFailure()){
1542  truthStatusIsGood = false;
1543  ATH_MSG_WARNING("Failed to fill truth parameters - skipping event");
1544  }
1545  if (truthStatusIsGood) {
1546  ATH_MSG_DEBUG ("-- Filling " << m_truthTree->GetName() << " entry " << m_truthTree->GetEntries()
1547  << " run: " << m_runNumber
1548  << " event: " << m_evtNumber
1549  << " Lumiblock: " << m_lumi_block
1550  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ");
1551  ATH_MSG_DEBUG ("Negative p: (" << m_negative_px << ", "
1552  << m_negative_py << ", "
1553  << m_negative_pz << ") "
1554  << " d0: " << m_negative_d0
1555  << " z0: " << m_negative_z0
1556  << " parent: " << m_negative_parent);
1557  ATH_MSG_DEBUG ("Positive p: (" << m_positive_px << ","
1558  << m_positive_py << ","
1559  << m_positive_pz << ") "
1560  << " d0: " << m_positive_d0
1561  << " z0: " << m_positive_z0
1562  << " parent: " << m_positive_parent);
1563 
1564  if (m_storeZmumuNtuple && m_truthTree) m_truthTree->Fill();
1565  m_Truth_pt.push_back(m_positive_pt);
1566  m_Truth_pt.push_back(m_negative_pt);
1567  m_Truth_eta.push_back(m_positive_eta);
1568  m_Truth_eta.push_back(m_negative_eta);
1569  m_Truth_phi.push_back(m_positive_phi);
1570  m_Truth_phi.push_back(m_negative_phi);
1571  m_Truth_d0.push_back(m_positive_d0);
1572  m_Truth_d0.push_back(m_negative_d0);
1573  m_Truth_z0.push_back(m_positive_z0);
1574  m_Truth_z0.push_back(m_negative_z0);
1575  m_Truth_qoverp.push_back(m_positive_qoverp);
1576  m_Truth_qoverp.push_back(m_negative_qoverp);
1577  m_Truth_parent.push_back(m_positive_parent);
1578  m_Truth_parent.push_back(m_negative_parent);
1579 
1580  } // truth info properly filled
1581  else {
1582  ATH_MSG_DEBUG("FAILED filling m_truthTree "
1583  << " for run: " << m_runNumber
1584  << " event: " << m_evtNumber
1585  << " Lumiblock: " << m_lumi_block);
1586  }
1587  } // if (m_isMC)
1588 
1589  // fill common tree
1590  if (m_commonTree ) {
1591  // fill ntuple if some of the collections is filled
1592  bool dofill = false;
1593  if (m_IDTrack_pt.size() >= 2) dofill = true;
1594  if (m_CBTrack_pt.size() >= 2) dofill = true;
1595  if (m_Refit1_pt.size() >= 2) dofill = true;
1596  if (m_Refit2_pt.size() >= 2) dofill = true;
1597  if (m_Truth_pt.size() >= 2) dofill = true;
1598 
1599  if (dofill) {
1600  ATH_MSG_DEBUG("-- Filling m_commonTree " << m_commonTree->GetName() << " entry " << m_commonTree->GetEntries()
1601  << " run: " << m_runNumber
1602  << " event: " << m_evtNumber
1603  << " Lumiblock: " << m_lumi_block
1604  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ");
1605  m_commonTree->Fill();
1606  }
1607  else {
1608  ATH_MSG_DEBUG("-- Filling m_commonTree " << m_commonTree->GetName() << " FAILED for "
1609  << " run: " << m_runNumber
1610  << " event: " << m_evtNumber
1611  << " Lumiblock: " << m_lumi_block);
1612  }
1613  }
1614 
1615  ATH_MSG_DEBUG(" --IDPerfMonZmumu::execute-- event completed -- Run: " << m_runNumber << " event: " << m_evtNumber);
1616 
1617  /* ***********************************************************
1618  * after all, let's make the collection for ALL MUON ID Tracks
1619  * ***********************************************************/
1620 
1621  ATH_MSG_DEBUG("IDTracks monitoring..");
1622  int nTracks = 0;
1623  TrackCollection* IDTracks = new TrackCollection(SG::OWN_ELEMENTS);
1624 
1625  // DIFFERENT RETRIEVAL
1626  const xAOD::MuonContainer* muons = PerfMonServices::getContainer<xAOD::MuonContainer>( PerfMonServices::MUON_COLLECTION );
1627  if(muons){
1628  for (auto muon : *muons) {
1629  const xAOD::TrackParticle* tp = muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
1630  if(!tp) {
1631  ATH_MSG_DEBUG(" - tpb = "<< tp << " -> is null? " << (!tp));
1632  continue;
1633  }
1634  const Trk::Track* t = tp->track();
1635  if ( !t ) {
1636  ATH_MSG_DEBUG(" - tpb does not have track ");
1637  continue;
1638  }
1639  const Trk::Perigee* tPerigee = t->perigeeParameters() ;
1640  if ( !tPerigee ) {
1641  ATH_MSG_DEBUG(" - t does not have perigree ");
1642  continue;
1643  }
1644  IDTracks->push_back ( new Trk::Track (*t));
1645  nTracks++;
1646  }
1647  }
1648  else ATH_MSG_WARNING ("Could not retrieve Muon container");
1649 
1650  ATH_MSG_DEBUG(" --> nTracks = " << nTracks);
1651 
1652  StatusCode scid = evtStore()->record(IDTracks, "IDTracks");
1653  if (scid.isSuccess()) {
1654  ATH_MSG_DEBUG ("Stored "<< IDTracks->size() << " IDTracks into StoreGate");
1655  }
1656  else{
1657  ATH_MSG_WARNING ("Failed storing IDTracks");
1658  }
1659 
1660  /*********************************************************
1661  * ..finish
1662  ********************************************************/
1663 
1664  return StatusCode::SUCCESS;
1665 }
1666 
1667 //==================================================================================
1668 StatusCode IDPerfMonZmumu::FillRecParametersTP(const xAOD::TrackParticle* trackp,
1669  const xAOD::TrackParticle* trackp_for_unbias,
1670  double charge,
1671  const xAOD::Vertex* vertex)
1672 {
1673  if (!trackp){
1674  //ATH_MSG_WARNING("Empty Trackparticle. Skipping.");
1675  return StatusCode::FAILURE;
1676  }
1677 
1678  if (m_doRemoval && !trackp_for_unbias && !m_skipMS){
1679  return StatusCode::FAILURE;
1680  }
1681 
1682  double px = 0;
1683  double py = 0;
1684  double pt = 0;
1685  double pz = 0;
1686  double phi= 0;
1687  double eta= 0;
1688  double d0 = 0;
1689  double z0 = 0;
1690  double d0res = 0;
1691  double z0res = 0;
1692  double PVd0res = 0;
1693  double PVz0res = 0;
1694  double PVd0 = 0;
1695  double PVz0 = 0;
1696  double sigma_pt = 0;
1697  double qoverp = 0;
1698  double sigma_qOverP = 1.; // use a large value by default as 0 is meaningless
1699 
1700 
1701  px = trackp->p4().Px();
1702  py = trackp->p4().Py();
1703  pt = trackp->p4().Pt();
1704  pz = trackp->p4().Pz();
1705  phi= trackp->p4().Phi();
1706  eta= trackp->p4().Eta();
1707  d0 = trackp->d0();
1708  z0 = trackp->z0();
1709  qoverp = trackp->qOverP();
1710 
1711  d0res = std::sqrt(trackp->definingParametersCovMatrix()(Trk::d0,Trk::d0));
1712  z0res = std::sqrt(trackp->definingParametersCovMatrix()(Trk::z0,Trk::z0));
1713  sigma_qOverP = std::sqrt(trackp->definingParametersCovMatrix()(Trk::qOverP,Trk::qOverP));
1714  double sigma_theta = std::sqrt(trackp->definingParametersCovMatrix()(Trk::theta,Trk::theta));
1715 
1716  // computing sigma_pt
1717  // pt = sin(theta) / qOverP --> sigma(pt) = (sin(theta)/ qOverP^2) x sigma(qOverP) // neglecting sigma(sin(theta))
1718  double sigma_pt_term1 = (sin(trackp->theta()) / pow(qoverp,2)) * sigma_qOverP;
1719  double sigma_pt_term2 = (1./qoverp) * cos(trackp->theta()) * sigma_theta;
1720  double sigma_pt_term3 = (cos(trackp->theta()) / pow(qoverp,2)) * sigma_theta * sigma_qOverP;
1721  sigma_pt = sqrt( pow(sigma_pt_term1,2) + pow(sigma_pt_term2,2) + 2 * sigma_pt_term3 * trackp->definingParametersCovMatrix()(Trk::qOverP,Trk::theta));
1722 
1723  //
1724  if (vertex == nullptr) {
1725  ATH_MSG_WARNING("in FillRecParametersTP. WARNING: Vertex is NULL");
1726  return StatusCode::FAILURE;
1727  }
1728  if (!m_trackToVertexIPEstimator) {
1729  ATH_MSG_WARNING("in FillRecParametersTP. WARNING: m_trackToVertexIPEstimator is NULL");
1730  return StatusCode::FAILURE;
1731  }
1732 
1733  if (m_doIP && vertex != nullptr && m_trackToVertexIPEstimator){
1734  std::unique_ptr<Trk::ImpactParametersAndSigma> iPandSigma(nullptr);
1735  ATH_MSG_DEBUG("-- using the trackToVertexIPEstimator --");
1736 
1737  //Calling the estimate(trackp,newtrackp,vertex,doRemoval)
1738  //The first track is used to unbias the vertex, the second to get the extrapolation
1739  if (!m_skipMS) iPandSigma = m_trackToVertexIPEstimator->estimate(trackp_for_unbias, trackp, vertex, m_doRemoval);
1740  else iPandSigma = m_trackToVertexIPEstimator->estimate(trackp, vertex);
1741  ATH_MSG_DEBUG("return from the trackToVertexIPEstimator->estimate()");
1742 
1743  if( !iPandSigma ){
1744  ATH_MSG_WARNING ("FillRecParametersTP::trackToVertexIPEstimator failed !");
1745  return StatusCode::FAILURE;
1746  }
1747  else{
1748  ATH_MSG_DEBUG("FillRecParametersTP::trackToVertexIPEstimator success !");
1749  PVd0 = iPandSigma->IPd0;
1750  PVd0res = iPandSigma->PVsigmad0;
1751  d0res = iPandSigma->sigmad0;
1752  PVz0 = iPandSigma->IPz0;
1753  PVz0res = iPandSigma->PVsigmaz0;
1754  z0res = iPandSigma->sigmaz0;
1755  }
1756  }
1757 
1758  if (charge == 1) {
1759  m_positive_px = px;
1760  m_positive_py = py;
1761  m_positive_pt = pt;
1762  m_positive_pz = pz;
1763  m_positive_phi= phi;
1764  m_positive_eta= eta;
1765  m_positive_z0 = z0;
1766  m_positive_z0_err = z0res;
1767  m_positive_d0 = d0;
1768  m_positive_d0_err = d0res;
1769  m_positive_sigma_pt = sigma_pt;
1770  m_positive_qoverp = qoverp;
1771  m_positive_sigma_qoverp = sigma_qOverP;
1772  if(m_doIP){
1773  m_positive_z0_PV = PVz0;
1774  m_positive_d0_PV = PVd0;
1775  m_positive_z0_PVerr = PVz0res;
1776  m_positive_d0_PVerr = PVd0res;
1777  }
1778  ATH_MSG_DEBUG("(Filled charge == 1 ) (reco)-> px : "<< px <<" py: "<<py <<" pt: "<<pt <<" pz: "<<pz
1779  <<" d0: "<<m_positive_d0 << " d0res : "<< d0res << " PVd0res : "<< PVd0res <<" z0: "<< m_positive_z0 << " z0res : " << z0res << " PVz0res : "<< PVz0res );
1780 
1781  } else if (charge == -1) {
1782  m_negative_px = px;
1783  m_negative_py = py;
1784  m_negative_pt = pt;
1785  m_negative_pz = pz;
1786  m_negative_phi= phi;
1787  m_negative_eta= eta;
1788  m_negative_z0 = z0;
1789  m_negative_z0_err = z0res;
1790  m_negative_d0 = d0;
1791  m_negative_d0_err = d0res;
1792  m_negative_sigma_pt = sigma_pt;
1793  m_negative_qoverp = qoverp;
1794  m_negative_sigma_qoverp = sigma_qOverP;
1795  if(m_doIP){
1796  m_negative_z0_PV = PVz0;
1797  m_negative_d0_PV = PVd0;
1798  m_negative_z0_PVerr = PVz0res;
1799  m_negative_d0_PVerr = PVd0res;
1800  }
1801  ATH_MSG_DEBUG("(Filled charge == -1 ) (reco)-> px : "<< px <<" py: "<< py <<" pt: " << pt <<" pz: "<<pz
1802  <<" d0: "<<m_negative_d0 << " d0res : "<< d0res << " PVd0res : "<< PVd0res <<" z0: "<< m_negative_z0 << " z0res : " << z0res << " PVz0res : "<< PVz0res );
1803  }
1804 
1805  return StatusCode::SUCCESS;
1806 }
1807 
1808 
1809 //==================================================================================
1810 StatusCode IDPerfMonZmumu::FillRecParameters (const Trk::Track* track, const xAOD::TrackParticle* trackp_for_unbias, double charge,const xAOD::Vertex* vertex, const EventContext& ctx)
1811 {
1812  if (!track){
1813  ATH_MSG_DEBUG("* FillRecParameters * Empty Track: track. Skipping.");
1814  return StatusCode::FAILURE;
1815  }
1816 
1817  if (m_doRemoval && !trackp_for_unbias && !m_skipMS) {
1818  ATH_MSG_DEBUG("* FillRecParameters * Empty Track: trackp_for_unbias. Skipping.");
1819  return StatusCode::FAILURE;
1820  }
1821 
1822  const Trk::Perigee* trkPerigee = track->perigeeParameters();
1823  const Trk::Perigee* trk_for_unbiasPerigee = nullptr;
1824  if (!m_skipMS) trk_for_unbiasPerigee = &(trackp_for_unbias->perigeeParameters());
1825 
1826  double px = 0;
1827  double py = 0;
1828  double pt = 0;
1829  double pz = 0;
1830  double phi= 0;
1831  double eta= 0;
1832  double d0 = 0;
1833  double z0 = 0;
1834 
1835  double d0_err = 999.;
1836  double z0_err = 999.;
1837 
1838  double PVd0 = 0;
1839  double PVz0 = 0;
1840  double PVd0res = 0;
1841  double PVz0res = 0;
1842 
1843 
1844  if (trkPerigee != nullptr){
1845  double qOverP = trkPerigee->parameters()[Trk::qOverP];
1846  if (qOverP) {
1847  px = trkPerigee->momentum().x();
1848  py = trkPerigee->momentum().y();
1849  pt = std::abs(trkPerigee->pT());
1850  pz = trkPerigee->momentum().z();
1851  phi= trkPerigee->parameters()[Trk::phi];
1852  eta= trkPerigee->eta();
1853  d0 = trkPerigee->parameters()[Trk::d0];
1854  z0 = trkPerigee->parameters()[Trk::z0];
1855  d0_err = Amg::error(*trkPerigee->covariance(),Trk::d0);
1856  z0_err = Amg::error(*trkPerigee->covariance(),Trk::z0);
1857  }
1858  }
1859 
1860  // access beam spot and extrapolate track till there
1861  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandleRec { m_beamSpotKey, ctx };
1862  auto beamline = m_trackToVertexTool->GetBeamLine(beamSpotHandleRec.cptr());
1863 
1864  auto trackBLtemp = m_trackToVertexTool->trackAtBeamline(ctx, *track , beamline.get() );
1865  const Trk::AtaStraightLine* atBL = dynamic_cast<const Trk::AtaStraightLine*>(trackBLtemp.get());
1866 
1867  if (atBL){
1868  double qOverP = atBL->parameters()[Trk::qOverP];
1869  if(qOverP){
1870  px = atBL->momentum().x();
1871  py = atBL->momentum().y();
1872  pt = std::abs(atBL->pT());
1873  pz = atBL->momentum().z();
1874  eta= trkPerigee->eta();
1875  phi= trkPerigee->parameters()[Trk::phi];
1876  d0 = atBL->parameters()[Trk::d0];
1877  z0 = atBL->parameters()[Trk::z0];
1878  // z0_err = Amg::error(*trkPerigee->covariance(),Trk::z0); //->Why not?
1879  // d0_err = Amg::error(*trkPerigee->covariance(),Trk::d0); //->Why not?
1880  }
1881  delete atBL;
1882  }
1883  else {
1884  ATH_MSG_WARNING("FillRecParameters::Failed extrapolation to the BeamLine");
1885  }
1886 
1887  Amg::Vector3D position = beamSpotHandleRec->beamPos();
1888  TLorentzVector vtrack = TLorentzVector (trkPerigee->momentum().x(),
1889  trkPerigee->momentum().y(),
1890  trkPerigee->momentum().z(),
1891  trkPerigee->momentum().mag());
1892  float trkd0 = trkPerigee->parameters()[Trk::d0];
1893  float trkz0 = trkPerigee->parameters()[Trk::z0];
1894  float bsX = position.x();
1895  float bsY = position.y();
1896  float bsZ = position.z();
1897  float btiltX = beamSpotHandleRec->beamTilt(0);
1898  float btiltY = beamSpotHandleRec->beamTilt(1);
1899  // correct the track parameters for the beamspot position
1900  float beamX = bsX + std::tan(btiltX) * (trkz0-bsZ);
1901  float beamY = bsY + std::tan(btiltY) * (trkz0-bsZ);
1902  float beamD0 = ( -std::sin(vtrack.Phi())*beamX + std::cos(vtrack.Phi())*beamY );
1903  float d0bscorr = trkd0 - beamD0;
1904  float z0bscorr = trkz0 - bsZ;
1905 
1906  if(m_doIP && vertex){ //I assume that the vertex is the same of the original track
1907  std::unique_ptr<Trk::ImpactParametersAndSigma> iPandSigma(nullptr);
1908  if (!m_skipMS) iPandSigma = m_trackToVertexIPEstimator->estimate(trk_for_unbiasPerigee,trkPerigee,vertex,m_doRemoval);
1909  else iPandSigma = m_trackToVertexIPEstimator->estimate(trkPerigee,vertex);
1910  if( iPandSigma==0 ){
1911  ATH_MSG_WARNING ("FillRecParameters::trackToVertexIPEstimator failed !");
1912  return StatusCode::FAILURE;
1913  }
1914  else{
1915  ATH_MSG_DEBUG("FillRecParameters::trackToVertexIPEstimator success !");
1916  PVd0 = iPandSigma->IPd0;
1917  PVd0res = iPandSigma->PVsigmad0;
1918  //d0res = iPandSigma->sigmad0; //-> ?
1919  PVz0 = iPandSigma->IPz0;
1920  PVz0res = iPandSigma->PVsigmaz0;
1921  //z0res = iPandSigma->sigmaz0; //-> ?
1922 
1923  if (vertex) {
1924  ATH_MSG_INFO(" FillRecParameters::trackToVertexIPEstimator vertex does exist ");
1925  m_pv_x = vertex->x();
1926  m_pv_y = vertex->y();
1927  m_pv_z = vertex->z();
1928  m_nTrkInVtx = vertex->nTrackParticles();
1929  }
1930 
1931  }
1932  }
1933 
1934  if (charge == 1) {
1935  m_positive_px = px;
1936  m_positive_py = py;
1937  m_positive_pt = pt;
1938  m_positive_pz = pz;
1939  m_positive_phi= phi;
1940  m_positive_eta= eta;
1941  m_positive_z0 = z0;
1942  m_positive_d0 = d0;
1943  m_positive_z0_manualBS = z0bscorr;
1944  m_positive_d0_manualBS = d0bscorr;
1945  m_positive_d0_err = d0_err;
1946  m_positive_z0_err = z0_err;
1947  if(m_doIP){
1948  m_positive_z0_PV = PVz0;
1949  m_positive_d0_PV = PVd0;
1950  m_positive_z0_PVerr = PVz0res;
1951  m_positive_d0_PVerr = PVd0res;
1952  }
1953  ATH_MSG_DEBUG("(Filled charge == 1 ) (reco)-> px : "<< px <<" py: "<<py <<" pz: "<<pz <<" d0: "<<d0<<" z0: "<< z0);
1954  }
1955  if (charge == -1) {
1956  m_negative_px = px;
1957  m_negative_py = py;
1958  m_negative_pt = pt;
1959  m_negative_pz = pz;
1960  m_negative_phi= phi;
1961  m_negative_eta= eta;
1962  m_negative_z0 = z0;
1963  m_negative_d0 = d0;
1964  m_negative_z0_manualBS = z0bscorr;
1965  m_negative_d0_manualBS = d0bscorr;
1966  m_negative_d0_err = d0_err;
1967  m_negative_z0_err = z0_err;
1968  if(m_doIP){
1969  m_negative_z0_PV = PVz0;
1970  m_negative_d0_PV = PVd0;
1971  m_negative_z0_PVerr = PVz0res;
1972  m_negative_d0_PVerr = PVd0res;
1973  }
1974  ATH_MSG_DEBUG("(Filled charge == -1 ) (reco)-> px : "<< px <<" py: "<<py <<" pz: "<<pz <<" d0: "<<d0<<" z0: "<<z0 );
1975  }
1976 
1977  return StatusCode::SUCCESS;
1978 }
1979 //==================================================================================
1980 StatusCode IDPerfMonZmumu::FillRecParametersSimple (const Trk::Track* track, float charge, const xAOD::Vertex* vertex)
1981 {
1982  if (!track){
1983  ATH_MSG_DEBUG("* FillRecParametersSimple * Empty Track: track. Skipping.");
1984  return StatusCode::FAILURE;
1985  }
1986 
1987  const Trk::Perigee* trkPerigee = track->perigeeParameters();
1988  if (not trkPerigee) {
1989  ATH_MSG_ERROR("trkPerigee pointer is null in IDPerfMonZmumu::FillRecParametersSimple");
1990  return StatusCode::FAILURE;
1991  }
1992  double px = 0;
1993  double py = 0;
1994  double pt = 0;
1995  double pz = 0;
1996  double phi= 0;
1997  double eta= 0;
1998 
1999  double d0 = 0;
2000  double z0 = 0;
2001  double d0_err = 999.;
2002  double z0_err = 999.;
2003 
2004  //
2005  double qOverP = trkPerigee->parameters()[Trk::qOverP];
2006  if (qOverP) {
2007  px = trkPerigee->momentum().x();
2008  py = trkPerigee->momentum().y();
2009  pt = std::abs(trkPerigee->pT());
2010  pz = trkPerigee->momentum().z();
2011  phi= trkPerigee->parameters()[Trk::phi];
2012  eta= trkPerigee->eta();
2013  d0 = trkPerigee->parameters()[Trk::d0];
2014  z0 = trkPerigee->parameters()[Trk::z0];
2015  d0_err = Amg::error(*trkPerigee->covariance(),Trk::d0);
2016  z0_err = Amg::error(*trkPerigee->covariance(),Trk::z0);
2017  }
2018 
2019  SG::ReadHandle<xAOD::EventInfo> eventInfo (m_EventInfoKey, getContext());
2020  Amg::Vector3D position (eventInfo->beamPosX(), eventInfo->beamPosY(), eventInfo->beamPosZ());
2021  TLorentzVector vtrack = TLorentzVector (trkPerigee->momentum().x(),
2022  trkPerigee->momentum().y(),
2023  trkPerigee->momentum().z(),
2024  trkPerigee->momentum().mag());
2025  float trkd0 = trkPerigee->parameters()[Trk::d0];
2026  float trkz0 = trkPerigee->parameters()[Trk::z0];
2027  float bsX = position.x();
2028  float bsY = position.y();
2029  float bsZ = position.z();
2030  float btiltX = eventInfo->beamTiltXZ();
2031  float btiltY = eventInfo->beamTiltYZ();
2032  // correct the track parameters for the beamspot position
2033  float beamX = bsX + std::tan(btiltX) * (trkz0-bsZ);
2034  float beamY = bsY + std::tan(btiltY) * (trkz0-bsZ);
2035  float beamD0 = ( -std::sin(vtrack.Phi())*beamX + std::cos(vtrack.Phi())*beamY );
2036  float d0bscorr = trkd0 - beamD0;
2037  float z0bscorr = trkz0 - bsZ - vertex->z();
2038 
2039  if (charge == 1) {
2040  m_positive_px = px;
2041  m_positive_py = py;
2042  m_positive_pt = pt;
2043  m_positive_pz = pz;
2044  m_positive_phi= phi;
2045  m_positive_eta= eta;
2046  m_positive_z0 = z0bscorr;
2047  m_positive_d0 = d0bscorr;
2048  m_positive_z0_manualBS = z0bscorr;
2049  m_positive_d0_manualBS = d0bscorr;
2050  m_positive_d0_err = d0_err;
2051  m_positive_z0_err = z0_err;
2052  }
2053  if (charge == -1) {
2054  m_negative_px = px;
2055  m_negative_py = py;
2056  m_negative_pt = pt;
2057  m_negative_pz = pz;
2058  m_negative_phi= phi;
2059  m_negative_eta= eta;
2060  m_negative_z0 = z0bscorr;
2061  m_negative_d0 = d0bscorr;
2062  m_negative_z0_manualBS = z0bscorr;
2063  m_negative_d0_manualBS = d0bscorr;
2064  m_negative_d0_err = d0_err;
2065  m_negative_z0_err = z0_err;
2066  }
2067 
2068  ATH_MSG_DEBUG("-- FillRecParametersSimple -- charge " << charge << " pt: " << pt << " d0: " << d0 << " z0: " << z0);
2069 
2070  return StatusCode::SUCCESS;
2071 }
2072 
2073 //==================================================================================
2074 StatusCode IDPerfMonZmumu::FillTruthParameters(const xAOD::TrackParticle* trackParticle)
2075 {
2076 
2077  if (!trackParticle ){//|| !trackParticle->vertex()){
2078  ATH_MSG_WARNING("-- FillTruthParameters -- Empty Trackparticle. Skipping.");
2079  return StatusCode::FAILURE;
2080  }
2081 
2082  static const SG::ConstAccessor<float> truthMatchProbabilityAcc("truthMatchProbability");
2083  float result = truthMatchProbabilityAcc.withDefault(*trackParticle,
2084  std::numeric_limits<float>::quiet_NaN());
2085  ATH_MSG_DEBUG(" -- FillTruthParameters -- TruthMatchProbablity of trackpartile : > " << result);
2086 
2087 
2088  const xAOD::TruthParticle* particle = getTruthParticle( *trackParticle );
2089  double charge = 0;
2090  if (!particle) {
2091  ATH_MSG_DEBUG(" -- FillTruthParameters -- Failure while retrieving the truth particle. Returning FAILURE.");
2092  return StatusCode::FAILURE;
2093  }
2094 
2095  if ( particle->pdgId() == 13) charge = -1.; // muon-
2096  if ( particle->pdgId() == -13) charge = 1.; // muon+
2097  if ( particle->isNeutral() ) {
2098  ATH_MSG_DEBUG(" -- FillTruthParameters -- reco muon associated to a truth neutral!! Returning FAILURE.");
2099  return StatusCode::FAILURE;
2100  }
2101  if ( charge == 0 ) {
2102  ATH_MSG_DEBUG(" -- FillTruthParameters -- reco muon associated to a non true muon!! Returning FAILURE.");
2103  return StatusCode::FAILURE;
2104  }
2105 
2106  const Amg::Vector3D momentum(particle->px(), particle->py(), particle->pz());
2107  const xAOD::TruthVertex * ptruthVertex(0);
2108  ptruthVertex=particle->prodVtx();
2109  if (!ptruthVertex){
2110  ATH_MSG_DEBUG("A production vertex pointer was retrieved, but it is NULL");
2111  return StatusCode::FAILURE;
2112  }
2113 
2114 
2115  if (particle->parent(0) != nullptr) {
2116  static const SG::ConstAccessor<int> truthTypeAcc("truthType");
2117  static const SG::ConstAccessor<int> truthOriginAcc("truthOrigin");
2118  if (truthTypeAcc.isAvailable(*particle)) {
2119  ATH_MSG_DEBUG(" -- FillTruthParameters -- truth particle is good. pdg: " << particle->pdgId()
2120  << " type: " << particle->type()
2121  << " nparents " << particle->nParents()
2122  << " parent->pdg: " << particle->parent(0)->pdgId()
2123  << " truthType: " << truthTypeAcc(*particle)
2124  << " truthOrigin: " << truthOriginAcc(*particle)
2125  );
2126 
2127  }
2128  else {
2129  ATH_MSG_DEBUG(" -- FillTruthParameters -- truth particle is good. pdg: " << particle->pdgId()
2130  << " type: " << particle->type()
2131  << " nparents " << particle->nParents()
2132  << " parent->pdg: " << particle->parent(0)->pdgId()
2133  << " truthType & truthOrigin: " << " NOT AVAILABLE "
2134  );
2135  }
2136  }
2137 
2138  const auto xPos=ptruthVertex->x();
2139  const auto yPos=ptruthVertex->y();
2140  const auto z_truth=ptruthVertex->z();
2141 
2142  const Amg::Vector3D position(xPos, yPos, z_truth);
2143  const Trk::CurvilinearParameters cParameters(position, momentum, charge);
2144 
2145  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandleTruth { m_beamSpotKey };
2146  Trk::PerigeeSurface persf( beamSpotHandleTruth->beamPos() );
2147 
2148  const EventContext& ctx = Gaudi::Hive::currentContext();
2149  std::unique_ptr<const Trk::TrackParameters> tP = m_extrapolator->extrapolate(ctx, cParameters,persf, Trk::anyDirection, false);
2150 
2151  double px = 0;
2152  double py = 0;
2153  double pt = 0;
2154  double pz = 0;
2155  double phi= 0;
2156  double eta= 0;
2157  double d0 = 0;
2158  double d0res = 0;
2159  double PVd0res = 0;
2160  double z0 = 0;
2161  double z0res = 0;
2162  double PVz0res = 0;
2163 
2164  double d0recoPos = m_positive_d0;
2165  double z0recoPos = m_positive_z0;
2166  double d0recoNeg = m_negative_d0;
2167  double z0recoNeg = m_negative_z0;
2168 
2169  ATH_MSG_DEBUG("reco IPs (pos): > d0 : "<<d0recoPos << " z0: " << z0recoPos << " trackp z0 : " << trackParticle->z0() << " trackp d0 : " << trackParticle->d0());
2170  ATH_MSG_DEBUG("reco IPs (neg): > d0 : "<<d0recoNeg << " z0: " << z0recoNeg << " trackp z0 : " << trackParticle->z0() <<" trackp d0 : " << trackParticle->d0() );
2171 
2172  double qOverP_truth = 0.;
2173  if (tP){
2174  qOverP_truth = tP->parameters()[Trk::qOverP];
2175  if( qOverP_truth ){
2176 
2177  px = tP->momentum().x();
2178  py = tP->momentum().y();
2179  pt = tP->pT();
2180  pz = tP->momentum().z();
2181  phi= tP->parameters()[Trk::phi];
2182  eta= tP->eta();
2183  d0 = tP->parameters()[Trk::d0];
2184  z0 = tP->parameters()[Trk::z0];
2185 
2186  ATH_MSG_DEBUG("cand perig HEP particle (truth) px : "<< tP->momentum().x());
2187  ATH_MSG_DEBUG("cand perig HEP particle (truth) py : "<< tP->momentum().y());
2188  ATH_MSG_DEBUG("cand perig HEP particle (truth) pz : "<< tP->momentum().z());
2189  ATH_MSG_DEBUG("cand perig HEP particle (truth) d0 : "<< tP->parameters()[Trk::d0]);
2190  ATH_MSG_DEBUG("cand perig HEP particle (truth) z0 : "<< tP->parameters()[Trk::z0]);
2191 
2192  }
2193  }
2194 
2195 
2196  if (charge == 1) {
2197  m_positive_px = px;
2198  m_positive_py = py;
2199  m_positive_pt = pt;
2200  m_positive_pz = pz;
2201  m_positive_phi= phi;
2202  m_positive_eta= eta;
2203  m_positive_z0 = z0recoPos -z0;
2204  m_positive_z0_err = z0res;
2205  m_positive_z0_PVerr = PVz0res;
2206  m_positive_d0 = d0recoPos -d0;
2207  m_positive_d0_err = d0res;
2208  m_positive_d0_PVerr = PVd0res;
2209  m_positive_qoverp = qOverP_truth;
2210 
2211  bool parentfound = false;
2212  if (particle->nParents()>0) {
2213  if (particle->parent(0) != nullptr) {
2214  m_positive_parent = particle->parent(0)->pdgId();
2215  parentfound = true;
2216  }
2217  }
2218  if (!parentfound) m_positive_parent = 0;
2219 
2220  ATH_MSG_DEBUG(" -- FillTruthParameters -- charge = 1 (truth)-> px : "<< m_positive_px
2221  <<" py: "<<m_positive_py
2222  <<" pz: "<<m_positive_pz
2223  <<" d0: "<<m_positive_d0
2224  <<" z0: "<< m_positive_z0
2225  <<" qoverp: " << m_positive_qoverp
2226  << " parent: " << m_positive_parent);
2227 
2228  } else if (charge == -1) {
2229  m_negative_px = px;
2230  m_negative_py = py;
2231  m_negative_pt = pt;
2232  m_negative_pz = pz;
2233  m_negative_phi= phi;
2234  m_negative_eta= eta;
2235  m_negative_z0 = z0recoNeg-z0;
2236  m_negative_z0_err = z0res;
2237  m_negative_z0_PVerr = PVz0res;
2238  m_negative_d0 = d0recoNeg-d0;
2239  m_negative_d0_err = d0res;
2240  m_negative_d0_PVerr = PVd0res;
2241  m_negative_qoverp = qOverP_truth;
2242 
2243  bool parentfound = false;
2244  if (particle->nParents()>0) {
2245  if (particle->parent(0) != nullptr) {
2246  m_negative_parent = particle->parent(0)->pdgId();
2247  parentfound = true;
2248  }
2249  }
2250  if (!parentfound) m_negative_parent = 0;
2251 
2252  ATH_MSG_DEBUG(" -- FillTruthParameters-- charge = -1 (truth)-> px : "<< m_negative_px
2253  << " py: "<<m_negative_py
2254  << " pz: "<<m_negative_pz
2255  << " d0: "<<m_negative_d0
2256  << " z0: "<< m_negative_z0
2257  <<" qoverp: " << m_negative_qoverp
2258  << " parent:" << m_negative_parent);
2259  }
2260  return StatusCode::SUCCESS;
2261 }
2262 
2263 
2264 //==================================================================================
2265 const xAOD::TruthParticle* IDPerfMonZmumu::getTruthParticle( const xAOD::IParticle& p ) {
2267  typedef ElementLink< xAOD::TruthParticleContainer > Link_t;
2269  static const SG::ConstAccessor< Link_t > acc( "truthParticleLink" );
2270  // Check if such a link exists on the object:
2271  if( ! acc.isAvailable( p ) ) {
2272  return nullptr;
2273  }
2274  // Get the link:
2275  const Link_t& link = acc( p );
2276  // Check if the link is valid:
2277  if( ! link.isValid() ) {
2278  return nullptr;
2279  }
2280  // Everything has passed, let's return the pointer:
2281  return *link;
2282 }
2283 
2284 //==================================================================================
2285 StatusCode IDPerfMonZmumu::finalize()
2286 {
2287  m_xZmm.finalize();
2288  return StatusCode::SUCCESS;
2289 }
2290 
2291 //==================================================================================
2292 StatusCode IDPerfMonZmumu::CheckTriggerStatusAndPrescale ()
2293 {
2294  m_triggerPrescale = 1; // default value
2295 
2296  // check trigger status
2297  if(m_triggerDecision.retrieve().isFailure()) {
2298  ATH_MSG_FATAL("Unable to retrieve " << m_triggerDecision << " turn it off");
2299  return StatusCode::FAILURE;
2300  }
2301  else {
2302  ATH_MSG_DEBUG("retrieved tool: " << m_triggerDecision );
2303  }
2304 
2305  float thisEventTriggerPrescale = 999999.9;
2306  float thisHLTTriggerPrescale = 999999.9;
2307  bool thisHLTIsPassed = false;
2308  std::string thisHLTTriggerName;
2309  std::string thisEventTriggerName;
2310 
2311  // HLT triggers
2312  const std::vector<std::string> myHLTtriglist = m_triggerDecision->getChainGroup("HLT_mu.*, HLT_2mu.*")->getListOfTriggers();
2313  for (int i=0; i < (int) myHLTtriglist.size(); i++) {
2314  if ( m_triggerDecision->isPassed(myHLTtriglist.at(i)) ) {
2315  ATH_MSG_DEBUG("HLT trigger = " << i << " out of " << myHLTtriglist.size() << " --> " << myHLTtriglist.at(i) << " isPassed? " << m_triggerDecision->isPassed(myHLTtriglist.at(i)) << " prescale: " << m_triggerDecision->getChainGroup(myHLTtriglist.at(i))->getPrescale() );
2316  }
2317  if ( m_triggerDecision->isPassed(myHLTtriglist.at(i)) ) { // trigger is passed
2318  thisHLTIsPassed = true;
2319  float thisprescale = m_triggerDecision->getChainGroup(myHLTtriglist.at(i))->getPrescale();
2320  if (thisprescale < thisHLTTriggerPrescale) {
2321  thisHLTTriggerPrescale = thisprescale;
2322  thisHLTTriggerName = myHLTtriglist.at(i);
2323  }
2324  }
2325  }
2326  if (thisHLTTriggerPrescale < 1) thisHLTTriggerPrescale = 1;
2327  ATH_MSG_DEBUG("Event HLT trigger prescale = " << thisHLTTriggerPrescale);
2328 
2329  //if (thisL1IsPassed && thisHLTIsPassed) {
2330  if (thisHLTIsPassed) {
2331  ATH_MSG_DEBUG("Trigger passed -> accept event");
2332  }
2333  else{
2334  ATH_MSG_DEBUG("Trigger Failed -> reject event");
2335  return StatusCode::FAILURE;
2336  }
2337 
2338  // event prescale
2339  thisEventTriggerPrescale = thisHLTTriggerPrescale;
2340  thisEventTriggerName = thisHLTTriggerName;
2341  ATH_MSG_DEBUG("Event trigger prescale = " << thisEventTriggerPrescale);
2342  ATH_MSG_DEBUG("Event trigger name = " << thisEventTriggerName);
2343 
2344  m_triggerPrescale = thisEventTriggerPrescale;
2345  m_triggerName = thisEventTriggerName;
2346 
2347  return StatusCode::SUCCESS;
2348 }
2349 
2350 
2351 //==================================================================================
2352 const xAOD::Vertex* IDPerfMonZmumu::GetDiMuonVertex(const xAOD::TrackParticle* muon1, const xAOD::TrackParticle* muon2) {
2353 
2354  const xAOD::VertexContainer* vxContainer(0);
2355  const xAOD::Vertex* myVtx(0);
2356  vxContainer = PerfMonServices::getContainer<xAOD::VertexContainer> (PerfMonServices::VTX_COLLECTION);
2357  if (!vxContainer) {
2358  return myVtx;
2359  }
2360 
2361  for (int ivtx=0; ivtx< (int) vxContainer->size();ivtx++) {
2362  myVtx = (*vxContainer)[ivtx];
2363  if ((myVtx->vertexType() == xAOD::VxType::PriVtx)) {
2364  if (m_Trk2VtxAssociationTool->isCompatible(*muon1,*myVtx) && (m_Trk2VtxAssociationTool->isCompatible(*muon2,*myVtx)))
2365  return myVtx;
2366  }
2367  }
2368  return myVtx;
2369 }
2370 
2371 //==================================================================================
2372 void IDPerfMonZmumu::ResetCommonNtupleVectors()
2373 {
2374  m_IDTrack_pt.clear();
2375  m_CBTrack_pt.clear();
2376  m_Refit1_pt.clear();
2377  m_Refit2_pt.clear();
2378  m_Truth_pt.clear();
2379 
2380  m_IDTrack_eta.clear();
2381  m_CBTrack_eta.clear();
2382  m_Refit1_eta.clear();
2383  m_Refit2_eta.clear();
2384  m_Truth_eta.clear();
2385 
2386  m_IDTrack_phi.clear();
2387  m_CBTrack_phi.clear();
2388  m_Refit1_phi.clear();
2389  m_Refit2_phi.clear();
2390  m_Truth_phi.clear();
2391 
2392  m_IDTrack_d0.clear();
2393  m_CBTrack_d0.clear();
2394  m_Refit1_d0.clear();
2395  m_Refit2_d0.clear();
2396  m_Truth_d0.clear();
2397 
2398  m_IDTrack_z0.clear();
2399  m_CBTrack_z0.clear();
2400  m_Refit1_z0.clear();
2401  m_Refit2_z0.clear();
2402  m_Truth_z0.clear();
2403 
2404  m_IDTrack_qoverp.clear();
2405  m_CBTrack_qoverp.clear();
2406  m_Refit1_qoverp.clear();
2407  m_Refit2_qoverp.clear();
2408  m_Truth_qoverp.clear();
2409 
2410  m_Truth_parent.clear();
2411 
2412  m_IDTrack_sigma_pt.clear();
2413  m_CBTrack_sigma_pt.clear();
2414  m_Refit1_sigma_pt.clear();
2415  m_Refit2_sigma_pt.clear();
2416 
2417  m_IDTrack_sigma_d0.clear();
2418  m_CBTrack_sigma_d0.clear();
2419  m_Refit1_sigma_d0.clear();
2420  m_Refit2_sigma_d0.clear();
2421 
2422  m_IDTrack_sigma_z0.clear();
2423  m_CBTrack_sigma_z0.clear();
2424  m_Refit1_sigma_z0.clear();
2425  m_Refit2_sigma_z0.clear();
2426 
2427  m_IDTrack_sigma_qoverp.clear();
2428  m_CBTrack_sigma_qoverp.clear();
2429  m_Refit1_sigma_qoverp.clear();
2430  m_Refit2_sigma_qoverp.clear();
2431 
2432  m_nBLhits.clear();
2433  m_nPIXhits.clear();
2434  m_nSCThits.clear();
2435  m_nTRThits.clear();
2436 
2437  return;
2438 }
2439 
2440 //==================================================================================
2441 void IDPerfMonZmumu::Clear4MuNtupleVariables()
2442 {
2443  m_positive_px = 0.;
2444  m_positive_py = 0.;
2445  m_positive_pz = 0.;
2446  m_positive_d0 = 0.;
2447  m_positive_z0 = 0.;
2448  m_positive_d0_manualBS = 0.;
2449  m_positive_z0_manualBS = 0.;
2450  m_positive_d0_err = 0.;
2451  m_positive_z0_err = 0.;
2452  m_positive_sigma_pt = 0.;
2453  m_positive_1_vtx = 0;
2454  m_positive_parent = 0;
2455 
2456  m_negative_px = 0.;
2457  m_negative_py = 0.;
2458  m_negative_pz = 0.;
2459  m_negative_d0 = 0.;
2460  m_negative_z0 = 0.;
2461  m_negative_d0_manualBS = 0.;
2462  m_negative_z0_manualBS = 0.;
2463  m_negative_d0_err = 0.;
2464  m_negative_z0_err = 0.;
2465  m_negative_sigma_pt = 0.;
2466  m_negative_1_vtx = 0;
2467  m_negative_parent = 0;
2468 
2469  m_positive_2_px = 0.;
2470  m_positive_2_py = 0.;
2471  m_positive_2_pz = 0.;
2472  m_positive_2_d0 = 0.;
2473  m_positive_2_z0 = 0.;
2474  m_positive_2_d0_err = 0.;
2475  m_positive_2_z0_err = 0.;
2476  m_positive_2_vtx = 0;
2477 
2478  m_negative_2_px = 0.;
2479  m_negative_2_py = 0.;
2480  m_negative_2_pz = 0.;
2481  m_negative_2_d0 = 0.;
2482  m_negative_2_z0 = 0.;
2483  m_negative_2_d0_err = 0.;
2484  m_negative_2_z0_err = 0.;
2485  m_negative_2_vtx = 0;
2486 
2487  // electrons
2488  m_el_negative1_px = 0.;
2489  m_el_negative1_py = 0.;
2490  m_el_negative1_pz = 0.;
2491  m_el_negative1_d0 = 0.;
2492  m_el_negative1_z0 = 0.;
2493  m_el_negative1_d0_err = 0.;
2494  m_el_negative1_z0_err = 0.;
2495  m_el_negative1_vtx = 0;
2496 
2497  m_el_negative2_px = 0.;
2498  m_el_negative2_py = 0.;
2499  m_el_negative2_pz = 0.;
2500  m_el_negative2_d0 = 0.;
2501  m_el_negative2_z0 = 0.;
2502  m_el_negative2_d0_err = 0.;
2503  m_el_negative2_z0_err = 0.;
2504  m_el_negative2_vtx = 0;
2505 
2506  m_el_positive1_px = 0.;
2507  m_el_positive1_py = 0.;
2508  m_el_positive1_pz = 0.;
2509  m_el_positive1_d0 = 0.;
2510  m_el_positive1_z0 = 0.;
2511  m_el_positive1_d0_err = 0.;
2512  m_el_positive1_z0_err = 0.;
2513  m_el_positive1_vtx = 0;
2514 
2515  m_el_positive2_px = 0.;
2516  m_el_positive2_py = 0.;
2517  m_el_positive2_pz = 0.;
2518  m_el_positive2_d0 = 0.;
2519  m_el_positive2_z0 = 0.;
2520  m_el_positive2_d0_err = 0.;
2521  m_el_positive2_z0_err = 0.;
2522  m_el_positive2_vtx = 0;
2523 
2524  // other quantities
2525  m_nVertex = 0;
2526  m_pv_x = 0; m_pv_y = 0; m_pv_z = 0;
2527  m_4mu_minv = 0.;
2528 
2529  return;
2530 }
2531 //==================================================================================
2532 StatusCode IDPerfMonZmumu::RunFourLeptonAnalysis()
2533 {
2534  StatusCode thisStatus = StatusCode::SUCCESS;
2535 
2536  if (m_doFourMuAnalysis) {
2537  ATH_MSG_DEBUG ("** RunFourLeptonAnalysis ** START ** run: " << m_runNumber << " event: " << m_evtNumber << " lumiblock:" << m_lumi_block);
2538 
2539  // Four lepton event
2540  m_4mu.setContainer(PerfMonServices::MUON_COLLECTION);
2541  m_4mu.doIsoSelection (m_doIsoSelection);
2542  m_4mu.doIPSelection (m_doIPSelection);
2543  m_4mu.doMCPSelection (m_doMCPSelection);
2544  m_4mu.SetMassWindowLow (m_MassWindowLow);
2545  m_4mu.SetMassWindowHigh (m_MassWindowHigh);
2546  m_4mu.SetLeadingMuonPtCut(m_LeadingMuonPtCut);
2547  m_4mu.SetSecondMuonPtCut (m_SecondMuonPtCut);
2548  m_4mu.SetOpeningAngleCut (m_OpeningAngleCut);
2549  m_4mu.SetZ0GapCut (m_Z0GapCut);
2550  m_4mu.setDebugMode (m_doDebug);
2551 
2552  // This is a report of the number of true electrons in the event
2553  if (false) {
2554  const xAOD::TruthParticleContainer* electronTruth = evtStore()->retrieve< const xAOD::TruthParticleContainer >( "egammaTruthParticles" );
2555  if( electronTruth) {
2556  ATH_MSG_DEBUG ( "retrieving electron Truth container with key: \"egammaTruthParticles\" SUCCESS ");
2557  // Check that the auxiliary store association was made successfully:
2558  if( electronTruth->hasStore() ) {
2559  ATH_MSG_DEBUG ( "Size of Truth gamma-electrons: " << electronTruth->size() );
2560  auto tr_itr = electronTruth->begin();
2561  auto tr_end = electronTruth->end();
2562  int electronCount = 0;
2563  for( int i = 0; tr_itr != tr_end; ++tr_itr, ++i ) {
2564  ATH_MSG_DEBUG( "Truth : Investigating truth electron #" << i << " pdgID= " << ( *tr_itr )->pdgId());
2565  if (fabs(( *tr_itr )->pdgId()) == 11) {
2566  if (( *tr_itr )->pt() > 10000 && fabs(( *tr_itr )->eta()) < 2.47) {
2567  ATH_MSG_INFO( " central electron found --> pt: " << ( *tr_itr )->charge()*( *tr_itr )->pt() << " eta " <<( *tr_itr )->eta() );
2568  electronCount++;
2569  }
2570  }
2571  }
2572  ATH_MSG_INFO( "#central electrons: " << electronCount );
2573  }
2574  else {
2575  ATH_MSG_WARNING ( "electronTruth container has no Store !!! FAILURE");
2576  }
2577  }
2578  else {
2579  ATH_MSG_WARNING ( "retrieve electron Truth container with key: \"egammaTruthParticles\" FAILURE");
2580  }
2581  }
2582 
2583  if (m_doDebug) std::cout << " ** RunFourLeptonAnalysis ** calling m_4mu.Reco() .... " << std::endl;
2584  bool statusOf4LeptReco = m_4mu.Reco();
2585 
2586  // print message
2587  if(statusOf4LeptReco) {
2588  thisStatus = StatusCode::SUCCESS;
2589  ATH_MSG_INFO ("4-lepton reconstruction SUCCESS. # accepted events " << m_4mu.getAcceptedEvents() << " Invariant mass = " << m_4mu.GetInvMass() << " GeV ");
2590  if (m_doDebug) std::cout << " ** RunFourLeptonAnalysis ** 4-lepton reconstruction SUCCESS. # accepted events " << m_4mu.getAcceptedEvents() << " Invariant mass = " << m_4mu.GetInvMass() << " GeV " << std::endl;
2591  }
2592  else {
2593  thisStatus = StatusCode::FAILURE;
2594  ATH_MSG_DEBUG ("4-lepton reconstruction FAILURE. m_4mu.Reco() returned FALSE --> event failed selection");
2595  if (m_doDebug) std::cout << " ** RunFourLeptonAnalysis ** 4-lepton reconstruction FAILURE. m_4mu.Reco() returned FALSE --> event failed selection" << std::endl;
2596  }
2597 
2598  if(statusOf4LeptReco) {
2599  if ( m_4mu.EventPassed() ) {
2600 
2601  this->Clear4MuNtupleVariables();
2602 
2603  const xAOD::TrackParticle* muon1_pos = m_4mu.getIDTrack(m_4mu.getPosMuon(1));
2604  const xAOD::TrackParticle* muon2_pos = m_4mu.getIDTrack(m_4mu.getPosMuon(2));
2605  const xAOD::TrackParticle* muon1_neg = m_4mu.getIDTrack(m_4mu.getNegMuon(1));
2606  const xAOD::TrackParticle* muon2_neg = m_4mu.getIDTrack(m_4mu.getNegMuon(2));
2607 
2608  // muons
2609  if (muon1_pos) {
2610  m_positive_px = muon1_pos->p4().Px();
2611  m_positive_py = muon1_pos->p4().Py();
2612  m_positive_pz = muon1_pos->p4().Pz();
2613  m_positive_d0 = muon1_pos->d0();
2614  m_positive_z0 = muon1_pos->z0();
2615  // m_positive_d0_err = muon1_pos->definingParametersCovMatrix()(0,0);
2616  m_positive_d0_err = muon1_pos->definingParametersCovMatrixVec()[0];
2617  m_positive_z0_err = muon1_pos->definingParametersCovMatrix()(1,1);
2618  }
2619  if (muon1_neg) {
2620  m_negative_px = muon1_neg->p4().Px();
2621  m_negative_py = muon1_neg->p4().Py();
2622  m_negative_pz = muon1_neg->p4().Pz();
2623  m_negative_d0 = muon1_neg->d0();
2624  m_negative_z0 = muon1_neg->z0();
2625  m_negative_d0_err = muon1_neg->definingParametersCovMatrix()(0,0);
2626  m_negative_z0_err = muon1_neg->definingParametersCovMatrix()(1,1);
2627  }
2628  if (muon2_pos) {
2629  m_positive_2_px = muon2_pos->p4().Px();
2630  m_positive_2_py = muon2_pos->p4().Py();
2631  m_positive_2_pz = muon2_pos->p4().Pz();
2632  m_positive_2_d0 = muon2_pos->d0();
2633  m_positive_2_z0 = muon2_pos->z0();
2634  m_positive_2_d0_err = muon2_pos->definingParametersCovMatrix()(0,0);
2635  m_positive_2_z0_err = muon2_pos->definingParametersCovMatrix()(1,1);
2636  }
2637  if (muon2_neg) {
2638  m_negative_2_px = muon2_neg->p4().Px();
2639  m_negative_2_py = muon2_neg->p4().Py();
2640  m_negative_2_pz = muon2_neg->p4().Pz();
2641  m_negative_2_d0 = muon2_neg->d0();
2642  m_negative_2_z0 = muon2_neg->z0();
2643  m_negative_2_d0_err = muon2_neg->definingParametersCovMatrix()(0,0);
2644  m_negative_2_z0_err = muon2_neg->definingParametersCovMatrix()(1,1);
2645  }
2646 
2647  // electrons
2648  const xAOD::TrackParticle* elec1_neg = m_4mu.getELTrack(0);
2649  const xAOD::TrackParticle* elec2_neg = m_4mu.getELTrack(1);
2650  const xAOD::TrackParticle* elec1_pos = m_4mu.getELTrack(2);
2651  const xAOD::TrackParticle* elec2_pos = m_4mu.getELTrack(3);
2652  if (elec1_neg) {
2653  m_el_negative1_px = elec1_neg->p4().Px();
2654  m_el_negative1_py = elec1_neg->p4().Py();
2655  m_el_negative1_pz = elec1_neg->p4().Pz();
2656  m_el_negative1_d0 = elec1_neg->d0();
2657  m_el_negative1_z0 = elec1_neg->z0();
2658  m_el_negative1_d0_err = elec1_neg->definingParametersCovMatrix()(0,0);
2659  m_el_negative1_z0_err = elec1_neg->definingParametersCovMatrix()(1,1);
2660  }
2661  if (elec2_neg) {
2662  m_el_negative2_px = elec2_neg->p4().Px();
2663  m_el_negative2_py = elec2_neg->p4().Py();
2664  m_el_negative2_pz = elec2_neg->p4().Pz();
2665  m_el_negative2_d0 = elec2_neg->d0();
2666  m_el_negative2_z0 = elec2_neg->z0();
2667  m_el_negative2_d0_err = elec2_neg->definingParametersCovMatrix()(0,0);
2668  m_el_negative2_z0_err = elec2_neg->definingParametersCovMatrix()(1,1);
2669  }
2670  if (elec1_pos) {
2671  m_el_positive1_px = elec1_pos->p4().Px();
2672  m_el_positive1_py = elec1_pos->p4().Py();
2673  m_el_positive1_pz = elec1_pos->p4().Pz();
2674  m_el_positive1_d0 = elec1_pos->d0();
2675  m_el_positive1_z0 = elec1_pos->z0();
2676  m_el_positive1_d0_err = elec1_pos->definingParametersCovMatrix()(0,0);
2677  m_el_positive1_z0_err = elec1_pos->definingParametersCovMatrix()(1,1);
2678  }
2679  if (elec2_pos) {
2680  m_el_positive2_px = elec2_pos->p4().Px();
2681  m_el_positive2_py = elec2_pos->p4().Py();
2682  m_el_positive2_pz = elec2_pos->p4().Pz();
2683  m_el_positive2_d0 = elec2_pos->d0();
2684  m_el_positive2_z0 = elec2_pos->z0();
2685  m_el_positive2_d0_err = elec2_pos->definingParametersCovMatrix()(0,0);
2686  m_el_positive2_z0_err = elec2_pos->definingParametersCovMatrix()(1,1);
2687  }
2688 
2689  // other quantities
2690  m_nVertex = m_4mu.GetNVertex ();
2691  m_negative_1_vtx = m_4mu.GetVertexMuNeg1();
2692  m_negative_2_vtx = m_4mu.GetVertexMuNeg2();
2693  m_positive_1_vtx = m_4mu.GetVertexMuPos1();
2694  m_positive_2_vtx = m_4mu.GetVertexMuPos2();
2695 
2696  m_el_negative1_vtx = m_4mu.GetVertexElec(0);
2697  m_el_negative2_vtx = m_4mu.GetVertexElec(1);
2698  m_el_positive1_vtx = m_4mu.GetVertexElec(2);
2699  m_el_positive2_vtx = m_4mu.GetVertexElec(3);
2700 
2701  m_pv_x = 0; m_pv_y = 0; m_pv_z = 0;
2702 
2703  m_4mu_minv = m_4mu.GetInvMass();
2704 
2705  // Obtain MET
2706  std::string metName = "MET_Reference_AntiKt4LCTopo";
2707  std::string metRefFinalName = "FinalClus";
2708  const xAOD::MissingETContainer* final_met = nullptr;
2709 
2710  m_met = -1; // default value
2711  m_metphi = -1;
2712 
2713  if (!evtStore()->contains<xAOD::MissingETContainer>(metName)) {
2714  ATH_MSG_WARNING ( "No Collection with name " << metName << " found in StoreGate");
2715  // return StatusCode::SUCCESS;
2716  }
2717  else {
2718  StatusCode sc = evtStore()->retrieve(final_met, metName);
2719  if (sc.isFailure()) {
2720  ATH_MSG_DEBUG ( "Could not retrieve Collection " << metName << " from StoreGate");
2721  // return StatusCode::SUCCESS;
2722  }
2723  }
2724  const xAOD::MissingET *met = nullptr;
2725  if (final_met) met = (*final_met)[metRefFinalName];
2726  if (met) { // load MET values
2727  m_met = met->met();
2728  m_metphi = met->phi();
2729  }
2730  ATH_MSG_DEBUG (" Zmumu event with MET = " << m_met);
2731 
2732  ATH_MSG_INFO (" -- IDPerfMonZmumu::execute -- Accepted event " << m_4mu.getAcceptedEvents() << " with m_4mu.GetInvMass= " << m_4mu_minv);
2733  ATH_MSG_DEBUG ("**** Filling m_FourMuTree ntuple " << m_FourMuTree->GetName() << " entry " << m_FourMuTree->GetEntries()
2734  << " for run: " << m_runNumber
2735  << " event: " << m_evtNumber
2736  << " Lumiblock: " << m_lumi_block
2737  << " Invariant mass = " << m_4mu_minv << " GeV ");
2738  if (muon1_pos != nullptr) ATH_MSG_DEBUG("mu1+ --> pxyz " << muon1_pos->p4().Px()
2739  << ", " << muon1_pos->p4().Py()
2740  << ", " << muon1_pos->p4().Pz()
2741  << " pt: " << muon1_pos->pt()
2742  << " d0: " << muon1_pos->d0()
2743  << " z0: " << muon1_pos->z0()
2744  << " d0unc: " << muon1_pos->definingParametersCovMatrixVec()[0]
2745  );
2746  if (muon1_neg != nullptr) ATH_MSG_DEBUG("mu1- --> pxyz " << muon1_neg->p4().Px()
2747  << ", " << muon1_neg->p4().Py()
2748  << ", " << muon1_neg->p4().Pz()
2749  << " pt: " << muon1_neg->pt()
2750  << " d0: " << muon1_neg->d0()
2751  << " z0: " << muon1_neg->z0()
2752  << " d0unc: " << muon1_neg->definingParametersCovMatrixVec()[0]
2753  );
2754  if (elec1_pos != nullptr) ATH_MSG_DEBUG("el1+ --> pxyz " << elec1_pos->p4().Px()
2755  << ", " << elec1_pos->p4().Py()
2756  << ", " << elec1_pos->p4().Pz()
2757  << " pt: " << elec1_pos->pt()
2758  << " d0: " << elec1_pos->d0()
2759  << " z0: " << elec1_pos->z0()
2760  << " d0unc: " << elec1_pos->definingParametersCovMatrixVec()[0]
2761  );
2762  // ntuple variables have been filled in FillRecParametersTP
2763  m_FourMuTree->Fill();
2764  }
2765  } // succesful 4mu reco
2766 
2767  } // end of fourMuon Analysis
2768 
2769  return thisStatus;
2770 }
2771 
2772 //==================================================================================
2773 void IDPerfMonZmumu::ExtractIDHitsInformation(const xAOD::Muon* muon_pos, const xAOD::Muon* muon_neg)
2774 {
2775  // hits info
2776  // positive Muon
2777  const xAOD::TrackParticle* IDTrkMuPos = muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
2778  const xAOD::TrackParticle* IDTrkMuNeg = muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
2779 
2780  int nBLhits, nhitsPIX, nhitsSCT, nhitsTRT, nContribPixLayers;
2781  int nPIXholes, nSCTholes;
2782  if (IDTrkMuPos && IDTrkMuNeg) { // make sure both summaries are available
2783  uint8_t dummy(-1);
2784  nBLhits = IDTrkMuPos->summaryValue( dummy, xAOD::numberOfBLayerHits ) ? dummy :-1;
2785  nhitsPIX = IDTrkMuPos->summaryValue( dummy, xAOD::numberOfPixelHits ) ? dummy :-1;
2786  nhitsSCT = IDTrkMuPos->summaryValue( dummy, xAOD::numberOfSCTHits ) ? dummy :-1;
2787  nhitsTRT = IDTrkMuPos->summaryValue( dummy, xAOD::numberOfTRTHits ) ? dummy :-1;
2788  nContribPixLayers = IDTrkMuPos->summaryValue( dummy, xAOD::numberOfContribPixelLayers )? dummy :-1;
2789 
2790  nPIXholes = IDTrkMuPos->summaryValue( dummy, xAOD::numberOfPixelHoles )? dummy :-1;
2791  nSCTholes = IDTrkMuPos->summaryValue( dummy, xAOD::numberOfSCTHoles )? dummy :-1;
2792 
2793 
2794  m_nBLhits.push_back(nBLhits);
2795  m_nPIXhits.push_back(nhitsPIX);
2796  m_nSCThits.push_back(nhitsSCT);
2797  m_nTRThits.push_back(nhitsTRT);
2798 
2799  ATH_MSG_DEBUG (" -- mu_pos -- HITS --"
2800  << " nBLhits: " << nBLhits
2801  << " nhitsPIX: " << nhitsPIX
2802  << " nPIXLayers: " << nContribPixLayers
2803  << " nhitsSCT: " << nhitsSCT
2804  << " Silicon holes: " << nPIXholes + nSCTholes
2805  << " nhitsTRT: " << nhitsTRT);
2806 
2807  nBLhits = IDTrkMuNeg->summaryValue( dummy, xAOD::numberOfBLayerHits ) ? dummy :-1;
2808  nhitsPIX = IDTrkMuNeg->summaryValue( dummy, xAOD::numberOfPixelHits ) ? dummy :-1;
2809  nhitsSCT = IDTrkMuNeg->summaryValue( dummy, xAOD::numberOfSCTHits ) ? dummy :-1;
2810  nhitsTRT = IDTrkMuNeg->summaryValue( dummy, xAOD::numberOfTRTHits ) ? dummy :-1;
2811  nContribPixLayers = IDTrkMuNeg->summaryValue( dummy, xAOD::numberOfContribPixelLayers )? dummy :-1;
2812  nPIXholes = IDTrkMuNeg->summaryValue( dummy, xAOD::numberOfPixelHoles )? dummy :-1;
2813  nSCTholes = IDTrkMuNeg->summaryValue( dummy, xAOD::numberOfSCTHoles )? dummy :-1;
2814 
2815  m_nBLhits.push_back(nBLhits);
2816  m_nPIXhits.push_back(nhitsPIX);
2817  m_nSCThits.push_back(nhitsSCT);
2818  m_nTRThits.push_back(nhitsTRT);
2819 
2820  ATH_MSG_DEBUG (" -- mu_neg -- HITS --"
2821  << " nBLhits: " << nBLhits
2822  << " nhitsPIX: " << nhitsPIX
2823  << " nPIXLayers: " << nContribPixLayers
2824  << " nhitsSCT: " << nhitsSCT
2825  << " Silicon holes: " << nPIXholes + nSCTholes
2826  << " nhitsTRT: " << nhitsTRT);
2827 
2828  }
2829  return;
2830 }
IDPerfMonZmumu::m_positive_sigma_qoverp
double m_positive_sigma_qoverp
Definition: IDPerfMonZmumu.h:251
IDPerfMonZmumu::m_doIP
bool m_doIP
Definition: IDPerfMonZmumu.h:122
IDPerfMonZmumu::m_negative_d0_manualBS
double m_negative_d0_manualBS
Definition: IDPerfMonZmumu.h:277
IDPerfMonZmumu::m_el_positive2_vtx
int m_el_positive2_vtx
Definition: IDPerfMonZmumu.h:354
IDPerfMonZmumu::m_negative_2_px
double m_negative_2_px
Definition: IDPerfMonZmumu.h:290
IDPerfMonZmumu::m_IDTrack_sigma_z0
std::vector< float > m_IDTrack_sigma_z0
Definition: IDPerfMonZmumu.h:416
IDPerfMonZmumu::m_doDebug
bool m_doDebug
Definition: IDPerfMonZmumu.h:207
IDPerfMonZmumu::m_selTool
ToolHandle< InDet::IInDetTrackSelectionTool > m_selTool
The track selection Tool.
Definition: IDPerfMonZmumu.h:148
Trk::anyDirection
@ anyDirection
Definition: PropDirection.h:22
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition: TrackingPrimitives.h:261
IDPerfMonZmumu::m_positive_d0
double m_positive_d0
Definition: IDPerfMonZmumu.h:240
IDPerfMonZmumu::m_el_negative2_pz
double m_el_negative2_pz
Definition: IDPerfMonZmumu.h:319
IDPerfMonZmumu::m_el_positive1_z0_err
double m_el_positive1_z0_err
Definition: IDPerfMonZmumu.h:335
IDPerfMonZmumu::m_IDTreeFolder
std::string m_IDTreeFolder
Definition: IDPerfMonZmumu.h:184
IDPerfMonZmumu::m_defaultTreeName
std::string m_defaultTreeName
Definition: IDPerfMonZmumu.h:167
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
IDPerfMonZmumu::m_positive_z0
double m_positive_z0
Definition: IDPerfMonZmumu.h:239
IDPerfMonZmumu::m_combTreeName
std::string m_combTreeName
Definition: IDPerfMonZmumu.h:172
IDPerfMonZmumu::m_nSCThits
std::vector< int > m_nSCThits
Definition: IDPerfMonZmumu.h:428
IDPerfMonZmumu::m_el_negative1_vtx
int m_el_negative1_vtx
Definition: IDPerfMonZmumu.h:315
IDPerfMonZmumu::m_Refit1_qoverp
std::vector< float > m_Refit1_qoverp
Definition: IDPerfMonZmumu.h:400
FourMuonEvent::Init
void Init()
Definition: FourMuonEvent.cxx:64
IDPerfMonZmumu::m_el_negative2_vtx
int m_el_negative2_vtx
Definition: IDPerfMonZmumu.h:328
IDPerfMonZmumu::m_positive_1_vtx
int m_positive_1_vtx
Definition: IDPerfMonZmumu.h:252
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
IDPerfMonZmumu::m_FourMuTree
TTree * m_FourMuTree
Definition: IDPerfMonZmumu.h:201
Trk::ParticleSwitcher::particle
constexpr ParticleHypothesis particle[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:76
IDPerfMonZmumu::m_trackToVertexTool
ToolHandle< Reco::ITrackToVertex > m_trackToVertexTool
tool to extrapolate tracks to BL
Definition: IDPerfMonZmumu.h:138
IDPerfMonZmumu::m_nBLhits
std::vector< int > m_nBLhits
Definition: IDPerfMonZmumu.h:426
IDPerfMonZmumu::m_truthTree
TTree * m_truthTree
Definition: IDPerfMonZmumu.h:198
IDPerfMonZmumu::m_triggerMatching
ToolHandle< Trig::IMatchingTool > m_triggerMatching
Definition: IDPerfMonZmumu.h:145
xAODConfigTool.h
IDPerfMonZmumu::m_4mu_minv
double m_4mu_minv
Definition: IDPerfMonZmumu.h:357
IDPerfMonZmumu::m_truthTreeFolder
std::string m_truthTreeFolder
Definition: IDPerfMonZmumu.h:187
IDPerfMonZmumu::m_negative_parent
int m_negative_parent
Definition: IDPerfMonZmumu.h:288
IDPerfMonZmumu::m_Refit1_phi
std::vector< float > m_Refit1_phi
Definition: IDPerfMonZmumu.h:382
get_generator_info.result
result
Definition: get_generator_info.py:21
IDPerfMonZmumu::m_truthLinkVecName
std::string m_truthLinkVecName
TrackParticle input name.
Definition: IDPerfMonZmumu.h:220
test_pyathena.px
px
Definition: test_pyathena.py:18
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
IDPerfMonZmumu::m_Trk2VtxAssociationTool
ToolHandle< CP::ITrackVertexAssociationTool > m_Trk2VtxAssociationTool
Definition: IDPerfMonZmumu.h:209
IDPerfMonZmumu::m_el_positive2_pz
double m_el_positive2_pz
Definition: IDPerfMonZmumu.h:345
FourMuonEvent::getELTrack
const xAOD::TrackParticle * getELTrack(unsigned int uPart)
Definition: FourMuonEvent.h:80
IDPerfMonZmumu::m_nPIXhits
std::vector< int > m_nPIXhits
Definition: IDPerfMonZmumu.h:427
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
IDPerfMonZmumu::m_negative_2_vtx
int m_negative_2_vtx
Definition: IDPerfMonZmumu.h:301
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
FourMuonEvent::GetVertexMuPos2
int GetVertexMuPos2()
Definition: FourMuonEvent.h:100
xAOD::EventInfo_v1::beamTiltXZ
float beamTiltXZ() const
The beam's tilt in radians in XZ.
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
IDPerfMonZmumu::m_el_negative1_py
double m_el_negative1_py
Definition: IDPerfMonZmumu.h:305
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:504
IDPerfMonZmumu::m_positive_qoverp
double m_positive_qoverp
Definition: IDPerfMonZmumu.h:250
IDPerfMonZmumu::m_Refit1_sigma_pt
std::vector< float > m_Refit1_sigma_pt
Definition: IDPerfMonZmumu.h:408
FourMuonEvent::SetZ0GapCut
void SetZ0GapCut(double newvalue)
Definition: FourMuonEvent.h:116
IDPerfMonZmumu::m_Truth_d0
std::vector< float > m_Truth_d0
Definition: IDPerfMonZmumu.h:390
IDPerfMonZmumu::m_CBTrack_d0
std::vector< float > m_CBTrack_d0
Definition: IDPerfMonZmumu.h:387
xAOD::TrackParticle_v1::charge
float charge() const
Returns the charge.
Definition: TrackParticle_v1.cxx:150
FourMuonEvent::SetMuonSelectionTool
void SetMuonSelectionTool(ToolHandle< CP::IMuonSelectionTool > mst)
Definition: FourMuonEvent.h:113
IDPerfMonZmumu::m_Refit2_z0
std::vector< float > m_Refit2_z0
Definition: IDPerfMonZmumu.h:395
Trk::PerigeeSurface
Definition: PerigeeSurface.h:43
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
IDPerfMonZmumu::m_defaultTree
TTree * m_defaultTree
Definition: IDPerfMonZmumu.h:194
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
IDPerfMonZmumu::m_TrackRefitter2
ToolHandle< IegammaTrkRefitterTool > m_TrackRefitter2
The track refitter.
Definition: IDPerfMonZmumu.h:135
IDPerfMonZmumu::m_CBTrack_phi
std::vector< float > m_CBTrack_phi
Definition: IDPerfMonZmumu.h:381
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
IDPerfMonZmumu::m_Truth_qoverp
std::vector< float > m_Truth_qoverp
Definition: IDPerfMonZmumu.h:402
IDPerfMonZmumu::m_doRemoval
bool m_doRemoval
Definition: IDPerfMonZmumu.h:206
IDPerfMonZmumu::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Definition: IDPerfMonZmumu.h:437
Trk::ImpactParametersAndSigma::PVsigmaz0
double PVsigmaz0
Definition: ITrackToVertexIPEstimator.h:41
FourMuonEvent::Reco
bool Reco()
Definition: FourMuonEvent.cxx:84
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:736
IDPerfMonZmumu::m_FourMuTreeName
std::string m_FourMuTreeName
Definition: IDPerfMonZmumu.h:174
EventPrimitivesHelpers.h
IDPerfMonZmumu::m_IDTrack_sigma_qoverp
std::vector< float > m_IDTrack_sigma_qoverp
Definition: IDPerfMonZmumu.h:421
IDPerfMonZmumu::m_CBTrack_eta
std::vector< float > m_CBTrack_eta
Definition: IDPerfMonZmumu.h:375
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
FourMuonEvent::GetNVertex
int GetNVertex()
Definition: FourMuonEvent.h:88
xAOD::JetInput::Track
@ Track
Definition: JetContainerInfo.h:61
IDPerfMonZmumu::m_negative_2_pz
double m_negative_2_pz
Definition: IDPerfMonZmumu.h:292
ZmumuEvent::getMSTrack
const xAOD::TrackParticle * getMSTrack(unsigned int uPart)
Definition: ZmumuEvent.h:75
IDPerfMonZmumu::m_trackContainerName
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trackContainerName
IDTtacks.
Definition: IDPerfMonZmumu.h:215
test_pyathena.pt
pt
Definition: test_pyathena.py:11
IDPerfMonZmumu::m_met
double m_met
Definition: IDPerfMonZmumu.h:364
xAOD::EventInfo_v1::beamTiltYZ
float beamTiltYZ() const
The beam's tilt in radians in YZ.
IDPerfMonZmumu::m_positive_2_d0
double m_positive_2_d0
Definition: IDPerfMonZmumu.h:259
IDPerfMonZmumu::m_isMC
bool m_isMC
Definition: IDPerfMonZmumu.h:119
xAOD::TrackParticle_v1::z0
float z0() const
Returns the parameter.
ParticleTest.tp
tp
Definition: ParticleTest.py:25
Trk::z0
@ z0
Definition: ParamDefs.h:70
ZmumuEvent.h
xAOD::TrackParticle_v1::definingParametersCovMatrixVec
std::vector< float > definingParametersCovMatrixVec() const
Returns the length 6 vector containing the elements of defining parameters covariance matrix.
Definition: TrackParticle_v1.cxx:385
FourMuonEvent::SetMassWindowHigh
void SetMassWindowHigh(double newvalue)
Definition: FourMuonEvent.h:111
IDPerfMonZmumu::m_positive_py
double m_positive_py
Definition: IDPerfMonZmumu.h:234
TrigDecisionTool.h
IDPerfMonZmumu::CheckTriggerStatusAndPrescale
StatusCode CheckTriggerStatusAndPrescale()
Definition: IDPerfMonZmumu.cxx:2292
Trk::ImpactParametersAndSigma::IPd0
double IPd0
Definition: ITrackToVertexIPEstimator.h:34
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:259
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:275
IDPerfMonZmumu::m_refit2Tree
TTree * m_refit2Tree
Definition: IDPerfMonZmumu.h:197
IDPerfMonZmumu::bookTrees
StatusCode bookTrees()
Definition: IDPerfMonZmumu.cxx:312
SG::ConstAccessor< float >
IDPerfMonZmumu::m_el_positive1_d0_err
double m_el_positive1_d0_err
Definition: IDPerfMonZmumu.h:336
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
IDPerfMonZmumu::m_negative_2_py
double m_negative_2_py
Definition: IDPerfMonZmumu.h:291
IDPerfMonZmumu::m_CBTrack_sigma_qoverp
std::vector< float > m_CBTrack_sigma_qoverp
Definition: IDPerfMonZmumu.h:422
InDetAccessor::qOverP
@ qOverP
perigee
Definition: InDetAccessor.h:35
IDPerfMonZmumu::m_CBTrack_pt
std::vector< float > m_CBTrack_pt
Definition: IDPerfMonZmumu.h:369
IDPerfMonZmumu::m_negative_px
double m_negative_px
Definition: IDPerfMonZmumu.h:268
PerfMonServices.h
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:40
ZmumuEvent::getNegMuon
unsigned int getNegMuon(ZTYPE eType)
Definition: ZmumuEvent.cxx:549
ChainGroup.h
IDPerfMonZmumu::m_Truth_pt
std::vector< float > m_Truth_pt
Definition: IDPerfMonZmumu.h:372
IDPerfMonZmumu::m_positive_px
double m_positive_px
Definition: IDPerfMonZmumu.h:233
IDPerfMonZmumu::m_el_negative2_px
double m_el_negative2_px
Definition: IDPerfMonZmumu.h:317
xAOD::Vertex_v1::vertexType
VxType::VertexType vertexType() const
The type of the vertex.
xAOD::EventInfo_v1::beamPosX
float beamPosX() const
X coordinate of the beam spot position.
IDPerfMonZmumu::m_refit1TreeFolder
std::string m_refit1TreeFolder
Definition: IDPerfMonZmumu.h:185
TrackTruthKey.h
IDPerfMonZmumu::m_Refit2_eta
std::vector< float > m_Refit2_eta
Definition: IDPerfMonZmumu.h:377
IDPerfMonZmumu::m_truthName
std::string m_truthName
Definition: IDPerfMonZmumu.h:218
IDPerfMonZmumu::m_el_negative1_px
double m_el_negative1_px
Definition: IDPerfMonZmumu.h:304
FourMuonEvent::GetVertexMuNeg1
int GetVertexMuNeg1()
Definition: FourMuonEvent.h:97
IDPerfMonZmumu::m_LeadingMuonPtCut
double m_LeadingMuonPtCut
Definition: IDPerfMonZmumu.h:115
xAOD::numberOfBLayerHits
@ numberOfBLayerHits
these are the hits in the first pixel layer, i.e.
Definition: TrackingPrimitives.h:231
xAOD::TruthVertex_v1::y
float y() const
Vertex y displacement.
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
IDPerfMonZmumu::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
used for truth parameters
Definition: IDPerfMonZmumu.h:155
IDPerfMonZmumu::m_positive_d0_manualBS
double m_positive_d0_manualBS
Definition: IDPerfMonZmumu.h:242
IDPerfMonZmumu::m_pv_z
double m_pv_z
Definition: IDPerfMonZmumu.h:361
xAOD::TrackParticle_v1::d0
float d0() const
Returns the parameter.
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
IDPerfMonZmumu::m_nTrkInVtx
unsigned int m_nTrkInVtx
Definition: IDPerfMonZmumu.h:362
IDPerfMonZmumu::finalize
virtual StatusCode finalize()
Definition: IDPerfMonZmumu.cxx:2285
IDPerfMonZmumu::m_el_positive1_py
double m_el_positive1_py
Definition: IDPerfMonZmumu.h:331
IDPerfMonZmumu::m_positive_z0_manualBS
double m_positive_z0_manualBS
Definition: IDPerfMonZmumu.h:241
IDPerfMonZmumu::m_TrackRefitter1
ToolHandle< IegammaTrkRefitterTool > m_TrackRefitter1
The track refitter.
Definition: IDPerfMonZmumu.h:132
ZmumuEvent::SetMaxLumiBlock
void SetMaxLumiBlock(int newlumiblock)
Definition: ZmumuEvent.h:89
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
IDPerfMonZmumu::m_MSTreeName
std::string m_MSTreeName
Definition: IDPerfMonZmumu.h:173
IDPerfMonZmumu::m_maxGoodLumiBlock
int m_maxGoodLumiBlock
Definition: IDPerfMonZmumu.h:128
IDPerfMonZmumu::m_positive_z0_PV
double m_positive_z0_PV
Definition: IDPerfMonZmumu.h:246
FourMuonEvent::EventPassed
bool EventPassed()
Definition: FourMuonEvent.h:76
IDPerfMonZmumu::m_Refit1_z0
std::vector< float > m_Refit1_z0
Definition: IDPerfMonZmumu.h:394
IegammaTrkRefitterTool::Cache
Struct Holding the result to return and intermediate objects Things are owned by the EDM or the uniqu...
Definition: IegammaTrkRefitterTool.h:39
IDPerfMonZmumu::m_el_positive1_d0
double m_el_positive1_d0
Definition: IDPerfMonZmumu.h:334
IDPerfMonZmumu::m_xZmm
ZmumuEvent m_xZmm
Definition: IDPerfMonZmumu.h:107
IDPerfMonZmumu::m_negative_d0_PV
double m_negative_d0_PV
Definition: IDPerfMonZmumu.h:282
IMuonSelectionTool.h
IDPerfMonZmumu::m_positive_2_pz
double m_positive_2_pz
Definition: IDPerfMonZmumu.h:257
IDPerfMonZmumu::m_commonTree
TTree * m_commonTree
Definition: IDPerfMonZmumu.h:193
FourMuonEvent::doIPSelection
void doIPSelection(bool doIPsel)
Definition: FourMuonEvent.h:74
IDPerfMonZmumu::m_minGoodLumiBlock
int m_minGoodLumiBlock
Definition: IDPerfMonZmumu.h:127
IDPerfMonZmumu::m_IDTrack_d0
std::vector< float > m_IDTrack_d0
Definition: IDPerfMonZmumu.h:386
xAOD::TrackParticle_v1::p4
virtual FourMom_t p4() const override final
The full 4-momentum of the particle.
Definition: TrackParticle_v1.cxx:129
Trk::ImpactParametersAndSigma::PVsigmad0
double PVsigmad0
Definition: ITrackToVertexIPEstimator.h:40
IDPerfMonZmumu::m_validationMode
bool m_validationMode
< boolean to switch to validation mode
Definition: IDPerfMonZmumu.h:163
IDPerfMonZmumu::m_trackParticleName
std::string m_trackParticleName
Track(Particle)TruthCollection input name.
Definition: IDPerfMonZmumu.h:219
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
IDPerfMonZmumu::m_positive_pz
double m_positive_pz
Definition: IDPerfMonZmumu.h:236
xAOD::EventInfo_v1::beamPosY
float beamPosY() const
Y coordinate of the beam spot position.
FourMuonEvent::getNegMuon
unsigned int getNegMuon(int eType)
Definition: FourMuonEvent.cxx:1277
IDPerfMonZmumu::m_doMCPSelection
bool m_doMCPSelection
Definition: IDPerfMonZmumu.h:112
xAOD::TrackParticle_v1::perigeeParameters
const Trk::Perigee & perigeeParameters() const
Returns the Trk::MeasuredPerigee track parameters.
Definition: TrackParticle_v1.cxx:485
IDPerfMonZmumu::m_ValidationTreeDescription
std::string m_ValidationTreeDescription
< validation tree description - second argument in TTree
Definition: IDPerfMonZmumu.h:179
met
Definition: IMETSignificance.h:24
IDPerfMonZmumu::m_refit2TreeFolder
std::string m_refit2TreeFolder
Definition: IDPerfMonZmumu.h:186
IDPerfMonZmumu::FillTruthParameters
StatusCode FillTruthParameters(const xAOD::TrackParticle *track)
Definition: IDPerfMonZmumu.cxx:2074
FourMuonEvent::GetInvMass
double GetInvMass()
Definition: FourMuonEvent.h:82
IDPerfMonZmumu::m_el_negative1_z0_err
double m_el_negative1_z0_err
Definition: IDPerfMonZmumu.h:309
IDPerfMonZmumu::m_Refit1_sigma_z0
std::vector< float > m_Refit1_sigma_z0
Definition: IDPerfMonZmumu.h:418
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
IDPerfMonZmumu::m_Refit2_qoverp
std::vector< float > m_Refit2_qoverp
Definition: IDPerfMonZmumu.h:401
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
IDPerfMonZmumu::m_skipMS
bool m_skipMS
Definition: IDPerfMonZmumu.h:125
IDPerfMonZmumu::m_CBTrack_sigma_pt
std::vector< float > m_CBTrack_sigma_pt
Definition: IDPerfMonZmumu.h:407
IDPerfMonZmumu::m_IDTree
TTree * m_IDTree
Definition: IDPerfMonZmumu.h:195
FourMuonEvent::getPosMuon
unsigned int getPosMuon(int eType)
Definition: FourMuonEvent.cxx:1266
IDPerfMonZmumu::m_positive_parent
int m_positive_parent
Definition: IDPerfMonZmumu.h:253
TrackTruthCollection.h
IDPerfMonZmumu::RegisterHistograms
void RegisterHistograms()
Definition: IDPerfMonZmumu.cxx:942
FourMuonEvent::GetVertexMuPos1
int GetVertexMuPos1()
Definition: FourMuonEvent.h:99
IDPerfMonZmumu::m_IDTrack_phi
std::vector< float > m_IDTrack_phi
Definition: IDPerfMonZmumu.h:380
lumiFormat.i
int i
Definition: lumiFormat.py:92
SG::OWN_ELEMENTS
@ OWN_ELEMENTS
this data object owns its elements
Definition: OwnershipPolicy.h:17
TrackCollection
DataVector< Trk::Track > TrackCollection
This typedef represents a collection of Trk::Track objects.
Definition: TrackCollection.h:19
IDPerfMonZmumu::m_positive_2_z0_err
double m_positive_2_z0_err
Definition: IDPerfMonZmumu.h:260
IDPerfMonZmumu::m_el_positive2_d0_err
double m_el_positive2_d0_err
Definition: IDPerfMonZmumu.h:349
IegammaTrkRefitterTool.h
IDPerfMonZmumu::m_CBTrack_sigma_z0
std::vector< float > m_CBTrack_sigma_z0
Definition: IDPerfMonZmumu.h:417
IDPerfMonZmumu::m_el_positive1_px
double m_el_positive1_px
Definition: IDPerfMonZmumu.h:330
IDPerfMonZmumu::m_runNumber
unsigned int m_runNumber
Definition: IDPerfMonZmumu.h:225
Trk::theta
@ theta
Definition: ParamDefs.h:72
IDPerfMonZmumu::m_combTreeFolder
std::string m_combTreeFolder
Definition: IDPerfMonZmumu.h:188
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::TruthParticle_v1
Class describing a truth particle in the MC record.
Definition: TruthParticle_v1.h:41
IDPerfMonZmumu::m_Refit1_sigma_qoverp
std::vector< float > m_Refit1_sigma_qoverp
Definition: IDPerfMonZmumu.h:423
IDPerfMonZmumu::m_doRefit
bool m_doRefit
Definition: IDPerfMonZmumu.h:120
IDPerfMonZmumu::m_el_negative1_z0
double m_el_negative1_z0
Definition: IDPerfMonZmumu.h:307
IDPerfMonZmumu::m_IDTrack_eta
std::vector< float > m_IDTrack_eta
Definition: IDPerfMonZmumu.h:374
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:571
Trk::ImpactParametersAndSigma::IPz0
double IPz0
Definition: ITrackToVertexIPEstimator.h:35
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
IDPerfMonZmumu::m_positive_2_py
double m_positive_2_py
Definition: IDPerfMonZmumu.h:256
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
xAOD::MissingET_v1
Principal data object for Missing ET.
Definition: MissingET_v1.h:25
FourMuonEvent::SetLeadingMuonPtCut
void SetLeadingMuonPtCut(double newvalue)
Definition: FourMuonEvent.cxx:1322
IDPerfMonZmumu::m_negative_pt
double m_negative_pt
Definition: IDPerfMonZmumu.h:270
IDPerfMonZmumu::m_IDTrack_z0
std::vector< float > m_IDTrack_z0
Definition: IDPerfMonZmumu.h:392
AthenaPoolTestRead.acc
acc
Definition: AthenaPoolTestRead.py:16
IDPerfMonZmumu::m_MuonQualityName
std::string m_MuonQualityName
Definition: IDPerfMonZmumu.h:434
python.xAODType.dummy
dummy
Definition: xAODType.py:4
IDPerfMonZmumu::m_positive_d0_err
double m_positive_d0_err
Definition: IDPerfMonZmumu.h:244
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IDPerfMonZmumu::m_triggerPrescale
int m_triggerPrescale
Definition: IDPerfMonZmumu.h:229
IDPerfMonZmumu::m_Refit1_eta
std::vector< float > m_Refit1_eta
Definition: IDPerfMonZmumu.h:376
IDPerfMonZmumu::m_IDTrack_sigma_d0
std::vector< float > m_IDTrack_sigma_d0
Definition: IDPerfMonZmumu.h:411
ZmumuEvent::AcceptEvent
bool AcceptEvent()
Definition: ZmumuEvent.h:67
IDPerfMonZmumu::m_negative_d0_PVerr
double m_negative_d0_PVerr
Definition: IDPerfMonZmumu.h:284
IDPerfMonZmumu::m_IDTrack_sigma_pt
std::vector< float > m_IDTrack_sigma_pt
Definition: IDPerfMonZmumu.h:406
IDPerfMonZmumu::m_metphi
double m_metphi
Definition: IDPerfMonZmumu.h:365
IDPerfMonZmumu::m_CBTrack_sigma_d0
std::vector< float > m_CBTrack_sigma_d0
Definition: IDPerfMonZmumu.h:412
IDPerfMonZmumu::m_nTRThits
std::vector< int > m_nTRThits
Definition: IDPerfMonZmumu.h:429
IDPerfMonZmumu::m_lumi_block
unsigned int m_lumi_block
Definition: IDPerfMonZmumu.h:227
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
IDPerfMonZmumu::m_Refit1_pt
std::vector< float > m_Refit1_pt
Definition: IDPerfMonZmumu.h:370
Trk::ImpactParametersAndSigma::sigmad0
double sigmad0
Definition: ITrackToVertexIPEstimator.h:37
IDPerfMonZmumu::~IDPerfMonZmumu
~IDPerfMonZmumu()
Definition: IDPerfMonZmumu.cxx:165
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
IDPerfMonZmumu::m_UseTrigger
bool m_UseTrigger
Definition: IDPerfMonZmumu.h:109
Trk::CurvilinearParametersT
Definition: CurvilinearParametersT.h:48
TRT::Track::z0
@ z0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:63
PerfMonServices::VTX_COLLECTION
@ VTX_COLLECTION
Definition: PerfMonServices.h:65
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:270
IDPerfMonZmumu::m_outputTracksName
std::string m_outputTracksName
Definition: IDPerfMonZmumu.h:433
IDPerfMonZmumu::m_Refit2_phi
std::vector< float > m_Refit2_phi
Definition: IDPerfMonZmumu.h:383
IDPerfMonZmumu::m_combTree
TTree * m_combTree
Definition: IDPerfMonZmumu.h:199
IDPerfMonZmumu::m_el_positive1_vtx
int m_el_positive1_vtx
Definition: IDPerfMonZmumu.h:341
DataVector< Trk::Track >
ZmumuEvent::doMCPSelection
void doMCPSelection(bool doMCP)
Definition: ZmumuEvent.h:66
IInDetTrackSelectionTool.h
ZmumuEvent::getCombMuon
const xAOD::Muon * getCombMuon(unsigned int uPart)
Definition: ZmumuEvent.h:70
IDPerfMonZmumu::m_positive_2_vtx
int m_positive_2_vtx
Definition: IDPerfMonZmumu.h:266
IDPerfMonZmumu::m_negative_qoverp
double m_negative_qoverp
Definition: IDPerfMonZmumu.h:285
IDPerfMonZmumu::m_el_negative2_z0_err
double m_el_negative2_z0_err
Definition: IDPerfMonZmumu.h:322
IDPerfMonZmumu::m_el_positive2_py
double m_el_positive2_py
Definition: IDPerfMonZmumu.h:344
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
IDPerfMonZmumu::m_negative_d0_err
double m_negative_d0_err
Definition: IDPerfMonZmumu.h:279
AthAlgorithm
Definition: AthAlgorithm.h:47
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
IDPerfMonZmumu::m_Refit2_d0
std::vector< float > m_Refit2_d0
Definition: IDPerfMonZmumu.h:389
IDPerfMonZmumu::m_positive_2_d0_err
double m_positive_2_d0_err
Definition: IDPerfMonZmumu.h:261
IDPerfMonZmumu::FillRecParametersSimple
StatusCode FillRecParametersSimple(const Trk::Track *track, float charge, const xAOD::Vertex *vertex)
Definition: IDPerfMonZmumu.cxx:1980
IDPerfMonZmumu::getTruthParticle
const xAOD::TruthParticle * getTruthParticle(const xAOD::IParticle &p)
Definition: IDPerfMonZmumu.cxx:2265
IDPerfMonZmumu::FillRecParameters
StatusCode FillRecParameters(const Trk::Track *track, const xAOD::TrackParticle *trackp_for_unbias, double charge, const xAOD::Vertex *vertex, const EventContext &ctx)
Definition: IDPerfMonZmumu.cxx:1810
IDPerfMonZmumu::m_OpeningAngleCut
double m_OpeningAngleCut
Definition: IDPerfMonZmumu.h:117
IDPerfMonZmumu::ResetCommonNtupleVectors
void ResetCommonNtupleVectors()
Definition: IDPerfMonZmumu.cxx:2372
IDPerfMonZmumu::m_negative_pz
double m_negative_pz
Definition: IDPerfMonZmumu.h:271
IDPerfMonZmumu::m_negative_2_d0_err
double m_negative_2_d0_err
Definition: IDPerfMonZmumu.h:296
IDPerfMonZmumu::m_negative_eta
double m_negative_eta
Definition: IDPerfMonZmumu.h:273
Trk::Track::perigeeParameters
const Perigee * perigeeParameters() const
return Perigee.
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:163
xAOD::TruthVertex_v1
Class describing a truth vertex in the MC record.
Definition: TruthVertex_v1.h:41
xAOD::MissingETContainer_v1
Container for xAOD::MissingET_v1 objects.
Definition: MissingETContainer_v1.h:21
ZmumuEvent::doIPSelection
void doIPSelection(bool doIPsel)
Definition: ZmumuEvent.h:65
Trk::ParametersBase::pT
double pT() const
Access method for transverse momentum.
FourMuonEvent::getAcceptedEvents
int getAcceptedEvents()
Definition: FourMuonEvent.h:78
IDPerfMonZmumu::m_Truth_z0
std::vector< float > m_Truth_z0
Definition: IDPerfMonZmumu.h:396
Amg::py
@ py
Definition: GeoPrimitives.h:39
MissingET.h
xAOD::EventInfo_v1::beamPosZ
float beamPosZ() const
Z coordinate of the beam spot position.
xAOD::TrackParticle_v1::qOverP
float qOverP() const
Returns the parameter.
IDPerfMonZmumu::m_negative_z0_PVerr
double m_negative_z0_PVerr
Definition: IDPerfMonZmumu.h:283
xAOD::TrackParticle_v1::definingParametersCovMatrix
const ParametersCovMatrix_t definingParametersCovMatrix() const
Returns the 5x5 symmetric matrix containing the defining parameters covariance matrix.
Definition: TrackParticle_v1.cxx:246
ZmumuEvent::setDebugMode
void setDebugMode(bool debug)
Definition: ZmumuEvent.h:88
IDPerfMonZmumu::m_negative_1_vtx
int m_negative_1_vtx
Definition: IDPerfMonZmumu.h:287
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
Trk::d0
@ d0
Definition: ParamDefs.h:69
IDPerfMonZmumu::m_useCustomMuonSelector
bool m_useCustomMuonSelector
Definition: IDPerfMonZmumu.h:126
MatchingTool.h
ZmumuEvent::SetMuonSelectionTool
void SetMuonSelectionTool(ToolHandle< CP::IMuonSelectionTool > mst)
Definition: ZmumuEvent.h:103
Amg::error
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
Definition: EventPrimitivesHelpers.h:40
IDPerfMonZmumu::m_vertexKey
SG::ReadHandleKey< xAOD::VertexContainer > m_vertexKey
Definition: IDPerfMonZmumu.h:212
IDPerfMonZmumu::m_el_positive2_d0
double m_el_positive2_d0
Definition: IDPerfMonZmumu.h:347
FourMuonEvent::setDebugMode
void setDebugMode(bool debug)
Definition: FourMuonEvent.h:108
ZmumuEvent::doIsoSelection
void doIsoSelection(bool doIso)
Definition: ZmumuEvent.h:64
IDPerfMonZmumu::m_Truth_phi
std::vector< float > m_Truth_phi
Definition: IDPerfMonZmumu.h:384
charge
double charge(const T &p)
Definition: AtlasPID.h:494
IDPerfMonZmumu::m_MSTreeFolder
std::string m_MSTreeFolder
Definition: IDPerfMonZmumu.h:189
IDPerfMonZmumu::m_Refit2_sigma_pt
std::vector< float > m_Refit2_sigma_pt
Definition: IDPerfMonZmumu.h:409
FourMuonEvent::setContainer
void setContainer(PerfMonServices::CONTAINERS container)
Definition: FourMuonEvent.h:107
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
IDPerfMonZmumu::m_el_negative2_py
double m_el_negative2_py
Definition: IDPerfMonZmumu.h:318
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
IDPerfMonZmumu::m_el_negative2_d0
double m_el_negative2_d0
Definition: IDPerfMonZmumu.h:321
IDPerfMonZmumu::m_positive_2_z0
double m_positive_2_z0
Definition: IDPerfMonZmumu.h:258
IDPerfMonZmumu::m_positive_phi
double m_positive_phi
Definition: IDPerfMonZmumu.h:237
IDPerfMonZmumu::m_MSTree
TTree * m_MSTree
Definition: IDPerfMonZmumu.h:200
IDPerfMonZmumu::m_Refit1_sigma_d0
std::vector< float > m_Refit1_sigma_d0
Definition: IDPerfMonZmumu.h:413
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
IDPerfMonZmumu::m_muonSelector
ToolHandle< CP::IMuonSelectionTool > m_muonSelector
used to pass a custom muon selector
Definition: IDPerfMonZmumu.h:159
IDPerfMonZmumu::m_negative_2_d0
double m_negative_2_d0
Definition: IDPerfMonZmumu.h:294
IDPerfMonZmumu::m_sTriggerChainName
std::string m_sTriggerChainName
Definition: IDPerfMonZmumu.h:432
IDPerfMonZmumu::m_negative_d0
double m_negative_d0
Definition: IDPerfMonZmumu.h:275
IDPerfMonZmumu::m_trackToVertexIPEstimator
ToolHandle< Trk::ITrackToVertexIPEstimator > m_trackToVertexIPEstimator
Needed for IP resolution studies.
Definition: IDPerfMonZmumu.h:152
IDPerfMonZmumu::m_refit1TreeName
std::string m_refit1TreeName
Definition: IDPerfMonZmumu.h:169
IDPerfMonZmumu::m_el_positive1_pz
double m_el_positive1_pz
Definition: IDPerfMonZmumu.h:332
ZmumuEvent::SetSecondMuonPtCut
void SetSecondMuonPtCut(double newvalue)
Definition: ZmumuEvent.cxx:617
ZmumuEvent::SetMuonQuality
void SetMuonQuality(const std::string &newname)
Definition: ZmumuEvent.h:92
xAOD::TruthVertex_v1::x
float x() const
Vertex x displacement.
IDPerfMonZmumu::initialize
virtual StatusCode initialize()
Definition: IDPerfMonZmumu.cxx:170
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
IDPerfMonZmumu::m_Z0GapCut
double m_Z0GapCut
Definition: IDPerfMonZmumu.h:118
IDPerfMonZmumu::m_nVertex
unsigned int m_nVertex
Definition: IDPerfMonZmumu.h:231
IDPerfMonZmumu::m_commonTreeFolder
std::string m_commonTreeFolder
Definition: IDPerfMonZmumu.h:182
ZmumuEvent::SetLeadingMuonPtCut
void SetLeadingMuonPtCut(double newvalue)
Definition: ZmumuEvent.cxx:600
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
IDPerfMonZmumu::m_positive_d0_PVerr
double m_positive_d0_PVerr
Definition: IDPerfMonZmumu.h:249
ZmumuEvent::SetMinLumiBlock
void SetMinLumiBlock(int newlumiblock)
Definition: ZmumuEvent.h:90
IDPerfMonZmumu::m_el_positive2_z0
double m_el_positive2_z0
Definition: IDPerfMonZmumu.h:346
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
ZmumuEvent::GetInvMass
double GetInvMass()
Definition: ZmumuEvent.h:72
IDPerfMonZmumu::m_el_positive2_z0_err
double m_el_positive2_z0_err
Definition: IDPerfMonZmumu.h:348
IDPerfMonZmumu::m_positive_d0_PV
double m_positive_d0_PV
Definition: IDPerfMonZmumu.h:247
FourMuonEvent.h
IDPerfMonZmumu::FillRecParametersTP
StatusCode FillRecParametersTP(const xAOD::TrackParticle *trackp, const xAOD::TrackParticle *trackp_for_unbias, double charge, const xAOD::Vertex *vertex=nullptr)
Definition: IDPerfMonZmumu.cxx:1668
IDPerfMonZmumu::m_IDTreeName
std::string m_IDTreeName
Definition: IDPerfMonZmumu.h:168
IDPerfMonZmumu::Clear4MuNtupleVariables
void Clear4MuNtupleVariables()
Definition: IDPerfMonZmumu.cxx:2441
IDPerfMonZmumu::execute
virtual StatusCode execute()
Definition: IDPerfMonZmumu.cxx:949
IDPerfMonZmumu::m_useTrackSelectionTool
bool m_useTrackSelectionTool
Definition: IDPerfMonZmumu.h:121
IDPerfMonZmumu::m_el_negative1_pz
double m_el_negative1_pz
Definition: IDPerfMonZmumu.h:306
ZmumuEvent::CB
@ CB
Definition: ZmumuEvent.h:55
IDPerfMonZmumu::m_positive_z0_err
double m_positive_z0_err
Definition: IDPerfMonZmumu.h:243
IDPerfMonZmumu::m_positive_eta
double m_positive_eta
Definition: IDPerfMonZmumu.h:238
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
ZmumuEvent::finalize
void finalize()
Definition: ZmumuEvent.cxx:669
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
IDPerfMonZmumu::m_el_negative1_d0_err
double m_el_negative1_d0_err
Definition: IDPerfMonZmumu.h:310
IDPerfMonZmumu::m_event_mu
unsigned int m_event_mu
Definition: IDPerfMonZmumu.h:228
IDPerfMonZmumu::m_CBTrack_z0
std::vector< float > m_CBTrack_z0
Definition: IDPerfMonZmumu.h:393
IDPerfMonZmumu::m_positive_pt
double m_positive_pt
Definition: IDPerfMonZmumu.h:235
IDPerfMonZmumu::RunFourLeptonAnalysis
StatusCode RunFourLeptonAnalysis()
Definition: IDPerfMonZmumu.cxx:2532
IDPerfMonZmumu::m_triggerName
std::string m_triggerName
Definition: IDPerfMonZmumu.h:230
IDPerfMonZmumu.h
IDPerfMonZmumu::m_negative_z0
double m_negative_z0
Definition: IDPerfMonZmumu.h:274
xAOD::TruthVertex_v1::z
float z() const
Vertex longitudinal distance along the beam line form the origin.
IDPerfMonZmumu::m_negative_py
double m_negative_py
Definition: IDPerfMonZmumu.h:269
Trk::ImpactParametersAndSigma::sigmaz0
double sigmaz0
Definition: ITrackToVertexIPEstimator.h:38
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:73
IDPerfMonZmumu::m_negative_phi
double m_negative_phi
Definition: IDPerfMonZmumu.h:272
ZmumuEvent::SetOpeningAngleCut
void SetOpeningAngleCut(double newvalue)
Definition: ZmumuEvent.h:98
IDPerfMonZmumu::m_positive_2_px
double m_positive_2_px
Definition: IDPerfMonZmumu.h:255
IDPerfMonZmumu::m_el_positive1_z0
double m_el_positive1_z0
Definition: IDPerfMonZmumu.h:333
FourMuonEvent::doMCPSelection
void doMCPSelection(bool doMCP)
Definition: FourMuonEvent.h:75
IDPerfMonZmumu::m_negative_sigma_qoverp
double m_negative_sigma_qoverp
Definition: IDPerfMonZmumu.h:286
IDPerfMonZmumu::m_negative_z0_err
double m_negative_z0_err
Definition: IDPerfMonZmumu.h:278
FourMuonEvent::GetVertexElec
int GetVertexElec(unsigned int uPart)
Definition: FourMuonEvent.h:92
ITrackToVertexIPEstimator.h
IDPerfMonZmumu::m_Refit1_d0
std::vector< float > m_Refit1_d0
Definition: IDPerfMonZmumu.h:388
IDPerfMonZmumu::m_MassWindowHigh
double m_MassWindowHigh
Definition: IDPerfMonZmumu.h:114
IDPerfMonZmumu::m_refit1Tree
TTree * m_refit1Tree
Definition: IDPerfMonZmumu.h:196
xAOD::numberOfContribPixelLayers
@ numberOfContribPixelLayers
number of contributing layers of the pixel detector [unit8_t].
Definition: TrackingPrimitives.h:230
IDPerfMonZmumu::m_doIsoSelection
bool m_doIsoSelection
Definition: IDPerfMonZmumu.h:110
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
IDPerfMonZmumu::m_Truth_eta
std::vector< float > m_Truth_eta
Definition: IDPerfMonZmumu.h:378
IDPerfMonZmumu::m_el_positive2_px
double m_el_positive2_px
Definition: IDPerfMonZmumu.h:343
IDPerfMonZmumu::m_Refit2_sigma_qoverp
std::vector< float > m_Refit2_sigma_qoverp
Definition: IDPerfMonZmumu.h:424
SG::ConstAccessor::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
Trk::ParametersBase::eta
double eta() const
Access method for pseudorapidity - from momentum.
IDPerfMonZmumu::m_extrapolator
ToolHandle< Trk::IExtrapolator > m_extrapolator
Definition: IDPerfMonZmumu.h:156
FourMuonEvent::SetMassWindowLow
void SetMassWindowLow(double newvalue)
Definition: FourMuonEvent.h:110
Trk::phi
@ phi
Definition: ParamDefs.h:81
IDPerfMonZmumu::m_doIPSelection
bool m_doIPSelection
Definition: IDPerfMonZmumu.h:111
IDPerfMonZmumu::m_el_negative1_d0
double m_el_negative1_d0
Definition: IDPerfMonZmumu.h:308
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
IDPerfMonZmumu::ExtractIDHitsInformation
void ExtractIDHitsInformation(const xAOD::Muon *muon_pos, const xAOD::Muon *muon_neg)
Definition: IDPerfMonZmumu.cxx:2773
xAOD::TrackParticle_v1::track
const Trk::Track * track() const
Returns a pointer (which can be NULL) to the Trk::Track which was used to make this TrackParticle.
Definition: TrackParticle_v1.cxx:805
ConstAccessor.h
Helper class to provide constant type-safe access to aux data.
IDPerfMonZmumu::m_evtNumber
unsigned int m_evtNumber
Definition: IDPerfMonZmumu.h:226
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
IDPerfMonZmumu::m_triggerDecision
ToolHandle< Trig::TrigDecisionTool > m_triggerDecision
Definition: IDPerfMonZmumu.h:141
IDPerfMonZmumu::m_h_cutflow
TH1F * m_h_cutflow
link vector to map HepMC onto xAOD truth
Definition: IDPerfMonZmumu.h:223
ZmumuEvent::SetSkipMSCheck
void SetSkipMSCheck(bool value)
Definition: ZmumuEvent.h:100
IDPerfMonZmumu::m_negative_2_z0_err
double m_negative_2_z0_err
Definition: IDPerfMonZmumu.h:295
IDPerfMonZmumu::m_pv_y
double m_pv_y
Definition: IDPerfMonZmumu.h:360
IDPerfMonZmumu::m_negative_z0_PV
double m_negative_z0_PV
Definition: IDPerfMonZmumu.h:281
IDPerfMonZmumu::m_positive_z0_PVerr
double m_positive_z0_PVerr
Definition: IDPerfMonZmumu.h:248
IDPerfMonZmumu::m_SecondMuonPtCut
double m_SecondMuonPtCut
Definition: IDPerfMonZmumu.h:116
PerfMonServices::InitialiseServices
static StatusCode InitialiseServices(ISvcLocator *pxSvcLocator)
Definition: PerfMonServices.cxx:50
IDPerfMonZmumu::m_negative_2_z0
double m_negative_2_z0
Definition: IDPerfMonZmumu.h:293
IDPerfMonZmumu::GetDiMuonVertex
const xAOD::Vertex * GetDiMuonVertex(const xAOD::TrackParticle *, const xAOD::TrackParticle *)
Definition: IDPerfMonZmumu.cxx:2352
IDPerfMonZmumu::m_4mu
FourMuonEvent m_4mu
Definition: IDPerfMonZmumu.h:108
FourMuonEvent::SetOpeningAngleCut
void SetOpeningAngleCut(double newvalue)
Definition: FourMuonEvent.h:115
ZmumuEvent::SetMassWindowHigh
void SetMassWindowHigh(double newvalue)
Definition: ZmumuEvent.h:95
IDPerfMonZmumu::m_Refit2_pt
std::vector< float > m_Refit2_pt
Definition: IDPerfMonZmumu.h:371
IDPerfMonZmumu::m_el_negative2_z0
double m_el_negative2_z0
Definition: IDPerfMonZmumu.h:320
IDPerfMonZmumu::m_Truth_parent
std::vector< int > m_Truth_parent
Definition: IDPerfMonZmumu.h:404
IDPerfMonZmumu::m_pv_x
double m_pv_x
Definition: IDPerfMonZmumu.h:359
IDPerfMonZmumu::m_Refit2_sigma_d0
std::vector< float > m_Refit2_sigma_d0
Definition: IDPerfMonZmumu.h:414
ZmumuEvent::SetZ0GapCut
void SetZ0GapCut(double newvalue)
Definition: ZmumuEvent.h:99
IDPerfMonZmumu::m_commonTreeName
std::string m_commonTreeName
Definition: IDPerfMonZmumu.h:166
xAOD::TrackParticle_v1::theta
float theta() const
Returns the parameter, which has range 0 to .
StoreGateSvc.h
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
IDPerfMonZmumu::m_truthTreeName
std::string m_truthTreeName
Definition: IDPerfMonZmumu.h:171
ZmumuEvent::getPosMuon
unsigned int getPosMuon(ZTYPE eType)
Definition: ZmumuEvent.cxx:516
IDPerfMonZmumu::m_Refit2_sigma_z0
std::vector< float > m_Refit2_sigma_z0
Definition: IDPerfMonZmumu.h:419
IDPerfMonZmumu::m_negative_z0_manualBS
double m_negative_z0_manualBS
Definition: IDPerfMonZmumu.h:276
IDPerfMonZmumu::m_IDTrack_qoverp
std::vector< float > m_IDTrack_qoverp
Definition: IDPerfMonZmumu.h:398
MissingETContainer.h
FourMuonEvent::GetVertexMuNeg2
int GetVertexMuNeg2()
Definition: FourMuonEvent.h:98
IDPerfMonZmumu::m_refit2TreeName
std::string m_refit2TreeName
Definition: IDPerfMonZmumu.h:170
FourMuonEvent::SetSecondMuonPtCut
void SetSecondMuonPtCut(double newvalue)
Definition: FourMuonEvent.cxx:1342
ZmumuEvent::setContainer
void setContainer(PerfMonServices::CONTAINERS container)
Definition: ZmumuEvent.h:102
ZmumuEvent::SetMassWindowLow
void SetMassWindowLow(double newvalue)
Definition: ZmumuEvent.h:94
IDPerfMonZmumu::m_CBTrack_qoverp
std::vector< float > m_CBTrack_qoverp
Definition: IDPerfMonZmumu.h:399
IDPerfMonZmumu::m_storeZmumuNtuple
bool m_storeZmumuNtuple
Definition: IDPerfMonZmumu.h:124
IDPerfMonZmumu::IDPerfMonZmumu
IDPerfMonZmumu(const std::string &name, ISvcLocator *pSvcLocator)
needed for IP resolution studies
Definition: IDPerfMonZmumu.cxx:47
PerfMonServices::MUON_COLLECTION
@ MUON_COLLECTION
Definition: PerfMonServices.h:45
FourMuonEvent::doIsoSelection
void doIsoSelection(bool doIso)
Definition: FourMuonEvent.h:73
IDPerfMonZmumu::m_MassWindowLow
double m_MassWindowLow
Definition: IDPerfMonZmumu.h:113
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
IDPerfMonZmumu::m_defaultTreeFolder
std::string m_defaultTreeFolder
Definition: IDPerfMonZmumu.h:183
FourMuonEvent::getIDTrack
const xAOD::TrackParticle * getIDTrack(unsigned int uPart)
Definition: FourMuonEvent.h:81
IDPerfMonZmumu::m_IDTrack_pt
std::vector< float > m_IDTrack_pt
Definition: IDPerfMonZmumu.h:368
xAOD::EventInfo_v1::actualInteractionsPerCrossing
float actualInteractionsPerCrossing() const
Average interactions per crossing for the current BCID - for in-time pile-up.
Definition: EventInfo_v1.cxx:380
ZmumuEvent::Reco
virtual bool Reco(int theLumiBlock=0)
Definition: ZmumuEvent.cxx:111
IDPerfMonZmumu::m_el_negative2_d0_err
double m_el_negative2_d0_err
Definition: IDPerfMonZmumu.h:323
IDPerfMonZmumu::m_negative_sigma_pt
double m_negative_sigma_pt
Definition: IDPerfMonZmumu.h:280
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.
IDPerfMonZmumu::m_doFourMuAnalysis
bool m_doFourMuAnalysis
Definition: IDPerfMonZmumu.h:123
IDPerfMonZmumu::m_FourMuTreeFolder
std::string m_FourMuTreeFolder
Root Validation Tree.
Definition: IDPerfMonZmumu.h:190
IDPerfMonZmumu::m_positive_sigma_pt
double m_positive_sigma_pt
Definition: IDPerfMonZmumu.h:245
Generated on Fri Jul 5 2024 21:17:20 for ATLAS Offline Software by   doxygen 1.8.18