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