IDPerfMonEoverP Class Reference

Create a simple ntuple to perform EoverP studies with. More...

#include <IDPerfMonEoverP.h>

Inheritance diagram for IDPerfMonEoverP:

Public Member Functions
	IDPerfMonEoverP (const std::string &name, ISvcLocator *pSvcLocator)
	Default constructor.
	~IDPerfMonEoverP ()
	Destructor.
StatusCode	initialize ()
	Gaudi algorithm hooks.
StatusCode	finalize ()
StatusCode	execute ()
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	addToValidationNtuple (const Trk::Perigee *, const xAOD::CaloCluster *, int isOrginal)
	addToValidationNutple
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>

Private Attributes
std::string	m_InputElectronContainerName
	Electron collection input name.
std::string	m_metRefFinalName
std::string	m_jetContainerName
	JEt collection input name.
std::string	m_missingEtObjectName
	MET input name.
std::string	m_primaryVertexCollection
	Primary vertex input name.
std::string	m_OutputTrackCollectionName_no1
	Name of output of Refitted Inner Detector Tracks.
std::string	m_OutputTrackCollectionName_no2
TrackCollection *	m_refittedTracks_no1
	Refitted track collection.
TrackCollection *	m_refittedTracks_no2
SG::ReadHandleKey< xAOD::EventInfo >	m_evt {this, "EvtInfo", "EventInfo", "EventInfo name"}
	ReadHandle to the Event Info.
ToolHandle< IegammaTrkRefitterTool >	m_TrackRefitter
	The track refitter.
ToolHandle< IegammaTrkRefitterTool >	m_TrackRefitter_no2
	The track refitter.
ToolHandle< Trig::TrigDecisionTool >	m_trigDec
	The trigger decision tool.
ToolHandle< IJetSelector >	m_jetCleaningTool {this,"JetCleaningTool","JetCleaningTool/JetCleaningTool",""}
	jet selector tool
bool	m_refitEverything
bool	m_isDATA
bool	m_fillVertexInfo
bool	m_validationMode
	< boolean to switch to validation mode
bool	m_fillDetailedTree
	validation tree name - to be acessed by this from root
std::string	m_validationTreeName
	validation tree description - second argument in TTree
std::string	m_validationTreeDescription
	stream/folder to for the TTree to be written out
std::string	m_validationTreeFolder
	Root Validation Tree.
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
float	m_electronTheta [3][NOS_ELECTRONS] {}
	Track theta at perigee.
float	m_electronEta [3][NOS_ELECTRONS] {}
	Track Eta at perigee.
float	m_electronPhi [3][NOS_ELECTRONS] {}
	Track Phi on electron.
float	m_electronQoverP [3][NOS_ELECTRONS] {}
	Track q over p on electron.
float	m_electrond0 [3][NOS_ELECTRONS] {}
	Track Phi on electron.
float	m_electronz0 [3][NOS_ELECTRONS] {}
	Track q over p on electron.
float	m_electronLMQoverP [3][NOS_ELECTRONS] {}
	Track q over p on electron.
float	m_electronErrTheta [3][NOS_ELECTRONS] {}
	Track theta error on electron.
float	m_electronErrPhi [3][NOS_ELECTRONS] {}
	Track phi error on electron.
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
std::string	m_smallValidationTreeName
	validation tree description - second argument in TTree
std::string	m_smallValidationTreeDescription
	stream/folder to for the TTree to be written out
std::string	m_smallValidationTreeFolder
	Root Validation Tree.
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)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
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.

                           :
  AthAlgorithm(name, pSvcLocator),
  m_refittedTracks_no1{},
  m_refittedTracks_no2{},
  m_TrackRefitter(""),
  m_TrackRefitter_no2(""),
  m_trigDec("Trig::TrigDecisionTool/TrigDecisionTool"),
  m_refitEverything(true),
  m_isDATA(true),
  m_validationMode(true),
  m_fillDetailedTree(false),
  m_validationTreeName( "EGrefitter" ),
  m_validationTreeDescription( "egamma track refitter caches" ),
  m_validationTreeFolder( "/ZmumuValidationUserSel/EGrefitter"), // use same root file name as Zmumu
  m_validationTree(0),
  m_runNumber{},
  m_evtNumber{},
  m_lumi_block{},
  m_nelectrons{},
  m_electronCounter(0),
  m_nbpv{},
  m_METgoodness{},
  m_sumet{},
  m_missingEt{},
  m_missingEtx{},
  m_missingEty{},
  m_ZeeLooseMassOS_Cluster(nullptr),
  m_ZeeLooseMassSS_Cluster(nullptr),
  m_ZeeMediumMassOS_Cluster(nullptr),
  m_ZeeMediumMassSS_Cluster(nullptr),
  m_ZeeMediumOS_ClusterPtEta(nullptr),
  m_WenuLooseElectronET(nullptr),
  m_WenuTight_Met(nullptr),
  m_WenuTight_MT(nullptr),
  m_WenuTightMet_MT(nullptr),
  m_WenuTightElectronET(nullptr),
  m_WenuTightW_PT(nullptr),
  m_WenuTightElectron_PTEtaPos(nullptr),
  m_WenuTightElectron_PTEtaNeg(nullptr),
  m_smallValidationTreeName("EGrefitterSmall"),
  m_smallValidationTreeDescription("Small Tree for E/p fits"),
  m_smallValidationTreeFolder("/eoverpValidation2/efitterValidation2"),
  m_smallValidationTree(nullptr),
  m_small_QoverP{},
  m_small1_QoverP{},
  m_small2_QoverP{},
  m_smallClusterEnergy{},
  m_smallClusterPhi{},
  m_smallClusterEta{},
  m_smallTrackTheta{},
  m_smallCharge{},
  m_smalld0{},
  m_smallz0{},
  m_LHToolLoose2015{},
  m_LHToolMedium2015{},
  m_LHToolTight2015{}
{
 
// The following properties are specified at run-time
// (declared in jobOptions file)
  declareProperty("RefitTracks",                      m_refitEverything);
  declareProperty("isDATA",                           m_isDATA);
  declareProperty("FillVertexInfo",                   m_fillVertexInfo = false, "job option to activate the filling of the vertex info");
  declareProperty("ReFitterTool",                     m_TrackRefitter, "ToolHandle for track fitter implementation");
  declareProperty("ReFitterTool2",                    m_TrackRefitter_no2, "ToolHandle for track fitter implementation");
  declareProperty("TrigDecisionTool",                 m_trigDec, "The TrigDecisionTool instance.");
  declareProperty("InputElectronContainerName",       m_InputElectronContainerName  = "Electrons");
  declareProperty("InputJetContainerName",            m_jetContainerName  = "AntiKt4LCTopoJets");
  //  declareProperty("MissingEtObjectName",              m_missingEtObjectName  = "MET_RefFinal");
  declareProperty("METFinalName",                     m_metRefFinalName= "FinalClus");
  declareProperty("MissingEtObjectName",              m_missingEtObjectName  = "MET_Reference_AntiKt4LCTopo");
  declareProperty("primaryVertexCollection",          m_primaryVertexCollection = "PrimaryVertices");
  declareProperty("RefittedElectronTrackContainer1",  m_OutputTrackCollectionName_no1="GSFTracks");
  declareProperty("RefittedElectronTrackContainer2",  m_OutputTrackCollectionName_no2="DNATracks");
  declareProperty("ValidationMode",                   m_validationMode);
  declareProperty("FillDetailedTree",                 m_fillDetailedTree);
  declareProperty("ElectronLikelihoodTune",           m_lhTune="mc15_20150712");
  declareProperty("ValidationTreeFolder",             m_validationTreeFolder, "/ZmumuValidationUserSel/EGrefitter"); // use same root file name as Zmumu
}

~IDPerfMonEoverP()

IDPerfMonEoverP::~IDPerfMonEoverP

(

)

Destructor.

Definition at line 142 of file IDPerfMonEoverP.cxx.

{
 
}

Member Function Documentation

addToValidationNtuple()

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

private

addToValidationNutple

Definition at line 704 of file IDPerfMonEoverP.cxx.

                                                                                                             {
  if (perigee){
    ATH_MSG_DEBUG(  "Adding data to ntuple" );
    if (isOriginal >=  0  &&  isOriginal <3){
      m_electrond0[isOriginal][m_electronCounter]    = perigee->parameters()[Trk::d0];
      m_electronz0[isOriginal][m_electronCounter]    = perigee->parameters()[Trk::z0];
      m_electronPhi[isOriginal][m_electronCounter]   = perigee->parameters()[Trk::phi0];
      m_electronTheta[isOriginal][m_electronCounter] = perigee->parameters()[Trk::theta];
      m_electronEta[isOriginal][m_electronCounter]   = perigee->eta();
      m_electronQoverP[isOriginal][m_electronCounter]= perigee->parameters()[Trk::qOverP];
      //
      const AmgSymMatrix(5)* matrix = perigee->covariance();
      if (matrix){
        m_electronErrd0[isOriginal][m_electronCounter] =std::sqrt( (*matrix)(Trk::d0,Trk::d0) );
        m_electronErrz0[isOriginal][m_electronCounter] = std::sqrt( (*matrix)(Trk::z0,Trk::z0) );
        m_electronErrPhi[isOriginal][m_electronCounter] = std::sqrt( (*matrix)(Trk::phi0,Trk::phi0) );
        m_electronErrTheta[isOriginal][m_electronCounter]= std::sqrt( (*matrix)(Trk::theta,Trk::theta) );
        m_electronErrQoverP[isOriginal][m_electronCounter]= std::sqrt( (*matrix)(Trk::qOverP,Trk::qOverP) );
      }
    }
  } else {
   ATH_MSG_DEBUG(  "No MeasuredPerigee - cannot add data to ntuple" );
  }
 
   ATH_MSG_DEBUG(  "Finished adding data to ntuple" );
}

clearValidationNtuple()

void IDPerfMonEoverP::clearValidationNtuple ( )

private

