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, V, H > &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, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &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 59 of file IDPerfMonEoverP.cxx.

60  :
61  AthAlgorithm(name, pSvcLocator),
62  m_refittedTracks_no1{},
63  m_refittedTracks_no2{},
64  m_TrackRefitter(""),
65  m_TrackRefitter_no2(""),
66  m_trigDec("Trig::TrigDecisionTool/TrigDecisionTool"),
67  m_refitEverything(true),
68  m_isDATA(true),
69  m_validationMode(true),
70  m_fillDetailedTree(false),
71  m_validationTreeName("EGrefitter"),
72  m_validationTreeDescription("egamma track refitter caches"),
73  m_validationTreeFolder("/eoverpValidation/efitterValidation"),
74  m_validationTree(0),
75  m_runNumber{},
76  m_evtNumber{},
77  m_lumi_block{},
78  m_nelectrons{},
79  m_electronCounter(0),
80  m_nbpv{},
81  m_METgoodness{},
82  m_sumet{},
83  m_missingEt{},
84  m_missingEtx{},
85  m_missingEty{},
86  m_ZeeLooseMassOS_Cluster(nullptr),
87  m_ZeeLooseMassSS_Cluster(nullptr),
88  m_ZeeMediumMassOS_Cluster(nullptr),
89  m_ZeeMediumMassSS_Cluster(nullptr),
90  m_ZeeMediumOS_ClusterPtEta(nullptr),
91  m_WenuLooseElectronET(nullptr),
92  m_WenuTight_Met(nullptr),
93  m_WenuTight_MT(nullptr),
94  m_WenuTightMet_MT(nullptr),
95  m_WenuTightElectronET(nullptr),
96  m_WenuTightW_PT(nullptr),
97  m_WenuTightElectron_PTEtaPos(nullptr),
98  m_WenuTightElectron_PTEtaNeg(nullptr),
99  m_smallValidationTreeName("EGrefitterSmall"),
100  m_smallValidationTreeDescription("Small Tree for E/p fits"),
101  m_smallValidationTreeFolder("/eoverpValidation2/efitterValidation2"),
102  m_smallValidationTree(nullptr),
103  m_small_QoverP{},
104  m_small1_QoverP{},
105  m_small2_QoverP{},
106  m_smallClusterEnergy{},
107  m_smallClusterPhi{},
108  m_smallClusterEta{},
109  m_smallTrackTheta{},
110  m_smallCharge{},
111  m_smalld0{},
112  m_smallz0{},
113  m_LHToolLoose2015{},
114  m_LHToolMedium2015{},
115  m_LHToolTight2015{}
116 {
117 
118 // The following properties are specified at run-time
119 // (declared in jobOptions file)
120  declareProperty("RefitTracks", m_refitEverything);
121  declareProperty("isDATA", m_isDATA);
122  declareProperty("ReFitterTool", m_TrackRefitter, "ToolHandle for track fitter implementation");
123  declareProperty("ReFitterTool2", m_TrackRefitter_no2, "ToolHandle for track fitter implementation");
124  declareProperty("TrigDecisionTool", m_trigDec, "The TrigDecisionTool instance.");
125  declareProperty("InputElectronContainerName", m_InputElectronContainerName = "Electrons");
126  declareProperty("InputJetContainerName", m_jetContainerName = "AntiKt4LCTopoJets");
127  // declareProperty("MissingEtObjectName", m_missingEtObjectName = "MET_RefFinal");
128  declareProperty("METFinalName", m_metRefFinalName= "FinalClus");
129  declareProperty("MissingEtObjectName", m_missingEtObjectName = "MET_Reference_AntiKt4LCTopo");
130  declareProperty("primaryVertexCollection", m_primaryVertexCollection = "PrimaryVertices");
131  declareProperty("RefittedElectronTrackContainer1", m_OutputTrackCollectionName_no1="GSFTracks");
132  declareProperty("RefittedElectronTrackContainer2", m_OutputTrackCollectionName_no2="DNATracks");
133  declareProperty("ValidationMode", m_validationMode);
134  declareProperty("FillDetailedTree", m_fillDetailedTree);
135  declareProperty("ElectronLikelihoodTune", m_lhTune="mc15_20150712");
136 }

◆ ~IDPerfMonEoverP()

IDPerfMonEoverP::~IDPerfMonEoverP ( )

Destructor.

Definition at line 140 of file IDPerfMonEoverP.cxx.

141 {
142 
143 }

Member Function Documentation

◆ addToValidationNtuple()

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

addToValidationNutple

Definition at line 669 of file IDPerfMonEoverP.cxx.

669  {
670  if (perigee){
671  ATH_MSG_DEBUG( "Adding data to ntuple" );
672  if (isOriginal >= 0 && isOriginal <3){
673  m_electrond0[isOriginal][m_electronCounter] = perigee->parameters()[Trk::d0];
674  m_electronz0[isOriginal][m_electronCounter] = perigee->parameters()[Trk::z0];
675  m_electronPhi[isOriginal][m_electronCounter] = perigee->parameters()[Trk::phi0];
676  m_electronTheta[isOriginal][m_electronCounter]= perigee->parameters()[Trk::theta];
677  m_electronQoverP[isOriginal][m_electronCounter]= perigee->parameters()[Trk::qOverP];
678  //
679  const AmgSymMatrix(5)* matrix = perigee->covariance();
680  if (matrix){
681  m_electronErrd0[isOriginal][m_electronCounter] =std::sqrt( (*matrix)(Trk::d0,Trk::d0) );
682  m_electronErrz0[isOriginal][m_electronCounter] = std::sqrt( (*matrix)(Trk::z0,Trk::z0) );
683  m_electronErrPhi[isOriginal][m_electronCounter] = std::sqrt( (*matrix)(Trk::phi0,Trk::phi0) );
684  m_electronErrTheta[isOriginal][m_electronCounter]= std::sqrt( (*matrix)(Trk::theta,Trk::theta) );
685  m_electronErrQoverP[isOriginal][m_electronCounter]= std::sqrt( (*matrix)(Trk::qOverP,Trk::qOverP) );
686  }
687  }
688  } else {
689  ATH_MSG_DEBUG( "No MeasuredPerigee - cannot add data to ntuple" );
690  }
691 
692  ATH_MSG_DEBUG( "Finished adding data to ntuple" );
693 
694 }

◆ clearValidationNtuple()

void IDPerfMonEoverP::clearValidationNtuple ( )
private

Definition at line 742 of file IDPerfMonEoverP.cxx.

743 {
744  ATH_MSG_DEBUG( "clearValidationNtuple" );
745  for (int i = 0 ; i < NOS_ELECTRONS ; ++i){
746  for (int j = 0 ; j <3 ; ++j){
747  m_electrond0[j][i] = 0;
748  m_electronz0[j][i] = 0;
749  m_electronPhi[j][i] = 0;
750  m_electronTheta[j][i] = 0;
751  m_electronQoverP[j][i] = 0;
752  m_electronLMQoverP[j][i] = 0;
753 
754  m_electronErrd0[j][i] = 0;
755  m_electronErrz0[j][i] = 0;
756  m_electronErrPhi[j][i] = 0;
757  m_electronErrTheta[j][i] = 0;
758  m_electronErrQoverP[j][i] = 0;
759 
760  }
761  m_associatedToVtx[i] = 0;
762 
763  m_author[i] = 0;
764 
765  m_ClusterEnergy[i] = 0;
766 
767  m_IsEMLoose[i] = false;
768  m_IsEMMedium[i] = false;
769  m_IsEMTight[i] = false;
770  m_IsEMTightTRT[i] = false;
771 
772 
773  for (int j = 0 ; j < 50 ; ++j){
774  m_ePID_ShowerType[j][i] =0;
775  m_ePID_IsolationType[j][i] =0;
776  m_ePID_TrackCaloMatchType[j][i] =0;
777  m_ePID_SummaryType[j][i] =0;
778  m_trigger[j] = false;
779  }
780  }
781 
782 
783  //Vertex information
784  m_nbpv =0;
785  for (int i(0); i< NO_PV; ++i){
786  m_pvtype[i] =0;
787  m_pvnbtk[i]=0;
788  m_pvsumpt[i]=0;
789  m_pvx[i]=0;
790  m_pvy[i]=0;
791  m_pvz[i]=0;
792  m_errpvx[i]=0;
793  m_errpvy[i]=0;
794  m_errpvz[i]=0;
795  m_covpvxpvy[i]=0;
796  m_covpvypvz[i]=0;
797  m_covpvzpvx[i]=0;
798  }
799  //MET
800  m_METgoodness=false;
801  m_sumet=0;
802  m_missingEt=0;
803  m_missingEtx=0;
804  m_missingEty=0;
805 
806 }

◆ 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, V, H > &  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, V, H > &  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, V, H > &  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, V, H > &  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, V, H > &  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 811 of file IDPerfMonEoverP.cxx.

812 {
813 
814 }

◆ 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 462 of file IDPerfMonEoverP.cxx.

