ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
IDPerfMonEoverP Class Reference

#include <IDPerfMonEoverP.h>

Inheritance diagram for IDPerfMonEoverP:
Collaboration diagram for IDPerfMonEoverP:

Public Member Functions

 IDPerfMonEoverP (const std::string &name, ISvcLocator *pSvcLocator)
 Default constructor. More...
 
 ~IDPerfMonEoverP ()
 Destructor. More...
 
StatusCode initialize ()
 Gaudi algorithm hooks. More...
 
StatusCode finalize ()
 
StatusCode execute ()
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

void addToValidationNtuple (const Trk::Perigee *, const xAOD::CaloCluster *, int isOrginal)
 addToValidationNutple More...
 
void clearValidationNtuple ()
 
void validationAction ()
 
void deleteAction () const
 
void fillIsEM (const xAOD::Electron *eg)
 
void fillGeneral (const xAOD::Electron *eg)
 
bool passMETCleaningCuts () const
 
bool fillVertexInformation (std::map< const xAOD::TrackParticle *, VxPos > &trackParticleVertexMap, xAOD::Vertex const *&primaryVertexFirstCandidate)
 
bool storeMETinformation ()
 
VxPos findAssociatedVertex (std::map< const xAOD::TrackParticle *, VxPos > &trackParticleVertexMap, const xAOD::Vertex *primaryVertexFirstCandidate, const xAOD::Electron *) const
 
void extrapolateToTheCalo (const Trk::TrackParameters *trkPar, const xAOD::CaloCluster *cluster, double *eta, double *phi, double *deltaEta, double *delatPhi)
 
void fillElectronInfo (const xAOD::Electron *p)
 
void fillTriggerInformation ()
 
bool fillLastMeasurement (const Trk::Track *track, const int fitter)
 
double correctIP_PV (int electron_i, bool do_d0)
 
std::vector< int > FillSimpleTree ()
 
bool passWenuSelection (std::vector< int > &electrons)
 
bool passZeeSelection (std::vector< int > &electrons)
 
double getMassCluster (int el1, int el2)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

std::string m_InputElectronContainerName
 Electron collection input name. More...
 
std::string m_metRefFinalName
 
std::string m_jetContainerName
 JEt collection input name. More...
 
std::string m_missingEtObjectName
 MET input name. More...
 
std::string m_primaryVertexCollection
 Primary vertex input name. More...
 
std::string m_OutputTrackCollectionName_no1
 Name of output of Refitted Inner Detector Tracks. More...
 
std::string m_OutputTrackCollectionName_no2
 
TrackCollection * m_refittedTracks_no1
 Refitted track collection. More...
 
TrackCollection * m_refittedTracks_no2
 
SG::ReadHandleKey< xAOD::EventInfo > m_evt {this, "EvtInfo", "EventInfo", "EventInfo name"}
 ReadHandle to the Event Info. More...
 
ToolHandle< IegammaTrkRefitterTool > m_TrackRefitter
 The track refitter. More...
 
ToolHandle< IegammaTrkRefitterTool > m_TrackRefitter_no2
 The track refitter. More...
 
ToolHandle< Trig::TrigDecisionTool > m_trigDec
 The trigger decision tool. More...
 
ToolHandle< IJetSelector > m_jetCleaningTool {this,"JetCleaningTool","JetCleaningTool/JetCleaningTool",""}
 jet selector tool More...
 
bool m_refitEverything
 
bool m_isDATA
 
bool m_validationMode
 < boolean to switch to validation mode More...
 
bool m_fillDetailedTree
 validation tree name - to be acessed by this from root More...
 
std::string m_validationTreeName
 validation tree description - second argument in TTree More...
 
std::string m_validationTreeDescription
 stream/folder to for the TTree to be written out More...
 
std::string m_validationTreeFolder
 Root Validation Tree. More...
 
TTree * m_validationTree
 
unsigned int m_runNumber
 
unsigned int m_evtNumber
 
unsigned int m_lumi_block
 
int m_nelectrons
 
int m_electronCounter
 counter for electrons More...
 
float m_electronTheta [3][NOS_ELECTRONS] {}
 Track theta on Surface. More...
 
float m_electronPhi [3][NOS_ELECTRONS] {}
 Track Phi on electron. More...
 
float m_electronQoverP [3][NOS_ELECTRONS] {}
 Track q over p on electron. More...
 
float m_electrond0 [3][NOS_ELECTRONS] {}
 Track Phi on electron. More...
 
float m_electronz0 [3][NOS_ELECTRONS] {}
 Track q over p on electron. More...
 
float m_electronLMQoverP [3][NOS_ELECTRONS] {}
 Track q over p on electron. More...
 
float m_electronErrTheta [3][NOS_ELECTRONS] {}
 Track theta error on electron. More...
 
float m_electronErrPhi [3][NOS_ELECTRONS] {}
 Track phi error on electron. More...
 
float m_electronErrQoverP [3][NOS_ELECTRONS] {}
 
float m_electronErrd0 [3][NOS_ELECTRONS] {}
 
float m_electronErrz0 [3][NOS_ELECTRONS] {}
 
int m_nTRT [NOS_ELECTRONS] {}
 
int m_nSCT [NOS_ELECTRONS] {}
 
int m_nBLayer [NOS_ELECTRONS] {}
 
int m_nPIX [NOS_ELECTRONS] {}
 
int m_nTRTout [NOS_ELECTRONS] {}
 
int m_nSCTout [NOS_ELECTRONS] {}
 
int m_nPIXout [NOS_ELECTRONS] {}
 
int m_nTRTHT [NOS_ELECTRONS] {}
 
int m_nTRTHTout [NOS_ELECTRONS] {}
 
int m_author [NOS_ELECTRONS] {}
 
float m_ClusterEnergy [NOS_ELECTRONS] {}
 
float m_ClusterEta [NOS_ELECTRONS] {}
 
float m_ClusterPhi [NOS_ELECTRONS] {}
 
bool m_IsEMLoose [NOS_ELECTRONS] {}
 
bool m_IsEMMedium [NOS_ELECTRONS] {}
 
bool m_IsEMTight [NOS_ELECTRONS] {}
 
bool m_IsEMTightTRT [NOS_ELECTRONS] {}
 
bool m_isGoodOQ [NOS_ELECTRONS] {}
 
int m_associatedToVtx [NOS_ELECTRONS] {}
 
VxPos m_vxpos [NOS_ELECTRONS]
 
int m_nbpv
 
int m_pvtype [NO_PV] {}
 
int m_pvnbtk [NO_PV] {}
 
float m_pvsumpt [NO_PV] {}
 
float m_pvx [NO_PV] {}
 
float m_pvy [NO_PV] {}
 
float m_pvz [NO_PV] {}
 
float m_errpvx [NO_PV] {}
 
float m_errpvy [NO_PV] {}
 
float m_errpvz [NO_PV] {}
 
float m_covpvxpvy [NO_PV] {}
 
float m_covpvypvz [NO_PV] {}
 
float m_covpvzpvx [NO_PV] {}
 
bool m_METgoodness
 
float m_sumet
 
float m_missingEt
 
float m_missingEtx
 
float m_missingEty
 
float m_ePID_ShowerType [50][NOS_ELECTRONS] {}
 
float m_ePID_IsolationType [50][NOS_ELECTRONS] {}
 
float m_ePID_TrackCaloMatchType [50][NOS_ELECTRONS] {}
 
float m_ePID_SummaryType [50][NOS_ELECTRONS] {}
 
std::vector< std::pair< xAOD::EgammaParameters::ShowerShapeType, std::string > > m_PID_ShowerType_Names
 
std::vector< std::pair< xAOD::Iso::IsolationType, std::string > > m_PID_IsolationType_Names
 
std::vector< std::pair< xAOD::EgammaParameters::TrackCaloMatchType, std::string > > m_PID_TrackCaloMatchType_Names
 
