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