463 {
464  ATH_MSG_DEBUG( "Executing IDPerfMonEoverP" );
465  StatusCode sc(StatusCode::SUCCESS);
466  std::map<const xAOD::TrackParticle*, VxPos > trackParticleVertexMap;
467  const xAOD::Vertex* primaryVertexFirstCandidate = nullptr;
468  if (m_validationMode){
469  clearValidationNtuple();
470  }else{
471  ATH_MSG_WARNING( " Validation Mode has been turned off ALG will do not fill Ntuples" );
472  return sc;
473  }
474 
475  ATH_MSG_DEBUG("Retrieving event info.");
476  SG::ReadHandle<xAOD::EventInfo> evt(m_evt);
477  if(evt.isValid()) {
478  m_runNumber = evt->runNumber();
479  m_evtNumber = evt->eventNumber();
480  m_lumi_block = evt->lumiBlock();
481  }
482  else {
483  ATH_MSG_ERROR("Could not retrieve event info."); // Keeping ERROR only to preserve old functionality
484  }
485 
486  ATH_MSG_DEBUG("Retrieved Trigger info.");
487  fillTriggerInformation();
488  if ( fillVertexInformation(trackParticleVertexMap, primaryVertexFirstCandidate) ){
489  ATH_MSG_DEBUG("Retrieved Primary Vertex info.");
490  } else {
491  ATH_MSG_DEBUG("No Primary Vertex");
492  }
493 
494  ATH_MSG_DEBUG("MET info.being stored");
495  if( storeMETinformation() )
496  ATH_MSG_DEBUG("MET info. stored");
497  // Get the electron AOD container
498  const xAOD::ElectronContainer* ElectronInput_container;
499 
500  sc = evtStore()->retrieve(ElectronInput_container, m_InputElectronContainerName);
501  if (sc!=StatusCode::SUCCESS){
502  ATH_MSG_WARNING("No electron container");
503  deleteAction();
504  return StatusCode::SUCCESS;
505  }
506 
507 
508  if (ElectronInput_container->empty() ){
509  deleteAction();
510  return StatusCode::SUCCESS;
511  }
512 
513  m_refittedTracks_no1 = new TrackCollection;
514  m_refittedTracks_no2 = new TrackCollection;
515 
516 
517  typedef xAOD::ElectronContainer::const_iterator electron_iterator;
518  electron_iterator iter = ElectronInput_container->begin();
519  electron_iterator iterEnd = ElectronInput_container->end();
520 
521  // Loop over the Electrons
522  ATH_MSG_DEBUG("Electron info. being stored");
523  for(; iter != iterEnd ; ++iter) {
524  if (m_electronCounter >= NOS_ELECTRONS) break;
525  const xAOD::Electron *pThisElectron = (*iter);
526  m_author[m_electronCounter] = pThisElectron->author(xAOD::EgammaParameters::AuthorElectron);
527 
528  // Cluster Info
529  fillElectronInfo ( pThisElectron );
530  // Fill General info
531  fillGeneral( pThisElectron );
532  // Fill IsEm info
533  fillIsEM( pThisElectron );
534 
535 
536  //Get the track particle
537  const xAOD::TrackParticle* mytp = (*iter)->trackParticle();
538 
539  if(mytp){
540  uint8_t dummy(0);
541  auto summaryByDetector=[&mytp,&dummy]( const xAOD::SummaryType & t){
542  return mytp->summaryValue(dummy, t) ? (dummy) : (-1);
543  };
544  m_nTRT[m_electronCounter] = summaryByDetector( xAOD::numberOfTRTHits );
545  m_nSCT[m_electronCounter] = summaryByDetector( xAOD::numberOfSCTHits );
546  m_nPIX[m_electronCounter] = summaryByDetector( xAOD::numberOfPixelHits );
547  m_nBLayer[m_electronCounter] = summaryByDetector( xAOD::numberOfInnermostPixelLayerHits);
548  m_nTRTout[m_electronCounter] = summaryByDetector( xAOD::numberOfTRTOutliers);
549  m_nSCTout[m_electronCounter] = summaryByDetector( xAOD::numberOfSCTOutliers);
550  m_nTRTHT[m_electronCounter] = summaryByDetector( xAOD::numberOfTRTHighThresholdHits);
551  m_nTRTHTout[m_electronCounter] = summaryByDetector( xAOD::numberOfTRTHighThresholdOutliers);
552  } else{
553  ATH_MSG_DEBUG("Electron with no track particle?? Possibly Forward");
554  continue;
555  }
556 
557  //Find which if any vertex the electron track is associated to
558  VxPos myVxPos = findAssociatedVertex( trackParticleVertexMap,
559  primaryVertexFirstCandidate,
560  pThisElectron );
561  m_associatedToVtx[m_electronCounter] = myVxPos.second;
562  if( mytp->track() ){
563  const Trk::Track* oTrkTrack = mytp->track();
564  if (oTrkTrack){
565  const Trk::Perigee* oMeasPer = oTrkTrack->perigeeParameters() ;
566  if (oMeasPer) addToValidationNtuple( oMeasPer, pThisElectron->caloCluster(), 0 );
567  fillLastMeasurement( oTrkTrack , 0 );
568  }
569  }
570  else {
571  ATH_MSG_DEBUG("mytp->track() == 0");
572  const Trk::Perigee* oMeasPer = &(mytp->perigeeParameters()) ;
573  addToValidationNtuple( oMeasPer, pThisElectron->caloCluster(), 0 );
574  }
575 
576 
577  if(m_refitEverything) {
578  // First Refitter................
579  ATH_MSG_DEBUG( "Refitting the track" );
580 
581  IegammaTrkRefitterTool::Cache cache1{};
582  StatusCode sc = m_TrackRefitter->refitTrack(Gaudi::Hive::currentContext(),
583  pThisElectron->trackParticle()->track(),
584  cache1 );
585 
586  if (sc == StatusCode::SUCCESS){
587  Trk::Track* trkTrack= cache1.refittedTrack.release();
588  m_refittedTracks_no1->push_back(trkTrack);
589  addToValidationNtuple( cache1.refittedTrackPerigee ,pThisElectron->caloCluster(), 1 );
590  fillLastMeasurement(trkTrack, 1 );
591  } else {
592  ATH_MSG_DEBUG( "Track Refit Failed" );
593  }
594  //******************************************************//
595  // Refit tracks using the second refitter if it is present
596  //******************************************************//
597  ATH_MSG_DEBUG( "Refitting the track again" );
598 
599  IegammaTrkRefitterTool::Cache cache2{};
600  sc = m_TrackRefitter_no2->refitTrack(Gaudi::Hive::currentContext(),
601  pThisElectron->trackParticle()->track(),
602  cache2 );
603 
604  if (sc == StatusCode::SUCCESS){
605  Trk::Track* trkTrack= cache2.refittedTrack.release();
606  //Add the refitted track to the TrackCollection
607  m_refittedTracks_no2->push_back( trkTrack );
608  //Add data to the trkRefitterNtuple
609 
610  addToValidationNtuple( cache2.refittedTrackPerigee ,pThisElectron->caloCluster(), 2 );
611  fillLastMeasurement( trkTrack, 2 );
612  } else {
613  ATH_MSG_DEBUG( "Track Refit Failed" );
614  }
615  } else {
616  ATH_MSG_DEBUG( "Not Refitting the track -- DO NOTHING" );
617  }//End if >6 silicon hits;
618  //Increment the electron counter for the validation nutple
619  ++m_electronCounter;
620  }
621  // Commit Data to Ntuple;
622  if( m_validationMode ) validationAction();
623  // Fill much smaller tree
624  std::vector<int> goodElectrons = FillSimpleTree();
625  TrackCollection* selectedElectrons = new TrackCollection;
626 
627  for( const auto & thisGoodElectron: goodElectrons){
628  IegammaTrkRefitterTool::Cache cache{};
629  StatusCode sc = m_TrackRefitter->refitTrack(Gaudi::Hive::currentContext(),
630  (*ElectronInput_container)[thisGoodElectron]->trackParticle()->track(),
631  cache );
632  if (sc == StatusCode::SUCCESS){
633  Trk::Track* trkTrack= cache.refittedTrack.release();
634  selectedElectrons->push_back(trkTrack);
635  }
636  }
637 
638  //******************************************************//
639  //* Add the newly created TrackCollection to StoreGate *//
640  //******************************************************//
641 
642  sc = evtStore()->record( m_refittedTracks_no1, m_OutputTrackCollectionName_no1, false );
643  if (sc.isFailure())
644  {
645  ATH_MSG_ERROR("Could not record "<< m_OutputTrackCollectionName_no1 <<" object.");
646  delete selectedElectrons;
647  return (StatusCode::FAILURE);
648  }
649  //
650  sc = evtStore()->record( m_refittedTracks_no2, m_OutputTrackCollectionName_no2, false );
651  if (sc.isFailure())
652  {
653  ATH_MSG_ERROR("Could not record "<< m_OutputTrackCollectionName_no2 <<" object.");
654  delete selectedElectrons;
655  return (StatusCode::FAILURE);
656  }
657  //
658  sc = evtStore()->record( selectedElectrons, m_OutputTrackCollectionName_no1 + "Selected", false );
659  if (sc.isFailure())
660  {
661  ATH_MSG_ERROR("Could not record "<< m_OutputTrackCollectionName_no1+"Selected" <<" object.");
662  delete selectedElectrons;
663  return (StatusCode::FAILURE);
664  }
665  ATH_MSG_DEBUG( "execute completed successfully");
666  return StatusCode::SUCCESS;
667 }

◆ 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 978 of file IDPerfMonEoverP.cxx.

979 {
980  ATH_MSG_VERBOSE( "In fillElectronInfo()" );
981  for (size_t i = 0; i < m_PID_ShowerType_Names.size(); i++) {
982  float dummy(-1);
983  m_ePID_ShowerType[i][m_electronCounter] = static_cast<float> (p->showerShapeValue( dummy, m_PID_ShowerType_Names[i].first ))? dummy :-1;
984  }
985  for (size_t i = 0; i < m_PID_TrackCaloMatchType_Names.size(); i++) {
986  float dummy(-1);
987  m_ePID_TrackCaloMatchType[i][m_electronCounter] = static_cast<float> (p->trackCaloMatchValue( dummy, m_PID_TrackCaloMatchType_Names[i].first ))? dummy :-1;
988  }
989 
990 for (size_t i = 0; i < m_PID_SummaryType_Names.size(); i++) {
991  float dummy(-1);
992  m_ePID_SummaryType[i][m_electronCounter] = static_cast<float> (p->trackParticleSummaryValue( dummy, m_PID_SummaryType_Names[i].first ))? dummy :-1;
993  }
994 
995  return;
996 
997 }

◆ fillGeneral()

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

Definition at line 729 of file IDPerfMonEoverP.cxx.

730 {
731  ATH_MSG_DEBUG( "fillGeneral" );
732  const xAOD::CaloCluster* cluster = eg->caloCluster();
733  if(!cluster) return;
734  m_ClusterEnergy[m_electronCounter] = cluster->e();
735  m_ClusterPhi[m_electronCounter] = cluster->phi();
736  m_ClusterEta[m_electronCounter] = cluster->eta();
737 }

◆ fillIsEM()

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

Definition at line 699 of file IDPerfMonEoverP.cxx.

700 {
701  ATH_MSG_DEBUG( "fillIsEM" );
702  int el_goodOQ = (int)eg->isGoodOQ(xAOD::EgammaParameters::BADCLUSELECTRON);
703  m_isGoodOQ[m_electronCounter] = el_goodOQ;
704  // check loose LH
705  bool val_loose = (bool) m_LHToolLoose2015->accept(eg);
706  ATH_MSG_DEBUG( "Loose value : " << val_loose);
707  if(val_loose){
708  m_IsEMLoose[m_electronCounter] = val_loose;
709  }//else{ATH_MSG_DEBUG("Loose electron not defined !");}
710 
711  // check medium LH
712  bool val_med = (bool) m_LHToolMedium2015->accept(eg);
713  ATH_MSG_DEBUG( "Medium value : " << val_med );
714  if(val_med){
715  m_IsEMMedium[m_electronCounter] = val_med;
716  }//else{ATH_MSG_DEBUG("Mediu, electron not defined !");}
717 
718  // check tight LH
719  bool val_tight = (bool) m_LHToolTight2015->accept(eg);
720  ATH_MSG_DEBUG( "Tight value : " << val_tight);
721  if(val_tight){
722  m_IsEMTight[m_electronCounter] = val_tight;
723  }//else{ATH_MSG_DEBUG("Tight electron not defined !");}
724  return;
725 
726 }