std::vector< std::pair< xAOD::SummaryType, std::string > > m_PID_SummaryType_Names
 
bool m_trigger [50] {}
 
std::vector< std::string > m_triggerNames
 
TH1F * m_ZeeLooseMassOS_Cluster
 
TH1F * m_ZeeLooseMassSS_Cluster
 
TH1F * m_ZeeMediumMassOS_Cluster
 
TH1F * m_ZeeMediumMassSS_Cluster
 
TH2F * m_ZeeMediumOS_ClusterPtEta
 
TH1F * m_WenuLooseElectronET
 
TH1F * m_WenuTight_Met
 
TH1F * m_WenuTight_MT
 
TH1F * m_WenuTightMet_MT
 
TH1F * m_WenuTightElectronET
 
TH1F * m_WenuTightW_PT
 
TH2F * m_WenuTightElectron_PTEtaPos
 
TH2F * m_WenuTightElectron_PTEtaNeg
 validation tree name - to be acessed by this from root More...
 
std::string m_smallValidationTreeName
 validation tree description - second argument in TTree More...
 
std::string m_smallValidationTreeDescription
 stream/folder to for the TTree to be written out More...
 
std::string m_smallValidationTreeFolder
 Root Validation Tree. More...
 
TTree * m_smallValidationTree
 
double m_small_QoverP
 
double m_small1_QoverP
 
double m_small2_QoverP
 
double m_smallClusterEnergy
 
double m_smallClusterPhi
 
double m_smallClusterEta
 
double m_smallTrackTheta
 
double m_smallCharge
 
double m_smalld0
 
double m_smallz0
 
std::string m_lhTune
 
AsgElectronLikelihoodTool * m_LHToolLoose2015
 
AsgElectronLikelihoodTool * m_LHToolMedium2015
 
AsgElectronLikelihoodTool * m_LHToolTight2015
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Create a simple ntuple to perform EoverP studies with

Author
A. Morley

Definition at line 81 of file IDPerfMonEoverP.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ IDPerfMonEoverP()

IDPerfMonEoverP::IDPerfMonEoverP ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Default constructor.

Definition at line 58 of file IDPerfMonEoverP.cxx.

59  :
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 }

◆ ~IDPerfMonEoverP()

IDPerfMonEoverP::~IDPerfMonEoverP ( )

Destructor.

Definition at line 139 of file IDPerfMonEoverP.cxx.

140 {
141 
142 }

Member Function Documentation

◆ addToValidationNtuple()

void IDPerfMonEoverP::addToValidationNtuple ( const Trk::Perigee *  perigee,
const xAOD::CaloCluster *  ,
int  isOrginal 
)
private

addToValidationNutple

Definition at line 668 of file IDPerfMonEoverP.cxx.

668  {
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 }

◆ clearValidationNtuple()

void IDPerfMonEoverP::clearValidationNtuple ( )
private

Definition at line 741 of file IDPerfMonEoverP.cxx.

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 }

◆ correctIP_PV()

double IDPerfMonEoverP::correctIP_PV ( int  electron_i,
bool  do_d0 
)
private

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ deleteAction()

void IDPerfMonEoverP::deleteAction ( ) const
private

Definition at line 810 of file IDPerfMonEoverP.cxx.

811 {
812 
813 }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode IDPerfMonEoverP::execute ( )

Definition at line 461 of file IDPerfMonEoverP.cxx.

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 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
55  return m_extendedExtraObjects;
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ extrapolateToTheCalo()

void IDPerfMonEoverP::extrapolateToTheCalo ( const Trk::TrackParameters *  trkPar,
const xAOD::CaloCluster *  cluster,
double *  eta,
double *  phi,
double *  deltaEta,
double *  delatPhi 
)
private

◆ fillElectronInfo()

void IDPerfMonEoverP::fillElectronInfo ( const xAOD::Electron *  p)
private

Definition at line 977 of file IDPerfMonEoverP.cxx.

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 }

◆ fillGeneral()

void IDPerfMonEoverP::fillGeneral ( const xAOD::Electron *  eg)
private

Definition at line 728 of file IDPerfMonEoverP.cxx.

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 }

◆ fillIsEM()

void IDPerfMonEoverP::fillIsEM ( const xAOD::Electron *  eg)
private

Definition at line 698 of file IDPerfMonEoverP.cxx.

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 }

◆ fillLastMeasurement()

bool IDPerfMonEoverP::fillLastMeasurement ( const Trk::Track *  track,
const int  fitter 
)
private

Definition at line 998 of file IDPerfMonEoverP.cxx.

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 }

◆ FillSimpleTree()

std::vector< int > IDPerfMonEoverP::FillSimpleTree ( )
private

Definition at line 1250 of file IDPerfMonEoverP.cxx.

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 }

◆ fillTriggerInformation()

void IDPerfMonEoverP::fillTriggerInformation ( )
private

Definition at line 958 of file IDPerfMonEoverP.cxx.

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 }

◆ fillVertexInformation()

bool IDPerfMonEoverP::fillVertexInformation ( std::map< const xAOD::TrackParticle *, VxPos > &  trackParticleVertexMap,
xAOD::Vertex const *&  primaryVertexFirstCandidate 
)
private

Definition at line 872 of file IDPerfMonEoverP.cxx.

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 }

◆ finalize()

StatusCode IDPerfMonEoverP::finalize ( )

Definition at line 454 of file IDPerfMonEoverP.cxx.

455 {
456  return StatusCode::SUCCESS;
457 }

◆ findAssociatedVertex()

VxPos IDPerfMonEoverP::findAssociatedVertex ( std::map< const xAOD::TrackParticle *, VxPos > &  trackParticleVertexMap,
const xAOD::Vertex *  primaryVertexFirstCandidate,
const xAOD::Electron *  eg 
) const
private

Definition at line 943 of file IDPerfMonEoverP.cxx.

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 }

◆ getMassCluster()

double IDPerfMonEoverP::getMassCluster ( int  el1,
int  el2 
)
private

Definition at line 1234 of file IDPerfMonEoverP.cxx.

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 }

◆ initialize()

StatusCode IDPerfMonEoverP::initialize ( )

Gaudi algorithm hooks.

Definition at line 148 of file IDPerfMonEoverP.cxx.

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  ServiceHandle<ITHistSvc> tHistSvc("THistSvc", name());
358  if (tHistSvc.retrieve().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 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ passMETCleaningCuts()

bool IDPerfMonEoverP::passMETCleaningCuts ( ) const
private

Definition at line 855 of file IDPerfMonEoverP.cxx.

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 }

◆ passWenuSelection()

bool IDPerfMonEoverP::passWenuSelection ( std::vector< int > &  electrons)
private

Definition at line 1130 of file IDPerfMonEoverP.cxx.

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 }

◆ passZeeSelection()

bool IDPerfMonEoverP::passZeeSelection ( std::vector< int > &  electrons)
private

Definition at line 1035 of file IDPerfMonEoverP.cxx.

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 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ storeMETinformation()

bool IDPerfMonEoverP::storeMETinformation ( )
private

Definition at line 829 of file IDPerfMonEoverP.cxx.

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 }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

◆ validationAction()

void IDPerfMonEoverP::validationAction ( )
private

Definition at line 815 of file IDPerfMonEoverP.cxx.

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 }

Member Data Documentation

◆ m_associatedToVtx

int IDPerfMonEoverP::m_associatedToVtx[NOS_ELECTRONS] {}
private

Definition at line 243 of file IDPerfMonEoverP.h.

◆ m_author

int IDPerfMonEoverP::m_author[NOS_ELECTRONS] {}
private

Definition at line 228 of file IDPerfMonEoverP.h.

◆ m_ClusterEnergy

