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