◆ fillLastMeasurement()

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

Definition at line 999 of file IDPerfMonEoverP.cxx.

1000 {
1001  ATH_MSG_VERBOSE("In fillLastMeasurement()");
1002  if(!track) return false;
1003  const Trk::TrackParameters* trkPara =0;
1004 
1005  const Trk::TrackStates* oldTrackStates = track->trackStateOnSurfaces();
1006  if (oldTrackStates == 0)
1007  {
1008  return false;
1009  }
1010 
1011  for ( Trk::TrackStates::const_reverse_iterator rItTSoS = oldTrackStates->rbegin(); rItTSoS != oldTrackStates->rend(); ++rItTSoS)
1012  {
1013  if (trkPara!=0){
1014  break;
1015  }
1016 
1017  if ( (*rItTSoS)->type(Trk::TrackStateOnSurface::Measurement) && (*rItTSoS)->trackParameters()!=0 && (*rItTSoS)->measurementOnTrack()!=0)
1018  {
1019  trkPara = (*rItTSoS)->trackParameters();
1020  }
1021  }
1022 
1023  if (trkPara !=0 ){
1024  m_electronLMQoverP[fitter][m_electronCounter] = trkPara->parameters()[Trk::qOverP] ;
1025  return true;
1026  }
1027 
1028  return false;
1029 
1030 }

◆ FillSimpleTree()

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

Definition at line 1251 of file IDPerfMonEoverP.cxx.

1252 {
1253  ATH_MSG_VERBOSE("In fillSimpleTree()");
1254  std::vector<int> electronsZee;
1255  std::vector<int> electronsWenu;
1256  passZeeSelection(electronsZee);
1257  passWenuSelection(electronsWenu);
1258  std::vector<int> allInterestingElectrons;
1259  for(int i(0); i < (int)electronsZee.size(); ++i){
1260  int ele = electronsZee[i];
1261  if ( std::find(allInterestingElectrons.begin(), allInterestingElectrons.end(), ele)==allInterestingElectrons.end() ){
1262  allInterestingElectrons.push_back(ele);
1263  }
1264  }
1265  for(int i(0); i < (int)electronsWenu.size(); ++i){
1266  int ele = electronsWenu[i];
1267  if ( std::find(allInterestingElectrons.begin(), allInterestingElectrons.end(), ele)==allInterestingElectrons.end() ){
1268  allInterestingElectrons.push_back(ele);
1269  }
1270  }
1271  ATH_MSG_DEBUG(" SimpleTreeElectrons " << allInterestingElectrons.size() );
1272  for(int i(0); i < (int)allInterestingElectrons.size(); ++i){
1273  int ele = allInterestingElectrons[i];
1274  if (m_electronQoverP[0][ele] > 0 )
1275  m_smallCharge = 1.;
1276  else
1277  m_smallCharge =-1.;
1278  m_smallTrackTheta = m_electronTheta[0][ele];
1279  m_small_QoverP = m_electronQoverP[0][ele];
1280  m_small1_QoverP = m_electronQoverP[1][ele];
1281  m_small2_QoverP = m_electronQoverP[2][ele];
1282  m_smallClusterEnergy = m_ClusterEnergy[ele];
1283  m_smallClusterPhi = m_ClusterPhi[ele];
1284  m_smallClusterEta = m_ClusterEta[ele];
1285  m_smallValidationTree->Fill();
1286  }
1287 
1288  return allInterestingElectrons;
1289 }

◆ fillTriggerInformation()

void IDPerfMonEoverP::fillTriggerInformation ( )
private

Definition at line 959 of file IDPerfMonEoverP.cxx.

960 {
961  ATH_MSG_VERBOSE("In fillTriggerInformation()");
962  ATH_MSG_DEBUG( "Pass state All = " << m_trigDec->isPassed( ".*" ) );
963  ATH_MSG_DEBUG( "Pass state L1 = " << m_trigDec->isPassed( "L1_.*" ) );
964  ATH_MSG_DEBUG( "Pass state L2 = " << m_trigDec->isPassed( "L2_.*" ) );
965  ATH_MSG_DEBUG( "Pass state EF = " << m_trigDec->isPassed( "EF_.*" ) );
966  ATH_MSG_DEBUG("HLT_.* is passed: " << m_trigDec->isPassed("HLT_.*"));
967  for (unsigned int i=0; i < m_triggerNames.size(); ++i){
968  if(m_triggerNames[i] == "ALL")
969  m_trigger[i] = m_trigDec->isPassed(".*");
970  else if(m_triggerNames[i] == "HLT_ALL")
971  m_trigger[i] = m_trigDec->isPassed("HLT_.*");
972  else
973  m_trigger[i] = m_trigDec->isPassed(m_triggerNames[i]);
974  }
975  return;
976 }

◆ fillVertexInformation()

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

Definition at line 873 of file IDPerfMonEoverP.cxx.

875 {
876  ATH_MSG_DEBUG( "fillVertexInformation()" );
877  const xAOD::VertexContainer* vxContainer(0);
878  int npv = 0;
879  StatusCode sc = evtStore()->retrieve(vxContainer, m_primaryVertexCollection);
880  if (sc.isFailure()) {
881  ATH_MSG_WARNING( "Could not retrieve primary vertex info: " << m_primaryVertexCollection );
882  return false;
883  } else {
884  ATH_MSG_DEBUG( "Found primary vertex info: " << m_primaryVertexCollection );
885  if(vxContainer) {
886  ATH_MSG_DEBUG("Nb of reco primary vertex for coll "
887  << " = " << vxContainer->size() );
888  primaryVertexFirstCandidate = std::begin(*vxContainer)[0];
889  ATH_MSG_DEBUG( "The primary vertex : " << primaryVertexFirstCandidate->type() );
890  for(const auto* vxI : *vxContainer ) {
891  int type = (int)(vxI)->vertexType();
892  const xAOD::Vertex* primaryVertex = vxI;
893  int nbtk = 0;
894  const std::vector< ElementLink< xAOD::TrackParticleContainer > > tpLinks = vxI->trackParticleLinks();
895  float sumpt = 0.;
896  if(not tpLinks.empty()) {
897  nbtk = tpLinks.size();
898  for(const auto& tp_elem : tpLinks ){
899  const xAOD::TrackParticle* trk = *tp_elem;
900  VxPos myVxPos = std::make_pair(vxI,npv);
901  trackParticleVertexMap.insert( std::make_pair( trk, myVxPos ) );
902  if(trk) {
903  sumpt += trk->p4().Perp();
904  }
905  }
906  ATH_MSG_DEBUG( "Reco PV " << npv << ": ("
907  << primaryVertex->position().x() << ","
908  << primaryVertex->position().y() << ","
909  << primaryVertex->position().z() << ")"
910  << " type=" << type
911  << " nbtk=" << nbtk
912  << " sumpt=" << sumpt);
913 
914  if(npv >= NO_PV) {
915  ATH_MSG_WARNING( "More than " << NO_PV << " reconstructed primary vertices in event "
916  << "for run= " << m_runNumber << " evt= " << m_evtNumber
917  << ". Truncated event. " );
918  } else {
919  m_pvtype[npv] = type;
920  m_pvnbtk[npv] = nbtk;
921  m_pvsumpt[npv] = sumpt;
922  m_pvx[npv] = primaryVertex->position().x();
923  m_pvy[npv] = primaryVertex->position().y();
924  m_pvz[npv] = primaryVertex->position().z();
925 
926  }
927  ++npv;
928  } else {
929  ATH_MSG_DEBUG( "Vertex " << npv << " has no tracks associated to it!" );
930  }
931  }
932  } else {
933  ATH_MSG_DEBUG( "No container in collection?? " << m_primaryVertexCollection );
934  }
935  }
936  m_nbpv = npv;
937 
938  ATH_MSG_DEBUG("Done filling Vertex information");
939 
940  if (npv == 0) return false;
941  return true;
942 }

◆ finalize()

StatusCode IDPerfMonEoverP::finalize ( )

Definition at line 455 of file IDPerfMonEoverP.cxx.

456 {
457  return StatusCode::SUCCESS;
458 }

◆ findAssociatedVertex()

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

Definition at line 944 of file IDPerfMonEoverP.cxx.

947 {
948  ATH_MSG_VERBOSE("In findAssociatedVertex()");
949  std::map<const xAOD::TrackParticle*, VxPos>::iterator tpVx =
950  trackParticleVertexMap.find(eg->trackParticle());
951  if (tpVx == trackParticleVertexMap.end() ){
952  return std::make_pair( primaryVertexFirstCandidate,-1 );
953  } else
954  return (*tpVx).second;
955 
956 }

◆ getMassCluster()

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

Definition at line 1235 of file IDPerfMonEoverP.cxx.

1236 {
1237  ATH_MSG_VERBOSE("In getMassCluster()");
1238  double ELECTRON_MASS = ParticleConstants::electronMassInMeV; //MeV
1239  TLorentzVector v0,v1;
1240  double pt1 = m_ClusterEnergy[el1]*std::sin(m_electronTheta[0][el1]);
1241  double pt2 = m_ClusterEnergy[el2]*std::sin(m_electronTheta[0][el2]);
1242  double eta1 = -std::log( std::tan(m_electronTheta[0][el1] * 0.5) );
1243  double eta2 = -std::log( std::tan(m_electronTheta[0][el2] * 0.5) );
1244  v0.SetPtEtaPhiM(pt1,eta1,m_electronPhi[0][el1], ELECTRON_MASS);
1245  v1.SetPtEtaPhiM(pt2,eta2,m_electronPhi[0][el2], ELECTRON_MASS);
1246  double mass = (v0+v1).M();
1247  return mass;
1248 
1249 }

◆ initialize()

StatusCode IDPerfMonEoverP::initialize ( )

Gaudi algorithm hooks.

Definition at line 149 of file IDPerfMonEoverP.cxx.