float IDPerfMonEoverP::m_ClusterEnergy[NOS_ELECTRONS] {}
private

Definition at line 230 of file IDPerfMonEoverP.h.

◆ m_ClusterEta

float IDPerfMonEoverP::m_ClusterEta[NOS_ELECTRONS] {}
private

Definition at line 231 of file IDPerfMonEoverP.h.

◆ m_ClusterPhi

float IDPerfMonEoverP::m_ClusterPhi[NOS_ELECTRONS] {}
private

Definition at line 232 of file IDPerfMonEoverP.h.

◆ m_covpvxpvy

float IDPerfMonEoverP::m_covpvxpvy[NO_PV] {}
private

Definition at line 257 of file IDPerfMonEoverP.h.

◆ m_covpvypvz

float IDPerfMonEoverP::m_covpvypvz[NO_PV] {}
private

Definition at line 258 of file IDPerfMonEoverP.h.

◆ m_covpvzpvx

float IDPerfMonEoverP::m_covpvzpvx[NO_PV] {}
private

Definition at line 259 of file IDPerfMonEoverP.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_electronCounter

int IDPerfMonEoverP::m_electronCounter
private

counter for electrons

Definition at line 200 of file IDPerfMonEoverP.h.

◆ m_electrond0

float IDPerfMonEoverP::m_electrond0[3][NOS_ELECTRONS] {}
private

Track Phi on electron.

Definition at line 205 of file IDPerfMonEoverP.h.

◆ m_electronErrd0

float IDPerfMonEoverP::m_electronErrd0[3][NOS_ELECTRONS] {}
private

Definition at line 213 of file IDPerfMonEoverP.h.

◆ m_electronErrPhi

float IDPerfMonEoverP::m_electronErrPhi[3][NOS_ELECTRONS] {}
private

Track phi error on electron.

Definition at line 211 of file IDPerfMonEoverP.h.

◆ m_electronErrQoverP

float IDPerfMonEoverP::m_electronErrQoverP[3][NOS_ELECTRONS] {}
private

Definition at line 212 of file IDPerfMonEoverP.h.

◆ m_electronErrTheta

float IDPerfMonEoverP::m_electronErrTheta[3][NOS_ELECTRONS] {}
private

Track theta error on electron.

Definition at line 210 of file IDPerfMonEoverP.h.

◆ m_electronErrz0

float IDPerfMonEoverP::m_electronErrz0[3][NOS_ELECTRONS] {}
private

Definition at line 214 of file IDPerfMonEoverP.h.

◆ m_electronLMQoverP

float IDPerfMonEoverP::m_electronLMQoverP[3][NOS_ELECTRONS] {}
private

Track q over p on electron.

Definition at line 208 of file IDPerfMonEoverP.h.

◆ m_electronPhi

float IDPerfMonEoverP::m_electronPhi[3][NOS_ELECTRONS] {}
private

Track Phi on electron.

Definition at line 203 of file IDPerfMonEoverP.h.

◆ m_electronQoverP

float IDPerfMonEoverP::m_electronQoverP[3][NOS_ELECTRONS] {}
private

Track q over p on electron.

Definition at line 204 of file IDPerfMonEoverP.h.

◆ m_electronTheta

float IDPerfMonEoverP::m_electronTheta[3][NOS_ELECTRONS] {}
private

Track theta on Surface.

Definition at line 202 of file IDPerfMonEoverP.h.

◆ m_electronz0

float IDPerfMonEoverP::m_electronz0[3][NOS_ELECTRONS] {}
private

Track q over p on electron.

Definition at line 206 of file IDPerfMonEoverP.h.

◆ m_ePID_IsolationType

float IDPerfMonEoverP::m_ePID_IsolationType[50][NOS_ELECTRONS] {}
private

Definition at line 270 of file IDPerfMonEoverP.h.

◆ m_ePID_ShowerType

float IDPerfMonEoverP::m_ePID_ShowerType[50][NOS_ELECTRONS] {}
private

Definition at line 269 of file IDPerfMonEoverP.h.

◆ m_ePID_SummaryType

float IDPerfMonEoverP::m_ePID_SummaryType[50][NOS_ELECTRONS] {}
private

Definition at line 272 of file IDPerfMonEoverP.h.

◆ m_ePID_TrackCaloMatchType

float IDPerfMonEoverP::m_ePID_TrackCaloMatchType[50][NOS_ELECTRONS] {}
private

Definition at line 271 of file IDPerfMonEoverP.h.

◆ m_errpvx

float IDPerfMonEoverP::m_errpvx[NO_PV] {}
private

Definition at line 254 of file IDPerfMonEoverP.h.

◆ m_errpvy

float IDPerfMonEoverP::m_errpvy[NO_PV] {}
private

Definition at line 255 of file IDPerfMonEoverP.h.

◆ m_errpvz

float IDPerfMonEoverP::m_errpvz[NO_PV] {}
private

Definition at line 256 of file IDPerfMonEoverP.h.

◆ m_evt

SG::ReadHandleKey<xAOD::EventInfo> IDPerfMonEoverP::m_evt {this, "EvtInfo", "EventInfo", "EventInfo name"}
private

ReadHandle to the Event Info.

Definition at line 155 of file IDPerfMonEoverP.h.

◆ m_evtNumber

unsigned int IDPerfMonEoverP::m_evtNumber
private

Definition at line 195 of file IDPerfMonEoverP.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_fillDetailedTree

bool IDPerfMonEoverP::m_fillDetailedTree
private

validation tree name - to be acessed by this from root

Definition at line 181 of file IDPerfMonEoverP.h.

◆ m_InputElectronContainerName

std::string IDPerfMonEoverP::m_InputElectronContainerName
private

Electron collection input name.

Definition at line 135 of file IDPerfMonEoverP.h.

◆ m_isDATA

bool IDPerfMonEoverP::m_isDATA
private

Definition at line 174 of file IDPerfMonEoverP.h.

◆ m_IsEMLoose

bool IDPerfMonEoverP::m_IsEMLoose[NOS_ELECTRONS] {}
private

Definition at line 234 of file IDPerfMonEoverP.h.

◆ m_IsEMMedium

bool IDPerfMonEoverP::m_IsEMMedium[NOS_ELECTRONS] {}
private

Definition at line 235 of file IDPerfMonEoverP.h.

◆ m_IsEMTight

bool IDPerfMonEoverP::m_IsEMTight[NOS_ELECTRONS] {}
private

Definition at line 236 of file IDPerfMonEoverP.h.

◆ m_IsEMTightTRT

bool IDPerfMonEoverP::m_IsEMTightTRT[NOS_ELECTRONS] {}
private

Definition at line 237 of file IDPerfMonEoverP.h.

◆ m_isGoodOQ

bool IDPerfMonEoverP::m_isGoodOQ[NOS_ELECTRONS] {}
private

Definition at line 238 of file IDPerfMonEoverP.h.

◆ m_jetCleaningTool

ToolHandle< IJetSelector > IDPerfMonEoverP::m_jetCleaningTool {this,"JetCleaningTool","JetCleaningTool/JetCleaningTool",""}
private

jet selector tool

Definition at line 167 of file IDPerfMonEoverP.h.

◆ m_jetContainerName

std::string IDPerfMonEoverP::m_jetContainerName
private

JEt collection input name.

Definition at line 140 of file IDPerfMonEoverP.h.

◆ m_LHToolLoose2015

AsgElectronLikelihoodTool* IDPerfMonEoverP::m_LHToolLoose2015
private

Definition at line 329 of file IDPerfMonEoverP.h.

◆ m_LHToolMedium2015

AsgElectronLikelihoodTool* IDPerfMonEoverP::m_LHToolMedium2015
private

Definition at line 330 of file IDPerfMonEoverP.h.

◆ m_LHToolTight2015

AsgElectronLikelihoodTool* IDPerfMonEoverP::m_LHToolTight2015
private