Definition at line 775 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_DEBUG(  "clear ValidationNtuple variables" );
  for (int i = 0 ;  i < NOS_ELECTRONS ; ++i){
    for (int j = 0 ;  j <3 ; ++j){
      m_electrond0[j][i]        = 0;
      m_electronz0[j][i]        = 0;
      m_electronPhi[j][i]       = 0;
      m_electronTheta[j][i]     = 0;
      m_electronEta[j][i]       = 0;
      m_electronQoverP[j][i]    = 0;
      m_electronLMQoverP[j][i]  = 0;
 
      m_electronErrd0[j][i]     = 0;
      m_electronErrz0[j][i]     = 0;
      m_electronErrPhi[j][i]    = 0;
      m_electronErrTheta[j][i]  = 0;
      m_electronErrQoverP[j][i] = 0;
 
    }
    m_associatedToVtx[i] = 0;
 
    m_author[i]               = 0;
 
    m_ClusterEnergy[i]        = 0;
 
    m_IsEMLoose[i]            = false;
    m_IsEMMedium[i]           = false;
    m_IsEMTight[i]            = false;
    m_IsEMTightTRT[i]         = false;
 
 
    for (int j = 0 ;  j < 50 ; ++j){
      m_ePID_ShowerType[j][i] =0;
      m_ePID_IsolationType[j][i] =0;
      m_ePID_TrackCaloMatchType[j][i] =0;
      m_ePID_SummaryType[j][i] =0;
      m_trigger[j] = false;
    }
  }
 
 
  //Vertex information
  m_nbpv =0;
  for (int i(0); i< NO_PV; ++i){
    m_pvtype[i] =0;
    m_pvnbtk[i]=0;
    m_pvsumpt[i]=0;
    m_pvx[i]=0;
    m_pvy[i]=0;
    m_pvz[i]=0;
    m_errpvx[i]=0;
    m_errpvy[i]=0;
    m_errpvz[i]=0;
    m_covpvxpvy[i]=0;
    m_covpvypvz[i]=0;
    m_covpvzpvx[i]=0;
  }
  //MET
  m_METgoodness=false;
  m_sumet=0;
  m_missingEt=0;
  m_missingEtx=0;
  m_missingEty=0;
 
  return;
}

correctIP_PV()

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

private

declareGaudiProperty()

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.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

deleteAction()

void IDPerfMonEoverP::deleteAction ( ) const

private

Definition at line 844 of file IDPerfMonEoverP.cxx.

{
 
}

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.

{ return m_detStore; }

evtStore()

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.

{ return m_evtStore; }

execute()

StatusCode IDPerfMonEoverP::execute

(

)

Definition at line 481 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_DEBUG( "Executing IDPerfMonEoverP" );
  StatusCode sc(StatusCode::SUCCESS);
  std::map<const xAOD::TrackParticle*, VxPos > trackParticleVertexMap;
  const xAOD::Vertex* primaryVertexFirstCandidate = nullptr;
  if (m_validationMode){
   clearValidationNtuple();
  }else{
    ATH_MSG_WARNING( "  Validation Mode has been turned off ALG will do not fill Ntuples" );
    return sc;
  }
 
  ATH_MSG_DEBUG("Retrieving event info.");
  SG::ReadHandle<xAOD::EventInfo> evt(m_evt);
  if(evt.isValid()) {
    m_runNumber = evt->runNumber();
    m_evtNumber = evt->eventNumber();
    m_lumi_block = evt->lumiBlock();
    ATH_MSG_DEBUG(" --> run: " << m_runNumber << "    event: " << m_evtNumber << "    lumiblock: " << m_lumi_block );
  }
  else {
    ATH_MSG_ERROR("Could not retrieve event info."); // Keeping ERROR only to preserve old functionality
  }
 
  ATH_MSG_DEBUG("Retrieved Trigger info.");
  fillTriggerInformation();
 
  if (m_fillVertexInfo) {
    if ( not fillVertexInformation(trackParticleVertexMap, primaryVertexFirstCandidate) ){
      ATH_MSG_DEBUG("No Primary Vertex info found");
    }
  } // doVertexInfo
 
  ATH_MSG_DEBUG("MET info.being stored");
  if( storeMETinformation() ) {
    ATH_MSG_DEBUG("MET info. stored");
  }
  else { 
    ATH_MSG_DEBUG("NO MET info. stored :(");
  }
  
  // Get the electron AOD container
  const xAOD::ElectronContainer* ElectronInput_container;
  ATH_MSG_DEBUG("Retrieving ElectronInput_container: " << m_InputElectronContainerName);
  sc =  evtStore()->retrieve(ElectronInput_container, m_InputElectronContainerName);
  if (sc != StatusCode::SUCCESS){
    ATH_MSG_WARNING("No electron container --> return");
    deleteAction();
    return StatusCode::SUCCESS;
  }
 
  if (ElectronInput_container->empty() ){
    ATH_MSG_DEBUG("-- ElectronInput_container is empty -> return");
    deleteAction();
    return StatusCode::SUCCESS;
  }
 
  m_refittedTracks_no1 = new TrackCollection;
  m_refittedTracks_no2 = new TrackCollection;
 
 
  typedef xAOD::ElectronContainer::const_iterator electron_iterator;
  electron_iterator iter    = ElectronInput_container->begin();
  electron_iterator iterEnd = ElectronInput_container->end();
 
  // Loop over the Electrons
  ATH_MSG_DEBUG("Electron info. being stored");
  for(; iter != iterEnd ; ++iter) {
    ATH_MSG_DEBUG("Dealing with electron: "<< m_electronCounter+1);
    if (m_electronCounter >= NOS_ELECTRONS) break;
    const xAOD::Electron *pThisElectron = (*iter);
 
    if (pThisElectron->passSelection("LHTight") ) { // keep only tight electrons
      m_author[m_electronCounter] = pThisElectron->author(xAOD::EgammaParameters::AuthorElectron);
      
      // Cluster Info
      fillElectronInfo ( pThisElectron );
      // Fill General info
      fillGeneral( pThisElectron );
      // Fill IsEm info
      fillIsEM( pThisElectron );
      
      //Get the track particle
      const xAOD::TrackParticle* mytp = (*iter)->trackParticle();
      if ( mytp != nullptr ) ATH_MSG_DEBUG("-- electron: "<< m_electronCounter+1 << "  pt: " << mytp->p4().Perp() );
      
      if( mytp != nullptr ){
    uint8_t dummy(0);
    auto summaryByDetector=[&mytp,&dummy]( const xAOD::SummaryType & t){
      return mytp->summaryValue(dummy, t) ? (dummy) : (-1);
    };
    m_nTRT[m_electronCounter]      = summaryByDetector( xAOD::numberOfTRTHits  );
    m_nSCT[m_electronCounter]      = summaryByDetector( xAOD::numberOfSCTHits );
    m_nPIX[m_electronCounter]      = summaryByDetector( xAOD::numberOfPixelHits );
    m_nBLayer[m_electronCounter]   = summaryByDetector( xAOD::numberOfInnermostPixelLayerHits);
    m_nTRTout[m_electronCounter]   = summaryByDetector( xAOD::numberOfTRTOutliers);
    m_nSCTout[m_electronCounter]   = summaryByDetector( xAOD::numberOfSCTOutliers);
    m_nTRTHT[m_electronCounter]    = summaryByDetector( xAOD::numberOfTRTHighThresholdHits);
    m_nTRTHTout[m_electronCounter] = summaryByDetector( xAOD::numberOfTRTHighThresholdOutliers);
      }
      else{
    ATH_MSG_DEBUG("Electron with no track particle??   Possibly Forward");
    continue;
      }
      
      //Find which if any vertex the electron track is associated to
      VxPos myVxPos = findAssociatedVertex( trackParticleVertexMap,
                        primaryVertexFirstCandidate,
                        pThisElectron );
      m_associatedToVtx[m_electronCounter] = myVxPos.second;
      if( mytp->track() ){
    const Trk::Track* oTrkTrack = mytp->track();
    if (oTrkTrack){
      const Trk::Perigee* oMeasPer =  oTrkTrack->perigeeParameters() ;
      if (oMeasPer) addToValidationNtuple( oMeasPer, pThisElectron->caloCluster(), 0 );
      fillLastMeasurement( oTrkTrack , 0 );
    }
      }
      else {
    ATH_MSG_DEBUG("mytp->track() == 0");
    const Trk::Perigee* oMeasPer = &(mytp->perigeeParameters()) ;
    addToValidationNtuple( oMeasPer, pThisElectron->caloCluster(), 0 );
      }
      
 
      if(m_refitEverything) {
    // First Refitter................
    ATH_MSG_DEBUG(  "Refitting the track" );
    
    IegammaTrkRefitterTool::Cache cache1{};
    StatusCode sc = m_TrackRefitter->refitTrack(Gaudi::Hive::currentContext(),
                            pThisElectron->trackParticle()->track(),
                            cache1 );
    
    if (sc == StatusCode::SUCCESS){
      Trk::Track* trkTrack= cache1.refittedTrack.release();
      m_refittedTracks_no1->push_back(trkTrack);
      addToValidationNtuple( cache1.refittedTrackPerigee ,pThisElectron->caloCluster(), 1 );
      fillLastMeasurement(trkTrack, 1 );
    } else {
      ATH_MSG_DEBUG(  "Track Refit Failed" );
    }
    //******************************************************//
    // Refit tracks using the second refitter if it is present
    //******************************************************//
    ATH_MSG_DEBUG(  "Refitting the track again" );
    
    IegammaTrkRefitterTool::Cache cache2{};
    sc = m_TrackRefitter_no2->refitTrack(Gaudi::Hive::currentContext(),
                         pThisElectron->trackParticle()->track(),
                         cache2 );
    
    if (sc == StatusCode::SUCCESS){
      Trk::Track* trkTrack= cache2.refittedTrack.release();
      //Add the refitted track to the TrackCollection
      m_refittedTracks_no2->push_back( trkTrack );
      //Add data to the trkRefitterNtuple
      
      addToValidationNtuple( cache2.refittedTrackPerigee ,pThisElectron->caloCluster(), 2 );
      fillLastMeasurement( trkTrack, 2 );
    }
    else {
      ATH_MSG_DEBUG( "Track Refit Failed" );
    }
      }
      else {
    ATH_MSG_DEBUG(  "Not Refitting the track -- DO NOTHING" );
      }//End if >6 silicon hits;
      
      //Increment the electron counter for the validation nutple
      ++m_electronCounter;
    } // isTightElec
  } // loop on electrons
  
  // Commit Data to Ntuple;
  if( m_validationMode ) validationAction();
  // Fill much smaller tree
  std::vector<int> goodElectrons = FillSimpleTree();
  TrackCollection* selectedElectrons = new TrackCollection;
 
  for( const auto & thisGoodElectron: goodElectrons){
    IegammaTrkRefitterTool::Cache cache{}; 
    StatusCode sc = m_TrackRefitter->refitTrack(Gaudi::Hive::currentContext(),
                                                (*ElectronInput_container)[thisGoodElectron]->trackParticle()->track(),
                                                cache );
    if (sc == StatusCode::SUCCESS){
      Trk::Track* trkTrack= cache.refittedTrack.release(); 
      selectedElectrons->push_back(trkTrack);
    }
  }
  
  //******************************************************//
  //* Add the newly created TrackCollection to StoreGate *//
  //******************************************************//
 
  sc = evtStore()->record( m_refittedTracks_no1, m_OutputTrackCollectionName_no1, false );
  if (sc.isFailure())
  {
    ATH_MSG_ERROR("Could not record "<< m_OutputTrackCollectionName_no1 <<" object.");
    delete selectedElectrons;
    return (StatusCode::FAILURE);
  }
  //
  sc = evtStore()->record( m_refittedTracks_no2, m_OutputTrackCollectionName_no2, false );
  if (sc.isFailure())
  {
    ATH_MSG_ERROR("Could not record "<< m_OutputTrackCollectionName_no2 <<" object.");
    delete selectedElectrons;
    return (StatusCode::FAILURE);
  }
  //
  sc = evtStore()->record( selectedElectrons, m_OutputTrackCollectionName_no1 + "Selected", false );
    if (sc.isFailure())
  {
    ATH_MSG_ERROR("Could not record "<< m_OutputTrackCollectionName_no1+"Selected" <<" object.");
    delete selectedElectrons;
    return (StatusCode::FAILURE);
  }
  ATH_MSG_DEBUG(  "execute completed successfully");
  return StatusCode::SUCCESS;
}

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.

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

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