150 {
151  ATH_MSG_INFO("Initializing IDPerfMonEoverP");
152 
153  ATH_CHECK( m_evt.initialize() );
154 
155  // Retrieve Jet selector tool
156  CHECK( m_jetCleaningTool.retrieve() );
157 
158  // Retrieve fitter
159  if (m_TrackRefitter.retrieve().isFailure()) {
160  ATH_MSG_FATAL("Unable to retrieve " << m_TrackRefitter );
161  return StatusCode::FAILURE;
162  } else
163  ATH_MSG_INFO("Retrieved tool" << m_TrackRefitter );
164 
165  // Retrieve the second fitter
166  if (m_TrackRefitter_no2.retrieve().isFailure()) {
167  ATH_MSG_FATAL("Unable to retrieve " << m_TrackRefitter_no2 );
168  return StatusCode::FAILURE;
169  } else {
170  ATH_MSG_INFO("Retrieved tool" << m_TrackRefitter_no2 );
171  }
172 
173  if(m_trigDec.retrieve().isFailure()) {
174  ATH_MSG_FATAL("Unable to retrieve " << m_trigDec << " turn it off");
175  return StatusCode::FAILURE;
176  }
177  else
178  ATH_MSG_INFO("Retrieved tool" << m_trigDec );
179 
180 
181  //
182  // Electron PID Variables
183  //
184  // Following are of ShowerShapeType
185  namespace xEgamma = xAOD::EgammaParameters;
186  namespace xIso = xAOD::Iso;
187  m_PID_ShowerType_Names = {
188  {xEgamma::f1, "f1"},
189  {xEgamma::emins1, "f1core"},
190  {xEgamma::fracs1, "fside"},
191  {xEgamma::e2tsts1, "Emax2"},
192  {xEgamma::weta1, "ws3"},
193  {xEgamma::wtots1, "wstot"},
194  {xEgamma::emaxs1,"emaxs1"},
195  {xEgamma::e233,"E233"},
196  {xEgamma::e237,"E237"},
197  {xEgamma::e277,"E277"},
198  {xEgamma::weta2,"weta2"},
199  {xEgamma::f3,"f3"},
200  {xEgamma::f3core,"f3core"}
201  };
202  // Following are of isolation type
203  m_PID_IsolationType_Names = {
204  {xIso::etcone20,"Etcone20"},
205  {xIso::etcone30,"Etcone30"},
206  {xIso::etcone40,"Etcone40"},
207  {xIso::ptcone30,"ptcone30"}
208  };
209  // Following are of trackcalomatch type
210  m_PID_TrackCaloMatchType_Names = {
211  {xEgamma::deltaEta1,"deltaeta1"},
212  {xEgamma::deltaEta2,"deltaeta2"},
213  {xEgamma::deltaPhi2,"deltaphi2"}
214  };
215 
216 
217 
218  //
219  // Trigger
220  //
221  m_triggerNames = {
222  "L1_MBTS_1",
223  "L1_EM2",
224  "L1_2EM2",
225  "L1_2EM4",
226  "L1_EM5",
227  "L1_EM10",
228  "L1_EM10I",
229  "L1_EM14",
230  "L1_EM18",
231  "L1_EM18I",
232  "L1_EM23I",
233  "L1_EM100",
234  "EF_2e5_medium",
235  "EF_e10_medium",
236  "EF_e20_loose",
237  "EF_em105_passHLT",
238  "EF_g20_loose",
239  "EF_e20_medium",
240  "EF_e22_medium",
241  //run 2 test
242  "HLT_e24_lhmedium_idperf_L1EM20VH",
243  "HLT_e24_medium_L1EM18VH",
244  "e5_vloose",
245  "ALL",
246  "HLT_ALL"
247  };
248 
249  // If the validation nuptle has been requested Setup the ntuple
250  if (m_validationMode){
251  if (m_validationTree == 0 ){
252  // create the new Tree
253  m_validationTree = new TTree(m_validationTreeName.c_str(), m_validationTreeDescription.c_str());
254  std::string FitterNames[3] = {"GX2","Refitted1","Refitted2"};
255  m_validationTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
256  m_validationTree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
257  m_validationTree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
258  // counter for number of electrons
259  m_validationTree->Branch("nElectrons" , &m_nelectrons, "nElectrons/I");
260  // Track fitter information
261  for(int fitter(0); fitter < 3; ++fitter){
262  m_validationTree->Branch(std::string(FitterNames[fitter]+"_Theta").c_str() , m_electronTheta[fitter], std::string(FitterNames[fitter]+"_Theta0[nElectrons]/F").c_str() );
263  m_validationTree->Branch(std::string(FitterNames[fitter]+"_Phi0").c_str() , m_electronPhi[fitter], std::string(FitterNames[fitter]+"_Phi0[nElectrons]/F").c_str() );
264  m_validationTree->Branch(std::string(FitterNames[fitter]+"_QoverP").c_str() , m_electronQoverP[fitter], std::string(FitterNames[fitter]+"_QoverP[nElectrons]/F").c_str());
265  m_validationTree->Branch(std::string(FitterNames[fitter]+"_d0").c_str() , m_electrond0[fitter], std::string(FitterNames[fitter]+"_d0[nElectrons]/F").c_str());
266  m_validationTree->Branch(std::string(FitterNames[fitter]+"_z0").c_str() , m_electronz0[fitter], std::string(FitterNames[fitter]+"_z0[nElectrons]/F").c_str());
267  m_validationTree->Branch(std::string(FitterNames[fitter]+"_LMQoverP").c_str() , m_electronLMQoverP[fitter], std::string(FitterNames[fitter]+"_LMQoverP[nElectrons]/F").c_str());
268  m_validationTree->Branch(std::string(FitterNames[fitter]+"_ThetaErr").c_str() , m_electronErrTheta[fitter], std::string(FitterNames[fitter]+"_Theta0Err[nElectrons]/F").c_str());
269  m_validationTree->Branch(std::string(FitterNames[fitter]+"_Phi0Err").c_str() , m_electronErrPhi[fitter], std::string(FitterNames[fitter]+"_Phi0Err[nElectrons]/F").c_str());
270  m_validationTree->Branch(std::string(FitterNames[fitter]+"_QoverPErr").c_str() , m_electronErrQoverP[fitter], std::string(FitterNames[fitter]+"_QoverPErr[nElectrons]/F").c_str());
271  m_validationTree->Branch(std::string(FitterNames[fitter]+"_d0Err").c_str() , m_electronErrd0[fitter], std::string(FitterNames[fitter]+"_d0Err[nElectrons]/F").c_str());
272  m_validationTree->Branch(std::string(FitterNames[fitter]+"_z0Err").c_str() , m_electronErrz0[fitter], std::string(FitterNames[fitter]+"_z0Err[nElectrons]/F").c_str());
273  }
274 
275  m_validationTree->Branch("associatedToVtx" , m_associatedToVtx, "associatedToVtx[nElectrons]/I");
276  m_validationTree->Branch("nbpv", &m_nbpv, "nbpv/I");
277  m_validationTree->Branch("pvtype", m_pvtype, "pvtype[nbpv]/I");
278  m_validationTree->Branch("pvnbtk", m_pvnbtk, "pvnbtk[nbpv]/I");
279  m_validationTree->Branch("pvsumpt", m_pvsumpt, "pvsumpt[nbpv]/F");
280  m_validationTree->Branch("pvx", m_pvx, "pvx[nbpv]/F");
281  m_validationTree->Branch("pvy", m_pvy, "pvy[nbpv]/F");
282  m_validationTree->Branch("pvz", m_pvz, "pvz[nbpv]/F");
283  m_validationTree->Branch("errpvx", m_errpvx, "errpvx[nbpv]/F");
284  m_validationTree->Branch("errpvy", m_errpvy, "errpvy[nbpv]/F");
285  m_validationTree->Branch("errpvz", m_errpvz, "errpvz[nbpv]/F");
286  m_validationTree->Branch("covpvxpvy", m_covpvxpvy, "covpvxpvy[nbpv]/F");
287  m_validationTree->Branch("covpvzpvx", m_covpvzpvx, "covpvzpvx[nbpv]/F");
288  m_validationTree->Branch("covpvypvz", m_covpvypvz, "covpvypvz[nbpv]/F");
289 
290 
291  m_validationTree->Branch("METgoodness", &m_METgoodness, "METgoodness/B");
292  m_validationTree->Branch("sumet", &m_sumet, "sumet/F");
293  m_validationTree->Branch("missingEt", &m_missingEt, "missingEt/F");
294  m_validationTree->Branch("missingEtx", &m_missingEtx, "missingEtx/F");
295  m_validationTree->Branch("missingEty", &m_missingEty, "missingEty/F");
296 
297 
298  m_validationTree->Branch("ElectronAuthor" , m_author, "ElectronAuthor[nElectrons]/I");
299  m_validationTree->Branch("ClusterEnergy" , m_ClusterEnergy, "ClusterEnergy[nElectrons]/F");
300  m_validationTree->Branch("ClusterEta" , m_ClusterEta, "ClusterEta[nElectrons]/F");
301  m_validationTree->Branch("ClusterPhi" , m_ClusterPhi, "ClusterPhi[nElectrons]/F");
302 
303  m_validationTree->Branch("IsEMLoose" , m_IsEMLoose, "m_IsEMLoose[nElectrons]/B");
304  m_validationTree->Branch("IsEMMedium" , m_IsEMMedium, "m_IsEMMedium[nElectrons]/B");
305  m_validationTree->Branch("IsEMTight" , m_IsEMTight, "m_IsEMTight[nElectrons]/B");
306  m_validationTree->Branch("isGoodOQ" , m_isGoodOQ, "isGoodOQ[nElectrons]/B");
307 
308  m_validationTree->Branch("nTRT" , m_nTRT , "nTRT[nElectrons]/I");
309  m_validationTree->Branch("nSCT" , m_nSCT, "nSCT[nElectrons]/I");
310  m_validationTree->Branch("nBLayer" , m_nBLayer, "nBLayer[nElectrons]/I");
311  m_validationTree->Branch("nPIX" , m_nPIX, "nPIX[nElectrons]/I");
312  m_validationTree->Branch("nTRTout" , m_nTRTout, "nTRTout[nElectrons]/I");
313  m_validationTree->Branch("nSCTout" , m_nSCTout, "nSCTout[nElectrons]/I");
314  m_validationTree->Branch("nPIXout" , m_nPIXout, "nPIXout[nElectrons]/I");
315  m_validationTree->Branch("nTRTHT" , m_nTRTHT, "nTRTHT[nElectrons]/I");
316  m_validationTree->Branch("nTRTHout" , m_nTRTHTout, "nTRTHTout[nElectrons]/I");
317 
318 
319  for(unsigned int item(0); item < m_PID_ShowerType_Names.size(); ++item){
320  m_validationTree->Branch( m_PID_ShowerType_Names[item].second.c_str() , m_ePID_ShowerType[item], std::string( m_PID_ShowerType_Names[item].second + "[nElectrons]/F").c_str() );
321  }
322 
323  for(unsigned int item(0); item < m_PID_IsolationType_Names.size(); ++item){
324  m_validationTree->Branch( m_PID_IsolationType_Names[item].second.c_str() , m_ePID_IsolationType[item], std::string( m_PID_IsolationType_Names[item].second + "[nElectrons]/F").c_str() );
325  }
326 
327  for(unsigned int item(0); item < m_PID_TrackCaloMatchType_Names.size(); ++item){
328  m_validationTree->Branch( m_PID_TrackCaloMatchType_Names[item].second.c_str() , m_ePID_TrackCaloMatchType[item], std::string( m_PID_TrackCaloMatchType_Names[item].second + "[nElectrons]/F").c_str() );
329  }
330 
331  for(unsigned int item(0); item < m_PID_SummaryType_Names.size(); ++item){
332  m_validationTree->Branch( m_PID_SummaryType_Names[item].second.c_str() , m_ePID_SummaryType[item], std::string( m_PID_SummaryType_Names[item].second + "[nElectrons]/F").c_str() );
333  }
334 
335  for(unsigned int item(0); item < m_triggerNames.size(); ++item){
336  m_validationTree->Branch( m_triggerNames[item].c_str() , &m_trigger[item], std::string( m_triggerNames[item]+ "/B" ).c_str() );
337  }
338 
339  }
340 
341 
342  if(m_smallValidationTree == 0){
343 
344  m_smallValidationTree = new TTree(m_smallValidationTreeName.c_str(), m_smallValidationTreeDescription.c_str());
345 
346  m_smallValidationTree->Branch("charge",&m_smallCharge,"charge/D");
347  m_smallValidationTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
348  m_smallValidationTree->Branch("Default_QoverP",&m_small_QoverP,"Default_QoverP/D");
349  m_smallValidationTree->Branch("Refitted1_QoverP",&m_small1_QoverP,"Refitted1_QoverP/D");
350  m_smallValidationTree->Branch("Refitted2_QoverP",&m_small2_QoverP,"Refitted2_QoverP/D");
351  m_smallValidationTree->Branch("ClusterEnergy",&m_smallClusterEnergy,"ClusterEnergy/D");
352  m_smallValidationTree->Branch("ClusterEta" ,&m_smallClusterEta,"ClusterEta/D");
353  m_smallValidationTree->Branch("ClusterPhi" ,&m_smallClusterPhi,"ClusterPhi/D");
354  m_smallValidationTree->Branch("TrackTheta" ,&m_smallTrackTheta,"TrackTheta/D");
355  }
356 
357  // now register the Tree
358  ServiceHandle<ITHistSvc> tHistSvc("THistSvc", name());
359  if (tHistSvc.retrieve().isFailure()){
360  ATH_MSG_ERROR("initialize() Could not find Hist Service -> Switching ValidationMode Off !");
361  delete m_validationTree; m_validationTree = 0;
362  delete m_smallValidationTree; m_smallValidationTree = 0;
363  m_validationMode = false;
364  }
365  if ((tHistSvc->regTree(m_validationTreeFolder, m_validationTree)).isFailure() ) {
366  ATH_MSG_ERROR("initialize() Could not register the validation Tree -> Switching ValidationMode Off !");
367  delete m_validationTree; m_validationTree = 0;
368  m_validationMode = false;
369  }
370  if ((tHistSvc->regTree(m_smallValidationTreeFolder, m_smallValidationTree)).isFailure() ) {
371  ATH_MSG_ERROR("initialize() Could not register the validation Tree -> Switching ValidationMode Off !");
372  delete m_smallValidationTree; m_smallValidationTree = 0;
373  m_validationMode = false;
374  } else {
375  m_ZeeLooseMassOS_Cluster = new TH1F("ZeeMassLooseOS","ZeeMassLooseOS", 120, 60000 ,120000);
376  m_ZeeLooseMassSS_Cluster = new TH1F("ZeeMassLooseSS","ZeeMassLooseSS", 120, 60000 ,120000);
377  m_ZeeMediumMassOS_Cluster = new TH1F("ZeeMassMediumOS","ZeeMassMediumOS", 120, 60000 ,120000);
378  m_ZeeMediumMassSS_Cluster = new TH1F("ZeeMassMediumSS","ZeeMassMediumSS", 120, 60000 ,120000);
379  m_WenuLooseElectronET= new TH1F("WenuLooseElectronET","WenuLooseElectronET", 80, 20000 ,100000);
380  m_WenuTight_Met = new TH1F("WenuTight_Met","WenuTight_Met", 120, 00000 ,120000);
381  m_WenuTight_MT = new TH1F("WenuTight_MT","WenuTight_MT", 120, 00000 ,120000);
382  m_WenuTightMet_MT = new TH1F("WenuTightMet_MT","WenuTightMet_MT", 120, 00000 ,120000);
383  m_WenuTightElectronET = new TH1F("WenuTightElectronET","WenuTightElectronET", 100, 00000 ,100000);
384  m_WenuTightW_PT = new TH1F("WenuTightW_PT","WenuTightW_PT", 100, 00000 ,100000);
385 
386  m_ZeeMediumOS_ClusterPtEta = new TH2F("ZeeMediumOS_ClusterPtEta", "ZeeMediumOS_ClusterPtEta",100,20000,120000,50,-2.5,2.5);
387  m_WenuTightElectron_PTEtaPos = new TH2F("WenuTightElectron_PTEtaPos", "WenuTightElectron_PTEtaPos",100,20000,120000,50,-2.5,2.5);
388  m_WenuTightElectron_PTEtaNeg = new TH2F("WenuTightElectron_PTEtaNeg", "WenuTightElectron_PTEtaNeg",100,20000,120000,50,-2.5,2.5);
389 
390  bool somethingFailed{};
391  somethingFailed |= ( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMassLooseOS",m_ZeeLooseMassOS_Cluster )).isFailure() );
392  somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMassLooseSS",m_ZeeLooseMassSS_Cluster )).isFailure() );
393  somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMassMediumOS",m_ZeeMediumMassOS_Cluster )).isFailure() );
394  somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMassMediumSS",m_ZeeMediumMassSS_Cluster )).isFailure() );
395  somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuLooseElectronET",m_WenuLooseElectronET )).isFailure() );
396  somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTight_Met",m_WenuTight_Met )).isFailure() );
397  somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTight_MT",m_WenuTight_MT )).isFailure() );
398  somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightMet_MT",m_WenuTightMet_MT )).isFailure() );
399  somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightElectronET",m_WenuTightElectronET )).isFailure() );
400  somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightW_PT",m_WenuTightW_PT )).isFailure() );
401  somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMediumOS_ClusterPtEta",m_ZeeMediumOS_ClusterPtEta )).isFailure() );
402  somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightElectron_PTEtaPos",m_WenuTightElectron_PTEtaPos )).isFailure() );
403  somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightElectron_PTEtaNeg",m_WenuTightElectron_PTEtaNeg )).isFailure() );
404  if (somethingFailed) ATH_MSG_ERROR("initialize() Could not register histogram ");
405 
406  ATH_MSG_INFO("Booked Small Tree add histograms");
407 
408  }
409 
410  ATH_MSG_INFO("Loaded THistSvc");
411  }
412 
413  //---Electron Likelihood tool---
414  ATH_MSG_INFO("IDPerfMonEoverP::Initialize() -- Setting up electron LH tool.");
415  m_LHToolLoose2015 = new AsgElectronLikelihoodTool ("m_LHToolLoose2015");
416  m_LHToolMedium2015 = new AsgElectronLikelihoodTool ("m_LHToolMedium2015");
417  m_LHToolTight2015 = new AsgElectronLikelihoodTool ("m_LHToolTight2015");
418 
419  if((m_LHToolLoose2015->setProperty("primaryVertexContainer",m_primaryVertexCollection)).isFailure())
420  ATH_MSG_WARNING("Failure setting primary vertex container " << m_primaryVertexCollection << "in loose electron likelihood tool");
421  if((m_LHToolMedium2015->setProperty("primaryVertexContainer",m_primaryVertexCollection)).isFailure())
422  ATH_MSG_WARNING("Failure setting primary vertex container " << m_primaryVertexCollection << "in medium electron likelihood tool");
423  if((m_LHToolTight2015->setProperty("primaryVertexContainer",m_primaryVertexCollection)).isFailure())
424  ATH_MSG_WARNING("Failure setting primary vertex container " << m_primaryVertexCollection << "in tight electron likelihood tool");
425 
426  //Set up electron LH level
427  std::string confDir = "ElectronPhotonSelectorTools/offline/"+m_lhTune+"/";
428  std::string configFileL = confDir+"ElectronLikelihoodLooseOfflineConfig2015.conf";
429  std::string configFileM = confDir+"ElectronLikelihoodMediumOfflineConfig2015.conf";
430  std::string configFileT = confDir+"ElectronLikelihoodTightOfflineConfig2015.conf";
431 
432  if((m_LHToolLoose2015->setProperty("ConfigFile",configFileL)).isFailure())
433  ATH_MSG_WARNING("Failure loading ConfigFile in loose electron likelihood tool.");
434  if((m_LHToolMedium2015->setProperty("ConfigFile",configFileM)).isFailure())
435  ATH_MSG_WARNING("Failure loading ConfigFile in medium electron likelihood tool.");
436  if((m_LHToolTight2015->setProperty("ConfigFile",configFileT)).isFailure())
437  ATH_MSG_WARNING("Failure loading ConfigFile in tight electron likelihood tool.");
438 
439  StatusCode lhl = m_LHToolLoose2015->initialize();
440  if(lhl.isFailure())
441  ATH_MSG_WARNING("Loose electron likelihood tool initialize() failed!");
442  StatusCode lhm = m_LHToolMedium2015->initialize();
443  if(lhm.isFailure())
444  ATH_MSG_WARNING("Medium electron likelihood tool initialize() failed!");
445  StatusCode lht = m_LHToolTight2015->initialize();
446  if(lht.isFailure())
447  ATH_MSG_WARNING("Tight electron likelihood tool initialize() failed!");
448  ATH_MSG_INFO( "Initialization completed successfully");
449  return StatusCode::SUCCESS;
450 
451 }

◆ 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 856 of file IDPerfMonEoverP.cxx.

857 {
858  const xAOD::JetContainer* jetTDS = nullptr;
859  StatusCode sc= evtStore()->retrieve( jetTDS, m_jetContainerName);
860  if( sc.isFailure() || !jetTDS ) {
861  ATH_MSG_WARNING("No " << m_jetContainerName << " jet container found in TDS");
862  return false;
863  }
864  if (jetTDS->empty()) return true;
865  bool cleanJet = true;
866  for(const auto* jet_elem : *jetTDS ) {
867  if(!m_jetCleaningTool->keep( *jet_elem )) cleanJet=false;
868  if(!cleanJet) break;
869  }
870  return cleanJet;
871 }

◆ passWenuSelection()

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

Definition at line 1131 of file IDPerfMonEoverP.cxx.

1132 {
1133  ATH_MSG_VERBOSE("In passWenuSelection()");
1134  if(m_nbpv<1) return false;
1135  bool primaryVertexOk(false);
1136  electrons.clear();
1137 
1138  for (int i(0); i<m_nbpv; ++i){
1139  if (m_pvnbtk[i] > 2) primaryVertexOk = true;
1140  }
1141  if(!primaryVertexOk) return false;
1142 
1143  //MET Goodness
1144  if( m_isDATA && !m_METgoodness) return false;
1145 
1146  //Trigger
1147  //no need to pass trigger for perfromance studies
1148 
1149 
1150  //Loose electron selection
1151  std::vector<int> goodLooseElectrons;
1152  for(int ele(0); ele<m_nelectrons; ++ele){
1153  //Loose electron selection
1154  if (!m_IsEMLoose[ele]) continue;
1155  //Pt
1156  double clusterEt = cosh( m_ClusterEta[ele] ) != 0 ? m_ClusterEnergy[ele] / std::cosh( m_ClusterEta[ele] ) : 0.;
1157  if (clusterEt <= 25000) continue;
1158  //Range
1159  double absEta = std::abs(m_ClusterEta[ele]);
1160  if (absEta >= 2.47 || ( absEta >= 1.37 && absEta <= 1.52 ) ) continue;
1161  //OTx ...
1162  if(!m_isGoodOQ[ele]) continue;
1163  //Author
1164  if(m_author[ele]!=1 && m_author[ele]!=3) continue;
1165  goodLooseElectrons.push_back(ele);
1166  }
1167 
1168  //Fill Loose electron ET spectrum;
1169  for(int gele(0); gele < (int) goodLooseElectrons.size(); ++gele){
1170  int ele = goodLooseElectrons[gele];
1171  double trackEt = m_ClusterEnergy[gele]*sin(m_electronTheta[0][ele]);
1172  m_WenuLooseElectronET->Fill(trackEt);
1173  }
1174 
1175  int nMediumElectrons(0);
1176  int nTightElectrons(0);
1177  int tightElectron(0);
1178 
1179  for(int gele(0); gele < (int) goodLooseElectrons.size(); ++gele){
1180  //
1181  int ele = goodLooseElectrons[gele];
1182  if(m_IsEMMedium[ele]) ++nMediumElectrons;
1183  if (!m_IsEMTight[ele]) continue;
1184  ++nTightElectrons;
1185  tightElectron = ele;
1186  }
1187 
1188  //Reject events with more than one good electron
1189  if (nMediumElectrons >2)
1190  return false;
1191  //Reject events with no tight electrons;
1192  if (nTightElectrons <1)
1193  return false;
1194 
1195  double metphi = atan2(m_missingEty,m_missingEtx);
1196  double trackEt = m_ClusterEnergy[tightElectron]*std::sin(m_electronTheta[0][tightElectron]);
1197  double clusterEt = std::cosh( m_ClusterEta[tightElectron] ) !=0 ? m_ClusterEnergy[tightElectron] / std::cosh( m_ClusterEta[tightElectron] ) : 0.;
1198 
1199  double massT = 2*m_missingEt*trackEt*(1-cos(m_electronPhi[0][tightElectron]-metphi));
1200  if(massT > 0) massT =std::sqrt(massT);
1201  else massT = 0;
1202 
1203 
1204  m_WenuTight_Met->Fill(m_missingEt);
1205  m_WenuTight_MT->Fill(massT);
1206 
1207  if (m_missingEt <= 25000) return false;
1208  m_WenuTightMet_MT->Fill(massT);
1209 
1210  if (massT <= 50000) return false;
1211 
1212  m_WenuTightElectronET->Fill(clusterEt);
1213 
1214  double sumpx = m_ClusterEnergy[tightElectron]*std::sin( m_electronPhi[0][tightElectron] ) * std::sin(m_electronTheta[0][tightElectron]) + m_missingEtx;
1215  double sumpy = m_ClusterEnergy[tightElectron]*std::cos( m_electronPhi[0][tightElectron] ) * std::sin(m_electronTheta[0][tightElectron]) + m_missingEty;
1216 
1217  double wpt = sumpx*sumpx +sumpy*sumpy - massT*massT;
1218  if(wpt > 0) wpt =std::sqrt(wpt);
1219  else wpt = 0;
1220 
1221  m_WenuTightW_PT->Fill(wpt);
1222 
1223 
1224  if(m_electronQoverP[0][tightElectron] > 0){
1225  m_WenuTightElectron_PTEtaPos->Fill(trackEt,m_ClusterEta[tightElectron]);
1226  } else {
1227  m_WenuTightElectron_PTEtaNeg->Fill(trackEt,m_ClusterEta[tightElectron]);
1228  }
1229 
1230  electrons.push_back(tightElectron);
1231 
1232  return true;
1233 }

◆ passZeeSelection()

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

Definition at line 1036 of file IDPerfMonEoverP.cxx.

1037 {
1038  ATH_MSG_VERBOSE("In passZeeSelection()");
1039  //ATH_MSG_WARNING("Zee seletion needs to be adjusted for run2");
1040  // Adjusted according to https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/WZCommonAnalysisTopics2015
1041  if(m_nbpv<1) return false;
1042  bool primaryVertexOk(false);
1043  electrons.clear();
1044 
1045  for (int i=0; i<m_nbpv; ++i){
1046  if (m_pvnbtk[i] > 2) primaryVertexOk = true;
1047  }
1048  if(!primaryVertexOk) return false;
1049 
1050  //Trigger
1051  //No need to pass the trigger for tracking performance studies
1052 
1053  //Loose electron selection
1054  std::vector<int> goodLooseElectrons;
1055 
1056  for(int ele=0; ele<m_nelectrons; ele++){
1057  //Loose electron selection
1058  if (!m_IsEMLoose[ele]) continue;
1059  //Pt
1060  double clusterEt = cosh( m_ClusterEta[ele] ) != 0 ? m_ClusterEnergy[ele] / std::cosh( m_ClusterEta[ele] ) : 0.;
1061  if (clusterEt <= 25000) continue;
1062 
1063  //Range
1064  double absEta = std::abs(m_ClusterEta[ele]);
1065  if (absEta >= 2.47 || ( absEta >= 1.37 && absEta <= 1.52 )) continue;
1066 
1067  //OTx ...
1068  if(!m_isGoodOQ[ele]) continue;
1069 
1070  //Author
1071  if(m_author[ele]!=1 && m_author[ele]!=3) continue;
1072 
1073  goodLooseElectrons.push_back(ele);
1074  }
1075 
1076  int pairsLooseInMassWindow = 0;
1077 
1078  ATH_MSG_DEBUG("N Loose electrons " << goodLooseElectrons.size());
1079 
1080  //Fill Loose electron ET spectrum;
1081  for(int gele1 = 0; gele1 < (int)goodLooseElectrons.size()-1; ++gele1){
1082  for(int gele2 = gele1+1; gele2 < (int)goodLooseElectrons.size(); ++gele2){
1083  int ele1 = goodLooseElectrons[gele1];
1084  int ele2 = goodLooseElectrons[gele2];
1085  double mass = getMassCluster(ele1,ele2);
1086  if (mass > 60000 && mass < 120000){
1087  ++pairsLooseInMassWindow;
1088  if(m_electronQoverP[0][ele1]*m_electronQoverP[0][ele2]<0)
1089  m_ZeeLooseMassOS_Cluster->Fill(mass);
1090  else
1091  m_ZeeLooseMassSS_Cluster->Fill(mass);
1092  }
1093  }
1094  }
1095 
1096  if (pairsLooseInMassWindow < 1) return false;
1097  std::vector<int> goodMediumElectrons;
1098 
1099  for(int gele = 0; gele < (int)goodLooseElectrons.size(); ++gele){
1100  int ele = goodLooseElectrons[gele];
1101  if(m_IsEMMedium[ele]){
1102  goodMediumElectrons.push_back(ele);
1103  }
1104  }
1105 
1106  //Reject events with more than two good electrons
1107  if (goodMediumElectrons.size() != 2) return false;
1108 
1109  // Make the mass out of the highest pt electrons ....
1110  double mass = getMassCluster(goodMediumElectrons[0],goodMediumElectrons[1]);
1111  if (mass > 66000 && mass < 116000){
1112  if(m_electronQoverP[0][goodMediumElectrons[0]]*m_electronQoverP[0][goodMediumElectrons[1]]<0){
1113  m_ZeeMediumMassOS_Cluster->Fill(mass);
1114  electrons.push_back(goodMediumElectrons[0]);
1115  electrons.push_back(goodMediumElectrons[1]);
1116 
1117  double trackEt = m_ClusterEnergy[goodMediumElectrons[0]]*sin(m_electronTheta[0][goodMediumElectrons[0]]);
1118  m_ZeeMediumOS_ClusterPtEta->Fill(trackEt, m_ClusterEta[0] );
1119  trackEt = m_ClusterEnergy[goodMediumElectrons[1]]*sin(m_electronTheta[0][goodMediumElectrons[1]]);
1120  m_ZeeMediumOS_ClusterPtEta->Fill(trackEt, m_ClusterEta[1] );
1121 
1122  return true;
1123  } else{
1124  m_ZeeMediumMassSS_Cluster->Fill(mass);
1125  return false;
1126  }
1127  }
1128  return false;
1129 }

◆ 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 830 of file IDPerfMonEoverP.cxx.

831 {
832  ATH_MSG_VERBOSE("In storeMETinformation()");
833  const xAOD::MissingETContainer *pMissingCont(0);
834  const xAOD::MissingET *MET;
835  if (!evtStore()->contains<xAOD::MissingETContainer>(m_missingEtObjectName)){
836  ATH_MSG_WARNING("No collection with name " << m_missingEtObjectName << " found in StoreGate");
837  return false;
838  }
839 
840  StatusCode sc;
841  sc = evtStore()->retrieve(pMissingCont,m_missingEtObjectName);
842  if (sc.isFailure()) {
843  ATH_MSG_ERROR( "Could not retrieve MissingETContainer" );
844  return false;
845  }
846  MET = (*pMissingCont)[m_metRefFinalName];
847  m_METgoodness = passMETCleaningCuts();
848  m_sumet = MET->sumet();
849  m_missingEt = MET->met();
850  m_missingEtx = MET->mpx();
851  m_missingEty = MET->mpy();
852  return true;
853 }

◆ 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 816 of file IDPerfMonEoverP.cxx.

817 {
818  ATH_MSG_DEBUG( "Writing Data to ntuple" );
819 
820  // first record the values
821  if (m_validationTree){
822  m_nelectrons = long(m_electronCounter);
823  if(m_fillDetailedTree)m_validationTree->Fill();
824  // then reset
825  m_electronCounter = 0;
826  }
827 }

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
IDPerfMonEoverP::m_WenuTight_MT
TH1F * m_WenuTight_MT
Definition: IDPerfMonEoverP.h:293
createLinkingScheme.iter
iter
Definition: createLinkingScheme.py:62
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
IDPerfMonEoverP::m_TrackRefitter
ToolHandle< IegammaTrkRefitterTool > m_TrackRefitter
The track refitter.
Definition: IDPerfMonEoverP.h:158
IDPerfMonEoverP::fillVertexInformation
bool fillVertexInformation(std::map< const xAOD::TrackParticle *, VxPos > &trackParticleVertexMap, xAOD::Vertex const *&primaryVertexFirstCandidate)
Definition: IDPerfMonEoverP.cxx:873
ParticleGun_SamplingFraction.eta2
eta2
Definition: ParticleGun_SamplingFraction.py:96
IDPerfMonEoverP::passWenuSelection
bool passWenuSelection(std::vector< int > &electrons)
Definition: IDPerfMonEoverP.cxx:1131
IDPerfMonEoverP::m_electronQoverP
float m_electronQoverP[3][NOS_ELECTRONS]
Track q over p on electron.
Definition: IDPerfMonEoverP.h:204
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:558
IDPerfMonEoverP::m_smallClusterEnergy
double m_smallClusterEnergy
Definition: IDPerfMonEoverP.h:314
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
ParticleTest.eg
eg
Definition: ParticleTest.py:29
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
Base_Fragment.mass
mass
Definition: Sherpa_i/share/common/Base_Fragment.py:59
IDPerfMonEoverP::m_electronErrd0
float m_electronErrd0[3][NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:213
IDPerfMonEoverP::passMETCleaningCuts
bool passMETCleaningCuts() const
Definition: IDPerfMonEoverP.cxx:856
IDPerfMonEoverP::addToValidationNtuple
void addToValidationNtuple(const Trk::Perigee *, const xAOD::CaloCluster *, int isOrginal)
addToValidationNutple
Definition: IDPerfMonEoverP.cxx:669
IDPerfMonEoverP::m_ePID_ShowerType
float m_ePID_ShowerType[50][NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:269
DataVector::rend
const_reverse_iterator rend() const noexcept
Return a const_reverse_iterator pointing at the beginning of the collection.
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
IDPerfMonEoverP::m_covpvxpvy
float m_covpvxpvy[NO_PV]
Definition: IDPerfMonEoverP.h:257
xAOD::Vertex_v1::trackParticleLinks
const TrackParticleLinks_t & trackParticleLinks() const
Get all the particles associated with the vertex.
IDPerfMonEoverP::m_WenuTight_Met
TH1F * m_WenuTight_Met
Definition: IDPerfMonEoverP.h:292
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:737
IDPerfMonEoverP::m_validationTree
TTree * m_validationTree
Definition: IDPerfMonEoverP.h:191
IDPerfMonEoverP::m_nSCT
int m_nSCT[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:218
IDPerfMonEoverP::clearValidationNtuple
void clearValidationNtuple()
Definition: IDPerfMonEoverP.cxx:742
IDPerfMonEoverP::m_electronLMQoverP
float m_electronLMQoverP[3][NOS_ELECTRONS]
Track q over p on electron.
Definition: IDPerfMonEoverP.h:208
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
xAOD::Egamma_v1::author
uint16_t author(uint16_t bitmask=EgammaParameters::AuthorALL) const
Get author.
Definition: Egamma_v1.cxx:166
IDPerfMonEoverP::m_pvx
float m_pvx[NO_PV]
Definition: IDPerfMonEoverP.h:251
python.SystemOfUnits.second
float second
Definition: SystemOfUnits.py:135
IDPerfMonEoverP::m_covpvzpvx
float m_covpvzpvx[NO_PV]
Definition: IDPerfMonEoverP.h:259
xAOD::Iso::ptcone30
@ ptcone30
Definition: IsolationType.h:41
IDPerfMonEoverP::m_TrackRefitter_no2
ToolHandle< IegammaTrkRefitterTool > m_TrackRefitter_no2
The track refitter.
Definition: IDPerfMonEoverP.h:161
IDPerfMonEoverP::m_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:260
xAOD::Electron_v1::trackParticle
const xAOD::TrackParticle * trackParticle(size_t index=0) const
Pointer to the xAOD::TrackParticle/s that match the electron candidate.
Definition: Electron_v1.cxx:55
IDPerfMonEoverP::m_trigger
bool m_trigger[50]
Definition: IDPerfMonEoverP.h:281
IDPerfMonEoverP::m_nPIXout
int m_nPIXout[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:223
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:276
xAOD::Vertex_v1::position
const Amg::Vector3D & position() const
Returns the 3-pos.
xAOD::EgammaParameters::BADCLUSELECTRON
const uint32_t BADCLUSELECTRON
Definition: EgammaDefs.h:116
xAOD::Iso::etcone30
@ etcone30
Definition: IsolationType.h:33
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
IDPerfMonEoverP::m_pvsumpt
float m_pvsumpt[NO_PV]
Definition: IDPerfMonEoverP.h:250
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
IDPerfMonEoverP::m_validationMode
bool m_validationMode
< boolean to switch to validation mode
Definition: IDPerfMonEoverP.h:178
IDPerfMonEoverP::m_small2_QoverP
double m_small2_QoverP
Definition: IDPerfMonEoverP.h:313
NO_PV
#define NO_PV
Definition: IDPerfMonEoverP.h:76
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
IDPerfMonEoverP::m_validationTreeDescription
std::string m_validationTreeDescription
stream/folder to for the TTree to be written out
Definition: IDPerfMonEoverP.h:187
IDPerfMonEoverP::m_METgoodness
bool m_METgoodness
Definition: IDPerfMonEoverP.h:262
IDPerfMonEoverP::m_primaryVertexCollection
std::string m_primaryVertexCollection
Primary vertex input name.
Definition: IDPerfMonEoverP.h:144
python.TrigEgammaMonitorHelper.TH2F
def TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:45
IDPerfMonEoverP::m_triggerNames
std::vector< std::string > m_triggerNames
Definition: IDPerfMonEoverP.h:282
IDPerfMonEoverP::m_LHToolTight2015
AsgElectronLikelihoodTool * m_LHToolTight2015
Definition: IDPerfMonEoverP.h:331
IDPerfMonEoverP::m_isDATA
bool m_isDATA
Definition: IDPerfMonEoverP.h:174
xAOD::EgammaParameters::wtots1
@ wtots1
shower width is determined in a window detaxdphi = 0,0625 ×~0,2, corresponding typically to 20 strips...
Definition: EgammaEnums.h:140
AsgElectronLikelihoodTool
Electron selector tool to select objects in Athena using an underlying pure ROOT tool.
Definition: AsgElectronLikelihoodTool.h:30
IDPerfMonEoverP::m_missingEtObjectName
std::string m_missingEtObjectName
MET input name.
Definition: IDPerfMonEoverP.h:142
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:50
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
TauGNNUtils::Variables::Scalar::absEta
bool absEta(const xAOD::TauJet &tau, float &out)
Definition: TauGNNUtils.cxx:107
IDPerfMonEoverP::m_nTRT
int m_nTRT[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:217
IDPerfMonEoverP::deleteAction
void deleteAction() const
Definition: IDPerfMonEoverP.cxx:811
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
xAOD::numberOfTRTHighThresholdHits
@ numberOfTRTHighThresholdHits
number of TRT hits which pass the high threshold (only xenon counted) [unit8_t].
Definition: TrackingPrimitives.h:279
IDPerfMonEoverP::m_smallClusterEta
double m_smallClusterEta
Definition: IDPerfMonEoverP.h:316
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:29
IDPerfMonEoverP::fillLastMeasurement
bool fillLastMeasurement(const Trk::Track *track, const int fitter)
Definition: IDPerfMonEoverP.cxx:999
IDPerfMonEoverP::m_ZeeMediumMassSS_Cluster
TH1F * m_ZeeMediumMassSS_Cluster
Definition: IDPerfMonEoverP.h:288
IDPerfMonEoverP::m_WenuTightElectron_PTEtaPos
TH2F * m_WenuTightElectron_PTEtaPos
Definition: IDPerfMonEoverP.h:297
xAOD::EgammaParameters::f3
@ f3
fraction of energy reconstructed in 3rd sampling
Definition: EgammaEnums.h:54
IDPerfMonEoverP::m_missingEty
float m_missingEty
Definition: IDPerfMonEoverP.h:266
IDPerfMonEoverP::m_runNumber
unsigned int m_runNumber
Definition: IDPerfMonEoverP.h:194
IDPerfMonEoverP::m_WenuTightW_PT
TH1F * m_WenuTightW_PT
Definition: IDPerfMonEoverP.h:296
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
xAOD::TrackParticle_v1::p4
virtual FourMom_t p4() const override final
The full 4-momentum of the particle.
Definition: TrackParticle_v1.cxx:130
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
IDPerfMonEoverP::m_OutputTrackCollectionName_no2
std::string m_OutputTrackCollectionName_no2
Definition: IDPerfMonEoverP.h:148
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
IDPerfMonEoverP::m_nTRTHT
int m_nTRTHT[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:224
IDPerfMonEoverP::m_refittedTracks_no2
TrackCollection * m_refittedTracks_no2
Definition: IDPerfMonEoverP.h:152
IDPerfMonEoverP::m_PID_TrackCaloMatchType_Names
std::vector< std::pair< xAOD::EgammaParameters::TrackCaloMatchType, std::string > > m_PID_TrackCaloMatchType_Names
Definition: IDPerfMonEoverP.h:276
IDPerfMonEoverP::m_nelectrons
int m_nelectrons
Definition: IDPerfMonEoverP.h:199
xAOD::numberOfTRTHighThresholdOutliers
@ numberOfTRTHighThresholdOutliers
number of TRT high threshold outliers (only xenon counted) [unit8_t].
Definition: TrackingPrimitives.h:282
xAOD::TrackParticle_v1::perigeeParameters
const Trk::Perigee & perigeeParameters() const
Returns the Trk::MeasuredPerigee track parameters.
Definition: TrackParticle_v1.cxx:486
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
IDPerfMonEoverP::m_ClusterPhi
float m_ClusterPhi[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:232
xAOD::SummaryType
SummaryType
Enumerates the different types of information stored in Summary.
Definition: TrackingPrimitives.h:229
IDPerfMonEoverP::m_nTRTHTout
int m_nTRTHTout[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:225
CP::Iso
@ Iso
Definition: MuonEfficiencyType.h:16
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:1235
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:729
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
parseMapping.v0
def v0
Definition: parseMapping.py:149
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
xAOD::EgammaParameters::emins1
@ emins1
energy reconstructed in the strip with the minimal value between the first and second maximum
Definition: EgammaEnums.h:143
IDPerfMonEoverP::m_covpvypvz
float m_covpvypvz[NO_PV]
Definition: IDPerfMonEoverP.h:258
xAOD::Egamma_v1::caloCluster
const xAOD::CaloCluster * caloCluster(size_t index=0) const
Pointer to the xAOD::CaloCluster/s that define the electron candidate.
Definition: Egamma_v1.cxx:388
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
IDPerfMonEoverP::m_pvy
float m_pvy[NO_PV]
Definition: IDPerfMonEoverP.h:252
TCS::MET
@ MET
Definition: Trigger/TrigT1/L1Topo/L1TopoCommon/L1TopoCommon/Types.h:16
xAOD::MissingET_v1
Principal data object for Missing ET.
Definition: MissingET_v1.h:25
IDPerfMonEoverP::m_ePID_SummaryType
float m_ePID_SummaryType[50][NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:272
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
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:830
IDPerfMonEoverP::m_associatedToVtx
int m_associatedToVtx[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:243
IDPerfMonEoverP::m_jetCleaningTool
ToolHandle< IJetSelector > m_jetCleaningTool
jet selector tool
Definition: IDPerfMonEoverP.h:168
IDPerfMonEoverP::passZeeSelection
bool passZeeSelection(std::vector< int > &electrons)
Definition: IDPerfMonEoverP.cxx:1036
IDPerfMonEoverP::fillElectronInfo
void fillElectronInfo(const xAOD::Electron *p)
Definition: IDPerfMonEoverP.cxx:978
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
DataVector::rbegin
const_reverse_iterator rbegin() const noexcept
Return a const_reverse_iterator pointing past the end of the collection.
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:816
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
Trk::d0
@ d0
Definition: ParamDefs.h:63
MET
Definition: MET.py:1
DataVector< const Trk::TrackStateOnSurface >::const_reverse_iterator
std::reverse_iterator< const_iterator > const_reverse_iterator
Standard const_reverse_iterator.
Definition: DataVector.h:846
IDPerfMonEoverP::m_lhTune
std::string m_lhTune
Definition: IDPerfMonEoverP.h:328
xAOD::EgammaParameters::deltaPhi2
@ deltaPhi2
difference between the cluster phi (second sampling) and the phi of the track extrapolated to the sec...
Definition: EgammaEnums.h:204
IDPerfMonEoverP::m_ClusterEta
float m_ClusterEta[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:231
IDPerfMonEoverP::m_nbpv
int m_nbpv
Definition: IDPerfMonEoverP.h:247
IDPerfMonEoverP::m_fillDetailedTree
bool m_fillDetailedTree
validation tree name - to be acessed by this from root
Definition: IDPerfMonEoverP.h:181
IDPerfMonEoverP::m_nSCTout
int m_nSCTout[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:222
IDPerfMonEoverP::m_IsEMTightTRT
bool m_IsEMTightTRT[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:237
IDPerfMonEoverP::m_nTRTout
int m_nTRTout[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:221
IDPerfMonEoverP::m_ZeeLooseMassSS_Cluster
TH1F * m_ZeeLooseMassSS_Cluster
Definition: IDPerfMonEoverP.h:286
IDPerfMonEoverP::m_sumet
float m_sumet
Definition: IDPerfMonEoverP.h:263
xAOD::Electron_v1
Definition: Electron_v1.h:34
IDPerfMonEoverP::m_small1_QoverP
double m_small1_QoverP
Definition: IDPerfMonEoverP.h:312
IDPerfMonEoverP::fillIsEM
void fillIsEM(const xAOD::Electron *eg)
Definition: IDPerfMonEoverP.cxx:699
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
xAOD::numberOfTRTOutliers
@ numberOfTRTOutliers
number of TRT outliers [unit8_t].
Definition: TrackingPrimitives.h:277
IDPerfMonEoverP::m_errpvx
float m_errpvx[NO_PV]
Definition: IDPerfMonEoverP.h:254
IDPerfMonEoverP::m_ZeeMediumMassOS_Cluster
TH1F * m_ZeeMediumMassOS_Cluster
Definition: IDPerfMonEoverP.h:287
IDPerfMonEoverP::m_refitEverything
bool m_refitEverything
Definition: IDPerfMonEoverP.h:171
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
python.testIfMatch.matrix
matrix
Definition: testIfMatch.py:63
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
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
IDPerfMonEoverP::m_ClusterEnergy
float m_ClusterEnergy[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:230
xAOD::numberOfSCTOutliers
@ numberOfSCTOutliers
number of SCT outliers [unit8_t].
Definition: TrackingPrimitives.h:270
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
IDPerfMonEoverP::m_author
int m_author[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:228
IDPerfMonEoverP::m_small_QoverP
double m_small_QoverP
Definition: IDPerfMonEoverP.h:311
DeMoScan.first
bool first
Definition: DeMoScan.py:534
IDPerfMonEoverP::m_pvnbtk
int m_pvnbtk[NO_PV]
Definition: IDPerfMonEoverP.h:249
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:67
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
IDPerfMonEoverP::m_ZeeLooseMassOS_Cluster
TH1F * m_ZeeLooseMassOS_Cluster
Definition: IDPerfMonEoverP.h:285
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
IDPerfMonEoverP::m_trigDec
ToolHandle< Trig::TrigDecisionTool > m_trigDec
The trigger decision tool.
Definition: IDPerfMonEoverP.h:164
IDPerfMonEoverP::fillTriggerInformation
void fillTriggerInformation()
Definition: IDPerfMonEoverP.cxx:959
IDPerfMonEoverP::m_nBLayer
int m_nBLayer[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:219
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:269
xAOD::EgammaParameters::e277
@ e277
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 7x7
Definition: EgammaEnums.h:80
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:801
AsgElectronLikelihoodTool::initialize
virtual StatusCode initialize() override
Gaudi Service Interface method implementations.
Definition: AsgElectronLikelihoodTool.cxx:80
IDPerfMonEoverP::m_pvtype
int m_pvtype[NO_PV]
Definition: IDPerfMonEoverP.h:248
xAOD::EgammaParameters::weta1
@ weta1
shower width using +/-3 strips around the one with the maximal energy deposit: w3 strips = sqrt{sum(E...
Definition: EgammaEnums.h:97
IDPerfMonEoverP::m_InputElectronContainerName
std::string m_InputElectronContainerName
Electron collection input name.
Definition: IDPerfMonEoverP.h:135
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
IDPerfMonEoverP::m_electronz0
float m_electronz0[3][NOS_ELECTRONS]
Track q over p on electron.
Definition: IDPerfMonEoverP.h:206
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
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:806
IDPerfMonEoverP::m_OutputTrackCollectionName_no1
std::string m_OutputTrackCollectionName_no1
Name of output of Refitted Inner Detector Tracks.
Definition: IDPerfMonEoverP.h:147
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
xAOD::EgammaParameters::deltaEta1
@ deltaEta1
difference between the cluster eta (first sampling) and the eta of the track extrapolated to the firs...
Definition: EgammaEnums.h:184
IDPerfMonEoverP::findAssociatedVertex
VxPos findAssociatedVertex(std::map< const xAOD::TrackParticle *, VxPos > &trackParticleVertexMap, const xAOD::Vertex *primaryVertexFirstCandidate, const xAOD::Electron *) const
Definition: IDPerfMonEoverP.cxx:944
xAOD::EgammaParameters::f3core
@ f3core
E3(3x3)/E fraction of the energy reconstructed in the third compartment of the electromagnetic calori...
Definition: EgammaEnums.h:65
xAOD::EgammaParameters::e2tsts1
@ e2tsts1
energy of the cell corresponding to second energy maximum in the first sampling
Definition: EgammaEnums.h:108
IDPerfMonEoverP::m_electronPhi
float m_electronPhi[3][NOS_ELECTRONS]
Track Phi on electron.
Definition: IDPerfMonEoverP.h:203
IDPerfMonEoverP::m_IsEMMedium
bool m_IsEMMedium[NOS_ELECTRONS]
Definition: IDPerfMonEoverP.h:235
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
VxPos
std::pair< const xAOD::Vertex *, int > VxPos
Definition: IDPerfMonEoverP.h:78
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:238
IDPerfMonEoverP::FillSimpleTree
std::vector< int > FillSimpleTree()
Definition: IDPerfMonEoverP.cxx:1251
IDPerfMonEoverP::m_LHToolLoose2015
AsgElectronLikelihoodTool * m_LHToolLoose2015
Definition: IDPerfMonEoverP.h:329
xAOD::EgammaParameters::AuthorElectron
const uint16_t AuthorElectron
Object Reconstructed by standard cluster-based algorithm.
Definition: EgammaDefs.h:24
IDPerfMonEoverP::m_smallClusterPhi
double m_smallClusterPhi
Definition: IDPerfMonEoverP.h:315
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
ParticleConstants::PDG2011::electronMassInMeV
constexpr double electronMassInMeV
the mass of the electron (in MeV)
Definition: ParticleConstants.h:26
Generated on Mon Sep 29 2025 21:36:01 for ATLAS Offline Software by   doxygen 1.8.18