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