{
  ATH_MSG_VERBOSE(  "In fillElectronInfo()" );
  for (size_t i = 0; i < m_PID_ShowerType_Names.size(); i++) {
    float dummy(-1);
    m_ePID_ShowerType[i][m_electronCounter] = static_cast<float> (p->showerShapeValue( dummy, m_PID_ShowerType_Names[i].first ))? dummy :-1;
  }
  for (size_t i = 0; i < m_PID_TrackCaloMatchType_Names.size(); i++) {
    float dummy(-1);
    m_ePID_TrackCaloMatchType[i][m_electronCounter] = static_cast<float> (p->trackCaloMatchValue( dummy, m_PID_TrackCaloMatchType_Names[i].first ))? dummy :-1;
  }
 
for (size_t i = 0; i < m_PID_SummaryType_Names.size(); i++) {
    float dummy(-1);
    m_ePID_SummaryType[i][m_electronCounter] = static_cast<float> (p->trackParticleSummaryValue( dummy, m_PID_SummaryType_Names[i].first ))? dummy :-1;
  }
 
  return;
 
}

fillGeneral()

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

private

Definition at line 762 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_DEBUG(  "fillGeneral" );
  const xAOD::CaloCluster* cluster = eg->caloCluster();
  if(!cluster) return;
  m_ClusterEnergy[m_electronCounter] = cluster->e();
  m_ClusterPhi[m_electronCounter] = cluster->phi();
  m_ClusterEta[m_electronCounter] = cluster->eta();
}

fillIsEM()

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

private

Definition at line 732 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_DEBUG(  "fillIsEM" );
  int el_goodOQ = (int)eg->isGoodOQ(xAOD::EgammaParameters::BADCLUSELECTRON);
  m_isGoodOQ[m_electronCounter] = el_goodOQ;
  // check loose LH
  bool val_loose = (bool) m_LHToolLoose2015->accept(eg);
  ATH_MSG_DEBUG( "Loose value : " << val_loose);
  if(val_loose){
    m_IsEMLoose[m_electronCounter] = val_loose;
  }//else{ATH_MSG_DEBUG("Loose electron not defined !");}
 
  // check medium LH
  bool val_med = (bool) m_LHToolMedium2015->accept(eg);
  ATH_MSG_DEBUG( "Medium value : " << val_med );
  if(val_med){
    m_IsEMMedium[m_electronCounter] = val_med;
  }//else{ATH_MSG_DEBUG("Mediu, electron not defined !");}
 
  // check tight LH
  bool val_tight = (bool) m_LHToolTight2015->accept(eg);
  ATH_MSG_DEBUG( "Tight value : " << val_tight);
  if(val_tight){
    m_IsEMTight[m_electronCounter] = val_tight;
  }//else{ATH_MSG_DEBUG("Tight electron not defined !");}
  return;
 
}

fillLastMeasurement()

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

private

Definition at line 1047 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_VERBOSE("In fillLastMeasurement()");
  if(!track) return false;
  const Trk::TrackParameters* trkPara =0;
 
  const Trk::TrackStates* oldTrackStates = track->trackStateOnSurfaces();
  if (oldTrackStates == 0)
  {
    return false;
  }
 
  for ( Trk::TrackStates::const_reverse_iterator rItTSoS = oldTrackStates->rbegin(); rItTSoS != oldTrackStates->rend(); ++rItTSoS)
  {
    if (trkPara!=0){
        break;
    }
 
    if ( (*rItTSoS)->type(Trk::TrackStateOnSurface::Measurement) && (*rItTSoS)->trackParameters()!=0 && (*rItTSoS)->measurementOnTrack()!=0)
    {
       trkPara = (*rItTSoS)->trackParameters();
    }
  }
 
  if (trkPara !=0 ){
    m_electronLMQoverP[fitter][m_electronCounter] =  trkPara->parameters()[Trk::qOverP] ;
    return true;
  }
 
  return false;
 
}

FillSimpleTree()

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

private

Definition at line 1325 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_VERBOSE("In fillSimpleTree()");
  std::vector<int> electronsZee;
  std::vector<int> electronsWenu;
 
  // check if Zee or Wenu event
  passZeeSelection(electronsZee);
  passWenuSelection(electronsWenu);
 
  std::vector<int> allInterestingElectrons;
  for(int i(0); i < (int)electronsZee.size(); ++i){
    int ele  = electronsZee[i];
    if ( std::find(allInterestingElectrons.begin(), allInterestingElectrons.end(), ele)==allInterestingElectrons.end() ){
      allInterestingElectrons.push_back(ele);
    }
  }
  for(int i(0); i < (int)electronsWenu.size(); ++i){
    int ele  = electronsWenu[i];
    if ( std::find(allInterestingElectrons.begin(), allInterestingElectrons.end(), ele)==allInterestingElectrons.end() ){
      allInterestingElectrons.push_back(ele);
    }
  }
  ATH_MSG_DEBUG(" SimpleTreeElectrons " << allInterestingElectrons.size() );
  for(int i(0); i < (int)allInterestingElectrons.size(); ++i){
    int ele = allInterestingElectrons[i];
    if (m_electronQoverP[0][ele] > 0 )
      m_smallCharge = 1.;
    else
      m_smallCharge =-1.;
    m_smallTrackTheta    = m_electronTheta[0][ele];
    m_small_QoverP       = m_electronQoverP[0][ele];
    m_small1_QoverP      = m_electronQoverP[1][ele];
    m_small2_QoverP      = m_electronQoverP[2][ele];
    m_smallClusterEnergy = m_ClusterEnergy[ele];
    m_smallClusterPhi    = m_ClusterPhi[ele];
    m_smallClusterEta    = m_ClusterEta[ele];
    m_smallValidationTree->Fill();
  }
 
  return allInterestingElectrons;
}

fillTriggerInformation()

void IDPerfMonEoverP::fillTriggerInformation ( )

private

Definition at line 1007 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_VERBOSE("In fillTriggerInformation()");
  ATH_MSG_DEBUG( "Pass state All = " << m_trigDec->isPassed( ".*" ) );
  ATH_MSG_DEBUG( "Pass state L1 = " << m_trigDec->isPassed( "L1_.*" ) );
  ATH_MSG_DEBUG( "Pass state L2 = " << m_trigDec->isPassed( "L2_.*" ) );
  ATH_MSG_DEBUG( "Pass state EF = " << m_trigDec->isPassed( "EF_.*" ) );
  ATH_MSG_DEBUG("HLT_.* is passed: " << m_trigDec->isPassed("HLT_.*"));
  for (unsigned int i=0; i < m_triggerNames.size(); ++i){
    if(m_triggerNames[i] == "ALL")
      m_trigger[i] = m_trigDec->isPassed(".*");
    else if(m_triggerNames[i] == "HLT_ALL")
      m_trigger[i] = m_trigDec->isPassed("HLT_.*");
    else
      m_trigger[i] = m_trigDec->isPassed(m_triggerNames[i]);
  }
  return;
}

fillVertexInformation()

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

private