Definition at line 331 of file IDPerfMonEoverP.h.

◆ m_lhTune

std::string IDPerfMonEoverP::m_lhTune
private

Definition at line 328 of file IDPerfMonEoverP.h.

◆ m_lumi_block

unsigned int IDPerfMonEoverP::m_lumi_block
private

Definition at line 196 of file IDPerfMonEoverP.h.

◆ m_METgoodness

bool IDPerfMonEoverP::m_METgoodness
private

Definition at line 262 of file IDPerfMonEoverP.h.

◆ m_metRefFinalName

std::string IDPerfMonEoverP::m_metRefFinalName
private

Definition at line 137 of file IDPerfMonEoverP.h.

◆ m_missingEt

float IDPerfMonEoverP::m_missingEt
private

Definition at line 264 of file IDPerfMonEoverP.h.

◆ m_missingEtObjectName

std::string IDPerfMonEoverP::m_missingEtObjectName
private

MET input name.

Definition at line 142 of file IDPerfMonEoverP.h.

◆ m_missingEtx

float IDPerfMonEoverP::m_missingEtx
private

Definition at line 265 of file IDPerfMonEoverP.h.

◆ m_missingEty

float IDPerfMonEoverP::m_missingEty
private

Definition at line 266 of file IDPerfMonEoverP.h.

◆ m_nBLayer

int IDPerfMonEoverP::m_nBLayer[NOS_ELECTRONS] {}
private

Definition at line 219 of file IDPerfMonEoverP.h.

◆ m_nbpv

int IDPerfMonEoverP::m_nbpv
private

Definition at line 247 of file IDPerfMonEoverP.h.

◆ m_nelectrons

int IDPerfMonEoverP::m_nelectrons
private

Definition at line 199 of file IDPerfMonEoverP.h.

◆ m_nPIX

int IDPerfMonEoverP::m_nPIX[NOS_ELECTRONS] {}
private

Definition at line 220 of file IDPerfMonEoverP.h.

◆ m_nPIXout

int IDPerfMonEoverP::m_nPIXout[NOS_ELECTRONS] {}
private

Definition at line 223 of file IDPerfMonEoverP.h.

◆ m_nSCT

int IDPerfMonEoverP::m_nSCT[NOS_ELECTRONS] {}
private

Definition at line 218 of file IDPerfMonEoverP.h.

◆ m_nSCTout

int IDPerfMonEoverP::m_nSCTout[NOS_ELECTRONS] {}
private

Definition at line 222 of file IDPerfMonEoverP.h.

◆ m_nTRT

int IDPerfMonEoverP::m_nTRT[NOS_ELECTRONS] {}
private

Definition at line 217 of file IDPerfMonEoverP.h.

◆ m_nTRTHT

int IDPerfMonEoverP::m_nTRTHT[NOS_ELECTRONS] {}
private

Definition at line 224 of file IDPerfMonEoverP.h.

◆ m_nTRTHTout

int IDPerfMonEoverP::m_nTRTHTout[NOS_ELECTRONS] {}
private

Definition at line 225 of file IDPerfMonEoverP.h.

◆ m_nTRTout

int IDPerfMonEoverP::m_nTRTout[NOS_ELECTRONS] {}
private

Definition at line 221 of file IDPerfMonEoverP.h.

◆ m_OutputTrackCollectionName_no1

std::string IDPerfMonEoverP::m_OutputTrackCollectionName_no1
private

Name of output of Refitted Inner Detector Tracks.

Definition at line 147 of file IDPerfMonEoverP.h.

◆ m_OutputTrackCollectionName_no2

std::string IDPerfMonEoverP::m_OutputTrackCollectionName_no2
private

Definition at line 148 of file IDPerfMonEoverP.h.

◆ m_PID_IsolationType_Names

std::vector< std::pair <xAOD::Iso::IsolationType, std::string > > IDPerfMonEoverP::m_PID_IsolationType_Names
private

Definition at line 275 of file IDPerfMonEoverP.h.

◆ m_PID_ShowerType_Names

std::vector< std::pair <xAOD::EgammaParameters::ShowerShapeType, std::string > > IDPerfMonEoverP::m_PID_ShowerType_Names
private

Definition at line 274 of file IDPerfMonEoverP.h.

◆ m_PID_SummaryType_Names

std::vector< std::pair <xAOD::SummaryType, std::string > > IDPerfMonEoverP::m_PID_SummaryType_Names
private

Definition at line 277 of file IDPerfMonEoverP.h.

◆ m_PID_TrackCaloMatchType_Names

std::vector< std::pair <xAOD::EgammaParameters::TrackCaloMatchType, std::string > > IDPerfMonEoverP::m_PID_TrackCaloMatchType_Names
private

Definition at line 276 of file IDPerfMonEoverP.h.

◆ m_primaryVertexCollection

std::string IDPerfMonEoverP::m_primaryVertexCollection
private

Primary vertex input name.

Definition at line 144 of file IDPerfMonEoverP.h.

◆ m_pvnbtk

int IDPerfMonEoverP::m_pvnbtk[NO_PV] {}
private

Definition at line 249 of file IDPerfMonEoverP.h.

◆ m_pvsumpt

float IDPerfMonEoverP::m_pvsumpt[NO_PV] {}
private

Definition at line 250 of file IDPerfMonEoverP.h.

◆ m_pvtype

int IDPerfMonEoverP::m_pvtype[NO_PV] {}
private

Definition at line 248 of file IDPerfMonEoverP.h.

◆ m_pvx

float IDPerfMonEoverP::m_pvx[NO_PV] {}
private

Definition at line 251 of file IDPerfMonEoverP.h.

◆ m_pvy

float IDPerfMonEoverP::m_pvy[NO_PV] {}
private

Definition at line 252 of file IDPerfMonEoverP.h.

◆ m_pvz

float IDPerfMonEoverP::m_pvz[NO_PV] {}
private

Definition at line 253 of file IDPerfMonEoverP.h.

◆ m_refitEverything

bool IDPerfMonEoverP::m_refitEverything
private

Definition at line 171 of file IDPerfMonEoverP.h.

◆ m_refittedTracks_no1

TrackCollection* IDPerfMonEoverP::m_refittedTracks_no1
private

Refitted track collection.

Definition at line 151 of file IDPerfMonEoverP.h.

◆ m_refittedTracks_no2

TrackCollection* IDPerfMonEoverP::m_refittedTracks_no2
private

Definition at line 152 of file IDPerfMonEoverP.h.

◆ m_runNumber

unsigned int IDPerfMonEoverP::m_runNumber
private

Definition at line 194 of file IDPerfMonEoverP.h.

◆ m_small1_QoverP

double IDPerfMonEoverP::m_small1_QoverP
private

Definition at line 312 of file IDPerfMonEoverP.h.

◆ m_small2_QoverP

double IDPerfMonEoverP::m_small2_QoverP
private

Definition at line 313 of file IDPerfMonEoverP.h.

◆ m_small_QoverP

double IDPerfMonEoverP::m_small_QoverP
private

Definition at line 311 of file IDPerfMonEoverP.h.

◆ m_smallCharge

double IDPerfMonEoverP::m_smallCharge
private

Definition at line 318 of file IDPerfMonEoverP.h.

◆ m_smallClusterEnergy

double IDPerfMonEoverP::m_smallClusterEnergy
private

Definition at line 314 of file IDPerfMonEoverP.h.

◆ m_smallClusterEta

double IDPerfMonEoverP::m_smallClusterEta
private

Definition at line 316 of file IDPerfMonEoverP.h.

◆ m_smallClusterPhi

double IDPerfMonEoverP::m_smallClusterPhi
private

Definition at line 315 of file IDPerfMonEoverP.h.

◆ m_smalld0

double IDPerfMonEoverP::m_smalld0
private

