ATLAS Offline Software
Loading...
Searching...
No Matches
IDPerfMonEoverP.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3*/
4
5/********************************************************************
6
7NAME: IDPerfMonEoverP.cxx
8PACKAGE: InDetPerformanceMonitoring
9
10AUTHORS: A. Morley
11CREATED: Jul 2011
12
13PURPOSE: Create a simple ntuple to perform EoverP studies with
14********************************************************************/
15
16// INCLUDE HEADER FILES:
17#include "egammaInterfaces/IegammaTrkRefitterTool.h"
18
19// INCLUDE GAUDI HEADER FILES:
20#include "GaudiKernel/MsgStream.h"
21#include "Gaudi/Property.h"
22#include "GaudiKernel/TypeNameString.h"
23
24#include <algorithm>
25#include <cmath>
26#include <vector>
27// Validation mode - TTree includes
28#include "GaudiKernel/ITHistSvc.h"
29
30#include "TrkTrack/Track.h"
31#include "Particle/TrackParticle.h"
32#include "TrkTrackSummary/TrackSummary.h"
33#include "TrkParticleBase/LinkToTrackParticleBase.h"
34
35#include "xAODMissingET/MissingET.h"
36#include "xAODMissingET/MissingETContainer.h"
37
38#include "TrigDecisionTool/TrigDecisionTool.h"
39
40
41//#include "JetUtils/JetCaloQualityUtils.h"
42#include "InDetPerformanceMonitoring/IDPerfMonEoverP.h"
43
44#include "TTree.h"
45#include "TMath.h"
46#include "TH1F.h"
47#include "TH2F.h"
48#include "TLorentzVector.h"
49#include "TruthUtils/ParticleConstants.h"
50
51using namespace std;
52using namespace Trk;
53// END OF HEADER FILES INCLUDE
54
56
57// CONSTRUCTOR:
58
59IDPerfMonEoverP::IDPerfMonEoverP(const std::string& name,
60 ISvcLocator* pSvcLocator):
61 AthAlgorithm(name, pSvcLocator),
62 m_refittedTracks_no1{},
63 m_refittedTracks_no2{},
64 m_TrackRefitter(""),
65 m_TrackRefitter_no2(""),
66 m_trigDec("Trig::TrigDecisionTool/TrigDecisionTool"),
67 m_refitEverything(true),
68 m_isDATA(true),
69 m_validationMode(true),
70 m_fillDetailedTree(false),
71 m_validationTreeName( "EGrefitter" ),
72 m_validationTreeDescription( "egamma track refitter caches" ),
73 m_validationTreeFolder( "/ZmumuValidationUserSel/EGrefitter"), // use same root file name as Zmumu
74 m_validationTree(0),
75 m_runNumber{},
76 m_evtNumber{},
77 m_lumi_block{},
78 m_nelectrons{},
79 m_electronCounter(0),
80 m_nbpv{},
81 m_METgoodness{},
82 m_sumet{},
83 m_missingEt{},
84 m_missingEtx{},
85 m_missingEty{},
86 m_ZeeLooseMassOS_Cluster(nullptr),
87 m_ZeeLooseMassSS_Cluster(nullptr),
88 m_ZeeMediumMassOS_Cluster(nullptr),
89 m_ZeeMediumMassSS_Cluster(nullptr),
90 m_ZeeMediumOS_ClusterPtEta(nullptr),
91 m_WenuLooseElectronET(nullptr),
92 m_WenuTight_Met(nullptr),
93 m_WenuTight_MT(nullptr),
94 m_WenuTightMet_MT(nullptr),
95 m_WenuTightElectronET(nullptr),
96 m_WenuTightW_PT(nullptr),
97 m_WenuTightElectron_PTEtaPos(nullptr),
98 m_WenuTightElectron_PTEtaNeg(nullptr),
99 m_smallValidationTreeName("EGrefitterSmall"),
100 m_smallValidationTreeDescription("Small Tree for E/p fits"),
101 m_smallValidationTreeFolder("/eoverpValidation2/efitterValidation2"),
102 m_smallValidationTree(nullptr),
103 m_small_QoverP{},
104 m_small1_QoverP{},
105 m_small2_QoverP{},
106 m_smallClusterEnergy{},
107 m_smallClusterPhi{},
108 m_smallClusterEta{},
109 m_smallTrackTheta{},
110 m_smallCharge{},
111 m_smalld0{},
112 m_smallz0{},
113 m_LHToolLoose2015{},
114 m_LHToolMedium2015{},
115 m_LHToolTight2015{}
116{
117
118// The following properties are specified at run-time
119// (declared in jobOptions file)
120 declareProperty("RefitTracks", m_refitEverything);
121 declareProperty("isDATA", m_isDATA);
122 declareProperty("ReFitterTool", m_TrackRefitter, "ToolHandle for track fitter implementation");
123 declareProperty("ReFitterTool2", m_TrackRefitter_no2, "ToolHandle for track fitter implementation");
124 declareProperty("TrigDecisionTool", m_trigDec, "The TrigDecisionTool instance.");
125 declareProperty("InputElectronContainerName", m_InputElectronContainerName = "Electrons");
126 declareProperty("InputJetContainerName", m_jetContainerName = "AntiKt4LCTopoJets");
127 // declareProperty("MissingEtObjectName", m_missingEtObjectName = "MET_RefFinal");
128 declareProperty("METFinalName", m_metRefFinalName= "FinalClus");
129 declareProperty("MissingEtObjectName", m_missingEtObjectName = "MET_Reference_AntiKt4LCTopo");
130 declareProperty("primaryVertexCollection", m_primaryVertexCollection = "PrimaryVertices");
131 declareProperty("RefittedElectronTrackContainer1", m_OutputTrackCollectionName_no1="GSFTracks");
132 declareProperty("RefittedElectronTrackContainer2", m_OutputTrackCollectionName_no2="DNATracks");
133 declareProperty("ValidationMode", m_validationMode);
134 declareProperty("FillDetailedTree", m_fillDetailedTree);
135 declareProperty("ElectronLikelihoodTune", m_lhTune="mc15_20150712");
136 declareProperty("ValidationTreeFolder", m_validationTreeFolder, "/ZmumuValidationUserSel/EGrefitter"); // use same root file name as Zmumu
137}
138
139// DESTRUCTOR:
140
145
147
148// INITIALIZE METHOD:
149
150StatusCode IDPerfMonEoverP::initialize()
151{
152 ATH_MSG_INFO("Initializing IDPerfMonEoverP");
153
154 ATH_CHECK( m_evt.initialize() );
155
156 // Retrieve Jet selector tool
157 CHECK( m_jetCleaningTool.retrieve() );
158
159 // Retrieve fitter
160 if (m_TrackRefitter.retrieve().isFailure()) {
161 ATH_MSG_FATAL("Unable to retrieve " << m_TrackRefitter );
162 return StatusCode::FAILURE;
163 } else
164 ATH_MSG_INFO("Retrieved tool" << m_TrackRefitter );
165
166 // Retrieve the second fitter
167 if (m_TrackRefitter_no2.retrieve().isFailure()) {
168 ATH_MSG_FATAL("Unable to retrieve " << m_TrackRefitter_no2 );
169 return StatusCode::FAILURE;
170 } else {
171 ATH_MSG_INFO("Retrieved tool" << m_TrackRefitter_no2 );
172 }
173
174 if(m_trigDec.retrieve().isFailure()) {
175 ATH_MSG_FATAL("Unable to retrieve " << m_trigDec << " turn it off");
176 return StatusCode::FAILURE;
177 }
178 else
179 ATH_MSG_INFO("Retrieved tool" << m_trigDec );
180
181
182 //
183 // Electron PID Variables
184 //
185 // Following are of ShowerShapeType
186 namespace xEgamma = xAOD::EgammaParameters;
187 namespace xIso = xAOD::Iso;
188 m_PID_ShowerType_Names = {
189 {xEgamma::f1, "f1"},
190 {xEgamma::emins1, "f1core"},
191 {xEgamma::fracs1, "fside"},
192 {xEgamma::e2tsts1, "Emax2"},
193 {xEgamma::weta1, "ws3"},
194 {xEgamma::wtots1, "wstot"},
195 {xEgamma::emaxs1,"emaxs1"},
196 {xEgamma::e233,"E233"},
197 {xEgamma::e237,"E237"},
198 {xEgamma::e277,"E277"},
199 {xEgamma::weta2,"weta2"},
200 {xEgamma::f3,"f3"},
201 {xEgamma::f3core,"f3core"}
202 };
203 // Following are of isolation type
204 m_PID_IsolationType_Names = {
205 {xIso::etcone20,"Etcone20"},
206 {xIso::etcone30,"Etcone30"},
207 {xIso::etcone40,"Etcone40"},
208 {xIso::ptcone30,"ptcone30"}
209 };
210 // Following are of trackcalomatch type
211 m_PID_TrackCaloMatchType_Names = {
212 {xEgamma::deltaEta1,"deltaeta1"},
213 {xEgamma::deltaEta2,"deltaeta2"},
214 {xEgamma::deltaPhi2,"deltaphi2"}
215 };
216
217
218
219 //
220 // Trigger
221 //
222 m_triggerNames = {
223 "L1_MBTS_1",
224 "L1_EM2",
225 "L1_2EM2",
226 "L1_2EM4",
227 "L1_EM5",
228 "L1_EM10",
229 "L1_EM10I",
230 "L1_EM14",
231 "L1_EM18",
232 "L1_EM18I",
233 "L1_EM23I",
234 "L1_EM100",
235 "EF_2e5_medium",
236 "EF_e10_medium",
237 "EF_e20_loose",
238 "EF_em105_passHLT",
239 "EF_g20_loose",
240 "EF_e20_medium",
241 "EF_e22_medium",
242 //run 2 test
243 "HLT_e24_lhmedium_idperf_L1EM20VH",
244 "HLT_e24_medium_L1EM18VH",
245 "e5_vloose",
246 "ALL",
247 "HLT_ALL"
248 };
249
250 // If the validation nuptle has been requested Setup the ntuple
251 if (m_validationMode){
252 if (m_validationTree == nullptr ){ // validation tree does not exist yet
253 // create the new Tree
254 ATH_MSG_DEBUG ( "Booking validationTree with name: " << m_validationTreeName );
255 m_validationTree = new TTree(m_validationTreeName.c_str(), m_validationTreeDescription.c_str());
256 std::string FitterNames[3] = {"GX2","Refitted1","Refitted2"};
257 m_validationTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
258 m_validationTree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
259 m_validationTree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
260 // counter for number of electrons
261 m_validationTree->Branch("nElectrons" , &m_nelectrons, "nElectrons/I");
262 // Track fitter information
263 for(int fitter(0); fitter < 3; ++fitter){
264 m_validationTree->Branch( (FitterNames[fitter]+"_Theta").c_str() , m_electronTheta[fitter], (FitterNames[fitter]+"_Theta0[nElectrons]/F").c_str() );
265 m_validationTree->Branch( (FitterNames[fitter]+"_Eta").c_str() , m_electronEta[fitter], (FitterNames[fitter]+"_Eta[nElectrons]/F").c_str() );
266 m_validationTree->Branch( (FitterNames[fitter]+"_Eta").c_str() , m_electronEta[fitter], (FitterNames[fitter]+"_Eta[nElectrons]/F").c_str() );
267 m_validationTree->Branch( (FitterNames[fitter]+"_Phi0").c_str() , m_electronPhi[fitter], (FitterNames[fitter]+"_Phi0[nElectrons]/F").c_str() );
268 m_validationTree->Branch( (FitterNames[fitter]+"_QoverP").c_str() , m_electronQoverP[fitter], (FitterNames[fitter]+"_QoverP[nElectrons]/F").c_str());
269 m_validationTree->Branch( (FitterNames[fitter]+"_d0").c_str() , m_electrond0[fitter], (FitterNames[fitter]+"_d0[nElectrons]/F").c_str());
270 m_validationTree->Branch( (FitterNames[fitter]+"_z0").c_str() , m_electronz0[fitter], (FitterNames[fitter]+"_z0[nElectrons]/F").c_str());
271 m_validationTree->Branch( (FitterNames[fitter]+"_LMQoverP").c_str() , m_electronLMQoverP[fitter], (FitterNames[fitter]+"_LMQoverP[nElectrons]/F").c_str());
272 m_validationTree->Branch( (FitterNames[fitter]+"_ThetaErr").c_str() , m_electronErrTheta[fitter], (FitterNames[fitter]+"_Theta0Err[nElectrons]/F").c_str());
273 m_validationTree->Branch( (FitterNames[fitter]+"_Phi0Err").c_str() , m_electronErrPhi[fitter], (FitterNames[fitter]+"_Phi0Err[nElectrons]/F").c_str());
274 m_validationTree->Branch( (FitterNames[fitter]+"_QoverPErr").c_str(), m_electronErrQoverP[fitter],(FitterNames[fitter]+"_QoverPErr[nElectrons]/F").c_str());
275 m_validationTree->Branch( (FitterNames[fitter]+"_d0Err").c_str() , m_electronErrd0[fitter], (FitterNames[fitter]+"_d0Err[nElectrons]/F").c_str());
276 m_validationTree->Branch( (FitterNames[fitter]+"_z0Err").c_str() , m_electronErrz0[fitter], (FitterNames[fitter]+"_z0Err[nElectrons]/F").c_str());
277 }
278
279 m_validationTree->Branch("associatedToVtx" , m_associatedToVtx, "associatedToVtx[nElectrons]/I");
280 m_validationTree->Branch("nbpv", &m_nbpv, "nbpv/I");
281 m_validationTree->Branch("pvtype", m_pvtype, "pvtype[nbpv]/I");
282 m_validationTree->Branch("pvnbtk", m_pvnbtk, "pvnbtk[nbpv]/I");
283 m_validationTree->Branch("pvsumpt", m_pvsumpt, "pvsumpt[nbpv]/F");
284 m_validationTree->Branch("pvx", m_pvx, "pvx[nbpv]/F");
285 m_validationTree->Branch("pvy", m_pvy, "pvy[nbpv]/F");
286 m_validationTree->Branch("pvz", m_pvz, "pvz[nbpv]/F");
287 m_validationTree->Branch("errpvx", m_errpvx, "errpvx[nbpv]/F");
288 m_validationTree->Branch("errpvy", m_errpvy, "errpvy[nbpv]/F");
289 m_validationTree->Branch("errpvz", m_errpvz, "errpvz[nbpv]/F");
290 m_validationTree->Branch("covpvxpvy", m_covpvxpvy, "covpvxpvy[nbpv]/F");
291 m_validationTree->Branch("covpvzpvx", m_covpvzpvx, "covpvzpvx[nbpv]/F");
292 m_validationTree->Branch("covpvypvz", m_covpvypvz, "covpvypvz[nbpv]/F");
293
294
295 m_validationTree->Branch("METgoodness", &m_METgoodness, "METgoodness/B");
296 m_validationTree->Branch("sumet", &m_sumet, "sumet/F");
297 m_validationTree->Branch("missingEt", &m_missingEt, "missingEt/F");
298 m_validationTree->Branch("missingEtx", &m_missingEtx, "missingEtx/F");
299 m_validationTree->Branch("missingEty", &m_missingEty, "missingEty/F");
300
301
302 m_validationTree->Branch("ElectronAuthor" , m_author, "ElectronAuthor[nElectrons]/I");
303 m_validationTree->Branch("ClusterEnergy" , m_ClusterEnergy, "ClusterEnergy[nElectrons]/F");
304 m_validationTree->Branch("ClusterEta" , m_ClusterEta, "ClusterEta[nElectrons]/F");
305 m_validationTree->Branch("ClusterPhi" , m_ClusterPhi, "ClusterPhi[nElectrons]/F");
306
307 m_validationTree->Branch("IsEMLoose" , m_IsEMLoose, "m_IsEMLoose[nElectrons]/B");
308 m_validationTree->Branch("IsEMMedium" , m_IsEMMedium, "m_IsEMMedium[nElectrons]/B");
309 m_validationTree->Branch("IsEMTight" , m_IsEMTight, "m_IsEMTight[nElectrons]/B");
310 m_validationTree->Branch("isGoodOQ" , m_isGoodOQ, "isGoodOQ[nElectrons]/B");
311
312 m_validationTree->Branch("nTRT" , m_nTRT , "nTRT[nElectrons]/I");
313 m_validationTree->Branch("nSCT" , m_nSCT, "nSCT[nElectrons]/I");
314 m_validationTree->Branch("nBLayer" , m_nBLayer, "nBLayer[nElectrons]/I");
315 m_validationTree->Branch("nPIX" , m_nPIX, "nPIX[nElectrons]/I");
316 m_validationTree->Branch("nTRTout" , m_nTRTout, "nTRTout[nElectrons]/I");
317 m_validationTree->Branch("nSCTout" , m_nSCTout, "nSCTout[nElectrons]/I");
318 m_validationTree->Branch("nPIXout" , m_nPIXout, "nPIXout[nElectrons]/I");
319 m_validationTree->Branch("nTRTHT" , m_nTRTHT, "nTRTHT[nElectrons]/I");
320 m_validationTree->Branch("nTRTHout" , m_nTRTHTout, "nTRTHTout[nElectrons]/I");
321
322
323 for(unsigned int item(0); item < m_PID_ShowerType_Names.size(); ++item){
324 m_validationTree->Branch( m_PID_ShowerType_Names[item].second.c_str() , m_ePID_ShowerType[item], std::string( m_PID_ShowerType_Names[item].second + "[nElectrons]/F").c_str() );
325 }
326
327 for(unsigned int item(0); item < m_PID_IsolationType_Names.size(); ++item){
328 m_validationTree->Branch( m_PID_IsolationType_Names[item].second.c_str() , m_ePID_IsolationType[item], std::string( m_PID_IsolationType_Names[item].second + "[nElectrons]/F").c_str() );
329 }
330
331 for(unsigned int item(0); item < m_PID_TrackCaloMatchType_Names.size(); ++item){
332 m_validationTree->Branch( m_PID_TrackCaloMatchType_Names[item].second.c_str() , m_ePID_TrackCaloMatchType[item], std::string( m_PID_TrackCaloMatchType_Names[item].second + "[nElectrons]/F").c_str() );
333 }
334
335 for(unsigned int item(0); item < m_PID_SummaryType_Names.size(); ++item){
336 m_validationTree->Branch( m_PID_SummaryType_Names[item].second.c_str() , m_ePID_SummaryType[item], std::string( m_PID_SummaryType_Names[item].second + "[nElectrons]/F").c_str() );
337 }
338
339 for(unsigned int item(0); item < m_triggerNames.size(); ++item){
340 m_validationTree->Branch( m_triggerNames[item].c_str() , &m_trigger[item], std::string( m_triggerNames[item]+ "/B" ).c_str() );
341 }
342
343 }
344
345
346 if(m_smallValidationTree == nullptr){
347
348 m_smallValidationTree = new TTree(m_smallValidationTreeName.c_str(), m_smallValidationTreeDescription.c_str());
349
350 m_smallValidationTree->Branch("charge",&m_smallCharge,"charge/D");
351 m_smallValidationTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
352 m_smallValidationTree->Branch("Default_QoverP",&m_small_QoverP,"Default_QoverP/D");
353 m_smallValidationTree->Branch("Refitted1_QoverP",&m_small1_QoverP,"Refitted1_QoverP/D");
354 m_smallValidationTree->Branch("Refitted2_QoverP",&m_small2_QoverP,"Refitted2_QoverP/D");
355 m_smallValidationTree->Branch("ClusterEnergy",&m_smallClusterEnergy,"ClusterEnergy/D");
356 m_smallValidationTree->Branch("ClusterEta" ,&m_smallClusterEta,"ClusterEta/D");
357 m_smallValidationTree->Branch("ClusterPhi" ,&m_smallClusterPhi,"ClusterPhi/D");
358 m_smallValidationTree->Branch("TrackTheta" ,&m_smallTrackTheta,"TrackTheta/D");
359 }
360
361 // Access THistSvc
362 ServiceHandle<ITHistSvc> tHistSvc("THistSvc", name());
363 if ( tHistSvc.retrieve().isSuccess()) {
364 ATH_MSG_DEBUG(" initialize() THistSvc successfully retrieved ");
365 }
366 else {
367 ATH_MSG_ERROR("initialize() Could not find Hist Service -> Switching ValidationMode Off !");
368 delete m_validationTree; m_validationTree = 0;
369 delete m_smallValidationTree; m_smallValidationTree = 0;
370 m_validationMode = false;
371 }
372
373 // now register the Tree
374 if (m_validationTree != nullptr ) {
375 if ( (tHistSvc->regTree(m_validationTreeFolder, m_validationTree)).isSuccess() ) {
376 ATH_MSG_DEBUG( "initialize() validation tree (" << m_validationTree->GetName() <<") successfully registered in folder " << m_validationTreeFolder );
377 }
378 else {
379 ATH_MSG_ERROR( "initialize() Could not register the validation Tree -> Switching ValidationMode Off !");
380 delete m_validationTree; m_validationTree = 0;
381 m_validationMode = false;
382 }
383 }
384 else {
385 ATH_MSG_DEBUG( "initialize() no validation tree to register :( ");
386 }
387
388 if ((tHistSvc->regTree(m_smallValidationTreeFolder, m_smallValidationTree)).isFailure() ) {
389 ATH_MSG_ERROR("initialize() Could not register the validation Tree -> Switching ValidationMode Off !");
390 delete m_smallValidationTree; m_smallValidationTree = 0;
391 m_validationMode = false;
392 }
393 else {
394 m_ZeeLooseMassOS_Cluster = new TH1F("ZeeMassLooseOS","ZeeMassLooseOS", 120, 60000 ,120000);
395 m_ZeeLooseMassSS_Cluster = new TH1F("ZeeMassLooseSS","ZeeMassLooseSS", 120, 60000 ,120000);
396 m_ZeeMediumMassOS_Cluster = new TH1F("ZeeMassMediumOS","ZeeMassMediumOS", 120, 60000 ,120000);
397 m_ZeeMediumMassSS_Cluster = new TH1F("ZeeMassMediumSS","ZeeMassMediumSS", 120, 60000 ,120000);
398 m_WenuLooseElectronET= new TH1F("WenuLooseElectronET","WenuLooseElectronET", 80, 20000 ,100000);
399 m_WenuTight_Met = new TH1F("WenuTight_Met","WenuTight_Met", 120, 00000 ,120000);
400 m_WenuTight_MT = new TH1F("WenuTight_MT","WenuTight_MT", 120, 00000 ,120000);
401 m_WenuTightMet_MT = new TH1F("WenuTightMet_MT","WenuTightMet_MT", 120, 00000 ,120000);
402 m_WenuTightElectronET = new TH1F("WenuTightElectronET","WenuTightElectronET", 100, 00000 ,100000);
403 m_WenuTightW_PT = new TH1F("WenuTightW_PT","WenuTightW_PT", 100, 00000 ,100000);
404
405 m_ZeeMediumOS_ClusterPtEta = new TH2F("ZeeMediumOS_ClusterPtEta", "ZeeMediumOS_ClusterPtEta",100,20000,120000,50,-2.5,2.5);
406 m_WenuTightElectron_PTEtaPos = new TH2F("WenuTightElectron_PTEtaPos", "WenuTightElectron_PTEtaPos",100,20000,120000,50,-2.5,2.5);
407 m_WenuTightElectron_PTEtaNeg = new TH2F("WenuTightElectron_PTEtaNeg", "WenuTightElectron_PTEtaNeg",100,20000,120000,50,-2.5,2.5);
408
409 bool somethingFailed{};
410 somethingFailed |= ( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMassLooseOS",m_ZeeLooseMassOS_Cluster )).isFailure() );
411 somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMassLooseSS",m_ZeeLooseMassSS_Cluster )).isFailure() );
412 somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMassMediumOS",m_ZeeMediumMassOS_Cluster )).isFailure() );
413 somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMassMediumSS",m_ZeeMediumMassSS_Cluster )).isFailure() );
414 somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuLooseElectronET",m_WenuLooseElectronET )).isFailure() );
415 somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTight_Met",m_WenuTight_Met )).isFailure() );
416 somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTight_MT",m_WenuTight_MT )).isFailure() );
417 somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightMet_MT",m_WenuTightMet_MT )).isFailure() );
418 somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightElectronET",m_WenuTightElectronET )).isFailure() );
419 somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightW_PT",m_WenuTightW_PT )).isFailure() );
420 somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMediumOS_ClusterPtEta",m_ZeeMediumOS_ClusterPtEta )).isFailure() );
421 somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightElectron_PTEtaPos",m_WenuTightElectron_PTEtaPos )).isFailure() );
422 somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightElectron_PTEtaNeg",m_WenuTightElectron_PTEtaNeg )).isFailure() );
423 if (somethingFailed) ATH_MSG_ERROR("initialize() Could not register histogram ");
424
425 ATH_MSG_INFO("Booked Small Tree add histograms");
426 }
427
428 ATH_MSG_INFO("Loaded THistSvc");
429 }
430
431 //---Electron Likelihood tool---
432 ATH_MSG_INFO("IDPerfMonEoverP::Initialize() -- Setting up electron LH tool.");
433 m_LHToolLoose2015 = new AsgElectronLikelihoodTool ("m_LHToolLoose2015");
434 m_LHToolMedium2015 = new AsgElectronLikelihoodTool ("m_LHToolMedium2015");
435 m_LHToolTight2015 = new AsgElectronLikelihoodTool ("m_LHToolTight2015");
436
437 if((m_LHToolLoose2015->setProperty("primaryVertexContainer",m_primaryVertexCollection)).isFailure())
438 ATH_MSG_WARNING("Failure setting primary vertex container " << m_primaryVertexCollection << "in loose electron likelihood tool");
439 if((m_LHToolMedium2015->setProperty("primaryVertexContainer",m_primaryVertexCollection)).isFailure())
440 ATH_MSG_WARNING("Failure setting primary vertex container " << m_primaryVertexCollection << "in medium electron likelihood tool");
441 if((m_LHToolTight2015->setProperty("primaryVertexContainer",m_primaryVertexCollection)).isFailure())
442 ATH_MSG_WARNING("Failure setting primary vertex container " << m_primaryVertexCollection << "in tight electron likelihood tool");
443
444 //Set up electron LH level
445 std::string confDir = "ElectronPhotonSelectorTools/offline/"+m_lhTune+"/";
446 std::string configFileL = confDir+"ElectronLikelihoodLooseOfflineConfig2015.conf";
447 std::string configFileM = confDir+"ElectronLikelihoodMediumOfflineConfig2015.conf";
448 std::string configFileT = confDir+"ElectronLikelihoodTightOfflineConfig2015.conf";
449
450 if((m_LHToolLoose2015->setProperty("ConfigFile",configFileL)).isFailure())
451 ATH_MSG_WARNING("Failure loading ConfigFile in loose electron likelihood tool.");
452 if((m_LHToolMedium2015->setProperty("ConfigFile",configFileM)).isFailure())
453 ATH_MSG_WARNING("Failure loading ConfigFile in medium electron likelihood tool.");
454 if((m_LHToolTight2015->setProperty("ConfigFile",configFileT)).isFailure())
455 ATH_MSG_WARNING("Failure loading ConfigFile in tight electron likelihood tool.");
456
457 StatusCode lhl = m_LHToolLoose2015->initialize();
458 if(lhl.isFailure())
459 ATH_MSG_WARNING("Loose electron likelihood tool initialize() failed!");
460 StatusCode lhm = m_LHToolMedium2015->initialize();
461 if(lhm.isFailure())
462 ATH_MSG_WARNING("Medium electron likelihood tool initialize() failed!");
463 StatusCode lht = m_LHToolTight2015->initialize();
464 if(lht.isFailure())
465 ATH_MSG_WARNING("Tight electron likelihood tool initialize() failed!");
466 ATH_MSG_INFO( "Initialization completed successfully");
467 return StatusCode::SUCCESS;
468
469}
470
471// FINALIZE METHOD:
472
473StatusCode IDPerfMonEoverP::finalize()
474{
475 return StatusCode::SUCCESS;
476}
477
479// ATHENA EXECUTE METHOD:
480StatusCode IDPerfMonEoverP::execute()
481{
482 ATH_MSG_DEBUG( "Executing IDPerfMonEoverP" );
483 StatusCode sc(StatusCode::SUCCESS);
484 std::map<const xAOD::TrackParticle*, VxPos > trackParticleVertexMap;
485 const xAOD::Vertex* primaryVertexFirstCandidate = nullptr;
486 if (m_validationMode){
487 clearValidationNtuple();
488 }else{
489 ATH_MSG_WARNING( " Validation Mode has been turned off ALG will do not fill Ntuples" );
490 return sc;
491 }
492
493 ATH_MSG_DEBUG("Retrieving event info.");
494 SG::ReadHandle<xAOD::EventInfo> evt(m_evt);
495 if(evt.isValid()) {
496 m_runNumber = evt->runNumber();
497 m_evtNumber = evt->eventNumber();
498 m_lumi_block = evt->lumiBlock();
499 ATH_MSG_DEBUG(" --> run: " << m_runNumber << " event: " << m_evtNumber << " lumiblock: " << m_lumi_block );
500 }
501 else {
502 ATH_MSG_ERROR("Could not retrieve event info."); // Keeping ERROR only to preserve old functionality
503 }
504
505 ATH_MSG_DEBUG("Retrieved Trigger info.");
506 fillTriggerInformation();
507
508 if ( not fillVertexInformation(trackParticleVertexMap, primaryVertexFirstCandidate) ){
509 ATH_MSG_DEBUG("No Primary Vertex info found");
510 }
511
512 ATH_MSG_DEBUG("MET info.being stored");
513 if( storeMETinformation() ) {
514 ATH_MSG_DEBUG("MET info. stored");
515 }
516 else {
517 ATH_MSG_DEBUG("NO MET info. stored :(");
518 }
519
520 // Get the electron AOD container
521 const xAOD::ElectronContainer* ElectronInput_container;
522 ATH_MSG_DEBUG("Retrieving ElectronInput_container: " << m_InputElectronContainerName);
523 sc = evtStore()->retrieve(ElectronInput_container, m_InputElectronContainerName);
524 if (sc != StatusCode::SUCCESS){
525 ATH_MSG_WARNING("No electron container --> return");
526 deleteAction();
527 return StatusCode::SUCCESS;
528 }
529
530 if (ElectronInput_container->empty() ){
531 ATH_MSG_DEBUG("-- ElectronInput_container is empty -> return");
532 deleteAction();
533 return StatusCode::SUCCESS;
534 }
535
536 m_refittedTracks_no1 = new TrackCollection;
537 m_refittedTracks_no2 = new TrackCollection;
538
539
540 typedef xAOD::ElectronContainer::const_iterator electron_iterator;
541 electron_iterator iter = ElectronInput_container->begin();
542 electron_iterator iterEnd = ElectronInput_container->end();
543
544 // Loop over the Electrons
545 ATH_MSG_DEBUG("Electron info. being stored");
546 for(; iter != iterEnd ; ++iter) {
547 ATH_MSG_DEBUG("Dealing with electron: "<< m_electronCounter+1);
548 if (m_electronCounter >= NOS_ELECTRONS) break;
549 const xAOD::Electron *pThisElectron = (*iter);
550 m_author[m_electronCounter] = pThisElectron->author(xAOD::EgammaParameters::AuthorElectron);
551
552 // Cluster Info
553 fillElectronInfo ( pThisElectron );
554 // Fill General info
555 fillGeneral( pThisElectron );
556 // Fill IsEm info
557 fillIsEM( pThisElectron );
558
559 //Get the track particle
560 const xAOD::TrackParticle* mytp = (*iter)->trackParticle();
561 if ( mytp != nullptr ) ATH_MSG_DEBUG("-- electron: "<< m_electronCounter+1 << " pt: " << mytp->p4().Perp() );
562
563
564 if( mytp != nullptr ){
565 uint8_t dummy(0);
566 auto summaryByDetector=[&mytp,&dummy]( const xAOD::SummaryType & t){
567 return mytp->summaryValue(dummy, t) ? (dummy) : (-1);
568 };
569 m_nTRT[m_electronCounter] = summaryByDetector( xAOD::numberOfTRTHits );
570 m_nSCT[m_electronCounter] = summaryByDetector( xAOD::numberOfSCTHits );
571 m_nPIX[m_electronCounter] = summaryByDetector( xAOD::numberOfPixelHits );
572 m_nBLayer[m_electronCounter] = summaryByDetector( xAOD::numberOfInnermostPixelLayerHits);
573 m_nTRTout[m_electronCounter] = summaryByDetector( xAOD::numberOfTRTOutliers);
574 m_nSCTout[m_electronCounter] = summaryByDetector( xAOD::numberOfSCTOutliers);
575 m_nTRTHT[m_electronCounter] = summaryByDetector( xAOD::numberOfTRTHighThresholdHits);
576 m_nTRTHTout[m_electronCounter] = summaryByDetector( xAOD::numberOfTRTHighThresholdOutliers);
577 } else{
578 ATH_MSG_DEBUG("Electron with no track particle?? Possibly Forward");
579 continue;
580 }
581
582 //Find which if any vertex the electron track is associated to
583 VxPos myVxPos = findAssociatedVertex( trackParticleVertexMap,
584 primaryVertexFirstCandidate,
585 pThisElectron );
586 m_associatedToVtx[m_electronCounter] = myVxPos.second;
587 if( mytp->track() ){
588 const Trk::Track* oTrkTrack = mytp->track();
589 if (oTrkTrack){
590 const Trk::Perigee* oMeasPer = oTrkTrack->perigeeParameters() ;
591 if (oMeasPer) addToValidationNtuple( oMeasPer, pThisElectron->caloCluster(), 0 );
592 fillLastMeasurement( oTrkTrack , 0 );
593 }
594 }
595 else {
596 ATH_MSG_DEBUG("mytp->track() == 0");
597 const Trk::Perigee* oMeasPer = &(mytp->perigeeParameters()) ;
598 addToValidationNtuple( oMeasPer, pThisElectron->caloCluster(), 0 );
599 }
600
601
602 if(m_refitEverything) {
603 // First Refitter................
604 ATH_MSG_DEBUG( "Refitting the track" );
605
606 IegammaTrkRefitterTool::Cache cache1{};
607 StatusCode sc = m_TrackRefitter->refitTrack(Gaudi::Hive::currentContext(),
608 pThisElectron->trackParticle()->track(),
609 cache1 );
610
611 if (sc == StatusCode::SUCCESS){
612 Trk::Track* trkTrack= cache1.refittedTrack.release();
613 m_refittedTracks_no1->push_back(trkTrack);
614 addToValidationNtuple( cache1.refittedTrackPerigee ,pThisElectron->caloCluster(), 1 );
615 fillLastMeasurement(trkTrack, 1 );
616 } else {
617 ATH_MSG_DEBUG( "Track Refit Failed" );
618 }
619 //******************************************************//
620 // Refit tracks using the second refitter if it is present
621 //******************************************************//
622 ATH_MSG_DEBUG( "Refitting the track again" );
623
624 IegammaTrkRefitterTool::Cache cache2{};
625 sc = m_TrackRefitter_no2->refitTrack(Gaudi::Hive::currentContext(),
626 pThisElectron->trackParticle()->track(),
627 cache2 );
628
629 if (sc == StatusCode::SUCCESS){
630 Trk::Track* trkTrack= cache2.refittedTrack.release();
631 //Add the refitted track to the TrackCollection
632 m_refittedTracks_no2->push_back( trkTrack );
633 //Add data to the trkRefitterNtuple
634
635 addToValidationNtuple( cache2.refittedTrackPerigee ,pThisElectron->caloCluster(), 2 );
636 fillLastMeasurement( trkTrack, 2 );
637 } else {
638 ATH_MSG_DEBUG( "Track Refit Failed" );
639 }
640 } else {
641 ATH_MSG_DEBUG( "Not Refitting the track -- DO NOTHING" );
642 }//End if >6 silicon hits;
643 //Increment the electron counter for the validation nutple
644 ++m_electronCounter;
645 }
646 // Commit Data to Ntuple;
647 if( m_validationMode ) validationAction();
648 // Fill much smaller tree
649 std::vector<int> goodElectrons = FillSimpleTree();
650 TrackCollection* selectedElectrons = new TrackCollection;
651
652 for( const auto & thisGoodElectron: goodElectrons){
653 IegammaTrkRefitterTool::Cache cache{};
654 StatusCode sc = m_TrackRefitter->refitTrack(Gaudi::Hive::currentContext(),
655 (*ElectronInput_container)[thisGoodElectron]->trackParticle()->track(),
656 cache );
657 if (sc == StatusCode::SUCCESS){
658 Trk::Track* trkTrack= cache.refittedTrack.release();
659 selectedElectrons->push_back(trkTrack);
660 }
661 }
662
663 //******************************************************//
664 //* Add the newly created TrackCollection to StoreGate *//
665 //******************************************************//
666
667 sc = evtStore()->record( m_refittedTracks_no1, m_OutputTrackCollectionName_no1, false );
668 if (sc.isFailure())
669 {
670 ATH_MSG_ERROR("Could not record "<< m_OutputTrackCollectionName_no1 <<" object.");
671 delete selectedElectrons;
672 return (StatusCode::FAILURE);
673 }
674 //
675 sc = evtStore()->record( m_refittedTracks_no2, m_OutputTrackCollectionName_no2, false );
676 if (sc.isFailure())
677 {
678 ATH_MSG_ERROR("Could not record "<< m_OutputTrackCollectionName_no2 <<" object.");
679 delete selectedElectrons;
680 return (StatusCode::FAILURE);
681 }
682 //
683 sc = evtStore()->record( selectedElectrons, m_OutputTrackCollectionName_no1 + "Selected", false );
684 if (sc.isFailure())
685 {
686 ATH_MSG_ERROR("Could not record "<< m_OutputTrackCollectionName_no1+"Selected" <<" object.");
687 delete selectedElectrons;
688 return (StatusCode::FAILURE);
689 }
690 ATH_MSG_DEBUG( "execute completed successfully");
691 return StatusCode::SUCCESS;
692}
693
694void IDPerfMonEoverP::addToValidationNtuple(const Trk::Perigee* perigee,const xAOD::CaloCluster* /*cluster*/, int isOriginal){
695 if (perigee){
696 ATH_MSG_DEBUG( "Adding data to ntuple" );
697 if (isOriginal >= 0 && isOriginal <3){
698 m_electrond0[isOriginal][m_electronCounter] = perigee->parameters()[Trk::d0];
699 m_electronz0[isOriginal][m_electronCounter] = perigee->parameters()[Trk::z0];
700 m_electronPhi[isOriginal][m_electronCounter] = perigee->parameters()[Trk::phi0];
701 m_electronTheta[isOriginal][m_electronCounter] = perigee->parameters()[Trk::theta];
702 m_electronEta[isOriginal][m_electronCounter] = perigee->eta();
703 m_electronQoverP[isOriginal][m_electronCounter]= perigee->parameters()[Trk::qOverP];
704 //
705 const AmgSymMatrix(5)* matrix = perigee->covariance();
706 if (matrix){
707 m_electronErrd0[isOriginal][m_electronCounter] =std::sqrt( (*matrix)(Trk::d0,Trk::d0) );
708 m_electronErrz0[isOriginal][m_electronCounter] = std::sqrt( (*matrix)(Trk::z0,Trk::z0) );
709 m_electronErrPhi[isOriginal][m_electronCounter] = std::sqrt( (*matrix)(Trk::phi0,Trk::phi0) );
710 m_electronErrTheta[isOriginal][m_electronCounter]= std::sqrt( (*matrix)(Trk::theta,Trk::theta) );
711 m_electronErrQoverP[isOriginal][m_electronCounter]= std::sqrt( (*matrix)(Trk::qOverP,Trk::qOverP) );
712 }
713 }
714 } else {
715 ATH_MSG_DEBUG( "No MeasuredPerigee - cannot add data to ntuple" );
716 }
717
718 ATH_MSG_DEBUG( "Finished adding data to ntuple" );
719}
720
722void IDPerfMonEoverP::fillIsEM(const xAOD::Electron *eg)
723{
724 ATH_MSG_DEBUG( "fillIsEM" );
725 int el_goodOQ = (int)eg->isGoodOQ(xAOD::EgammaParameters::BADCLUSELECTRON);
726 m_isGoodOQ[m_electronCounter] = el_goodOQ;
727 // check loose LH
728 bool val_loose = (bool) m_LHToolLoose2015->accept(eg);
729 ATH_MSG_DEBUG( "Loose value : " << val_loose);
730 if(val_loose){
731 m_IsEMLoose[m_electronCounter] = val_loose;
732 }//else{ATH_MSG_DEBUG("Loose electron not defined !");}
733
734 // check medium LH
735 bool val_med = (bool) m_LHToolMedium2015->accept(eg);
736 ATH_MSG_DEBUG( "Medium value : " << val_med );
737 if(val_med){
738 m_IsEMMedium[m_electronCounter] = val_med;
739 }//else{ATH_MSG_DEBUG("Mediu, electron not defined !");}
740
741 // check tight LH
742 bool val_tight = (bool) m_LHToolTight2015->accept(eg);
743 ATH_MSG_DEBUG( "Tight value : " << val_tight);
744 if(val_tight){
745 m_IsEMTight[m_electronCounter] = val_tight;
746 }//else{ATH_MSG_DEBUG("Tight electron not defined !");}
747 return;
748
749}
750
751
752void IDPerfMonEoverP::fillGeneral(const xAOD::Electron *eg)
753{
754 ATH_MSG_DEBUG( "fillGeneral" );
755 const xAOD::CaloCluster* cluster = eg->caloCluster();
756 if(!cluster) return;
757 m_ClusterEnergy[m_electronCounter] = cluster->e();
758 m_ClusterPhi[m_electronCounter] = cluster->phi();
759 m_ClusterEta[m_electronCounter] = cluster->eta();
760}
761
762
763
764
765void IDPerfMonEoverP::clearValidationNtuple()
766{
767 ATH_MSG_DEBUG( "clear ValidationNtuple variables" );
768 for (int i = 0 ; i < NOS_ELECTRONS ; ++i){
769 for (int j = 0 ; j <3 ; ++j){
770 m_electrond0[j][i] = 0;
771 m_electronz0[j][i] = 0;
772 m_electronPhi[j][i] = 0;
773 m_electronTheta[j][i] = 0;
774 m_electronEta[j][i] = 0;
775 m_electronQoverP[j][i] = 0;
776 m_electronLMQoverP[j][i] = 0;
777
778 m_electronErrd0[j][i] = 0;
779 m_electronErrz0[j][i] = 0;
780 m_electronErrPhi[j][i] = 0;
781 m_electronErrTheta[j][i] = 0;
782 m_electronErrQoverP[j][i] = 0;
783
784 }
785 m_associatedToVtx[i] = 0;
786
787 m_author[i] = 0;
788
789 m_ClusterEnergy[i] = 0;
790
791 m_IsEMLoose[i] = false;
792 m_IsEMMedium[i] = false;
793 m_IsEMTight[i] = false;
794 m_IsEMTightTRT[i] = false;
795
796
797 for (int j = 0 ; j < 50 ; ++j){
798 m_ePID_ShowerType[j][i] =0;
799 m_ePID_IsolationType[j][i] =0;
800 m_ePID_TrackCaloMatchType[j][i] =0;
801 m_ePID_SummaryType[j][i] =0;
802 m_trigger[j] = false;
803 }
804 }
805
806
807 //Vertex information
808 m_nbpv =0;
809 for (int i(0); i< NO_PV; ++i){
810 m_pvtype[i] =0;
811 m_pvnbtk[i]=0;
812 m_pvsumpt[i]=0;
813 m_pvx[i]=0;
814 m_pvy[i]=0;
815 m_pvz[i]=0;
816 m_errpvx[i]=0;
817 m_errpvy[i]=0;
818 m_errpvz[i]=0;
819 m_covpvxpvy[i]=0;
820 m_covpvypvz[i]=0;
821 m_covpvzpvx[i]=0;
822 }
823 //MET
824 m_METgoodness=false;
825 m_sumet=0;
826 m_missingEt=0;
827 m_missingEtx=0;
828 m_missingEty=0;
829
830 return;
831}
832
834void IDPerfMonEoverP::deleteAction() const
835{
836
837}
838
840void IDPerfMonEoverP::validationAction()
841{
842 ATH_MSG_DEBUG( "validationAction() -- START -- ");
843 // first record the values
844 if (m_validationTree){
845 m_nelectrons = long(m_electronCounter);
846 if(m_fillDetailedTree) {
847 m_validationTree->Fill();
848 ATH_MSG_DEBUG( "Writing data into ntuple " << m_validationTree->GetName() << ". Entry #" << m_validationTree->GetEntries() );
849 }
850 // then reset
851 m_electronCounter = 0;
852 }
853 ATH_MSG_DEBUG( "validationAction() -- completed -- current number of entries " << m_validationTree->GetEntries() );
854}
855
856
857bool IDPerfMonEoverP::storeMETinformation()
858{
859 ATH_MSG_VERBOSE("In storeMETinformation()");
860 const xAOD::MissingETContainer *pMissingCont(0);
861 const xAOD::MissingET *MET;
862 if (!evtStore()->contains<xAOD::MissingETContainer>(m_missingEtObjectName)){
863 ATH_MSG_WARNING("No collection with name " << m_missingEtObjectName << " found in StoreGate");
864 return false;
865 }
866
867 StatusCode sc;
868 sc = evtStore()->retrieve(pMissingCont,m_missingEtObjectName);
869 if (sc.isFailure()) {
870 ATH_MSG_ERROR( "Could not retrieve MissingETContainer" );
871 return false;
872 }
873 MET = (*pMissingCont)[m_metRefFinalName];
874 m_METgoodness = passMETCleaningCuts();
875 m_sumet = MET->sumet();
876 m_missingEt = MET->met();
877 m_missingEtx = MET->mpx();
878 m_missingEty = MET->mpy();
879 return true;
880}
881
882
883bool IDPerfMonEoverP::passMETCleaningCuts() const
884{
885 const xAOD::JetContainer* jetTDS = nullptr;
886 StatusCode sc= evtStore()->retrieve( jetTDS, m_jetContainerName);
887 if( sc.isFailure() || !jetTDS ) {
888 ATH_MSG_WARNING("No " << m_jetContainerName << " jet container found in TDS");
889 return false;
890 }
891 if (jetTDS->empty()) return true;
892 bool cleanJet = true;
893 for(const auto* jet_elem : *jetTDS ) {
894 if(!m_jetCleaningTool->keep( *jet_elem )) cleanJet=false;
895 if(!cleanJet) break;
896 }
897 return cleanJet;
898}
899
901bool IDPerfMonEoverP::fillVertexInformation(std::map<const xAOD::TrackParticle*, VxPos >& trackParticleVertexMap,
902 xAOD::Vertex const* & primaryVertexFirstCandidate)
903{
904 ATH_MSG_DEBUG( "fillVertexInformation() -- START --" );
905 const xAOD::VertexContainer* vxContainer(0);
906 int npv = 0;
907 StatusCode sc = evtStore()->retrieve(vxContainer, m_primaryVertexCollection);
908 if (sc.isFailure()) {
909 ATH_MSG_WARNING( "Could not retrieve primary vertex info: " << m_primaryVertexCollection );
910 return false;
911 }
912 else {
913 ATH_MSG_DEBUG( "Found primary vertex info: " << m_primaryVertexCollection );
914 if(vxContainer) {
915 ATH_MSG_DEBUG("Nb of reco primary vertex for coll "
916 << " = " << vxContainer->size() );
917 primaryVertexFirstCandidate = std::begin(*vxContainer)[0];
918 ATH_MSG_DEBUG( "The primary vertex type: " << primaryVertexFirstCandidate->type() );
919 int vtxCount = 0;
920 for(const auto* vxI : *vxContainer ) {
921 int type = (int)(vxI)->vertexType();
922 const xAOD::Vertex* primaryVertex = vxI;
923 vtxCount++;
924 ATH_MSG_DEBUG( " -- dealing with vertex " << vtxCount << " type: " << type );
925 int nbtk = 0;
926 const std::vector< ElementLink< xAOD::TrackParticleContainer > > tpLinks = vxI->trackParticleLinks();
927 float sumpt = 0.;
928 if(not tpLinks.empty()) {
929 nbtk = tpLinks.size();
930 ATH_MSG_DEBUG( " -- vertex " << vtxCount << " has " << nbtk << " track particles" );
931 for(const auto& tp_elem : tpLinks ){
932 const xAOD::TrackParticle* trk = *tp_elem;
933 if (trk != NULL) {
934 VxPos myVxPos = std::make_pair(vxI,npv);
935 trackParticleVertexMap.insert( std::make_pair( trk, myVxPos ) );
936 if(trk) {
937 sumpt += trk->p4().Perp();
938 }
939 }
940 else {
941 ATH_MSG_DEBUG( " -- trk is NULL :(" );
942 } // trk not null
943 } // loop on tracks
944 ATH_MSG_DEBUG( "Reco PV " << npv << ": ("
945 << primaryVertex->position().x() << ","
946 << primaryVertex->position().y() << ","
947 << primaryVertex->position().z() << ")"
948 << " type=" << type
949 << " nbtk=" << nbtk
950 << " sumpt=" << sumpt);
951
952 if(npv >= NO_PV) {
953 ATH_MSG_WARNING( "More than " << NO_PV << " reconstructed primary vertices in event "
954 << "for run= " << m_runNumber << " evt= " << m_evtNumber
955 << ". Truncated event. " );
956 } else {
957 m_pvtype[npv] = type;
958 m_pvnbtk[npv] = nbtk;
959 m_pvsumpt[npv] = sumpt;
960 m_pvx[npv] = primaryVertex->position().x();
961 m_pvy[npv] = primaryVertex->position().y();
962 m_pvz[npv] = primaryVertex->position().z();
963
964 }
965 ++npv;
966 } else {
967 ATH_MSG_DEBUG( "Vertex " << npv << " has no tracks associated to it!" );
968 }
969 }
970 } else {
971 ATH_MSG_DEBUG( "No container in collection?? " << m_primaryVertexCollection );
972 }
973 }
974 m_nbpv = npv;
975
976 ATH_MSG_DEBUG("Done filling Vertex information -- completed -- ");
977
978 if (npv == 0) return false;
979 return true;
980}
981
982VxPos IDPerfMonEoverP::findAssociatedVertex(std::map<const xAOD::TrackParticle*, VxPos >& trackParticleVertexMap,
983 const xAOD::Vertex* primaryVertexFirstCandidate,
984 const xAOD::Electron* eg) const
985{
986 ATH_MSG_VERBOSE("In findAssociatedVertex()");
987 std::map<const xAOD::TrackParticle*, VxPos>::iterator tpVx =
988 trackParticleVertexMap.find(eg->trackParticle());
989 if (tpVx == trackParticleVertexMap.end() ){
990 return std::make_pair( primaryVertexFirstCandidate,-1 );
991 } else
992 return (*tpVx).second;
993
994}
995
996
997void IDPerfMonEoverP::fillTriggerInformation()
998{
999 ATH_MSG_VERBOSE("In fillTriggerInformation()");
1000 ATH_MSG_DEBUG( "Pass state All = " << m_trigDec->isPassed( ".*" ) );
1001 ATH_MSG_DEBUG( "Pass state L1 = " << m_trigDec->isPassed( "L1_.*" ) );
1002 ATH_MSG_DEBUG( "Pass state L2 = " << m_trigDec->isPassed( "L2_.*" ) );
1003 ATH_MSG_DEBUG( "Pass state EF = " << m_trigDec->isPassed( "EF_.*" ) );
1004 ATH_MSG_DEBUG("HLT_.* is passed: " << m_trigDec->isPassed("HLT_.*"));
1005 for (unsigned int i=0; i < m_triggerNames.size(); ++i){
1006 if(m_triggerNames[i] == "ALL")
1007 m_trigger[i] = m_trigDec->isPassed(".*");
1008 else if(m_triggerNames[i] == "HLT_ALL")
1009 m_trigger[i] = m_trigDec->isPassed("HLT_.*");
1010 else
1011 m_trigger[i] = m_trigDec->isPassed(m_triggerNames[i]);
1012 }
1013 return;
1014}
1015
1016void IDPerfMonEoverP::fillElectronInfo (const xAOD::Electron *p)
1017{
1018 ATH_MSG_VERBOSE( "In fillElectronInfo()" );
1019 for (size_t i = 0; i < m_PID_ShowerType_Names.size(); i++) {
1020 float dummy(-1);
1021 m_ePID_ShowerType[i][m_electronCounter] = static_cast<float> (p->showerShapeValue( dummy, m_PID_ShowerType_Names[i].first ))? dummy :-1;
1022 }
1023 for (size_t i = 0; i < m_PID_TrackCaloMatchType_Names.size(); i++) {
1024 float dummy(-1);
1025 m_ePID_TrackCaloMatchType[i][m_electronCounter] = static_cast<float> (p->trackCaloMatchValue( dummy, m_PID_TrackCaloMatchType_Names[i].first ))? dummy :-1;
1026 }
1027
1028for (size_t i = 0; i < m_PID_SummaryType_Names.size(); i++) {
1029 float dummy(-1);
1030 m_ePID_SummaryType[i][m_electronCounter] = static_cast<float> (p->trackParticleSummaryValue( dummy, m_PID_SummaryType_Names[i].first ))? dummy :-1;
1031 }
1032
1033 return;
1034
1035}
1036
1037bool IDPerfMonEoverP::fillLastMeasurement(const Trk::Track* track, const int fitter)
1038{
1039 ATH_MSG_VERBOSE("In fillLastMeasurement()");
1040 if(!track) return false;
1041 const Trk::TrackParameters* trkPara =0;
1042
1043 const Trk::TrackStates* oldTrackStates = track->trackStateOnSurfaces();
1044 if (oldTrackStates == 0)
1045 {
1046 return false;
1047 }
1048
1049 for ( Trk::TrackStates::const_reverse_iterator rItTSoS = oldTrackStates->rbegin(); rItTSoS != oldTrackStates->rend(); ++rItTSoS)
1050 {
1051 if (trkPara!=0){
1052 break;
1053 }
1054
1055 if ( (*rItTSoS)->type(Trk::TrackStateOnSurface::Measurement) && (*rItTSoS)->trackParameters()!=0 && (*rItTSoS)->measurementOnTrack()!=0)
1056 {
1057 trkPara = (*rItTSoS)->trackParameters();
1058 }
1059 }
1060
1061 if (trkPara !=0 ){
1062 m_electronLMQoverP[fitter][m_electronCounter] = trkPara->parameters()[Trk::qOverP] ;
1063 return true;
1064 }
1065
1066 return false;
1067
1068}
1069
1071bool IDPerfMonEoverP::passZeeSelection(std::vector<int>& electrons)
1072{
1073 ATH_MSG_VERBOSE("In passZeeSelection() -- START -- ");
1074 //ATH_MSG_WARNING("Zee seletion needs to be adjusted for run2");
1075 // Adjusted according to https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/WZCommonAnalysisTopics2015
1076 if(m_nbpv<1) {
1077 ATH_MSG_DEBUG (" -- passZeeSelection() -- failing on primary vertices: m_nbpv= " << m_nbpv);
1078 return false;
1079 }
1080
1081 bool primaryVertexOk(false);
1082 electrons.clear();
1083
1084 for (int i=0; i<m_nbpv; ++i){
1085 if (m_pvnbtk[i] > 2) primaryVertexOk = true;
1086 }
1087 if(!primaryVertexOk) {
1088 ATH_MSG_DEBUG (" -- passZeeSelection() -- failing on primary vertices");
1089 return false;
1090 }
1091 //Trigger
1092 //No need to pass the trigger for tracking performance studies
1093
1094 //Loose electron selection
1095 std::vector<int> goodLooseElectrons;
1096
1097 for(int ele=0; ele<m_nelectrons; ele++){
1098 //Loose electron selection
1099 if (!m_IsEMLoose[ele]) continue;
1100 //Pt
1101 double clusterEt = cosh( m_ClusterEta[ele] ) != 0 ? m_ClusterEnergy[ele] / std::cosh( m_ClusterEta[ele] ) : 0.;
1102 if (clusterEt <= 25000) continue;
1103
1104 //Range
1105 double absEta = std::abs(m_ClusterEta[ele]);
1106 if (absEta >= 2.47 || ( absEta >= 1.37 && absEta <= 1.52 )) continue;
1107
1108 //OTx ...
1109 if(!m_isGoodOQ[ele]) continue;
1110
1111 //Author
1112 if(m_author[ele]!=1 && m_author[ele]!=3) continue;
1113
1114 goodLooseElectrons.push_back(ele);
1115 }
1116
1117 int pairsLooseInMassWindow = 0;
1118
1119 ATH_MSG_DEBUG(" -- passZeeSelection() -- report -- N Loose electrons " << goodLooseElectrons.size());
1120
1121 //Fill Loose electron ET spectrum;
1122 for(int gele1 = 0; gele1 < (int)goodLooseElectrons.size()-1; ++gele1){
1123 for(int gele2 = gele1+1; gele2 < (int)goodLooseElectrons.size(); ++gele2){
1124 int ele1 = goodLooseElectrons[gele1];
1125 int ele2 = goodLooseElectrons[gele2];
1126 double mass = getMassCluster(ele1,ele2);
1127 if (mass > 60000 && mass < 120000){
1128 ++pairsLooseInMassWindow;
1129 if(m_electronQoverP[0][ele1]*m_electronQoverP[0][ele2]<0)
1130 m_ZeeLooseMassOS_Cluster->Fill(mass);
1131 else
1132 m_ZeeLooseMassSS_Cluster->Fill(mass);
1133 }
1134 }
1135 }
1136
1137 if (pairsLooseInMassWindow < 1) {
1138 ATH_MSG_DEBUG (" -- passZeeSelection() -- failing pairsLooseInMassWindow= " << pairsLooseInMassWindow );
1139 return false;
1140 }
1141 std::vector<int> goodMediumElectrons;
1142
1143 for(int gele = 0; gele < (int)goodLooseElectrons.size(); ++gele){
1144 int ele = goodLooseElectrons[gele];
1145 if(m_IsEMMedium[ele]){
1146 goodMediumElectrons.push_back(ele);
1147 }
1148 }
1149
1150 //Reject events with more than two good electrons
1151 if (goodMediumElectrons.size() != 2) {
1152 ATH_MSG_DEBUG (" -- passZeeSelection() -- failing goodMediumElectrons != 2 --> " << goodMediumElectrons.size());
1153 return false;
1154 }
1155
1156 // Make the mass out of the highest pt electrons ....
1157 double mass = getMassCluster(goodMediumElectrons[0],goodMediumElectrons[1]);
1158 if (mass > 66000 && mass < 116000){
1159 if(m_electronQoverP[0][goodMediumElectrons[0]]*m_electronQoverP[0][goodMediumElectrons[1]]<0){
1160 m_ZeeMediumMassOS_Cluster->Fill(mass);
1161 electrons.push_back(goodMediumElectrons[0]);
1162 electrons.push_back(goodMediumElectrons[1]);
1163
1164 double trackEt = m_ClusterEnergy[goodMediumElectrons[0]]*sin(m_electronTheta[0][goodMediumElectrons[0]]);
1165 m_ZeeMediumOS_ClusterPtEta->Fill(trackEt, m_ClusterEta[0] );
1166 trackEt = m_ClusterEnergy[goodMediumElectrons[1]]*sin(m_electronTheta[0][goodMediumElectrons[1]]);
1167 m_ZeeMediumOS_ClusterPtEta->Fill(trackEt, m_ClusterEta[1] );
1168
1169 return true;
1170 } else{
1171 m_ZeeMediumMassSS_Cluster->Fill(mass);
1172 return false;
1173 }
1174 }
1175 return false;
1176}
1177
1179bool IDPerfMonEoverP::passWenuSelection(std::vector<int>& electrons)
1180{
1181 ATH_MSG_VERBOSE("In passWenuSelection() -- START -- ");
1182 if(m_nbpv<1) return false;
1183 bool primaryVertexOk(false);
1184 electrons.clear();
1185
1186 for (int i(0); i<m_nbpv; ++i){
1187 if (m_pvnbtk[i] > 2) primaryVertexOk = true;
1188 }
1189 if(!primaryVertexOk) {
1190 ATH_MSG_DEBUG (" -- passWenuSelection() -- failing on primary vertices");
1191 return false;
1192 }
1193
1194 //MET Goodness
1195 if( m_isDATA && !m_METgoodness) {
1196 ATH_MSG_DEBUG (" -- passWenuSelection() -- failing on m_isDATA && !m_METgoodness");
1197 return false;
1198 }
1199
1200 //Trigger
1201 //no need to pass trigger for perfromance studies
1202
1203
1204 //Loose electron selection
1205 std::vector<int> goodLooseElectrons;
1206 for(int ele(0); ele<m_nelectrons; ++ele){
1207 //Loose electron selection
1208 if (!m_IsEMLoose[ele]) continue;
1209 //Pt
1210 double clusterEt = cosh( m_ClusterEta[ele] ) != 0 ? m_ClusterEnergy[ele] / std::cosh( m_ClusterEta[ele] ) : 0.;
1211 if (clusterEt <= 25000) continue;
1212 //Range
1213 double absEta = std::abs(m_ClusterEta[ele]);
1214 if (absEta >= 2.47 || ( absEta >= 1.37 && absEta <= 1.52 ) ) continue;
1215 //OTx ...
1216 if(!m_isGoodOQ[ele]) continue;
1217 //Author
1218 if(m_author[ele]!=1 && m_author[ele]!=3) continue;
1219 goodLooseElectrons.push_back(ele);
1220 }
1221
1222 //Fill Loose electron ET spectrum;
1223 for(int gele(0); gele < (int) goodLooseElectrons.size(); ++gele){
1224 int ele = goodLooseElectrons[gele];
1225 double trackEt = m_ClusterEnergy[gele]*sin(m_electronTheta[0][ele]);
1226 m_WenuLooseElectronET->Fill(trackEt);
1227 }
1228
1229 int nMediumElectrons(0);
1230 int nTightElectrons(0);
1231 int tightElectron(0);
1232
1233 for(int gele(0); gele < (int) goodLooseElectrons.size(); ++gele){
1234 //
1235 int ele = goodLooseElectrons[gele];
1236 if(m_IsEMMedium[ele]) ++nMediumElectrons;
1237 if (!m_IsEMTight[ele]) continue;
1238 ++nTightElectrons;
1239 tightElectron = ele;
1240 }
1241
1242 //Reject events with more than one good electron
1243 if (nMediumElectrons >2) {
1244 ATH_MSG_DEBUG (" -- passWenuSelection() -- failing number of medium electrons cut " << nMediumElectrons );
1245 return false;
1246 }
1247 //Reject events with no tight electrons;
1248 if (nTightElectrons <1) {
1249 ATH_MSG_DEBUG (" -- passWenuSelection() -- failing number of tight electrons cut " << nTightElectrons );
1250 return false;
1251 }
1252 double metphi = atan2(m_missingEty,m_missingEtx);
1253 double trackEt = m_ClusterEnergy[tightElectron]*std::sin(m_electronTheta[0][tightElectron]);
1254 double clusterEt = std::cosh( m_ClusterEta[tightElectron] ) !=0 ? m_ClusterEnergy[tightElectron] / std::cosh( m_ClusterEta[tightElectron] ) : 0.;
1255
1256 double massT = 2*m_missingEt*trackEt*(1-cos(m_electronPhi[0][tightElectron]-metphi));
1257 if(massT > 0) massT =std::sqrt(massT);
1258 else massT = 0;
1259
1260
1261 m_WenuTight_Met->Fill(m_missingEt);
1262 m_WenuTight_MT->Fill(massT);
1263
1264 if (m_missingEt <= 25000) {
1265 ATH_MSG_DEBUG (" -- passWenuSelection() -- failing missingEt cut " << m_missingEt );
1266 return false;
1267 }
1268 m_WenuTightMet_MT->Fill(massT);
1269
1270 if (massT <= 50000) {
1271 ATH_MSG_DEBUG (" -- passWenuSelection() -- failing transverse mass cut " << massT );
1272 return false;
1273 }
1274
1275 m_WenuTightElectronET->Fill(clusterEt);
1276
1277 double sumpx = m_ClusterEnergy[tightElectron]*std::sin( m_electronPhi[0][tightElectron] ) * std::sin(m_electronTheta[0][tightElectron]) + m_missingEtx;
1278 double sumpy = m_ClusterEnergy[tightElectron]*std::cos( m_electronPhi[0][tightElectron] ) * std::sin(m_electronTheta[0][tightElectron]) + m_missingEty;
1279
1280 double wpt = sumpx*sumpx +sumpy*sumpy - massT*massT;
1281 if(wpt > 0) wpt =std::sqrt(wpt);
1282 else wpt = 0;
1283
1284 m_WenuTightW_PT->Fill(wpt);
1285
1286
1287 if(m_electronQoverP[0][tightElectron] > 0){
1288 m_WenuTightElectron_PTEtaPos->Fill(trackEt,m_ClusterEta[tightElectron]);
1289 } else {
1290 m_WenuTightElectron_PTEtaNeg->Fill(trackEt,m_ClusterEta[tightElectron]);
1291 }
1292
1293 electrons.push_back(tightElectron);
1294
1295 ATH_MSG_VERBOSE("In passWenuSelection() -- completed -- ");
1296 return true;
1297}
1298
1299double IDPerfMonEoverP::getMassCluster(int el1, int el2)
1300{
1301 ATH_MSG_VERBOSE("In getMassCluster()");
1302 double ELECTRON_MASS = ParticleConstants::electronMassInMeV; //MeV
1303 TLorentzVector v0,v1;
1304 double pt1 = m_ClusterEnergy[el1]*std::sin(m_electronTheta[0][el1]);
1305 double pt2 = m_ClusterEnergy[el2]*std::sin(m_electronTheta[0][el2]);
1306 double eta1 = -std::log( std::tan(m_electronTheta[0][el1] * 0.5) );
1307 double eta2 = -std::log( std::tan(m_electronTheta[0][el2] * 0.5) );
1308 v0.SetPtEtaPhiM(pt1,eta1,m_electronPhi[0][el1], ELECTRON_MASS);
1309 v1.SetPtEtaPhiM(pt2,eta2,m_electronPhi[0][el2], ELECTRON_MASS);
1310 double mass = (v0+v1).M();
1311 return mass;
1312
1313}
1314
1315std::vector<int> IDPerfMonEoverP::FillSimpleTree()
1316{
1317 ATH_MSG_VERBOSE("In fillSimpleTree()");
1318 std::vector<int> electronsZee;
1319 std::vector<int> electronsWenu;
1320
1321 // check if Zee or Wenu event
1322 passZeeSelection(electronsZee);
1323 passWenuSelection(electronsWenu);
1324
1325 std::vector<int> allInterestingElectrons;
1326 for(int i(0); i < (int)electronsZee.size(); ++i){
1327 int ele = electronsZee[i];
1328 if ( std::find(allInterestingElectrons.begin(), allInterestingElectrons.end(), ele)==allInterestingElectrons.end() ){
1329 allInterestingElectrons.push_back(ele);
1330 }
1331 }
1332 for(int i(0); i < (int)electronsWenu.size(); ++i){
1333 int ele = electronsWenu[i];
1334 if ( std::find(allInterestingElectrons.begin(), allInterestingElectrons.end(), ele)==allInterestingElectrons.end() ){
1335 allInterestingElectrons.push_back(ele);
1336 }
1337 }
1338 ATH_MSG_DEBUG(" SimpleTreeElectrons " << allInterestingElectrons.size() );
1339 for(int i(0); i < (int)allInterestingElectrons.size(); ++i){
1340 int ele = allInterestingElectrons[i];
1341 if (m_electronQoverP[0][ele] > 0 )
1342 m_smallCharge = 1.;
1343 else
1344 m_smallCharge =-1.;
1345 m_smallTrackTheta = m_electronTheta[0][ele];
1346 m_small_QoverP = m_electronQoverP[0][ele];
1347 m_small1_QoverP = m_electronQoverP[1][ele];
1348 m_small2_QoverP = m_electronQoverP[2][ele];
1349 m_smallClusterEnergy = m_ClusterEnergy[ele];
1350 m_smallClusterPhi = m_ClusterPhi[ele];
1351 m_smallClusterEta = m_ClusterEta[ele];
1352 m_smallValidationTree->Fill();
1353 }
1354
1355 return allInterestingElectrons;
1356}
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_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition AthMsgStreamMacros.h:28
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition Control/AthenaKernel/AthenaKernel/errorcheck.h:422
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition EventPrimitives.h:50
NO_PV
#define NO_PV
Definition IDPerfMonEoverP.h:76
VxPos
std::pair< const xAOD::Vertex *, int > VxPos
Definition IDPerfMonEoverP.h:78
NOS_ELECTRONS
#define NOS_ELECTRONS
Definition IDPerfMonEoverP.h:75
sc
static Double_t sc
Definition LArPhysWaveHECTool.cxx:37
ParticleConstants.h
A number of constexpr particle constants to avoid hardcoding them directly in various places.
TrackCollection
DataVector< Trk::Track > TrackCollection
This typedef represents a collection of Trk::Track objects.
Definition TrackCollection.h:19
AsgElectronLikelihoodTool
Electron selector tool to select objects in Athena using an underlying pure ROOT tool.
Definition AsgElectronLikelihoodTool.h:30
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< xAOD::Electron_v1 >::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:838
DataVector::rend
const_reverse_iterator rend() const noexcept
Return a const_reverse_iterator pointing at the beginning of the collection.
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::rbegin
const_reverse_iterator rbegin() const noexcept
Return a const_reverse_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< const Trk::TrackStateOnSurface >::const_reverse_iterator
std::reverse_iterator< const_iterator > const_reverse_iterator
Definition DataVector.h:847
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
IDPerfMonEoverP::m_pvy
float m_pvy[NO_PV]
Definition IDPerfMonEoverP.h:253
IDPerfMonEoverP::m_electronErrd0
float m_electronErrd0[3][NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:214
IDPerfMonEoverP::m_evt
SG::ReadHandleKey< xAOD::EventInfo > m_evt
ReadHandle to the Event Info.
Definition IDPerfMonEoverP.h:155
IDPerfMonEoverP::fillGeneral
void fillGeneral(const xAOD::Electron *eg)
Definition IDPerfMonEoverP.cxx:752
IDPerfMonEoverP::m_missingEtObjectName
std::string m_missingEtObjectName
MET input name.
Definition IDPerfMonEoverP.h:142
IDPerfMonEoverP::m_PID_ShowerType_Names
std::vector< std::pair< xAOD::EgammaParameters::ShowerShapeType, std::string > > m_PID_ShowerType_Names
Definition IDPerfMonEoverP.h:275
IDPerfMonEoverP::m_ZeeMediumMassOS_Cluster
TH1F * m_ZeeMediumMassOS_Cluster
Definition IDPerfMonEoverP.h:288
IDPerfMonEoverP::m_nTRT
int m_nTRT[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:218
IDPerfMonEoverP::m_OutputTrackCollectionName_no2
std::string m_OutputTrackCollectionName_no2
Definition IDPerfMonEoverP.h:148
IDPerfMonEoverP::m_nTRTout
int m_nTRTout[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:222
IDPerfMonEoverP::m_WenuTightElectron_PTEtaNeg
TH2F * m_WenuTightElectron_PTEtaNeg
validation tree name - to be acessed by this from root
Definition IDPerfMonEoverP.h:299
IDPerfMonEoverP::m_LHToolLoose2015
AsgElectronLikelihoodTool * m_LHToolLoose2015
Definition IDPerfMonEoverP.h:330
IDPerfMonEoverP::m_nBLayer
int m_nBLayer[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:220
IDPerfMonEoverP::m_ePID_ShowerType
float m_ePID_ShowerType[50][NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:270
IDPerfMonEoverP::m_ClusterPhi
float m_ClusterPhi[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:233
IDPerfMonEoverP::getMassCluster
double getMassCluster(int el1, int el2)
Definition IDPerfMonEoverP.cxx:1299
IDPerfMonEoverP::m_smallValidationTree
TTree * m_smallValidationTree
Definition IDPerfMonEoverP.h:309
IDPerfMonEoverP::m_smallValidationTreeName
std::string m_smallValidationTreeName
validation tree description - second argument in TTree
Definition IDPerfMonEoverP.h:303
IDPerfMonEoverP::m_ePID_SummaryType
float m_ePID_SummaryType[50][NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:273
IDPerfMonEoverP::m_PID_SummaryType_Names
std::vector< std::pair< xAOD::SummaryType, std::string > > m_PID_SummaryType_Names
Definition IDPerfMonEoverP.h:278
IDPerfMonEoverP::m_covpvxpvy
float m_covpvxpvy[NO_PV]
Definition IDPerfMonEoverP.h:258
IDPerfMonEoverP::addToValidationNtuple
void addToValidationNtuple(const Trk::Perigee *, const xAOD::CaloCluster *, int isOrginal)
addToValidationNutple
Definition IDPerfMonEoverP.cxx:694
IDPerfMonEoverP::m_ZeeMediumMassSS_Cluster
TH1F * m_ZeeMediumMassSS_Cluster
Definition IDPerfMonEoverP.h:289
IDPerfMonEoverP::fillIsEM
void fillIsEM(const xAOD::Electron *eg)
Definition IDPerfMonEoverP.cxx:722
IDPerfMonEoverP::m_TrackRefitter
ToolHandle< IegammaTrkRefitterTool > m_TrackRefitter
The track refitter.
Definition IDPerfMonEoverP.h:158
IDPerfMonEoverP::m_validationTreeName
std::string m_validationTreeName
validation tree description - second argument in TTree
Definition IDPerfMonEoverP.h:185
IDPerfMonEoverP::m_electronEta
float m_electronEta[3][NOS_ELECTRONS]
Track Eta at perigee.
Definition IDPerfMonEoverP.h:203
IDPerfMonEoverP::passMETCleaningCuts
bool passMETCleaningCuts() const
Definition IDPerfMonEoverP.cxx:883
IDPerfMonEoverP::m_electrond0
float m_electrond0[3][NOS_ELECTRONS]
Track Phi on electron.
Definition IDPerfMonEoverP.h:206
IDPerfMonEoverP::findAssociatedVertex
VxPos findAssociatedVertex(std::map< const xAOD::TrackParticle *, VxPos > &trackParticleVertexMap, const xAOD::Vertex *primaryVertexFirstCandidate, const xAOD::Electron *) const
Definition IDPerfMonEoverP.cxx:982
IDPerfMonEoverP::m_jetCleaningTool
ToolHandle< IJetSelector > m_jetCleaningTool
jet selector tool
Definition IDPerfMonEoverP.h:168
IDPerfMonEoverP::m_WenuTightElectron_PTEtaPos
TH2F * m_WenuTightElectron_PTEtaPos
Definition IDPerfMonEoverP.h:298
IDPerfMonEoverP::m_ZeeLooseMassSS_Cluster
TH1F * m_ZeeLooseMassSS_Cluster
Definition IDPerfMonEoverP.h:287
IDPerfMonEoverP::m_ePID_TrackCaloMatchType
float m_ePID_TrackCaloMatchType[50][NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:272
IDPerfMonEoverP::initialize
StatusCode initialize()
Gaudi algorithm hooks.
Definition IDPerfMonEoverP.cxx:150
IDPerfMonEoverP::m_refittedTracks_no2
TrackCollection * m_refittedTracks_no2
Definition IDPerfMonEoverP.h:152
IDPerfMonEoverP::m_electronz0
float m_electronz0[3][NOS_ELECTRONS]
Track q over p on electron.
Definition IDPerfMonEoverP.h:207
IDPerfMonEoverP::m_covpvzpvx
float m_covpvzpvx[NO_PV]
Definition IDPerfMonEoverP.h:260
IDPerfMonEoverP::m_nSCT
int m_nSCT[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:219
IDPerfMonEoverP::~IDPerfMonEoverP
~IDPerfMonEoverP()
Destructor.
Definition IDPerfMonEoverP.cxx:141
IDPerfMonEoverP::m_primaryVertexCollection
std::string m_primaryVertexCollection
Primary vertex input name.
Definition IDPerfMonEoverP.h:144
IDPerfMonEoverP::m_evtNumber
unsigned int m_evtNumber
Definition IDPerfMonEoverP.h:195
IDPerfMonEoverP::m_smallValidationTreeDescription
std::string m_smallValidationTreeDescription
stream/folder to for the TTree to be written out
Definition IDPerfMonEoverP.h:305
IDPerfMonEoverP::m_nPIX
int m_nPIX[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:221
IDPerfMonEoverP::m_ePID_IsolationType
float m_ePID_IsolationType[50][NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:271
IDPerfMonEoverP::m_lumi_block
unsigned int m_lumi_block
Definition IDPerfMonEoverP.h:196
IDPerfMonEoverP::m_IsEMMedium
bool m_IsEMMedium[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:236
IDPerfMonEoverP::m_refittedTracks_no1
TrackCollection * m_refittedTracks_no1
Refitted track collection.
Definition IDPerfMonEoverP.h:151
IDPerfMonEoverP::m_InputElectronContainerName
std::string m_InputElectronContainerName
Electron collection input name.
Definition IDPerfMonEoverP.h:135
IDPerfMonEoverP::m_electronErrz0
float m_electronErrz0[3][NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:215
IDPerfMonEoverP::m_electronPhi
float m_electronPhi[3][NOS_ELECTRONS]
Track Phi on electron.
Definition IDPerfMonEoverP.h:204
IDPerfMonEoverP::m_pvsumpt
float m_pvsumpt[NO_PV]
Definition IDPerfMonEoverP.h:251
IDPerfMonEoverP::m_validationTreeFolder
std::string m_validationTreeFolder
Root Validation Tree.
Definition IDPerfMonEoverP.h:189
IDPerfMonEoverP::m_errpvy
float m_errpvy[NO_PV]
Definition IDPerfMonEoverP.h:256
IDPerfMonEoverP::m_PID_IsolationType_Names
std::vector< std::pair< xAOD::Iso::IsolationType, std::string > > m_PID_IsolationType_Names
Definition IDPerfMonEoverP.h:276
IDPerfMonEoverP::m_validationMode
bool m_validationMode
< boolean to switch to validation mode
Definition IDPerfMonEoverP.h:178
IDPerfMonEoverP::m_author
int m_author[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:229
IDPerfMonEoverP::m_associatedToVtx
int m_associatedToVtx[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:244
IDPerfMonEoverP::m_nTRTHT
int m_nTRTHT[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:225
IDPerfMonEoverP::m_IsEMTight
bool m_IsEMTight[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:237
IDPerfMonEoverP::m_electronErrPhi
float m_electronErrPhi[3][NOS_ELECTRONS]
Track phi error on electron.
Definition IDPerfMonEoverP.h:212
IDPerfMonEoverP::m_isGoodOQ
bool m_isGoodOQ[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:239
IDPerfMonEoverP::m_IsEMTightTRT
bool m_IsEMTightTRT[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:238
IDPerfMonEoverP::finalize
StatusCode finalize()
Definition IDPerfMonEoverP.cxx:473
IDPerfMonEoverP::m_ClusterEnergy
float m_ClusterEnergy[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:231
IDPerfMonEoverP::m_electronErrTheta
float m_electronErrTheta[3][NOS_ELECTRONS]
Track theta error on electron.
Definition IDPerfMonEoverP.h:211
IDPerfMonEoverP::m_OutputTrackCollectionName_no1
std::string m_OutputTrackCollectionName_no1
Name of output of Refitted Inner Detector Tracks.
Definition IDPerfMonEoverP.h:147
IDPerfMonEoverP::m_electronCounter
int m_electronCounter
counter for electrons
Definition IDPerfMonEoverP.h:200
IDPerfMonEoverP::m_ZeeMediumOS_ClusterPtEta
TH2F * m_ZeeMediumOS_ClusterPtEta
Definition IDPerfMonEoverP.h:290
IDPerfMonEoverP::m_pvx
float m_pvx[NO_PV]
Definition IDPerfMonEoverP.h:252
IDPerfMonEoverP::m_metRefFinalName
std::string m_metRefFinalName
Definition IDPerfMonEoverP.h:137
IDPerfMonEoverP::fillElectronInfo
void fillElectronInfo(const xAOD::Electron *p)
Definition IDPerfMonEoverP.cxx:1016
IDPerfMonEoverP::m_nSCTout
int m_nSCTout[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:223
IDPerfMonEoverP::m_lhTune
std::string m_lhTune
Definition IDPerfMonEoverP.h:329
IDPerfMonEoverP::m_electronLMQoverP
float m_electronLMQoverP[3][NOS_ELECTRONS]
Track q over p on electron.
Definition IDPerfMonEoverP.h:209
IDPerfMonEoverP::fillLastMeasurement
bool fillLastMeasurement(const Trk::Track *track, const int fitter)
Definition IDPerfMonEoverP.cxx:1037
IDPerfMonEoverP::m_LHToolTight2015
AsgElectronLikelihoodTool * m_LHToolTight2015
Definition IDPerfMonEoverP.h:332
IDPerfMonEoverP::IDPerfMonEoverP
IDPerfMonEoverP(const std::string &name, ISvcLocator *pSvcLocator)
Default constructor.
Definition IDPerfMonEoverP.cxx:59
IDPerfMonEoverP::m_runNumber
unsigned int m_runNumber
Definition IDPerfMonEoverP.h:194
IDPerfMonEoverP::m_pvz
float m_pvz[NO_PV]
Definition IDPerfMonEoverP.h:254
IDPerfMonEoverP::FillSimpleTree
std::vector< int > FillSimpleTree()
Definition IDPerfMonEoverP.cxx:1315
IDPerfMonEoverP::m_covpvypvz
float m_covpvypvz[NO_PV]
Definition IDPerfMonEoverP.h:259
IDPerfMonEoverP::m_ZeeLooseMassOS_Cluster
TH1F * m_ZeeLooseMassOS_Cluster
Definition IDPerfMonEoverP.h:286
IDPerfMonEoverP::m_trigDec
ToolHandle< Trig::TrigDecisionTool > m_trigDec
The trigger decision tool.
Definition IDPerfMonEoverP.h:164
IDPerfMonEoverP::m_ClusterEta
float m_ClusterEta[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:232
IDPerfMonEoverP::m_nTRTHTout
int m_nTRTHTout[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:226
IDPerfMonEoverP::m_nPIXout
int m_nPIXout[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:224
IDPerfMonEoverP::fillVertexInformation
bool fillVertexInformation(std::map< const xAOD::TrackParticle *, VxPos > &trackParticleVertexMap, xAOD::Vertex const *&primaryVertexFirstCandidate)
Definition IDPerfMonEoverP.cxx:901
IDPerfMonEoverP::m_electronQoverP
float m_electronQoverP[3][NOS_ELECTRONS]
Track q over p on electron.
Definition IDPerfMonEoverP.h:205
IDPerfMonEoverP::passWenuSelection
bool passWenuSelection(std::vector< int > &electrons)
Definition IDPerfMonEoverP.cxx:1179
IDPerfMonEoverP::m_errpvz
float m_errpvz[NO_PV]
Definition IDPerfMonEoverP.h:257
IDPerfMonEoverP::passZeeSelection
bool passZeeSelection(std::vector< int > &electrons)
Definition IDPerfMonEoverP.cxx:1071
IDPerfMonEoverP::m_fillDetailedTree
bool m_fillDetailedTree
validation tree name - to be acessed by this from root
Definition IDPerfMonEoverP.h:181
IDPerfMonEoverP::m_LHToolMedium2015
AsgElectronLikelihoodTool * m_LHToolMedium2015
Definition IDPerfMonEoverP.h:331
IDPerfMonEoverP::m_electronTheta
float m_electronTheta[3][NOS_ELECTRONS]
Track theta at perigee.
Definition IDPerfMonEoverP.h:202
IDPerfMonEoverP::m_electronErrQoverP
float m_electronErrQoverP[3][NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:213
IDPerfMonEoverP::m_jetContainerName
std::string m_jetContainerName
JEt collection input name.
Definition IDPerfMonEoverP.h:140
IDPerfMonEoverP::m_errpvx
float m_errpvx[NO_PV]
Definition IDPerfMonEoverP.h:255
IDPerfMonEoverP::m_IsEMLoose
bool m_IsEMLoose[NOS_ELECTRONS]
Definition IDPerfMonEoverP.h:235
IDPerfMonEoverP::m_triggerNames
std::vector< std::string > m_triggerNames
Definition IDPerfMonEoverP.h:283
IDPerfMonEoverP::m_validationTreeDescription
std::string m_validationTreeDescription
stream/folder to for the TTree to be written out
Definition IDPerfMonEoverP.h:187
IDPerfMonEoverP::m_smallValidationTreeFolder
std::string m_smallValidationTreeFolder
Root Validation Tree.
Definition IDPerfMonEoverP.h:307
IDPerfMonEoverP::m_PID_TrackCaloMatchType_Names
std::vector< std::pair< xAOD::EgammaParameters::TrackCaloMatchType, std::string > > m_PID_TrackCaloMatchType_Names
Definition IDPerfMonEoverP.h:277
IDPerfMonEoverP::deleteAction
void deleteAction() const
Definition IDPerfMonEoverP.cxx:834
IDPerfMonEoverP::m_TrackRefitter_no2
ToolHandle< IegammaTrkRefitterTool > m_TrackRefitter_no2
The track refitter.
Definition IDPerfMonEoverP.h:161
Trk::ParametersBase::eta
double eta() const
Access method for pseudorapidity - from momentum.
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition TrackStateOnSurface.h:101
Trk::Track::perigeeParameters
const Perigee * perigeeParameters() const
return Perigee.
Definition Tracking/TrkEvent/TrkTrack/src/Track.cxx:163
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition CaloCluster_v1.cxx:251
xAOD::CaloCluster_v1::e
virtual double e() const
The total energy of the particle.
Definition CaloCluster_v1.cxx:265
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition CaloCluster_v1.cxx:256
xAOD::Egamma_v1::author
uint16_t author(uint16_t bitmask=EgammaParameters::AuthorALL) const
Get author.
Definition Egamma_v1.cxx:155
xAOD::Egamma_v1::caloCluster
const xAOD::CaloCluster * caloCluster(size_t index=0) const
Pointer to the xAOD::CaloCluster/s that define the electron candidate.
Definition Egamma_v1.cxx:377
xAOD::Electron_v1::trackParticle
const xAOD::TrackParticle * trackParticle(size_t index=0) const
Pointer to the xAOD::TrackParticle/s that match the electron candidate.
Definition Electron_v1.cxx:60
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:415
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:734
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition TrackParticle_v1.cxx:666
xAOD::Vertex_v1::type
Type::ObjectType type() const
A little helper function for identifying the type in template code.
Definition Vertex_v1.cxx:58
xAOD::Vertex_v1::position
const Amg::Vector3D & position() const
Returns the 3-pos.
contains
bool contains(const std::string &s, const std::string &regx)
does a string contain the substring
Definition hcg.cxx:114
MET
Definition MET.py:1
ParticleConstants::PDG2011::electronMassInMeV
constexpr double electronMassInMeV
the mass of the electron (in MeV)
Definition ParticleConstants.h:26
Trk
Ensure that the ATLAS eigen extensions are properly loaded.
Definition FakeTrackBuilder.h:9
Trk::TrackStates
DataVector< const Trk::TrackStateOnSurface > TrackStates
Definition Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:30
Trk::Perigee
ParametersT< TrackParametersDim, Charged, PerigeeSurface > Perigee
Definition Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h:33
Trk::phi0
@ phi0
Definition ParamDefs.h:65
Trk::theta
@ theta
Definition ParamDefs.h:66
Trk::qOverP
@ qOverP
perigee
Definition ParamDefs.h:67
Trk::d0
@ d0
Definition ParamDefs.h:63
Trk::z0
@ z0
Definition ParamDefs.h:64
Trk::TrackParameters
ParametersBase< TrackParametersDim, Charged > TrackParameters
Definition Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h:27
std
STL namespace.
xAOD::EgammaParameters::BADCLUSELECTRON
const uint32_t BADCLUSELECTRON
Definition EgammaDefs.h:116
xAOD::EgammaParameters::AuthorElectron
const uint16_t AuthorElectron
Object Reconstructed by standard cluster-based algorithm.
Definition EgammaDefs.h:24
xAOD::Iso
Namespace holding the IsolationType enumeration.
Definition IsolationConeSize.h:13
xAOD::ElectronContainer
ElectronContainer_v1 ElectronContainer
Definition of the current "electron container version".
Definition Event/xAOD/xAODEgamma/xAODEgamma/ElectronContainer.h:17
xAOD::MissingET
MissingET_v1 MissingET
Version control by type defintion.
Definition Event/xAOD/xAODMissingET/xAODMissingET/MissingET.h:15
xAOD::CaloCluster
CaloCluster_v1 CaloCluster
Define the latest version of the calorimeter cluster class.
Definition Event/xAOD/xAODCaloEvent/xAODCaloEvent/CaloCluster.h:19
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::JetContainer
JetContainer_v1 JetContainer
Definition of the current "jet container version".
Definition JetContainer.h:17
xAOD::SummaryType
SummaryType
Enumerates the different types of information stored in Summary.
Definition TrackingPrimitives.h:229
xAOD::numberOfTRTHighThresholdOutliers
@ numberOfTRTHighThresholdOutliers
number of TRT high threshold outliers (only xenon counted) [unit8_t].
Definition TrackingPrimitives.h:282
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition TrackingPrimitives.h:276
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition TrackingPrimitives.h:269
xAOD::numberOfSCTOutliers
@ numberOfSCTOutliers
number of SCT outliers [unit8_t].
Definition TrackingPrimitives.h:270
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition TrackingPrimitives.h:238
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition TrackingPrimitives.h:260
xAOD::numberOfTRTHighThresholdHits
@ numberOfTRTHighThresholdHits
number of TRT hits which pass the high threshold (only xenon counted) [unit8_t].
Definition TrackingPrimitives.h:279
xAOD::numberOfTRTOutliers
@ numberOfTRTOutliers
number of TRT outliers [unit8_t].
Definition TrackingPrimitives.h:277
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition Event/xAOD/xAODEgamma/xAODEgamma/Electron.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
IegammaTrkRefitterTool::Cache::refittedTrackPerigee
const Trk::Perigee * refittedTrackPerigee
Pointer to the refitted MeasuredPerigee.
Definition IegammaTrkRefitterTool.h:43
type
Generated on for ATLAS Offline Software by doxygen 1.14.0