Definition at line 911 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_DEBUG( "fillVertexInformation() -- START --" );
  const xAOD::VertexContainer* vxContainer(0);
  int npv = 0;
  StatusCode sc = evtStore()->retrieve(vxContainer, m_primaryVertexCollection);
  if (sc.isFailure()) {
    ATH_MSG_WARNING( "Could not retrieve primary vertex info: " << m_primaryVertexCollection );
    return false;
  }
  else {
    ATH_MSG_DEBUG( "Found primary vertex info: " << m_primaryVertexCollection );
    if(vxContainer) {
      ATH_MSG_DEBUG("Nb of reco primary vertex for coll "
            << " = " << vxContainer->size() );
      primaryVertexFirstCandidate = std::begin(*vxContainer)[0];
      ATH_MSG_DEBUG( "The primary vertex type: " << primaryVertexFirstCandidate->type() );
      int vtxCount = 0;
      for(const auto* vxI : *vxContainer ) {
        int type = (int)(vxI)->vertexType();
    const xAOD::Vertex* primaryVertex = vxI;
    vtxCount++;
    ATH_MSG_DEBUG( " -- dealing with vertex " << vtxCount << "  type: " << type );
        int nbtk = 0;
    const std::vector< ElementLink< xAOD::TrackParticleContainer > > tpLinks =  vxI->trackParticleLinks();
    float sumpt = 0.;
    if(not tpLinks.empty()) {
      nbtk = tpLinks.size();
      ATH_MSG_DEBUG( " -- vertex " << vtxCount << "  has  "  << nbtk << " track particles" );
      for(const auto& tp_elem : tpLinks ){
        const xAOD::TrackParticle* trk = *tp_elem;
        if (trk != NULL) {
          VxPos myVxPos = std::make_pair(vxI,npv);
          trackParticleVertexMap.insert( std::make_pair( trk, myVxPos )  );
          if(trk) { 
        sumpt += trk->p4().Perp();
          }
        }
        else {
          ATH_MSG_DEBUG( "   -- trk is NULL :(" );
        } // trk not null
      } // loop on tracks 
      ATH_MSG_DEBUG( "Reco PV " << npv << ": ("
             << primaryVertex->position().x() << ","
             << primaryVertex->position().y() << ","
             << primaryVertex->position().z() << ")"
             << " type=" << type
             << " nbtk=" << nbtk
             << " sumpt=" << sumpt);
 
      if(npv >= NO_PV) {
        ATH_MSG_WARNING( "More than " << NO_PV << " reconstructed primary vertices in event "
                 << "for run= " << m_runNumber << " evt= " << m_evtNumber
                 << ". Truncated event. " );
      } else {
        m_pvtype[npv] = type;
        m_pvnbtk[npv] = nbtk;
        m_pvsumpt[npv] = sumpt;
        m_pvx[npv] = primaryVertex->position().x();
        m_pvy[npv] = primaryVertex->position().y();
        m_pvz[npv] = primaryVertex->position().z();
       
      }
      ++npv;
    } else {
      ATH_MSG_DEBUG( "Vertex " << npv << " has no tracks associated to it!"  );
    }
      }
    } else {
      ATH_MSG_DEBUG( "No container in collection?? " << m_primaryVertexCollection );
    }
  }
  m_nbpv = npv;
 
  ATH_MSG_DEBUG("Done filling Vertex information -- completed -- ");
 
  if (npv == 0)  return false;
  return true;
}

finalize()

StatusCode IDPerfMonEoverP::finalize

(

)

Definition at line 474 of file IDPerfMonEoverP.cxx.

{
  return StatusCode::SUCCESS;
}

findAssociatedVertex()

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

private

Definition at line 992 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_VERBOSE("In findAssociatedVertex()");
  std::map<const xAOD::TrackParticle*, VxPos>::iterator tpVx =
    trackParticleVertexMap.find(eg->trackParticle());
  if (tpVx == trackParticleVertexMap.end() ){
    return std::make_pair( primaryVertexFirstCandidate,-1 );
  } else
    return (*tpVx).second;
 
}

getMassCluster()

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

private

Definition at line 1309 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_VERBOSE("In getMassCluster()");
  double ELECTRON_MASS  = ParticleConstants::electronMassInMeV; //MeV
  TLorentzVector v0,v1;
  double pt1 = m_ClusterEnergy[el1]*std::sin(m_electronTheta[0][el1]);
  double pt2 = m_ClusterEnergy[el2]*std::sin(m_electronTheta[0][el2]);
  double eta1 = -std::log( std::tan(m_electronTheta[0][el1] * 0.5) );
  double eta2 = -std::log( std::tan(m_electronTheta[0][el2] * 0.5) );
  v0.SetPtEtaPhiM(pt1,eta1,m_electronPhi[0][el1], ELECTRON_MASS);
  v1.SetPtEtaPhiM(pt2,eta2,m_electronPhi[0][el2], ELECTRON_MASS);
  double mass  =  (v0+v1).M();
  return mass;
 
}

initialize()

StatusCode IDPerfMonEoverP::initialize

(

)

Gaudi algorithm hooks.