Definition at line 319 of file IDPerfMonEoverP.h.

◆ m_smallTrackTheta

double IDPerfMonEoverP::m_smallTrackTheta
private

Definition at line 317 of file IDPerfMonEoverP.h.

◆ m_smallValidationTree

TTree* IDPerfMonEoverP::m_smallValidationTree
private

Definition at line 308 of file IDPerfMonEoverP.h.

◆ m_smallValidationTreeDescription

std::string IDPerfMonEoverP::m_smallValidationTreeDescription
private

stream/folder to for the TTree to be written out

Definition at line 304 of file IDPerfMonEoverP.h.

◆ m_smallValidationTreeFolder

std::string IDPerfMonEoverP::m_smallValidationTreeFolder
private

Root Validation Tree.

Definition at line 306 of file IDPerfMonEoverP.h.

◆ m_smallValidationTreeName

std::string IDPerfMonEoverP::m_smallValidationTreeName
private

validation tree description - second argument in TTree

Definition at line 302 of file IDPerfMonEoverP.h.

◆ m_smallz0

double IDPerfMonEoverP::m_smallz0
private

Definition at line 320 of file IDPerfMonEoverP.h.

◆ m_sumet

float IDPerfMonEoverP::m_sumet
private

Definition at line 263 of file IDPerfMonEoverP.h.

◆ m_TrackRefitter

ToolHandle<IegammaTrkRefitterTool> IDPerfMonEoverP::m_TrackRefitter
private

The track refitter.

Definition at line 158 of file IDPerfMonEoverP.h.

◆ m_TrackRefitter_no2

ToolHandle<IegammaTrkRefitterTool> IDPerfMonEoverP::m_TrackRefitter_no2
private

The track refitter.

Definition at line 161 of file IDPerfMonEoverP.h.

◆ m_trigDec

ToolHandle<Trig::TrigDecisionTool> IDPerfMonEoverP::m_trigDec
private

The trigger decision tool.

Definition at line 164 of file IDPerfMonEoverP.h.

◆ m_trigger

bool IDPerfMonEoverP::m_trigger[50] {}
private

Definition at line 281 of file IDPerfMonEoverP.h.

◆ m_triggerNames

std::vector<std::string> IDPerfMonEoverP::m_triggerNames
private

Definition at line 282 of file IDPerfMonEoverP.h.

◆ m_validationMode

bool IDPerfMonEoverP::m_validationMode
private

< boolean to switch to validation mode

boolean to switch to on Detailed Tree Filling – large increase in the ntuple size

Definition at line 178 of file IDPerfMonEoverP.h.

◆ m_validationTree

TTree* IDPerfMonEoverP::m_validationTree
private

Definition at line 191 of file IDPerfMonEoverP.h.

◆ m_validationTreeDescription

std::string IDPerfMonEoverP::m_validationTreeDescription
private

stream/folder to for the TTree to be written out

Definition at line 187 of file IDPerfMonEoverP.h.

◆ m_validationTreeFolder

std::string IDPerfMonEoverP::m_validationTreeFolder
private

Root Validation Tree.

Definition at line 189 of file IDPerfMonEoverP.h.

◆ m_validationTreeName

std::string IDPerfMonEoverP::m_validationTreeName
private

validation tree description - second argument in TTree

Definition at line 185 of file IDPerfMonEoverP.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vxpos

VxPos IDPerfMonEoverP::m_vxpos[NOS_ELECTRONS]
private

Definition at line 244 of file IDPerfMonEoverP.h.

◆ m_WenuLooseElectronET

TH1F* IDPerfMonEoverP::m_WenuLooseElectronET
private

Definition at line 291 of file IDPerfMonEoverP.h.

◆ m_WenuTight_Met

TH1F* IDPerfMonEoverP::m_WenuTight_Met
private

Definition at line 292 of file IDPerfMonEoverP.h.

◆ m_WenuTight_MT

TH1F* IDPerfMonEoverP::m_WenuTight_MT
private

Definition at line 293 of file IDPerfMonEoverP.h.

◆ m_WenuTightElectron_PTEtaNeg

TH2F* IDPerfMonEoverP::m_WenuTightElectron_PTEtaNeg
private

validation tree name - to be acessed by this from root

Definition at line 298 of file IDPerfMonEoverP.h.

◆ m_WenuTightElectron_PTEtaPos

TH2F* IDPerfMonEoverP::m_WenuTightElectron_PTEtaPos
private

Definition at line 297 of file IDPerfMonEoverP.h.

◆ m_WenuTightElectronET

TH1F* IDPerfMonEoverP::m_WenuTightElectronET
private

Definition at line 295 of file IDPerfMonEoverP.h.

◆ m_WenuTightMet_MT

TH1F* IDPerfMonEoverP::m_WenuTightMet_MT
private

Definition at line 294 of file IDPerfMonEoverP.h.

◆ m_WenuTightW_PT

TH1F* IDPerfMonEoverP::m_WenuTightW_PT
private

Definition at line 296 of file IDPerfMonEoverP.h.

◆ m_ZeeLooseMassOS_Cluster

TH1F* IDPerfMonEoverP::m_ZeeLooseMassOS_Cluster
private

Definition at line 285 of file IDPerfMonEoverP.h.

◆ m_ZeeLooseMassSS_Cluster

TH1F* IDPerfMonEoverP::m_ZeeLooseMassSS_Cluster
private

Definition at line 286 of file IDPerfMonEoverP.h.

◆ m_ZeeMediumMassOS_Cluster

TH1F* IDPerfMonEoverP::m_ZeeMediumMassOS_Cluster
private

Definition at line 287 of file IDPerfMonEoverP.h.

◆ m_ZeeMediumMassSS_Cluster

TH1F* IDPerfMonEoverP::m_ZeeMediumMassSS_Cluster
private

Definition at line 288 of file IDPerfMonEoverP.h.

◆ m_ZeeMediumOS_ClusterPtEta

TH2F* IDPerfMonEoverP::m_ZeeMediumOS_ClusterPtEta
private

Definition at line 289 of file IDPerfMonEoverP.h.

The documentation for this class was generated from the following files:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
IDPerfMonEoverP::m_smallValidationTreeFolder
std::string m_smallValidationTreeFolder
Root Validation Tree.
Definition: IDPerfMonEoverP.h:306
IDPerfMonEoverP::m_missingEt
float m_missingEt
Definition: IDPerfMonEoverP.h:264
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: CaloCluster_v1.cxx:256
xAOD::EgammaParameters::e233
@ e233
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 3x3 (in cell units e...
Definition: EgammaEnums.h:68
IDPerfMonEoverP::m_jetContainerName
std::string m_jetContainerName
JEt collection input name.
Definition: IDPerfMonEoverP.h:140
IDPerfMonEoverP::m_ePID_IsolationType
float m_ePID_IsolationType[50][NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:270
IDPerfMonEoverP::m_smallValidationTreeName
std::string m_smallValidationTreeName
validation tree description - second argument in TTree
Definition: IDPerfMonEoverP.h:302
LArSamples::FitterData::fitter
const ShapeFitter * fitter
Definition: ShapeFitter.cxx:23
IDPerfMonEoverP::m_lumi_block
unsigned int m_lumi_block
Definition: IDPerfMonEoverP.h:196
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
IDPerfMonEoverP::m_WenuTight_MT
TH1F * m_WenuTight_MT
Definition: IDPerfMonEoverP.h:293
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:872
ParticleGun_SamplingFraction.eta2
eta2
Definition: ParticleGun_SamplingFraction.py:96
IDPerfMonEoverP::passWenuSelection
bool passWenuSelection(std::vector< int > &electrons)
Definition: IDPerfMonEoverP.cxx:1130
IDPerfMonEoverP::m_electronQoverP
float m_electronQoverP[3][NOS_ELECTRONS]
Track q over p on electron.
Definition: IDPerfMonEoverP.h:204
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
IDPerfMonEoverP::m_smallClusterEnergy
double m_smallClusterEnergy
Definition: IDPerfMonEoverP.h:314
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
ParticleTest.eg
eg
Definition: ParticleTest.py:29
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
Base_Fragment.mass
mass
Definition: Sherpa_i/share/common/Base_Fragment.py:59
IDPerfMonEoverP::m_electronErrd0
float m_electronErrd0[3][NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:213
IDPerfMonEoverP::passMETCleaningCuts
bool passMETCleaningCuts() const
Definition: IDPerfMonEoverP.cxx: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:269
DataVector::rend
const_reverse_iterator rend() const noexcept
Return a const_reverse_iterator pointing at the beginning of the collection.
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
IDPerfMonEoverP::m_covpvxpvy
float m_covpvxpvy[NO_PV]
Definition: IDPerfMonEoverP.h:257
xAOD::Vertex_v1::trackParticleLinks
const TrackParticleLinks_t & trackParticleLinks() const
Get all the particles associated with the vertex.
IDPerfMonEoverP::m_WenuTight_Met
TH1F * m_WenuTight_Met
Definition: IDPerfMonEoverP.h:292
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:736
IDPerfMonEoverP::m_validationTree
TTree * m_validationTree
Definition: IDPerfMonEoverP.h:191
IDPerfMonEoverP::m_nSCT
int m_nSCT[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:218
IDPerfMonEoverP::clearValidationNtuple
void clearValidationNtuple()
Definition: IDPerfMonEoverP.cxx:741
IDPerfMonEoverP::m_electronLMQoverP
float m_electronLMQoverP[3][NOS_ELECTRONS]
Track q over p on electron.
Definition: IDPerfMonEoverP.h:208
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
xAOD::Egamma_v1::author
uint16_t author(uint16_t bitmask=EgammaParameters::AuthorALL) const
Get author.
Definition: Egamma_v1.cxx:166
IDPerfMonEoverP::m_pvx
float m_pvx[NO_PV]
Definition: IDPerfMonEoverP.h:251
IDPerfMonEoverP::m_covpvzpvx
float m_covpvzpvx[NO_PV]
Definition: IDPerfMonEoverP.h:259
xAOD::Iso::ptcone30
@ ptcone30
Definition: IsolationType.h:41
IDPerfMonEoverP::m_TrackRefitter_no2
ToolHandle< IegammaTrkRefitterTool > m_TrackRefitter_no2
The track refitter.
Definition: IDPerfMonEoverP.h:161
IDPerfMonEoverP::m_smallz0
double m_smallz0
Definition: IDPerfMonEoverP.h:320
IDPerfMonEoverP::m_smallCharge
double m_smallCharge
Definition: IDPerfMonEoverP.h:318
xAOD::EgammaParameters::deltaEta2
@ deltaEta2
difference between the cluster eta (second sampling) and the eta of the track extrapolated to the sec...
Definition: EgammaEnums.h:187
AsgElectronLikelihoodTool::accept
virtual asg::AcceptData accept(const xAOD::IParticle *part) const override final
The main accept method: using the generic interface.
Definition: AsgElectronLikelihoodTool.cxx:868
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
xAOD::Iso::etcone40
@ etcone40
Definition: IsolationType.h:34
IDPerfMonEoverP::m_isGoodOQ
bool m_isGoodOQ[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:238
Trk::z0
@ z0
Definition: ParamDefs.h:64
IDPerfMonEoverP::m_IsEMTight
bool m_IsEMTight[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:236
xAOD::eta1
setEt setPhi setE277 setWeta2 eta1
Definition: TrigEMCluster_v1.cxx:41
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:281
IDPerfMonEoverP::m_nPIXout
int m_nPIXout[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:223
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h: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:250
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
IDPerfMonEoverP::m_validationMode
bool m_validationMode
< boolean to switch to validation mode
Definition: IDPerfMonEoverP.h:178
IDPerfMonEoverP::m_small2_QoverP
double m_small2_QoverP
Definition: IDPerfMonEoverP.h:313
NO_PV
#define NO_PV
Definition: IDPerfMonEoverP.h:76
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
IDPerfMonEoverP::m_validationTreeDescription
std::string m_validationTreeDescription
stream/folder to for the TTree to be written out
Definition: IDPerfMonEoverP.h:187
IDPerfMonEoverP::m_METgoodness
bool m_METgoodness
Definition: IDPerfMonEoverP.h:262
IDPerfMonEoverP::m_primaryVertexCollection
std::string m_primaryVertexCollection
Primary vertex input name.
Definition: IDPerfMonEoverP.h:144
python.TrigEgammaMonitorHelper.TH2F
def TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:45
IDPerfMonEoverP::m_triggerNames
std::vector< std::string > m_triggerNames
Definition: IDPerfMonEoverP.h:282
IDPerfMonEoverP::m_LHToolTight2015
AsgElectronLikelihoodTool * m_LHToolTight2015
Definition: IDPerfMonEoverP.h:331
IDPerfMonEoverP::m_isDATA
bool m_isDATA
Definition: IDPerfMonEoverP.h:174
xAOD::EgammaParameters::wtots1
@ wtots1
shower width is determined in a window detaxdphi = 0,0625 ×~0,2, corresponding typically to 20 strips...
Definition: EgammaEnums.h:140
AsgElectronLikelihoodTool
Electron selector tool to select objects in Athena using an underlying pure ROOT tool.
Definition: AsgElectronLikelihoodTool.h:30
IDPerfMonEoverP::m_missingEtObjectName
std::string m_missingEtObjectName
MET input name.
Definition: IDPerfMonEoverP.h:142
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:50
IDPerfMonEoverP::m_nTRT
int m_nTRT[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:217
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:316
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDPerfMonEoverP::m_ePID_TrackCaloMatchType
float m_ePID_TrackCaloMatchType[50][NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:271
IegammaTrkRefitterTool::Cache
Struct Holding the result to return and intermediate objects Things are owned by the EDM or the uniqu...
Definition: IegammaTrkRefitterTool.h:39
IDPerfMonEoverP::m_PID_IsolationType_Names
std::vector< std::pair< xAOD::Iso::IsolationType, std::string > > m_PID_IsolationType_Names
Definition: IDPerfMonEoverP.h:275
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
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:288
IDPerfMonEoverP::m_WenuTightElectron_PTEtaPos
TH2F * m_WenuTightElectron_PTEtaPos
Definition: IDPerfMonEoverP.h:297
xAOD::EgammaParameters::f3
@ f3
fraction of energy reconstructed in 3rd sampling
Definition: EgammaEnums.h:54
IDPerfMonEoverP::m_missingEty
float m_missingEty
Definition: IDPerfMonEoverP.h:266
IDPerfMonEoverP::m_runNumber
unsigned int m_runNumber
Definition: IDPerfMonEoverP.h:194
IDPerfMonEoverP::m_WenuTightW_PT
TH1F * m_WenuTightW_PT
Definition: IDPerfMonEoverP.h:296
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
xAOD::TrackParticle_v1::p4
virtual FourMom_t p4() const override final
The full 4-momentum of the particle.
Definition: TrackParticle_v1.cxx:129
IDPerfMonEoverP::m_OutputTrackCollectionName_no2
std::string m_OutputTrackCollectionName_no2
Definition: IDPerfMonEoverP.h:148
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
IDPerfMonEoverP::m_nTRTHT
int m_nTRTHT[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:224
IDPerfMonEoverP::m_refittedTracks_no2
TrackCollection * m_refittedTracks_no2
Definition: IDPerfMonEoverP.h:152
IDPerfMonEoverP::m_PID_TrackCaloMatchType_Names
std::vector< std::pair< xAOD::EgammaParameters::TrackCaloMatchType, std::string > > m_PID_TrackCaloMatchType_Names
Definition: IDPerfMonEoverP.h:276
IDPerfMonEoverP::m_nelectrons
int m_nelectrons
Definition: IDPerfMonEoverP.h:199
xAOD::numberOfTRTHighThresholdOutliers
@ numberOfTRTHighThresholdOutliers
number of TRT high threshold outliers (only xenon counted) [unit8_t].
Definition: TrackingPrimitives.h: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
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
IDPerfMonEoverP::m_ClusterPhi
float m_ClusterPhi[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:232
xAOD::SummaryType
SummaryType
Enumerates the different types of information stored in Summary.
Definition: TrackingPrimitives.h:228
IDPerfMonEoverP::m_nTRTHTout
int m_nTRTHTout[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:225
CP::Iso
@ Iso
Definition: MuonEfficiencyType.h:16
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
IDPerfMonEoverP::m_errpvz
float m_errpvz[NO_PV]
Definition: IDPerfMonEoverP.h:256
IDPerfMonEoverP::m_WenuLooseElectronET
TH1F * m_WenuLooseElectronET
Definition: IDPerfMonEoverP.h:291
IDPerfMonEoverP::getMassCluster
double getMassCluster(int el1, int el2)
Definition: IDPerfMonEoverP.cxx:1234
IDPerfMonEoverP::m_electronErrQoverP
float m_electronErrQoverP[3][NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:212
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
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:85
TrackCollection
DataVector< Trk::Track > TrackCollection
This typedef represents a collection of Trk::Track objects.
Definition: TrackCollection.h:19
IDPerfMonEoverP::m_metRefFinalName
std::string m_metRefFinalName
Definition: IDPerfMonEoverP.h:137
IDPerfMonEoverP::m_errpvy
float m_errpvy[NO_PV]
Definition: IDPerfMonEoverP.h:255
IDPerfMonEoverP::m_electronTheta
float m_electronTheta[3][NOS_ELECTRONS]
Track theta on Surface.
Definition: IDPerfMonEoverP.h:202
IDPerfMonEoverP::m_IsEMLoose
bool m_IsEMLoose[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:234
IDPerfMonEoverP::m_missingEtx
float m_missingEtx
Definition: IDPerfMonEoverP.h:265
IDPerfMonEoverP::m_evtNumber
unsigned int m_evtNumber
Definition: IDPerfMonEoverP.h:195
IDPerfMonEoverP::m_pvz
float m_pvz[NO_PV]
Definition: IDPerfMonEoverP.h:253
xAOD::Iso::etcone20
@ etcone20
Calorimeter isolation.
Definition: IsolationType.h:32
IDPerfMonEoverP::m_smallValidationTree
TTree * m_smallValidationTree
Definition: IDPerfMonEoverP.h:308
Trk::theta
@ theta
Definition: ParamDefs.h:66
IDPerfMonEoverP::m_evt
SG::ReadHandleKey< xAOD::EventInfo > m_evt
ReadHandle to the Event Info.
Definition: IDPerfMonEoverP.h:155
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
IDPerfMonEoverP::m_validationTreeName
std::string m_validationTreeName
validation tree description - second argument in TTree
Definition: IDPerfMonEoverP.h:185
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::EgammaParameters::emins1
@ emins1
energy reconstructed in the strip with the minimal value between the first and second maximum
Definition: EgammaEnums.h:143
IDPerfMonEoverP::m_covpvypvz
float m_covpvypvz[NO_PV]
Definition: IDPerfMonEoverP.h:258
xAOD::Egamma_v1::caloCluster
const xAOD::CaloCluster * caloCluster(size_t index=0) const
Pointer to the xAOD::CaloCluster/s that define the electron candidate.
Definition: Egamma_v1.cxx:388
IDPerfMonEoverP::m_pvy
float m_pvy[NO_PV]
Definition: IDPerfMonEoverP.h:252
TCS::MET
@ MET
Definition: Trigger/TrigT1/L1Topo/L1TopoCommon/L1TopoCommon/Types.h:16
xAOD::MissingET_v1
Principal data object for Missing ET.
Definition: MissingET_v1.h:25
IDPerfMonEoverP::m_ePID_SummaryType
float m_ePID_SummaryType[50][NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:272
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::ParametersBase
Definition: ParametersBase.h:55
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
IDPerfMonEoverP::m_WenuTightElectronET
TH1F * m_WenuTightElectronET
Definition: IDPerfMonEoverP.h:295
IDPerfMonEoverP::storeMETinformation
bool storeMETinformation()
Definition: IDPerfMonEoverP.cxx:829
IDPerfMonEoverP::m_associatedToVtx
int m_associatedToVtx[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:243
IDPerfMonEoverP::m_jetCleaningTool
ToolHandle< IJetSelector > m_jetCleaningTool
jet selector tool
Definition: IDPerfMonEoverP.h:168
IDPerfMonEoverP::passZeeSelection
bool passZeeSelection(std::vector< int > &electrons)
Definition: IDPerfMonEoverP.cxx: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.
IDPerfMonEoverP::m_electronErrz0
float m_electronErrz0[3][NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:214
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
IDPerfMonEoverP::m_LHToolMedium2015
AsgElectronLikelihoodTool * m_LHToolMedium2015
Definition: IDPerfMonEoverP.h:330
IDPerfMonEoverP::m_PID_ShowerType_Names
std::vector< std::pair< xAOD::EgammaParameters::ShowerShapeType, std::string > > m_PID_ShowerType_Names
Definition: IDPerfMonEoverP.h:274
Trk::Track::perigeeParameters
const Perigee * perigeeParameters() const
return Perigee.
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:163
xAOD::MissingETContainer_v1
Container for xAOD::MissingET_v1 objects.
Definition: MissingETContainer_v1.h:21
IDPerfMonEoverP::m_electronCounter
int m_electronCounter
counter for electrons
Definition: IDPerfMonEoverP.h:200
xAOD::EgammaParameters
Definition: EgammaDefs.h:19
IDPerfMonEoverP::m_WenuTightElectron_PTEtaNeg
TH2F * m_WenuTightElectron_PTEtaNeg
validation tree name - to be acessed by this from root
Definition: IDPerfMonEoverP.h:298
IDPerfMonEoverP::validationAction
void validationAction()
Definition: IDPerfMonEoverP.cxx:815
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
Trk::d0
@ d0
Definition: ParamDefs.h:63
MET
Definition: MET.py:1
DataVector< const Trk::TrackStateOnSurface >::const_reverse_iterator
std::reverse_iterator< const_iterator > const_reverse_iterator
Standard const_reverse_iterator.
Definition: DataVector.h:846
IDPerfMonEoverP::m_lhTune
std::string m_lhTune
Definition: IDPerfMonEoverP.h:328
xAOD::EgammaParameters::deltaPhi2
@ deltaPhi2
difference between the cluster phi (second sampling) and the phi of the track extrapolated to the sec...
Definition: EgammaEnums.h:204
IDPerfMonEoverP::m_ClusterEta
float m_ClusterEta[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:231
IDPerfMonEoverP::m_nbpv
int m_nbpv
Definition: IDPerfMonEoverP.h:247
IDPerfMonEoverP::m_fillDetailedTree
bool m_fillDetailedTree
validation tree name - to be acessed by this from root
Definition: IDPerfMonEoverP.h:181
IDPerfMonEoverP::m_nSCTout
int m_nSCTout[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:222
item
Definition: ItemListSvc.h:43
IDPerfMonEoverP::m_IsEMTightTRT
bool m_IsEMTightTRT[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:237
IDPerfMonEoverP::m_nTRTout
int m_nTRTout[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:221
IDPerfMonEoverP::m_ZeeLooseMassSS_Cluster
TH1F * m_ZeeLooseMassSS_Cluster
Definition: IDPerfMonEoverP.h:286
IDPerfMonEoverP::m_sumet
float m_sumet
Definition: IDPerfMonEoverP.h:263
xAOD::Electron_v1
Definition: Electron_v1.h:34
IDPerfMonEoverP::m_small1_QoverP
double m_small1_QoverP
Definition: IDPerfMonEoverP.h:312
IDPerfMonEoverP::fillIsEM
void fillIsEM(const xAOD::Electron *eg)
Definition: IDPerfMonEoverP.cxx: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:254
IDPerfMonEoverP::m_ZeeMediumMassOS_Cluster
TH1F * m_ZeeMediumMassOS_Cluster
Definition: IDPerfMonEoverP.h:287
IDPerfMonEoverP::m_refitEverything
bool m_refitEverything
Definition: IDPerfMonEoverP.h:171
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
python.testIfMatch.matrix
matrix
Definition: testIfMatch.py:66
a
TList * a
Definition: liststreamerinfos.cxx:10
IDPerfMonEoverP::m_validationTreeFolder
std::string m_validationTreeFolder
Root Validation Tree.
Definition: IDPerfMonEoverP.h:189
h
IDPerfMonEoverP::m_ZeeMediumOS_ClusterPtEta
TH2F * m_ZeeMediumOS_ClusterPtEta
Definition: IDPerfMonEoverP.h:289
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
IDPerfMonEoverP::m_ClusterEnergy
float m_ClusterEnergy[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:230
xAOD::numberOfSCTOutliers
@ numberOfSCTOutliers
number of SCT outliers [unit8_t].
Definition: TrackingPrimitives.h:269
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
IDPerfMonEoverP::m_author
int m_author[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:228
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
IDPerfMonEoverP::m_small_QoverP
double m_small_QoverP
Definition: IDPerfMonEoverP.h:311
DeMoScan.first
bool first
Definition: DeMoScan.py:536
IDPerfMonEoverP::m_pvnbtk
int m_pvnbtk[NO_PV]
Definition: IDPerfMonEoverP.h:249
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:67
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
IDPerfMonEoverP::m_ZeeLooseMassOS_Cluster
TH1F * m_ZeeLooseMassOS_Cluster
Definition: IDPerfMonEoverP.h:285
TauGNNUtils::Variables::absEta
bool absEta(const xAOD::TauJet &tau, double &out)
Definition: TauGNNUtils.cxx:234
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
IDPerfMonEoverP::m_trigDec
ToolHandle< Trig::TrigDecisionTool > m_trigDec
The trigger decision tool.
Definition: IDPerfMonEoverP.h:164
IDPerfMonEoverP::fillTriggerInformation
void fillTriggerInformation()
Definition: IDPerfMonEoverP.cxx:958
IDPerfMonEoverP::m_nBLayer
int m_nBLayer[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:219
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
xAOD::EgammaParameters::e277
@ e277
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 7x7
Definition: EgammaEnums.h:80
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
IDPerfMonEoverP::m_electronErrPhi
float m_electronErrPhi[3][NOS_ELECTRONS]
Track phi error on electron.
Definition: IDPerfMonEoverP.h:211
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
AsgElectronLikelihoodTool::initialize
virtual StatusCode initialize() override
Gaudi Service Interface method implementations.
Definition: AsgElectronLikelihoodTool.cxx:80
IDPerfMonEoverP::m_pvtype
int m_pvtype[NO_PV]
Definition: IDPerfMonEoverP.h:248
xAOD::EgammaParameters::weta1
@ weta1
shower width using +/-3 strips around the one with the maximal energy deposit: w3 strips = sqrt{sum(E...
Definition: EgammaEnums.h:97
IDPerfMonEoverP::m_InputElectronContainerName
std::string m_InputElectronContainerName
Electron collection input name.
Definition: IDPerfMonEoverP.h:135
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
IDPerfMonEoverP::m_electronz0
float m_electronz0[3][NOS_ELECTRONS]
Track q over p on electron.
Definition: IDPerfMonEoverP.h:206
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
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:147
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
xAOD::EgammaParameters::deltaEta1
@ deltaEta1
difference between the cluster eta (first sampling) and the eta of the track extrapolated to the firs...
Definition: EgammaEnums.h:184
IDPerfMonEoverP::findAssociatedVertex
VxPos findAssociatedVertex(std::map< const xAOD::TrackParticle *, VxPos > &trackParticleVertexMap, const xAOD::Vertex *primaryVertexFirstCandidate, const xAOD::Electron *) const
Definition: IDPerfMonEoverP.cxx: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:203
IDPerfMonEoverP::m_IsEMMedium
bool m_IsEMMedium[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:235
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
VxPos
std::pair< const xAOD::Vertex *, int > VxPos
Definition: IDPerfMonEoverP.h:78
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
xAOD::EgammaParameters::emaxs1
@ emaxs1
energy of strip with maximal energy deposit
Definition: EgammaEnums.h:145
xAOD::CaloCluster_v1::e
virtual double e() const
The total energy of the particle.
Definition: CaloCluster_v1.cxx:265
IDPerfMonEoverP::m_nPIX
int m_nPIX[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:220
IDPerfMonEoverP::m_PID_SummaryType_Names
std::vector< std::pair< xAOD::SummaryType, std::string > > m_PID_SummaryType_Names
Definition: IDPerfMonEoverP.h:277
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
Trk::phi0
@ phi0
Definition: ParamDefs.h:65
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition: TrackStateOnSurface.h:101
InDetDD::electrons
@ electrons
Definition: InDetDD_Defs.h:17
xAOD::EgammaParameters::fracs1
@ fracs1
shower shape in the shower core : [E(+/-3)-E(+/-1)]/E(+/-1), where E(+/-n) is the energy in ± n strip...
Definition: EgammaEnums.h:111
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
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:329
xAOD::EgammaParameters::AuthorElectron
const uint16_t AuthorElectron
Object Reconstructed by standard cluster-based algorithm.
Definition: EgammaDefs.h:24
IDPerfMonEoverP::m_smallClusterPhi
double m_smallClusterPhi
Definition: IDPerfMonEoverP.h:315
IDPerfMonEoverP::m_smalld0
double m_smalld0
Definition: IDPerfMonEoverP.h:319
read_hist_ntuple.f1
f1
Definition: read_hist_ntuple.py:4
xAOD::EgammaParameters::weta2
@ weta2
the lateral width is calculated with a window of 3x5 cells using the energy weighted sum over all cel...
Definition: EgammaEnums.h:103
IDPerfMonEoverP::m_electrond0
float m_electrond0[3][NOS_ELECTRONS]
Track Phi on electron.
Definition: IDPerfMonEoverP.h:205
IDPerfMonEoverP::m_electronErrTheta
float m_electronErrTheta[3][NOS_ELECTRONS]
Track theta error on electron.
Definition: IDPerfMonEoverP.h:210
NOS_ELECTRONS
#define NOS_ELECTRONS
Definition: IDPerfMonEoverP.h:75
ServiceHandle< ITHistSvc >
IDPerfMonEoverP::m_smallTrackTheta
double m_smallTrackTheta
Definition: IDPerfMonEoverP.h:317
IDPerfMonEoverP::m_refittedTracks_no1
TrackCollection * m_refittedTracks_no1
Refitted track collection.
Definition: IDPerfMonEoverP.h:151
IDPerfMonEoverP::m_WenuTightMet_MT
TH1F * m_WenuTightMet_MT
Definition: IDPerfMonEoverP.h:294
IDPerfMonEoverP::m_smallValidationTreeDescription
std::string m_smallValidationTreeDescription
stream/folder to for the TTree to be written out
Definition: IDPerfMonEoverP.h:304
Generated on Thu Nov 7 2024 21:45:24 for ATLAS Offline Software by   doxygen 1.8.18