Definition at line 151 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_INFO("Initializing IDPerfMonEoverP");
 
  ATH_CHECK( m_evt.initialize() );
 
  // Retrieve Jet selector tool
  CHECK( m_jetCleaningTool.retrieve() );
 
  // Retrieve fitter
  if (m_TrackRefitter.retrieve().isFailure()) {
    ATH_MSG_FATAL("Unable to retrieve " << m_TrackRefitter );
    return StatusCode::FAILURE;
  } else
    ATH_MSG_INFO("Retrieved tool" << m_TrackRefitter );
 
  // Retrieve the second fitter
  if (m_TrackRefitter_no2.retrieve().isFailure()) {
    ATH_MSG_FATAL("Unable to retrieve " << m_TrackRefitter_no2 );
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_INFO("Retrieved tool" << m_TrackRefitter_no2 );
  }
 
  if(m_trigDec.retrieve().isFailure()) {
    ATH_MSG_FATAL("Unable to retrieve " << m_trigDec << " turn it off");
    return StatusCode::FAILURE;
  }
  else {
    ATH_MSG_INFO("Retrieved tool " << m_trigDec );
  }
 
 
  //
  //  Electron PID Variables
  //
  // Following are of ShowerShapeType
  namespace xEgamma = xAOD::EgammaParameters;
  namespace xIso = xAOD::Iso;
  m_PID_ShowerType_Names = {
    {xEgamma::f1, "f1"},
    {xEgamma::emins1, "f1core"},
    {xEgamma::fracs1, "fside"},
    {xEgamma::e2tsts1, "Emax2"},
    {xEgamma::weta1, "ws3"},
    {xEgamma::wtots1, "wstot"},
    {xEgamma::emaxs1,"emaxs1"},
    {xEgamma::e233,"E233"},
    {xEgamma::e237,"E237"},
    {xEgamma::e277,"E277"},
    {xEgamma::weta2,"weta2"},
    {xEgamma::f3,"f3"},
    {xEgamma::f3core,"f3core"}
  };
  // Following are of isolation type
  m_PID_IsolationType_Names = {
    {xIso::etcone20,"Etcone20"},
    {xIso::etcone30,"Etcone30"},
    {xIso::etcone40,"Etcone40"},
    {xIso::ptcone30,"ptcone30"}
  };
  // Following are of trackcalomatch type
  m_PID_TrackCaloMatchType_Names = {
    {xEgamma::deltaEta1,"deltaeta1"},
    {xEgamma::deltaEta2,"deltaeta2"},
    {xEgamma::deltaPhi2,"deltaphi2"}
  };
  
 
 
  //
  //  Trigger
  //
  m_triggerNames = {
    "L1_MBTS_1", 
    "L1_EM2",
    "L1_2EM2",
    "L1_2EM4",
    "L1_EM5",
    "L1_EM10",
    "L1_EM10I",
    "L1_EM14",
    "L1_EM18",
    "L1_EM18I",
    "L1_EM23I",
    "L1_EM100",
    "EF_2e5_medium",
    "EF_e10_medium",
    "EF_e20_loose",
    "EF_em105_passHLT",
    "EF_g20_loose",
    "EF_e20_medium",
    "EF_e22_medium",
    //run 2 test
    "HLT_e24_lhmedium_idperf_L1EM20VH",
    "HLT_e24_medium_L1EM18VH",
    "e5_vloose",
    "ALL",
    "HLT_ALL"
  };
  
  // If the validation nuptle has been requested Setup the ntuple
  if (m_validationMode){
    if (m_validationTree == nullptr ){ // validation tree does not exist yet
      // create the new Tree
      ATH_MSG_DEBUG ( "Booking validationTree with name: " << m_validationTreeName );
      m_validationTree = new TTree(m_validationTreeName.c_str(), m_validationTreeDescription.c_str());
      std::string FitterNames[3] = {"GX2","Refitted1","Refitted2"};
      m_validationTree->Branch("runNumber"      ,  &m_runNumber,  "runNumber/I");
      m_validationTree->Branch("eventNumber"      ,  &m_evtNumber,  "eventNumber/I");
      m_validationTree->Branch("lumi_block"      ,  &m_lumi_block,  "lumi_block/I");
      // counter for number of electrons
      m_validationTree->Branch("nElectrons"      ,  &m_nelectrons,  "nElectrons/I");
      // Track fitter information
      for(int fitter(0); fitter < 3; ++fitter){
        m_validationTree->Branch( (FitterNames[fitter]+"_Theta").c_str()    ,  m_electronTheta[fitter],    (FitterNames[fitter]+"_Theta0[nElectrons]/F").c_str() );
        m_validationTree->Branch( (FitterNames[fitter]+"_Eta").c_str()      ,  m_electronEta[fitter],      (FitterNames[fitter]+"_Eta[nElectrons]/F").c_str() );
    m_validationTree->Branch( (FitterNames[fitter]+"_Eta").c_str()      ,  m_electronEta[fitter],      (FitterNames[fitter]+"_Eta[nElectrons]/F").c_str() );
        m_validationTree->Branch( (FitterNames[fitter]+"_Phi0").c_str()     ,  m_electronPhi[fitter],      (FitterNames[fitter]+"_Phi0[nElectrons]/F").c_str() );
        m_validationTree->Branch( (FitterNames[fitter]+"_QoverP").c_str()   ,  m_electronQoverP[fitter],   (FitterNames[fitter]+"_QoverP[nElectrons]/F").c_str());
        m_validationTree->Branch( (FitterNames[fitter]+"_d0").c_str()       ,  m_electrond0[fitter],       (FitterNames[fitter]+"_d0[nElectrons]/F").c_str());
        m_validationTree->Branch( (FitterNames[fitter]+"_z0").c_str()       ,  m_electronz0[fitter],       (FitterNames[fitter]+"_z0[nElectrons]/F").c_str());
        m_validationTree->Branch( (FitterNames[fitter]+"_LMQoverP").c_str() ,  m_electronLMQoverP[fitter], (FitterNames[fitter]+"_LMQoverP[nElectrons]/F").c_str());
        m_validationTree->Branch( (FitterNames[fitter]+"_ThetaErr").c_str() ,  m_electronErrTheta[fitter], (FitterNames[fitter]+"_Theta0Err[nElectrons]/F").c_str());
        m_validationTree->Branch( (FitterNames[fitter]+"_Phi0Err").c_str()  ,  m_electronErrPhi[fitter],   (FitterNames[fitter]+"_Phi0Err[nElectrons]/F").c_str());
        m_validationTree->Branch( (FitterNames[fitter]+"_QoverPErr").c_str(),  m_electronErrQoverP[fitter],(FitterNames[fitter]+"_QoverPErr[nElectrons]/F").c_str());
        m_validationTree->Branch( (FitterNames[fitter]+"_d0Err").c_str()    ,  m_electronErrd0[fitter],    (FitterNames[fitter]+"_d0Err[nElectrons]/F").c_str());
        m_validationTree->Branch( (FitterNames[fitter]+"_z0Err").c_str()    ,  m_electronErrz0[fitter],    (FitterNames[fitter]+"_z0Err[nElectrons]/F").c_str());
      }
 
      m_validationTree->Branch("associatedToVtx" ,  m_associatedToVtx, "associatedToVtx[nElectrons]/I");
      m_validationTree->Branch("nbpv",    &m_nbpv, "nbpv/I");
      m_validationTree->Branch("pvtype",  m_pvtype, "pvtype[nbpv]/I");
      m_validationTree->Branch("pvnbtk",  m_pvnbtk, "pvnbtk[nbpv]/I");
      m_validationTree->Branch("pvsumpt", m_pvsumpt, "pvsumpt[nbpv]/F");
      m_validationTree->Branch("pvx", m_pvx, "pvx[nbpv]/F");
      m_validationTree->Branch("pvy", m_pvy, "pvy[nbpv]/F");
      m_validationTree->Branch("pvz", m_pvz, "pvz[nbpv]/F");
      m_validationTree->Branch("errpvx", m_errpvx, "errpvx[nbpv]/F");
      m_validationTree->Branch("errpvy", m_errpvy, "errpvy[nbpv]/F");
      m_validationTree->Branch("errpvz", m_errpvz, "errpvz[nbpv]/F");
      m_validationTree->Branch("covpvxpvy", m_covpvxpvy, "covpvxpvy[nbpv]/F");
      m_validationTree->Branch("covpvzpvx", m_covpvzpvx, "covpvzpvx[nbpv]/F");
      m_validationTree->Branch("covpvypvz", m_covpvypvz, "covpvypvz[nbpv]/F");
 
 
      m_validationTree->Branch("METgoodness",    &m_METgoodness, "METgoodness/B");
      m_validationTree->Branch("sumet",    &m_sumet, "sumet/F");
      m_validationTree->Branch("missingEt",    &m_missingEt, "missingEt/F");
      m_validationTree->Branch("missingEtx",    &m_missingEtx, "missingEtx/F");
      m_validationTree->Branch("missingEty",    &m_missingEty, "missingEty/F");
 
 
      m_validationTree->Branch("ElectronAuthor"     ,  m_author, "ElectronAuthor[nElectrons]/I");
      m_validationTree->Branch("ClusterEnergy"      ,  m_ClusterEnergy, "ClusterEnergy[nElectrons]/F");
      m_validationTree->Branch("ClusterEta"         ,  m_ClusterEta, "ClusterEta[nElectrons]/F");
      m_validationTree->Branch("ClusterPhi"         ,  m_ClusterPhi, "ClusterPhi[nElectrons]/F");
 
      m_validationTree->Branch("IsEMLoose"          ,  m_IsEMLoose, "m_IsEMLoose[nElectrons]/O");
      m_validationTree->Branch("IsEMMedium"         ,  m_IsEMMedium, "m_IsEMMedium[nElectrons]/O");
      m_validationTree->Branch("IsEMTight"          ,  m_IsEMTight, "m_IsEMTight[nElectrons]/O");
      m_validationTree->Branch("isGoodOQ"          ,  m_isGoodOQ, "isGoodOQ[nElectrons]/O");
 
      m_validationTree->Branch("nTRT"               , m_nTRT , "nTRT[nElectrons]/I");
      m_validationTree->Branch("nSCT"               , m_nSCT, "nSCT[nElectrons]/I");
      m_validationTree->Branch("nBLayer"            , m_nBLayer, "nBLayer[nElectrons]/I");
      m_validationTree->Branch("nPIX"               , m_nPIX, "nPIX[nElectrons]/I");
      m_validationTree->Branch("nTRTout"            , m_nTRTout, "nTRTout[nElectrons]/I");
      m_validationTree->Branch("nSCTout"            , m_nSCTout, "nSCTout[nElectrons]/I");
      m_validationTree->Branch("nPIXout"            , m_nPIXout, "nPIXout[nElectrons]/I");
      m_validationTree->Branch("nTRTHT"             , m_nTRTHT, "nTRTHT[nElectrons]/I");
      m_validationTree->Branch("nTRTHout"           , m_nTRTHTout, "nTRTHTout[nElectrons]/I");
 
 
      for(unsigned int item(0); item < m_PID_ShowerType_Names.size(); ++item){
        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() );
      }
 
      for(unsigned int item(0); item < m_PID_IsolationType_Names.size(); ++item){
        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() );
      }
 
      for(unsigned int item(0); item < m_PID_TrackCaloMatchType_Names.size(); ++item){
        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() );
      }
 
      for(unsigned int item(0); item < m_PID_SummaryType_Names.size(); ++item){
        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() );
      }
 
      for(unsigned int item(0); item < m_triggerNames.size(); ++item){
        m_validationTree->Branch( m_triggerNames[item].c_str()  , &m_trigger[item], std::string( m_triggerNames[item]+ "/B" ).c_str() );
      }
 
    }
 
 
    if(m_smallValidationTree == nullptr){
 
      m_smallValidationTree = new TTree(m_smallValidationTreeName.c_str(), m_smallValidationTreeDescription.c_str());
 
      m_smallValidationTree->Branch("charge",&m_smallCharge,"charge/D");
      m_smallValidationTree->Branch("runNumber"  ,  &m_runNumber,  "runNumber/I");
      m_smallValidationTree->Branch("Default_QoverP",&m_small_QoverP,"Default_QoverP/D");
      m_smallValidationTree->Branch("Refitted1_QoverP",&m_small1_QoverP,"Refitted1_QoverP/D");
      m_smallValidationTree->Branch("Refitted2_QoverP",&m_small2_QoverP,"Refitted2_QoverP/D");
      m_smallValidationTree->Branch("ClusterEnergy",&m_smallClusterEnergy,"ClusterEnergy/D");
      m_smallValidationTree->Branch("ClusterEta"   ,&m_smallClusterEta,"ClusterEta/D");
      m_smallValidationTree->Branch("ClusterPhi"   ,&m_smallClusterPhi,"ClusterPhi/D");
      m_smallValidationTree->Branch("TrackTheta"   ,&m_smallTrackTheta,"TrackTheta/D");
    }
 
    // Access THistSvc
    ServiceHandle<ITHistSvc> tHistSvc("THistSvc", name());
    if ( tHistSvc.retrieve().isSuccess()) {
      ATH_MSG_DEBUG(" initialize() THistSvc successfully retrieved ");
    }
    else {
      ATH_MSG_ERROR("initialize() Could not find Hist Service -> Switching ValidationMode Off !");
      delete m_validationTree;      m_validationTree = 0;
      delete m_smallValidationTree; m_smallValidationTree = 0;
      m_validationMode = false;
    }
    
    // now register the Tree
    if (m_validationTree != nullptr ) {
      if ( (tHistSvc->regTree(m_validationTreeFolder, m_validationTree)).isSuccess() ) {
    ATH_MSG_DEBUG( "initialize() validation tree (" << m_validationTree->GetName() <<") successfully registered in folder " << m_validationTreeFolder );
      }
      else {
    ATH_MSG_ERROR( "initialize() Could not register the validation Tree -> Switching ValidationMode Off !");
    delete m_validationTree; m_validationTree = 0;
    m_validationMode = false;
      }
    }
    else {
      ATH_MSG_DEBUG( "initialize() no validation tree to register :( ");
    }
 
    if ((tHistSvc->regTree(m_smallValidationTreeFolder, m_smallValidationTree)).isFailure() ) {
      ATH_MSG_ERROR("initialize() Could not register the validation Tree -> Switching ValidationMode Off !");
      delete m_smallValidationTree; m_smallValidationTree = 0;
      m_validationMode = false;
    }
    else {
      m_ZeeLooseMassOS_Cluster = new TH1F("ZeeMassLooseOS","ZeeMassLooseOS", 120, 60000 ,120000);
      m_ZeeLooseMassSS_Cluster  = new TH1F("ZeeMassLooseSS","ZeeMassLooseSS", 120, 60000 ,120000);
      m_ZeeMediumMassOS_Cluster = new TH1F("ZeeMassMediumOS","ZeeMassMediumOS", 120, 60000 ,120000);
      m_ZeeMediumMassSS_Cluster  = new TH1F("ZeeMassMediumSS","ZeeMassMediumSS", 120, 60000 ,120000);
      m_WenuLooseElectronET= new TH1F("WenuLooseElectronET","WenuLooseElectronET", 80, 20000 ,100000);
      m_WenuTight_Met = new TH1F("WenuTight_Met","WenuTight_Met", 120, 00000 ,120000);
      m_WenuTight_MT = new TH1F("WenuTight_MT","WenuTight_MT", 120, 00000 ,120000);
      m_WenuTightMet_MT  = new TH1F("WenuTightMet_MT","WenuTightMet_MT", 120, 00000 ,120000);
      m_WenuTightElectronET  = new TH1F("WenuTightElectronET","WenuTightElectronET", 100, 00000 ,100000);
      m_WenuTightW_PT  = new TH1F("WenuTightW_PT","WenuTightW_PT", 100, 00000 ,100000);
 
      m_ZeeMediumOS_ClusterPtEta   = new TH2F("ZeeMediumOS_ClusterPtEta", "ZeeMediumOS_ClusterPtEta",100,20000,120000,50,-2.5,2.5);
      m_WenuTightElectron_PTEtaPos = new TH2F("WenuTightElectron_PTEtaPos", "WenuTightElectron_PTEtaPos",100,20000,120000,50,-2.5,2.5);
      m_WenuTightElectron_PTEtaNeg = new TH2F("WenuTightElectron_PTEtaNeg", "WenuTightElectron_PTEtaNeg",100,20000,120000,50,-2.5,2.5);
      
      bool somethingFailed{};
      somethingFailed |= ( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMassLooseOS",m_ZeeLooseMassOS_Cluster )).isFailure() );
      somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMassLooseSS",m_ZeeLooseMassSS_Cluster )).isFailure() );
      somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMassMediumOS",m_ZeeMediumMassOS_Cluster )).isFailure() );
      somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMassMediumSS",m_ZeeMediumMassSS_Cluster )).isFailure() );
      somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuLooseElectronET",m_WenuLooseElectronET )).isFailure() );
      somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTight_Met",m_WenuTight_Met )).isFailure() );
      somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTight_MT",m_WenuTight_MT )).isFailure() );
      somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightMet_MT",m_WenuTightMet_MT )).isFailure() );
      somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightElectronET",m_WenuTightElectronET )).isFailure() );
      somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightW_PT",m_WenuTightW_PT )).isFailure() );
      somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/ZeeMediumOS_ClusterPtEta",m_ZeeMediumOS_ClusterPtEta )).isFailure() );
      somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightElectron_PTEtaPos",m_WenuTightElectron_PTEtaPos )).isFailure() );
      somethingFailed |=( (tHistSvc->regHist(m_smallValidationTreeFolder + "/WenuTightElectron_PTEtaNeg",m_WenuTightElectron_PTEtaNeg )).isFailure() );
      if (somethingFailed) ATH_MSG_ERROR("initialize() Could not register histogram ");
        
      ATH_MSG_INFO("Booked Small Tree add histograms");
    }
 
    ATH_MSG_INFO("Loaded THistSvc");
  }
 
  //---Electron Likelihood tool---
  ATH_MSG_INFO("IDPerfMonEoverP::Initialize() -- Setting up electron LH tool.");
  m_LHToolLoose2015  = new AsgElectronLikelihoodTool ("m_LHToolLoose2015");
  m_LHToolMedium2015 = new AsgElectronLikelihoodTool ("m_LHToolMedium2015");
  m_LHToolTight2015  = new AsgElectronLikelihoodTool ("m_LHToolTight2015");
 
  if((m_LHToolLoose2015->setProperty("primaryVertexContainer",m_primaryVertexCollection)).isFailure())
    ATH_MSG_WARNING("Failure setting primary vertex container " << m_primaryVertexCollection << "in loose electron likelihood tool");
  if((m_LHToolMedium2015->setProperty("primaryVertexContainer",m_primaryVertexCollection)).isFailure())
    ATH_MSG_WARNING("Failure setting primary vertex container " << m_primaryVertexCollection << "in medium electron likelihood tool");
  if((m_LHToolTight2015->setProperty("primaryVertexContainer",m_primaryVertexCollection)).isFailure())
    ATH_MSG_WARNING("Failure setting primary vertex container " << m_primaryVertexCollection << "in tight electron likelihood tool");
 
  //Set up electron LH level
  std::string confDir = "ElectronPhotonSelectorTools/offline/"+m_lhTune+"/";
  std::string configFileL = confDir+"ElectronLikelihoodLooseOfflineConfig2015.conf";
  std::string configFileM = confDir+"ElectronLikelihoodMediumOfflineConfig2015.conf";
  std::string configFileT = confDir+"ElectronLikelihoodTightOfflineConfig2015.conf";
 
  if((m_LHToolLoose2015->setProperty("ConfigFile",configFileL)).isFailure())
    ATH_MSG_WARNING("Failure loading ConfigFile in loose electron likelihood tool.");
  if((m_LHToolMedium2015->setProperty("ConfigFile",configFileM)).isFailure())
    ATH_MSG_WARNING("Failure loading ConfigFile in medium electron likelihood tool.");
  if((m_LHToolTight2015->setProperty("ConfigFile",configFileT)).isFailure())
    ATH_MSG_WARNING("Failure loading ConfigFile in tight electron likelihood tool.");
 
  StatusCode lhl = m_LHToolLoose2015->initialize();
  if(lhl.isFailure())
    ATH_MSG_WARNING("Loose electron likelihood tool initialize() failed!");
  StatusCode lhm = m_LHToolMedium2015->initialize();
  if(lhm.isFailure())
    ATH_MSG_WARNING("Medium electron likelihood tool initialize() failed!");
  StatusCode lht = m_LHToolTight2015->initialize();
  if(lht.isFailure())
    ATH_MSG_WARNING("Tight electron likelihood tool initialize() failed!");
  ATH_MSG_INFO( "Initialization completed successfully");
  return StatusCode::SUCCESS;
}

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()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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

{
  const xAOD::JetContainer* jetTDS = nullptr;
  StatusCode sc= evtStore()->retrieve( jetTDS, m_jetContainerName);
  if( sc.isFailure()  ||  !jetTDS ) {
    ATH_MSG_WARNING("No " << m_jetContainerName << " jet container found in TDS");
    return false;
  }
  if (jetTDS->empty()) return true;
  bool cleanJet = true;
  for(const auto* jet_elem : *jetTDS ) {
    if(!m_jetCleaningTool->keep( *jet_elem )) cleanJet=false;
    if(!cleanJet) break;
  }
  return cleanJet;
}

passWenuSelection()

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

private

Definition at line 1189 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_VERBOSE("In passWenuSelection() -- START -- ");
  if(m_nbpv<1) return false;
  bool primaryVertexOk(false);
  electrons.clear();
 
  for (int i(0); i<m_nbpv; ++i){
    if (m_pvnbtk[i] > 2) primaryVertexOk = true;
  }
  if(!primaryVertexOk) {
    ATH_MSG_DEBUG (" -- passWenuSelection() -- failing on primary vertices");
    return false;
  }
  
  //MET Goodness
  if( m_isDATA && !m_METgoodness) {
    ATH_MSG_DEBUG (" -- passWenuSelection() -- failing on m_isDATA && !m_METgoodness");
    return false;
  }
 
  //Trigger
  //no need to pass trigger for perfromance studies
 
 
  //Loose electron selection
  std::vector<int> goodLooseElectrons;
  for(int ele(0); ele<m_nelectrons; ++ele){
    //Loose electron selection
    if (!m_IsEMLoose[ele]) continue;
    //Pt
    double clusterEt = cosh( m_ClusterEta[ele] ) != 0 ?  m_ClusterEnergy[ele] / std::cosh( m_ClusterEta[ele] ) : 0.;
    if (clusterEt <= 25000) continue;
    //Range
    double absEta = std::abs(m_ClusterEta[ele]);
    if (absEta >= 2.47 || ( absEta >= 1.37 && absEta <= 1.52 ) ) continue;
    //OTx ...
    if(!m_isGoodOQ[ele]) continue;
    //Author
    if(m_author[ele]!=1 && m_author[ele]!=3) continue;
    goodLooseElectrons.push_back(ele);
  }
 
  //Fill Loose electron ET spectrum;
  for(int gele(0); gele < (int) goodLooseElectrons.size(); ++gele){
    int ele  = goodLooseElectrons[gele];
    double trackEt = m_ClusterEnergy[gele]*sin(m_electronTheta[0][ele]);
    m_WenuLooseElectronET->Fill(trackEt);
  }
 
  int nMediumElectrons(0);
  int nTightElectrons(0);
  int tightElectron(0);
 
  for(int gele(0); gele < (int) goodLooseElectrons.size(); ++gele){
    //
    int ele  = goodLooseElectrons[gele];
    if(m_IsEMMedium[ele]) ++nMediumElectrons;
    if (!m_IsEMTight[ele]) continue;
    ++nTightElectrons;
    tightElectron = ele;
  }
 
  //Reject events with more than one good electron
  if (nMediumElectrons >2) {
    ATH_MSG_DEBUG (" -- passWenuSelection() -- failing number of medium electrons cut " << nMediumElectrons ); 
    return false;
  }
  //Reject events with no tight electrons;
  if (nTightElectrons <1) {
    ATH_MSG_DEBUG (" -- passWenuSelection() -- failing number of tight electrons cut " << nTightElectrons ); 
    return false;
  }
  double metphi = atan2(m_missingEty,m_missingEtx);
  double trackEt = m_ClusterEnergy[tightElectron]*std::sin(m_electronTheta[0][tightElectron]);
  double clusterEt = std::cosh( m_ClusterEta[tightElectron] ) !=0 ?  m_ClusterEnergy[tightElectron] / std::cosh( m_ClusterEta[tightElectron] ) : 0.;
 
  double massT = 2*m_missingEt*trackEt*(1-cos(m_electronPhi[0][tightElectron]-metphi));
  if(massT > 0) massT =std::sqrt(massT);
  else massT = 0;
 
 
  m_WenuTight_Met->Fill(m_missingEt);
  m_WenuTight_MT->Fill(massT);
 
  if (m_missingEt <= 25000) {
    ATH_MSG_DEBUG (" -- passWenuSelection() -- failing missingEt cut " << m_missingEt );
    return false;
  }
  m_WenuTightMet_MT->Fill(massT);
 
  if (massT <= 50000) {
    ATH_MSG_DEBUG (" -- passWenuSelection() -- failing transverse mass cut " << massT );
    return false;
  }
 
  m_WenuTightElectronET->Fill(clusterEt);
 
  double sumpx = m_ClusterEnergy[tightElectron]*std::sin( m_electronPhi[0][tightElectron] ) * std::sin(m_electronTheta[0][tightElectron]) + m_missingEtx;
  double sumpy = m_ClusterEnergy[tightElectron]*std::cos( m_electronPhi[0][tightElectron] ) * std::sin(m_electronTheta[0][tightElectron]) + m_missingEty;
 
  double wpt = sumpx*sumpx +sumpy*sumpy - massT*massT;
  if(wpt > 0) wpt  =std::sqrt(wpt);
  else wpt = 0;
 
  m_WenuTightW_PT->Fill(wpt);
 
 
  if(m_electronQoverP[0][tightElectron] > 0){
    m_WenuTightElectron_PTEtaPos->Fill(trackEt,m_ClusterEta[tightElectron]);
  } else {
    m_WenuTightElectron_PTEtaNeg->Fill(trackEt,m_ClusterEta[tightElectron]);
  }
 
  electrons.push_back(tightElectron);
 
  ATH_MSG_VERBOSE("In passWenuSelection() -- completed -- ");
  return true;
}

passZeeSelection()

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

private

Definition at line 1081 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_VERBOSE("In passZeeSelection() -- START -- ");
  //ATH_MSG_WARNING("Zee seletion needs to be adjusted for run2");
  // Adjusted according to https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/WZCommonAnalysisTopics2015
  if(m_nbpv<1) {
    ATH_MSG_DEBUG (" -- passZeeSelection() -- failing on primary vertices: m_nbpv= " << m_nbpv);
    return false;
  }
  
  bool primaryVertexOk(false);
  electrons.clear();
 
  for (int i=0; i<m_nbpv; ++i){
    if (m_pvnbtk[i] > 2) primaryVertexOk = true;
  }
  if(!primaryVertexOk) {
    ATH_MSG_DEBUG (" -- passZeeSelection() -- failing on primary vertices");
    return false;
  }
  //Trigger
  //No need to pass the trigger for tracking performance studies
 
  //Loose electron selection
  std::vector<int> goodLooseElectrons;
 
  for(int ele=0; ele<m_nelectrons; ele++){
    //Loose electron selection
    if (!m_IsEMLoose[ele]) continue;
    //Pt
    double clusterEt = cosh( m_ClusterEta[ele] ) != 0 ?  m_ClusterEnergy[ele] / std::cosh( m_ClusterEta[ele] ) : 0.;
    if (clusterEt <= 25000) continue;
 
    //Range
    double absEta = std::abs(m_ClusterEta[ele]);
    if (absEta >= 2.47 || ( absEta >= 1.37 && absEta <= 1.52 )) continue;
 
    //OTx ...
    if(!m_isGoodOQ[ele]) continue;
 
    //Author
    if(m_author[ele]!=1 && m_author[ele]!=3) continue;
 
    goodLooseElectrons.push_back(ele);
  }
 
  int pairsLooseInMassWindow = 0;
 
  ATH_MSG_DEBUG(" -- passZeeSelection() -- report -- N Loose electrons " << goodLooseElectrons.size());
 
  //Fill Loose electron ET spectrum;
  for(int gele1 = 0; gele1 < (int)goodLooseElectrons.size()-1; ++gele1){
    for(int gele2 = gele1+1; gele2 < (int)goodLooseElectrons.size(); ++gele2){
      int ele1 = goodLooseElectrons[gele1];
      int ele2 = goodLooseElectrons[gele2];
      double mass = getMassCluster(ele1,ele2);
      if (mass > 60000 && mass < 120000){
        ++pairsLooseInMassWindow;
        if(m_electronQoverP[0][ele1]*m_electronQoverP[0][ele2]<0)
          m_ZeeLooseMassOS_Cluster->Fill(mass);
        else
          m_ZeeLooseMassSS_Cluster->Fill(mass);
      }
    }
  }
 
  if (pairsLooseInMassWindow < 1) {
    ATH_MSG_DEBUG (" -- passZeeSelection() -- failing pairsLooseInMassWindow= " << pairsLooseInMassWindow );
    return false;
  }
  std::vector<int> goodMediumElectrons;
 
  for(int gele = 0; gele < (int)goodLooseElectrons.size(); ++gele){
    int ele  = goodLooseElectrons[gele];
    if(m_IsEMMedium[ele]){
      goodMediumElectrons.push_back(ele);
    }
  }
 
  //Reject events with more than two good electrons
  if (goodMediumElectrons.size() != 2) {
    ATH_MSG_DEBUG (" -- passZeeSelection() -- failing goodMediumElectrons != 2 --> " << goodMediumElectrons.size());
    return false;
  }
 
  // Make the mass out of the highest pt electrons ....
  double mass = getMassCluster(goodMediumElectrons[0],goodMediumElectrons[1]);
  if (mass > 66000 && mass < 116000){
    if(m_electronQoverP[0][goodMediumElectrons[0]]*m_electronQoverP[0][goodMediumElectrons[1]]<0){
      m_ZeeMediumMassOS_Cluster->Fill(mass);
      electrons.push_back(goodMediumElectrons[0]);
      electrons.push_back(goodMediumElectrons[1]);
 
      double trackEt = m_ClusterEnergy[goodMediumElectrons[0]]*sin(m_electronTheta[0][goodMediumElectrons[0]]);
      m_ZeeMediumOS_ClusterPtEta->Fill(trackEt, m_ClusterEta[0] );
      trackEt = m_ClusterEnergy[goodMediumElectrons[1]]*sin(m_electronTheta[0][goodMediumElectrons[1]]);
      m_ZeeMediumOS_ClusterPtEta->Fill(trackEt, m_ClusterEta[1] );
 
      return true;
    } else{
      m_ZeeMediumMassSS_Cluster->Fill(mass);
      return false;
    }
  }
  return false;
}

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.

  {
    h.renounce();
    PBASE::renounce (h);
  }

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.

                                                          {
    handlesArray.renounce();
  }

storeMETinformation()

bool IDPerfMonEoverP::storeMETinformation ( )

private

Definition at line 867 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_VERBOSE("In storeMETinformation()");
  const xAOD::MissingETContainer *pMissingCont(0);
  const xAOD::MissingET *MET;
  if (!evtStore()->contains<xAOD::MissingETContainer>(m_missingEtObjectName)){
    ATH_MSG_WARNING("No collection with name " << m_missingEtObjectName << " found in StoreGate");
    return false;
  }
 
  StatusCode sc;
  sc = evtStore()->retrieve(pMissingCont,m_missingEtObjectName);
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Could not retrieve MissingETContainer" );
    return false;
  }
  MET = (*pMissingCont)[m_metRefFinalName];
  m_METgoodness = passMETCleaningCuts();
  m_sumet       = MET->sumet();
  m_missingEt   = MET->met();
  m_missingEtx  = MET->mpx();
  m_missingEty  = MET->mpy();
  return true;
}

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, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

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.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

validationAction()

void IDPerfMonEoverP::validationAction ( )

private

Definition at line 850 of file IDPerfMonEoverP.cxx.

{
  ATH_MSG_DEBUG( "validationAction() -- START -- ");
  // first record the values
  if (m_validationTree){
    m_nelectrons = long(m_electronCounter);
    if(m_fillDetailedTree) {
      m_validationTree->Fill();
      ATH_MSG_DEBUG( "Writing data into ntuple " << m_validationTree->GetName() << ". Entry #" << m_validationTree->GetEntries() );
    }
    // then reset
    m_electronCounter = 0;
  }
  ATH_MSG_DEBUG( "validationAction() -- completed -- current number of entries " << m_validationTree->GetEntries() );
}

Member Data Documentation

m_associatedToVtx

int IDPerfMonEoverP::m_associatedToVtx[NOS_ELECTRONS] {}

private

Definition at line 247 of file IDPerfMonEoverP.h.

{};

m_author

int IDPerfMonEoverP::m_author[NOS_ELECTRONS] {}

private

Definition at line 232 of file IDPerfMonEoverP.h.

{};

m_ClusterEnergy

float IDPerfMonEoverP::m_ClusterEnergy[NOS_ELECTRONS] {}

private

Definition at line 234 of file IDPerfMonEoverP.h.

{};

m_ClusterEta

float IDPerfMonEoverP::m_ClusterEta[NOS_ELECTRONS] {}

private

Definition at line 235 of file IDPerfMonEoverP.h.

{};

m_ClusterPhi

float IDPerfMonEoverP::m_ClusterPhi[NOS_ELECTRONS] {}

private

Definition at line 236 of file IDPerfMonEoverP.h.

{};

m_covpvxpvy

float IDPerfMonEoverP::m_covpvxpvy[NO_PV] {}

private

Definition at line 261 of file IDPerfMonEoverP.h.

{};

m_covpvypvz

float IDPerfMonEoverP::m_covpvypvz[NO_PV] {}

private

Definition at line 262 of file IDPerfMonEoverP.h.

{};

m_covpvzpvx

float IDPerfMonEoverP::m_covpvzpvx[NO_PV] {}

private

Definition at line 263 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 203 of file IDPerfMonEoverP.h.

m_electrond0

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

private

Track Phi on electron.

Definition at line 209 of file IDPerfMonEoverP.h.

{};       

m_electronErrd0

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

private

Definition at line 217 of file IDPerfMonEoverP.h.

{};

m_electronErrPhi

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

private

Track phi error on electron.

Definition at line 215 of file IDPerfMonEoverP.h.

{};    

m_electronErrQoverP

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

private

Definition at line 216 of file IDPerfMonEoverP.h.

{};

m_electronErrTheta

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

private

Track theta error on electron.

Definition at line 214 of file IDPerfMonEoverP.h.

{};  

m_electronErrz0

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

private

Definition at line 218 of file IDPerfMonEoverP.h.

{};

m_electronEta

float IDPerfMonEoverP::m_electronEta[3][NOS_ELECTRONS] {}

private

Track Eta at perigee.

Definition at line 206 of file IDPerfMonEoverP.h.

{};     

m_electronLMQoverP

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

private

Track q over p on electron.

Definition at line 212 of file IDPerfMonEoverP.h.

{};    

m_electronPhi

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

private

Track Phi on electron.

Definition at line 207 of file IDPerfMonEoverP.h.

{};       

m_electronQoverP

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

private

Track q over p on electron.

Definition at line 208 of file IDPerfMonEoverP.h.

{};    

m_electronTheta

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

private

Track theta at perigee.

Definition at line 205 of file IDPerfMonEoverP.h.

{};     

m_electronz0

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

private

Track q over p on electron.

Definition at line 210 of file IDPerfMonEoverP.h.

{};    

m_ePID_IsolationType

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

private

Definition at line 274 of file IDPerfMonEoverP.h.

{};

m_ePID_ShowerType

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

private

Definition at line 273 of file IDPerfMonEoverP.h.

{};

m_ePID_SummaryType

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

private

Definition at line 276 of file IDPerfMonEoverP.h.

{};

m_ePID_TrackCaloMatchType

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

private

Definition at line 275 of file IDPerfMonEoverP.h.

{};

m_errpvx

float IDPerfMonEoverP::m_errpvx[NO_PV] {}

private

Definition at line 258 of file IDPerfMonEoverP.h.

{};

m_errpvy

float IDPerfMonEoverP::m_errpvy[NO_PV] {}

private

Definition at line 259 of file IDPerfMonEoverP.h.

{};

m_errpvz

float IDPerfMonEoverP::m_errpvz[NO_PV] {}

private

Definition at line 260 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.

{this, "EvtInfo", "EventInfo", "EventInfo name"};

m_evtNumber

unsigned int IDPerfMonEoverP::m_evtNumber

private

Definition at line 198 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 184 of file IDPerfMonEoverP.h.

m_fillVertexInfo

bool IDPerfMonEoverP::m_fillVertexInfo

private

Definition at line 177 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 238 of file IDPerfMonEoverP.h.

{};

m_IsEMMedium

bool IDPerfMonEoverP::m_IsEMMedium[NOS_ELECTRONS] {}

private

Definition at line 239 of file IDPerfMonEoverP.h.

{};

m_IsEMTight

bool IDPerfMonEoverP::m_IsEMTight[NOS_ELECTRONS] {}

private

Definition at line 240 of file IDPerfMonEoverP.h.

{};

m_IsEMTightTRT

bool IDPerfMonEoverP::m_IsEMTightTRT[NOS_ELECTRONS] {}

private

Definition at line 241 of file IDPerfMonEoverP.h.

{};

m_isGoodOQ

bool IDPerfMonEoverP::m_isGoodOQ[NOS_ELECTRONS] {}

private

Definition at line 242 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.

{this,"JetCleaningTool","JetCleaningTool/JetCleaningTool",""};

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 333 of file IDPerfMonEoverP.h.

m_LHToolMedium2015

AsgElectronLikelihoodTool* IDPerfMonEoverP::m_LHToolMedium2015

private

Definition at line 334 of file IDPerfMonEoverP.h.

m_LHToolTight2015

AsgElectronLikelihoodTool* IDPerfMonEoverP::m_LHToolTight2015

private

Definition at line 335 of file IDPerfMonEoverP.h.

m_lhTune

std::string IDPerfMonEoverP::m_lhTune

private

Definition at line 332 of file IDPerfMonEoverP.h.

m_lumi_block

unsigned int IDPerfMonEoverP::m_lumi_block

private

Definition at line 199 of file IDPerfMonEoverP.h.

m_METgoodness

bool IDPerfMonEoverP::m_METgoodness

private

Definition at line 266 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 268 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 269 of file IDPerfMonEoverP.h.

m_missingEty

float IDPerfMonEoverP::m_missingEty

private

Definition at line 270 of file IDPerfMonEoverP.h.

m_nBLayer

int IDPerfMonEoverP::m_nBLayer[NOS_ELECTRONS] {}

private

Definition at line 223 of file IDPerfMonEoverP.h.

{};

m_nbpv

int IDPerfMonEoverP::m_nbpv

private

Definition at line 251 of file IDPerfMonEoverP.h.

m_nelectrons

int IDPerfMonEoverP::m_nelectrons

private

Definition at line 202 of file IDPerfMonEoverP.h.

m_nPIX

int IDPerfMonEoverP::m_nPIX[NOS_ELECTRONS] {}

private

Definition at line 224 of file IDPerfMonEoverP.h.

{};

m_nPIXout

int IDPerfMonEoverP::m_nPIXout[NOS_ELECTRONS] {}

private

Definition at line 227 of file IDPerfMonEoverP.h.

{};

m_nSCT

int IDPerfMonEoverP::m_nSCT[NOS_ELECTRONS] {}

private

Definition at line 222 of file IDPerfMonEoverP.h.

{};

m_nSCTout

int IDPerfMonEoverP::m_nSCTout[NOS_ELECTRONS] {}

private

Definition at line 226 of file IDPerfMonEoverP.h.

{};

m_nTRT

int IDPerfMonEoverP::m_nTRT[NOS_ELECTRONS] {}

private

Definition at line 221 of file IDPerfMonEoverP.h.

{};

m_nTRTHT

int IDPerfMonEoverP::m_nTRTHT[NOS_ELECTRONS] {}

private

Definition at line 228 of file IDPerfMonEoverP.h.

{};

m_nTRTHTout

int IDPerfMonEoverP::m_nTRTHTout[NOS_ELECTRONS] {}

private

Definition at line 229 of file IDPerfMonEoverP.h.

{};

m_nTRTout

int IDPerfMonEoverP::m_nTRTout[NOS_ELECTRONS] {}

private

Definition at line 225 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 279 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 278 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 281 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 280 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 253 of file IDPerfMonEoverP.h.

{};

m_pvsumpt

float IDPerfMonEoverP::m_pvsumpt[NO_PV] {}

private

Definition at line 254 of file IDPerfMonEoverP.h.

{};

m_pvtype

int IDPerfMonEoverP::m_pvtype[NO_PV] {}

private

Definition at line 252 of file IDPerfMonEoverP.h.

{};

m_pvx

float IDPerfMonEoverP::m_pvx[NO_PV] {}

private

Definition at line 255 of file IDPerfMonEoverP.h.

{};

m_pvy

float IDPerfMonEoverP::m_pvy[NO_PV] {}

private

Definition at line 256 of file IDPerfMonEoverP.h.

{};

m_pvz

float IDPerfMonEoverP::m_pvz[NO_PV] {}

private

Definition at line 257 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 197 of file IDPerfMonEoverP.h.

m_small1_QoverP

double IDPerfMonEoverP::m_small1_QoverP

private

Definition at line 316 of file IDPerfMonEoverP.h.

m_small2_QoverP

double IDPerfMonEoverP::m_small2_QoverP

private

Definition at line 317 of file IDPerfMonEoverP.h.

m_small_QoverP

double IDPerfMonEoverP::m_small_QoverP

private

Definition at line 315 of file IDPerfMonEoverP.h.

m_smallCharge

double IDPerfMonEoverP::m_smallCharge

private

Definition at line 322 of file IDPerfMonEoverP.h.

m_smallClusterEnergy

double IDPerfMonEoverP::m_smallClusterEnergy

private

Definition at line 318 of file IDPerfMonEoverP.h.

m_smallClusterEta

double IDPerfMonEoverP::m_smallClusterEta

private

Definition at line 320 of file IDPerfMonEoverP.h.

m_smallClusterPhi

double IDPerfMonEoverP::m_smallClusterPhi

private

Definition at line 319 of file IDPerfMonEoverP.h.

m_smalld0

double IDPerfMonEoverP::m_smalld0

private

Definition at line 323 of file IDPerfMonEoverP.h.

m_smallTrackTheta

double IDPerfMonEoverP::m_smallTrackTheta

private

Definition at line 321 of file IDPerfMonEoverP.h.

m_smallValidationTree

TTree* IDPerfMonEoverP::m_smallValidationTree

private

Definition at line 312 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 308 of file IDPerfMonEoverP.h.

m_smallValidationTreeFolder

std::string IDPerfMonEoverP::m_smallValidationTreeFolder

private

Root Validation Tree.

Definition at line 310 of file IDPerfMonEoverP.h.

m_smallValidationTreeName

std::string IDPerfMonEoverP::m_smallValidationTreeName

private

validation tree description - second argument in TTree

Definition at line 306 of file IDPerfMonEoverP.h.

m_smallz0

double IDPerfMonEoverP::m_smallz0

private

Definition at line 324 of file IDPerfMonEoverP.h.

m_sumet

float IDPerfMonEoverP::m_sumet

private

Definition at line 267 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 285 of file IDPerfMonEoverP.h.

{};

m_triggerNames

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

private

Definition at line 286 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 181 of file IDPerfMonEoverP.h.

m_validationTree

TTree* IDPerfMonEoverP::m_validationTree

private

Definition at line 194 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 190 of file IDPerfMonEoverP.h.

m_validationTreeFolder

std::string IDPerfMonEoverP::m_validationTreeFolder

private

Root Validation Tree.

Definition at line 192 of file IDPerfMonEoverP.h.

m_validationTreeName

std::string IDPerfMonEoverP::m_validationTreeName

private

validation tree description - second argument in TTree

Definition at line 188 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 248 of file IDPerfMonEoverP.h.

m_WenuLooseElectronET

TH1F* IDPerfMonEoverP::m_WenuLooseElectronET

private

Definition at line 295 of file IDPerfMonEoverP.h.

m_WenuTight_Met

TH1F* IDPerfMonEoverP::m_WenuTight_Met

private

Definition at line 296 of file IDPerfMonEoverP.h.

m_WenuTight_MT

TH1F* IDPerfMonEoverP::m_WenuTight_MT

private

Definition at line 297 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 302 of file IDPerfMonEoverP.h.

m_WenuTightElectron_PTEtaPos

TH2F* IDPerfMonEoverP::m_WenuTightElectron_PTEtaPos

private

Definition at line 301 of file IDPerfMonEoverP.h.

m_WenuTightElectronET

TH1F* IDPerfMonEoverP::m_WenuTightElectronET

private

Definition at line 299 of file IDPerfMonEoverP.h.

m_WenuTightMet_MT

TH1F* IDPerfMonEoverP::m_WenuTightMet_MT

private

Definition at line 298 of file IDPerfMonEoverP.h.

m_WenuTightW_PT

TH1F* IDPerfMonEoverP::m_WenuTightW_PT

private

Definition at line 300 of file IDPerfMonEoverP.h.

m_ZeeLooseMassOS_Cluster

TH1F* IDPerfMonEoverP::m_ZeeLooseMassOS_Cluster

private

Definition at line 289 of file IDPerfMonEoverP.h.

m_ZeeLooseMassSS_Cluster

TH1F* IDPerfMonEoverP::m_ZeeLooseMassSS_Cluster

private

Definition at line 290 of file IDPerfMonEoverP.h.

m_ZeeMediumMassOS_Cluster

TH1F* IDPerfMonEoverP::m_ZeeMediumMassOS_Cluster

private

Definition at line 291 of file IDPerfMonEoverP.h.

m_ZeeMediumMassSS_Cluster

TH1F* IDPerfMonEoverP::m_ZeeMediumMassSS_Cluster

private

Definition at line 292 of file IDPerfMonEoverP.h.

m_ZeeMediumOS_ClusterPtEta

TH2F* IDPerfMonEoverP::m_ZeeMediumOS_ClusterPtEta

private

Definition at line 293 of file IDPerfMonEoverP.h.

---

The documentation for this class was generated from the following files:

• IDPerfMonEoverP.h
• IDPerfMonEoverP.cxx