Electron selector tool to select objects in Athena using an underlying pure ROOT tool. More...

#include <AsgElectronLikelihoodTool.h>

Inheritance diagram for AsgElectronLikelihoodTool:

Collaboration diagram for AsgElectronLikelihoodTool:

Public Member Functions
virtual StatusCode	initialize () override
	Gaudi Service Interface method implementations. More...

virtual const asg::AcceptInfo &	getAcceptInfo () const override
	Method to get the plain AcceptInfo. More...

virtual asg::AcceptData	accept (const xAOD::IParticle *part) const override final
	The main accept method: using the generic interface. More...

virtual asg::AcceptData	accept (const EventContext &ctx, const xAOD::IParticle *part) const override final

virtual asg::AcceptData	accept (const EventContext &ctx, const xAOD::Electron *eg) const override final
	The main accept method: the actual cuts are applied here. More...

virtual asg::AcceptData	accept (const EventContext &ctx, const xAOD::Egamma *eg) const override final
	The main accept method: the actual cuts are applied here. More...

virtual asg::AcceptData	accept (const EventContext &ctx, const xAOD::Electron *eg, double mu) const override final
	The main accept method: in case mu not in EventInfo online. More...

virtual asg::AcceptData	accept (const EventContext &ctx, const xAOD::Egamma *eg, double mu) const override final
	The main accept method: in case mu not in EventInfo online. More...

virtual double	calculate (const EventContext &ctx, const xAOD::IParticle *part) const override final
	calculate method: for pointer to IParticle More...

virtual double	calculate (const EventContext &ctx, const xAOD::Electron *eg) const override final
	The main result method: the actual likelihood is calculated here. More...

virtual double	calculate (const EventContext &ctx, const xAOD::Egamma *eg) const override final
	The main result method: the actual likelihood is calculated here. More...

virtual double	calculate (const EventContext &ctx, const xAOD::Electron *eg, double mu) const override final
	The main result method: the actual likelihood is calculated here. More...

virtual double	calculate (const EventContext &ctx, const xAOD::Egamma *eg, double mu) const override final
	The main result method: the actual likelihood is calculated here. More...

virtual std::vector< float >	calculateMultipleOutputs (const EventContext &ctx, const xAOD::Electron *eg, double mu=-99) const override final
	The result method for multiple outputs: only one output is used so return vector of that output. More...

virtual std::string	getOperatingPointName () const override final
	Get the name of the current operating point. More...

virtual void	print () const
	Print the state of the tool. 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	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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

void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
virtual ASG_TOOL_CLASS2(AsgElectronLikelihoodTool, IAsgElectronLikelihoodTool, IAsgSelectionTool) public	~AsgElectronLikelihoodTool ()
	Standard constructor. More...

double	getIpVariable (double mu, const EventContext &ctx) const
	Get IP variable based on user configuration. More...

unsigned int	getNPrimVertices (const EventContext &ctx) const
	Get the number of primary vertices. More...

double	getAverageMu (const EventContext &ctx) const
	Get the average mu. More...

double	getFcalEt (const EventContext &ctx) const
	Get the FCal ET for centrality determination (for HI collisions) More...

bool	isForwardElectron (const xAOD::Egamma *eg, const float eta) const
	check for FwdElectron More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
std::string	m_WorkingPoint
	Working Point. More...

std::string	m_configFile

Root::TElectronLikelihoodTool *	m_rootTool
	Pointer to the underlying ROOT based tool. More...

bool	m_usePVCont
	Whether to use the PV (not available for trigger) More...

unsigned int	m_nPVdefault
	defualt nPV (when not using PVCont) More...

bool	m_useCaloSumsCont
	Whether or not to use the CaloSums container in HI events. More...

double	m_fcalEtDefault
	defualt FCal ET (when not using CaloSums container, in HI events) More...

std::string	m_pdfFileName
	The input ROOT file name that holds the PDFs. More...

bool	m_caloOnly = false
	Flag for calo only LH. More...

bool	m_skipDeltaPoverP
	Flag for skip the use of deltaPoverP in LH computation (like at HLT) More...

bool	m_correctDeltaEta = false
	Flag to toggle the correction of deltaEta1 for the pear shape distortion of the LAr. More...

bool	m_useAverageMu = false

SG::ReadHandleKey< xAOD::HIEventShapeContainer >	m_HIESContKey
	read handle key to heavy ion container More...

SG::ReadHandleKey< xAOD::VertexContainer >	m_primVtxContKey
	read handle key to primary vertex container More...

SG::ReadDecorHandleKey< xAOD::EventInfo >	m_avgMuKey
	read handle key to averager mu More...

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

Electron selector tool to select objects in Athena using an underlying pure ROOT tool.

Author: Karsten Koeneke , Jovan Mitrevski

Date: October 2012 @update April 2014, converted to ASGTool by Jovan Mitrevski

Definition at line 27 of file AsgElectronLikelihoodTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ~AsgElectronLikelihoodTool()

AsgElectronLikelihoodTool::~AsgElectronLikelihoodTool ( )

privatevirtual

Standard constructor.

Standard destructor

Definition at line 74 of file AsgElectronLikelihoodTool.cxx.

 {
   delete m_rootTool;
 }

Member Function Documentation

◆ accept() [1/6]

virtual asg::AcceptData AsgElectronLikelihoodTool::accept	(	const EventContext &	ctx,
		const xAOD::Egamma *	eg
	)		const

inlinefinaloverridevirtual

The main accept method: the actual cuts are applied here.

Implements IAsgElectronLikelihoodTool.

Definition at line 71 of file AsgElectronLikelihoodTool.h.

   {
     return accept(ctx, eg, -99); // mu = -99 as input will force accept to grab
                                  // the pileup variable from the xAOD object
   }

◆ accept() [2/6]

asg::AcceptData AsgElectronLikelihoodTool::accept	(	const EventContext &	ctx,
		const xAOD::Egamma *	eg,
		double	mu
	)		const

finaloverridevirtual

The main accept method: in case mu not in EventInfo online.

Implements IAsgElectronLikelihoodTool.

Definition at line 409 of file AsgElectronLikelihoodTool.cxx.

 {
   if (!eg) {
     ATH_MSG_ERROR("Failed, no egamma object.");
     return m_rootTool->accept();
   }
   // Call the main accept if this is not a calo-only LH
   if (!m_caloOnly) {
     if (eg->type() == xAOD::Type::Electron) {
       const xAOD::Electron* el = static_cast<const xAOD::Electron*>(eg);
       return accept(ctx, el, mu);
     }
     ATH_MSG_ERROR("Input is not an electron and not caloOnly is set");
     return m_rootTool->accept();
   }
  
   // Calo only LH
   const xAOD::CaloCluster* cluster = eg->caloCluster();
   if (!cluster) {
     ATH_MSG_ERROR("Failed, no cluster.");
     return m_rootTool->accept();
   }
   if (!cluster->hasSampling(CaloSampling::CaloSample::EMB2) &&
       !cluster->hasSampling(CaloSampling::CaloSample::EME2)) {
     ATH_MSG_ERROR("Failed, cluster is missing samplings EMB2 and EME2");
     return m_rootTool->accept();
   }
  
   const double energy = cluster->e();
   const float eta = (cluster->etaBE(2));
   if (isForwardElectron(eg, eta)) {
     ATH_MSG_WARNING(
       "Failed, this is a forward electron! The AsgElectronLikelihoodTool is "
       "only suitable for central electrons!");
     return m_rootTool->accept();
   }
  
   const double et = (cosh(eta) != 0.) ? energy / cosh(eta) : 0.;
  
   // Variables the EFCaloLH ignores
   uint8_t nSiHitsPlusDeadSensors(0);
   uint8_t nPixHitsPlusDeadSensors(0);
   bool passBLayerRequirement(false);
   uint8_t ambiguityBit(0);
  
   // Get the pileup or centrality information
   double ip = getIpVariable(mu, ctx);
  
   // for now don't cache.
   double likelihood = calculate(ctx, eg, ip);
  
   double deltaEta = 0;
   double deltaPhiRescaled2 = 0;
   double d0 = 0;
   float wstot = 0;
   float EoverP = 0;
  
   bool allFound = true;
   std::string notFoundList = "";
  
   // Wstot for use when CutWstotAtHighET vector is filled
   if (!eg->showerShapeValue(wstot, xAOD::EgammaParameters::wtots1)) {
     allFound = false;
     notFoundList += "wtots1 ";
   }
  
   if (!allFound) {
     ATH_MSG_ERROR(
       "Skipping LH rectangular cuts! The following variables are missing: "
       << notFoundList);
     return m_rootTool->accept();
   }
  
   // Get the answer from the underlying ROOT tool
   return m_rootTool->accept(likelihood,
                             eta,
                             et,
                             nSiHitsPlusDeadSensors,
                             nPixHitsPlusDeadSensors,
                             passBLayerRequirement,
                             ambiguityBit,
                             d0,
                             deltaEta,
                             deltaPhiRescaled2,
                             wstot,
                             EoverP,
                             ip);
 }

◆ accept() [3/6]

virtual asg::AcceptData AsgElectronLikelihoodTool::accept	(	const EventContext &	ctx,
		const xAOD::Electron *	eg
	)		const

inlinefinaloverridevirtual

The main accept method: the actual cuts are applied here.

Implements IAsgElectronLikelihoodTool.

Definition at line 63 of file AsgElectronLikelihoodTool.h.

   {
     return accept(ctx, eg, -99); // mu = -99 as input will force accept to grab
                                  // the pileup variable from the xAOD object
   }

◆ accept() [4/6]

asg::AcceptData AsgElectronLikelihoodTool::accept	(	const EventContext &	ctx,
		const xAOD::Electron *	eg,
		double	mu
	)		const

finaloverridevirtual

The main accept method: in case mu not in EventInfo online.

Implements IAsgElectronLikelihoodTool.

Definition at line 265 of file AsgElectronLikelihoodTool.cxx.

 {
   if (!el) {
     ATH_MSG_ERROR("Failed, no electron object.");
     return m_rootTool->accept();
   }
  
   const xAOD::CaloCluster* cluster = el->caloCluster();
   if (!cluster) {
     ATH_MSG_ERROR("exiting because cluster is NULL " << cluster);
     return m_rootTool->accept();
   }
  
   if (!cluster->hasSampling(CaloSampling::CaloSample::EMB2) &&
       !cluster->hasSampling(CaloSampling::CaloSample::EME2)) {
     ATH_MSG_ERROR("Failed, cluster is missing samplings EMB2 and EME2");
     return m_rootTool->accept();
   }
  
   const double energy = cluster->e();
   const float eta = (cluster->etaBE(2));
  
   if (isForwardElectron(el, eta)) {
     ATH_MSG_WARNING(
       "Failed, this is a forward electron! The AsgElectronLikelihoodTool is "
       "only suitable for central electrons!");
     return m_rootTool->accept();
   }
  
   double et = 0.;
   if (el->trackParticle() && !m_caloOnly) {
     et = (cosh(el->trackParticle()->eta()) != 0.)
            ? energy / cosh(el->trackParticle()->eta())
            : 0.;
   } else
     et = (cosh(eta) != 0.) ? energy / cosh(eta) : 0.;
  
   // number of track hits
   uint8_t nSiHitsPlusDeadSensors(0);
   uint8_t nPixHitsPlusDeadSensors(0);
   bool passBLayerRequirement(false);
   float d0(0.0);
   float deltaEta = 0;
   float deltaPhiRescaled2 = 0;
   float wstot = 0;
   float EoverP = 0;
   uint8_t ambiguityBit(0);
   double ip(0);
  
   bool allFound = true;
   std::string notFoundList = "";
  
   // Wstot for use when CutWstotAtHighET vector is filled
   if (!el->showerShapeValue(wstot, xAOD::EgammaParameters::wtots1)) {
     allFound = false;
     notFoundList += "wtots1 ";
   }
  
   // get the ambiguity type from the decoration
   if (!m_rootTool->m_cutAmbiguity.empty()) {
     static const SG::AuxElement::Accessor<uint8_t> ambiguityTypeAcc("ambiguityType");
     if (ambiguityTypeAcc.isAvailable(*el)) {
       ambiguityBit = ambiguityTypeAcc(*el);
     } else {
       allFound = false;
       notFoundList += "ambiguityType ";
     }
   }
  
   if (!m_caloOnly) {
     // retrieve associated track
     const xAOD::TrackParticle* t = el->trackParticle();
     if (t) {
       nSiHitsPlusDeadSensors =
         ElectronSelectorHelpers::numberOfSiliconHitsAndDeadSensors(*t);
       nPixHitsPlusDeadSensors =
         ElectronSelectorHelpers::numberOfPixelHitsAndDeadSensors(*t);
       passBLayerRequirement = ElectronSelectorHelpers::passBLayerRequirement(*t);
       d0 = t->d0();
       EoverP = std::abs(t->qOverP()) * energy;
     } else {
       ATH_MSG_ERROR("Failed, no track particle. et= " << et << "eta= " << eta);
       return m_rootTool->accept();
     }
  
     if (!el->trackCaloMatchValue(deltaEta, xAOD::EgammaParameters::deltaEta1)) {
       allFound = false;
       notFoundList += "deltaEta1 ";
     }
     // correction of deltaEta1 for pear shape distortion
     else if (m_correctDeltaEta) {
       const static SG::AuxElement::Accessor<float> acc(
         "deltaEta1PearDistortion");
       if (acc.isAvailable(*el)) {
         deltaEta -= acc(*el);
       } else {
         allFound = false;
         notFoundList += "deltaEta1PearDistortion ";
       }
     }
  
     if (!el->trackCaloMatchValue(deltaPhiRescaled2,
                                  xAOD::EgammaParameters::deltaPhiRescaled2)) {
       allFound = false;
       notFoundList += "deltaPhiRescaled2 ";
     }
  
   } // if not calo ONly
  
   // Get the number of primary vertices,
   // avg mu or FCal ET in this event,
   // depending on user configuration
   ip = getIpVariable(mu, ctx);
  
   // for now don't cache.
   double likelihood = calculate(ctx, el, ip);
  
   if (!allFound) {
     ATH_MSG_ERROR(
       "Skipping LH rectangular cuts! The following variables are missing: "
       << notFoundList);
     return m_rootTool->accept();
   }
  
   // Get the answer from the underlying ROOT tool
   return m_rootTool->accept(likelihood,
                             eta,
                             et,
                             nSiHitsPlusDeadSensors,
                             nPixHitsPlusDeadSensors,
                             passBLayerRequirement,
                             ambiguityBit,
                             d0,
                             deltaEta,
                             deltaPhiRescaled2,
                             wstot,
                             EoverP,
                             ip);
 }

◆ accept() [5/6]

asg::AcceptData AsgElectronLikelihoodTool::accept	(	const EventContext &	ctx,
		const xAOD::IParticle *	part
	)		const

finaloverridevirtual

Implements IAsgElectronLikelihoodTool.

Definition at line 875 of file AsgElectronLikelihoodTool.cxx.

 {
   if (part->type() == xAOD::Type::Electron) {
     const xAOD::Electron* el = static_cast<const xAOD::Electron*>(part);
     return accept(ctx, el);
   }
   ATH_MSG_ERROR("Input is not an electron");
   return m_rootTool->accept();
 }

◆ accept() [6/6]

asg::AcceptData AsgElectronLikelihoodTool::accept ( const xAOD::IParticle * part ) const

finaloverridevirtual

The main accept method: using the generic interface.

Implements IAsgElectronLikelihoodTool.

Definition at line 868 of file AsgElectronLikelihoodTool.cxx.

 {
   // Backwards compatibility
   return accept(Gaudi::Hive::currentContext(), part);
 }

◆ calculate() [1/5]

virtual double AsgElectronLikelihoodTool::calculate	(	const EventContext &	ctx,
		const xAOD::Egamma *	eg
	)		const

inlinefinaloverridevirtual

The main result method: the actual likelihood is calculated here.

Implements IAsgElectronLikelihoodTool.

Definition at line 102 of file AsgElectronLikelihoodTool.h.

   {
     return calculate(
       ctx, eg, -99); // mu = -99 as input will force accept to grab the pileup
                      // variable from the xAOD object
   }

◆ calculate() [2/5]

double AsgElectronLikelihoodTool::calculate	(	const EventContext &	ctx,
		const xAOD::Egamma *	eg,
		double	mu
	)		const

finaloverridevirtual

The main result method: the actual likelihood is calculated here.

Implements IAsgElectronLikelihoodTool.

Definition at line 723 of file AsgElectronLikelihoodTool.cxx.

 {
   if (!eg) {
     ATH_MSG_ERROR("Failed, no egamma object.");
     return -999;
   }
  
   if (!m_caloOnly) {
     if (eg->type() == xAOD::Type::Electron) {
       const xAOD::Electron* el = static_cast<const xAOD::Electron*>(eg);
       return calculate(ctx, el);
     }
  
     ATH_MSG_ERROR("Input is not an electron and not Calo Only is required");
     return -999;
   }
  
   const xAOD::CaloCluster* cluster = eg->caloCluster();
   if (!cluster) {
     ATH_MSG_ERROR("Failed, no cluster.");
     return -999;
   }
  
   if (!cluster->hasSampling(CaloSampling::CaloSample::EMB2) &&
       !cluster->hasSampling(CaloSampling::CaloSample::EME2)) {
     ATH_MSG_ERROR("Failed, cluster is missing samplings EMB2 and EME2");
     return -999;
   }
  
   const double energy = cluster->e();
   const float eta = cluster->etaBE(2);
  
   if (isForwardElectron(eg, eta)) {
     ATH_MSG_WARNING(
       "Failed, this is a forward electron! The AsgElectronLikelihoodTool is "
       "only suitable for central electrons!");
     return -999;
   }
  
   const double et = (cosh(eta) != 0.) ? energy / cosh(eta) : 0.;
  
   // Track variables that the EFCaloLH will not use
   float d0(0.0);
   float d0sigma(0.0);
   double dpOverp(0.0);
  
   float deltaEta = 0;
   float deltaPhiRescaled2 = 0;
   float TRT_PID(0.0);
  
   // Calo Variables
   float Reta(0);
   float Rphi(0);
   float Rhad1(0);
   float Rhad(0);
   float w2(0);
   float f1(0);
   float Eratio(0);
   float f3(0);
  
   bool allFound = true;
   std::string notFoundList = "";
  
   // reta = e237/e277
   if (!eg->showerShapeValue(Reta, xAOD::EgammaParameters::Reta)) {
     allFound = false;
     notFoundList += "Reta ";
   }
   // rphi e233/e237
   if (!eg->showerShapeValue(Rphi, xAOD::EgammaParameters::Rphi)) {
     allFound = false;
     notFoundList += "Rphi ";
   }
   // rhad1 = ethad1/et
   if (!eg->showerShapeValue(Rhad1, xAOD::EgammaParameters::Rhad1)) {
     allFound = false;
     notFoundList += "Rhad1 ";
   }
   // rhad = ethad/et
   if (!eg->showerShapeValue(Rhad, xAOD::EgammaParameters::Rhad)) {
     allFound = false;
     notFoundList += "Rhad ";
   }
   // shower width in 2nd sampling
   if (!eg->showerShapeValue(w2, xAOD::EgammaParameters::weta2)) {
     allFound = false;
     notFoundList += "weta2 ";
   }
   // fraction of energy reconstructed in the 1st sampling
   if (!eg->showerShapeValue(f1, xAOD::EgammaParameters::f1)) {
     allFound = false;
     notFoundList += "f1 ";
   }
   // E of 2nd max between max and min in strips
   if (!eg->showerShapeValue(Eratio, xAOD::EgammaParameters::Eratio)) {
     allFound = false;
     notFoundList += "Eratio ";
   }
   // fraction of energy reconstructed in the 3rd sampling
   if (!eg->showerShapeValue(f3, xAOD::EgammaParameters::f3)) {
     allFound = false;
     notFoundList += "f3 ";
   }
  
   // Get the pileup or centrality information
   double ip = getIpVariable(mu, ctx);
  
   if (!allFound) {
     ATH_MSG_ERROR(
       "Skipping LH calculation! The following variables are missing: "
       << notFoundList);
     return -999;
   }
  
   // Get the answer from the underlying ROOT tool
   return m_rootTool->calculate(eta,
                                et,
                                f3,
                                Rhad,
                                Rhad1,
                                Reta,
                                w2,
                                f1,
                                Eratio,
                                deltaEta,
                                d0,
                                d0sigma,
                                Rphi,
                                dpOverp,
                                deltaPhiRescaled2,
                                TRT_PID,
                                ip);
 }

◆ calculate() [3/5]

virtual double AsgElectronLikelihoodTool::calculate	(	const EventContext &	ctx,
		const xAOD::Electron *	eg
	)		const

inlinefinaloverridevirtual

The main result method: the actual likelihood is calculated here.

Implements IAsgElectronLikelihoodTool.

Definition at line 94 of file AsgElectronLikelihoodTool.h.

   {
     return calculate(
       ctx, eg, -99); // mu = -99 as input will force accept to grab the pileup
                      // variable from the xAOD object
   }

◆ calculate() [4/5]

double AsgElectronLikelihoodTool::calculate	(	const EventContext &	ctx,
		const xAOD::Electron *	eg,
		double	mu
	)		const

finaloverridevirtual

The main result method: the actual likelihood is calculated here.

Implements IAsgElectronLikelihoodTool.

Definition at line 502 of file AsgElectronLikelihoodTool.cxx.

 {
   if (!el) {
     ATH_MSG_ERROR("Failed, no egamma object.");
     return -999;
   }
   const xAOD::CaloCluster* cluster = el->caloCluster();
   if (!cluster) {
     ATH_MSG_ERROR("Failed, no cluster.");
     return -999;
   }
   if (!cluster->hasSampling(CaloSampling::CaloSample::EMB2) &&
       !cluster->hasSampling(CaloSampling::CaloSample::EME2)) {
     ATH_MSG_ERROR("Failed, cluster is missing samplings EMB2 and EME2");
     return -999;
   }
  
   const double energy = cluster->e();
   const float eta = cluster->etaBE(2);
  
   if (isForwardElectron(el, eta)) {
     ATH_MSG_WARNING(
       "Failed, this is a forward electron! The AsgElectronLikelihoodTool is "
       "only suitable for central electrons!");
     return -999;
   }
  
   double et = 0.;
   if (el->trackParticle() && !m_caloOnly) {
     et = (cosh(el->trackParticle()->eta()) != 0.)
            ? energy / cosh(el->trackParticle()->eta())
            : 0.;
   } else {
     et = (cosh(eta) != 0.) ? energy / cosh(eta) : 0.;
   }
  
   // number of track hits and other track quantities
   float trackqoverp(0.0);
   float d0(0.0);
   float d0sigma(0.0);
   double dpOverp(0.0);
   float TRT_PID(0.0);
   double trans_TRT_PID(0.0);
   float deltaEta = 0;
   float deltaPhiRescaled2 = 0;
  
   bool allFound = true;
   std::string notFoundList = "";
  
   if (!m_caloOnly) {
     // retrieve associated TrackParticle
     const xAOD::TrackParticle* t = el->trackParticle();
     if (t) {
       trackqoverp = t->qOverP();
       d0 = t->d0();
       float vard0 = t->definingParametersCovMatrix()(0, 0);
       if (vard0 > 0) {
         d0sigma = sqrtf(vard0);
       }
  
       const static SG::AuxElement::Accessor<float> trans_TRT_PID_acc("transformed_e_probability_ht");
       if (!trans_TRT_PID_acc.isAvailable(*el)) {
         // most probable case, need to compute the variable
  
         if (!t->summaryValue(TRT_PID, xAOD::eProbabilityHT)) {
           allFound = false;
           notFoundList += "eProbabilityHT ";
         }
  
         // Transform the TRT PID output for use in the LH tool.
         const double tau = 15.0;
         const double fEpsilon = 1.0e-30; // to avoid zero division
         double pid_tmp = TRT_PID;
         if (pid_tmp >= 1.0)
           pid_tmp = 1.0 - 1.0e-15; // this number comes from TMVA
         else if (pid_tmp <= fEpsilon)
           pid_tmp = fEpsilon;
         trans_TRT_PID = -log(1.0 / pid_tmp - 1.0) * (1. / double(tau));
       }
       else
       {
         // it means the variable have been already computed by another tool
         // usually this is the EGammaVariableCorrection, which means that
         // it is also fudged (only MC)
         trans_TRT_PID = trans_TRT_PID_acc(*el);
       }
  
       unsigned int index;
       if (t->indexOfParameterAtPosition(index, xAOD::LastMeasurement)) {
  
         double refittedTrack_LMqoverp =
           t->charge() / sqrt(std::pow(t->parameterPX(index), 2) +
                              std::pow(t->parameterPY(index), 2) +
                              std::pow(t->parameterPZ(index), 2));
  
         dpOverp = 1 - trackqoverp / (refittedTrack_LMqoverp);
       } else if (!m_skipDeltaPoverP) {
         allFound = false;
         notFoundList += "deltaPoverP ";
       }
  
     } else {
       ATH_MSG_ERROR("Failed, no track particle. et= " << et << "eta= " << eta);
       return -999;
     }
   } // if not calo Only
  
   float Reta(0);
   float Rphi(0);
   float Rhad1(0);
   float Rhad(0);
   float w2(0);
   float f1(0);
   float Eratio(0);
   float f3(0);
  
   // reta = e237/e277
   if (!el->showerShapeValue(Reta, xAOD::EgammaParameters::Reta)) {
     allFound = false;
     notFoundList += "Reta ";
   }
   // rphi e233/e237
   if (!el->showerShapeValue(Rphi, xAOD::EgammaParameters::Rphi)) {
     allFound = false;
     notFoundList += "Rphi ";
   }
   // rhad1 = ethad1/et
   if (!el->showerShapeValue(Rhad1, xAOD::EgammaParameters::Rhad1)) {
     allFound = false;
     notFoundList += "Rhad1 ";
   }
   // rhad = ethad/et
   if (!el->showerShapeValue(Rhad, xAOD::EgammaParameters::Rhad)) {
     allFound = false;
     notFoundList += "Rhad ";
   }
   // shower width in 2nd sampling
   if (!el->showerShapeValue(w2, xAOD::EgammaParameters::weta2)) {
     allFound = false;
     notFoundList += "weta2 ";
   }
   // fraction of energy reconstructed in the 1st sampling
   if (!el->showerShapeValue(f1, xAOD::EgammaParameters::f1)) {
     allFound = false;
     notFoundList += "f1 ";
   }
   // E of 2nd max between max and min in strips
   if (!el->showerShapeValue(Eratio, xAOD::EgammaParameters::Eratio)) {
     allFound = false;
     notFoundList += "Eratio ";
   }
   // fraction of energy reconstructed in the 3rd sampling
   if (!el->showerShapeValue(f3, xAOD::EgammaParameters::f3)) {
     allFound = false;
     notFoundList += "f3 ";
   }
  
   if (!m_caloOnly) {
     // deltaEta1
     if (!el->trackCaloMatchValue(deltaEta, xAOD::EgammaParameters::deltaEta1)) {
       allFound = false;
       notFoundList += "deltaEta1 ";
     }
     // correction of deltaEta1 for pear shape distortion
     else if (m_correctDeltaEta) {
       const static SG::AuxElement::Accessor<float> acc(
         "deltaEta1PearDistortion");
       if (acc.isAvailable(*el)) {
         deltaEta -= acc(*el);
       } else {
         allFound = false;
         notFoundList += "deltaEta1PearDistortion ";
       }
     }
  
     // difference between the cluster phi (sampling 2) and the eta of the track
     // extrapolated from the last measurement point.
     if (!el->trackCaloMatchValue(deltaPhiRescaled2,
                                  xAOD::EgammaParameters::deltaPhiRescaled2)) {
       allFound = false;
       notFoundList += "deltaPhiRescaled2 ";
     }
   }
  
   // Get the number of primary vertices, avg mu or FCal ET in this event,
   // depending on user configuration
   double ip = static_cast<double>(m_nPVdefault);
  
   ip = getIpVariable(mu, ctx);
  
   if (!allFound) {
     ATH_MSG_ERROR(
       "Skipping LH calculation! The following variables are missing: "
       << notFoundList);
     return -999;
   }
  
   // Get the answer from the underlying ROOT tool
   return m_rootTool->calculate(eta,
                                et,
                                f3,
                                Rhad,
                                Rhad1,
                                Reta,
                                w2,
                                f1,
                                Eratio,
                                deltaEta,
                                d0,
                                d0sigma,
                                Rphi,
                                dpOverp,
                                deltaPhiRescaled2,
                                trans_TRT_PID,
                                ip);
 }

◆ calculate() [5/5]

double AsgElectronLikelihoodTool::calculate	(	const EventContext &	ctx,
		const xAOD::IParticle *	part
	)		const

finaloverridevirtual

calculate method: for pointer to IParticle

Implements IAsgElectronLikelihoodTool.

Definition at line 887 of file AsgElectronLikelihoodTool.cxx.

 {
   if (part->type() == xAOD::Type::Electron) {
     const xAOD::Electron* el = static_cast<const xAOD::Electron*>(part);
     return calculate(ctx, el);
   }
  
   ATH_MSG_ERROR("Input is not an electron");
   return -999;
 }

◆ calculateMultipleOutputs()

virtual std::vector<float> AsgElectronLikelihoodTool::calculateMultipleOutputs	(	const EventContext &	ctx,
		const xAOD::Electron *	eg,
		double	mu = `-99`
	)		const

inlinefinaloverridevirtual

The result method for multiple outputs: only one output is used so return vector of that output.

Implements IAsgElectronLikelihoodTool.

Definition at line 122 of file AsgElectronLikelihoodTool.h.

   {
     return {static_cast<float>(calculate(ctx, eg, mu))};
   }

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

inlineprivateinherited

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

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation 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.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation 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.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

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

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation 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.

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

◆ declareProperty() [5/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation 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.

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

◆ declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

◆ getAcceptInfo()

const asg::AcceptInfo & AsgElectronLikelihoodTool::getAcceptInfo ( ) const

overridevirtual

Method to get the plain AcceptInfo.

This is needed so that one can already get the AcceptInfo and query what cuts are defined before the first object is passed to the tool.

Implements IAsgSelectionTool.

Definition at line 258 of file AsgElectronLikelihoodTool.cxx.

 {
   return m_rootTool->getAcceptInfo();
 }

◆ getAverageMu()

double AsgElectronLikelihoodTool::getAverageMu ( const EventContext & ctx ) const

private

Get the average mu.

Definition at line 940 of file AsgElectronLikelihoodTool.cxx.

 {
   SG::ReadDecorHandle<xAOD::EventInfo,float> eventInfoDecor(m_avgMuKey, ctx);
   if(!eventInfoDecor.isPresent()) {
     ATH_MSG_WARNING("Cannot find " << m_avgMuKey.key()
             << ", returning 0");
   }
   return eventInfoDecor(0);
 }

◆ getFcalEt()

double AsgElectronLikelihoodTool::getFcalEt ( const EventContext & ctx ) const

private

Get the FCal ET for centrality determination (for HI collisions)

Definition at line 952 of file AsgElectronLikelihoodTool.cxx.

 {
   static const SG::ConstAccessor<std::string> SummaryAcc ("Summary");
   double fcalEt(0.);
   SG::ReadHandle<xAOD::HIEventShapeContainer> HIESCont(m_HIESContKey, ctx);
   xAOD::HIEventShapeContainer::const_iterator es_itr = HIESCont->begin();
   xAOD::HIEventShapeContainer::const_iterator es_end = HIESCont->end();
   for (; es_itr != es_end; ++es_itr) {
     double et = (*es_itr)->et();
     const std::string name = SummaryAcc (**es_itr);
     if (name == "FCal")
       fcalEt = et * 1.e-6;
   }
   return fcalEt;
 }

◆ getIpVariable()

double AsgElectronLikelihoodTool::getIpVariable	(	double	mu,
		const EventContext &	ctx
	)		const

private

Get IP variable based on user configuration.

Definition at line 902 of file AsgElectronLikelihoodTool.cxx.

 {
   if (mu < 0) { // determine variable if mu is negative (not given)
     bool doCentralityTransform = m_rootTool->m_doCentralityTransform;
     if (doCentralityTransform)
       return static_cast<double>(m_useCaloSumsCont ? this->getFcalEt(ctx)
                                                  : m_fcalEtDefault);
     else if (m_useAverageMu)
       return this->getAverageMu(ctx);
     else
       return static_cast<double>(m_usePVCont ? this->getNPrimVertices(ctx)
                                            : m_nPVdefault);
   }
   return mu;
 }

◆ getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void * ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also: asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns: The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                     {
  
 #ifdef XAOD_STANDALONE
       // In case we use @c xAOD::TEvent, we have a direct function call
       // for this.
       return evtStore()->event()->getKey( ptr );
 #else
       const SG::DataProxy* proxy = evtStore()->proxy( ptr );
       return ( proxy == nullptr ? 0 : proxy->sgkey() );
 #endif // XAOD_STANDALONE
    }

◆ getName()

const std::string & asg::AsgTool::getName ( const void * ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also: asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns: The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                             {
  
 #ifdef XAOD_STANDALONE
       // In case we use @c xAOD::TEvent, we have a direct function call
       // for this.
       return evtStore()->event()->getName( ptr );
 #else
       const SG::DataProxy* proxy = evtStore()->proxy( ptr );
       static const std::string dummy = "";
       return ( proxy == nullptr ? dummy : proxy->name() );
 #endif // XAOD_STANDALONE
    }

◆ getNPrimVertices()

unsigned int AsgElectronLikelihoodTool::getNPrimVertices ( const EventContext & ctx ) const

private

Get the number of primary vertices.

Definition at line 921 of file AsgElectronLikelihoodTool.cxx.

 {
   unsigned int nVtx(0);
   SG::ReadHandle<xAOD::VertexContainer> vtxCont(m_primVtxContKey, ctx);
   if (!vtxCont.isValid()) {
     ATH_MSG_WARNING("Cannot find " << m_primVtxContKey.key()
             << " container, returning default nVtx");
     return m_nPVdefault;
   }
   for (const auto *vxcand : *vtxCont) {
     if (vxcand->nTrackParticles() >= 2)
       nVtx++;
   }
   return nVtx;
 }

◆ getOperatingPointName()

std::string AsgElectronLikelihoodTool::getOperatingPointName ( ) const

finaloverridevirtual

Get the name of the current operating point.

Implements IAsgElectronLikelihoodTool.

Definition at line 861 of file AsgElectronLikelihoodTool.cxx.

 {
   return m_WorkingPoint;
 }

◆ getProperty()

template<class T >

const T* asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

◆ initialize()

StatusCode AsgElectronLikelihoodTool::initialize ( )

overridevirtual

Gaudi Service Interface method implementations.

--------—Begin of text config-------------------------—

--------—End of text config-------------------------—

Reimplemented from asg::AsgTool.

Definition at line 80 of file AsgElectronLikelihoodTool.cxx.

 {
   std::string configFile, PDFfilename, resolvedPDF; // Default
  
   if (!m_WorkingPoint.empty()) {
     m_configFile = AsgConfigHelper::findConfigFile(
         m_WorkingPoint, EgammaSelectors::LHPointToConfFile);
   }
  
   if (!m_configFile.empty()) {
     configFile = PathResolverFindCalibFile(m_configFile);
     if (configFile.empty()) {
       ATH_MSG_ERROR("Could not locate config " << m_configFile);
       return StatusCode::FAILURE;
     }
  
     TEnv env;
     if (env.ReadFile(configFile.c_str(), kEnvLocal)) {
       ATH_MSG_ERROR("Could not open config " << configFile);
       return StatusCode::FAILURE;
     }
  
     // Get the input PDFs for the tool.
     // We need to see if the user had provided
     // an override, if not needs to be in the input
     // config file
     if (!m_pdfFileName.empty()) {
       // If the property was set by the user, take that.
       ATH_MSG_INFO("Setting user specified PDF file " << m_pdfFileName);
       PDFfilename = m_pdfFileName;
     } else {
       if (!env.Defined("inputPDFFileName")) {
         ATH_MSG_WARNING("will use default PDF filename "
                         "since none is specified in the config "
                         << m_configFile);
       }
       PDFfilename = env.GetValue(
         "inputPDFFileName",
         "ElectronPhotonSelectorTools/v1/ElectronLikelihoodPdfs.root");
       if (PDFfilename.empty()) {
         ATH_MSG_ERROR("empty inputPDFFilename in " << configFile);
         return StatusCode::FAILURE;
       }
       if (m_configFile.find("dev/") != std::string::npos) {
         PDFfilename.insert(0, "dev/");
       }
     }
  
     resolvedPDF = PathResolverFindCalibFile(PDFfilename);
     if (!resolvedPDF.empty()) {
       m_rootTool->setPDFFileName(resolvedPDF);
     } else {
       ATH_MSG_ERROR("Couldn't resolve PDF filename from "
                     << PDFfilename << ", config file = " << configFile);
       return StatusCode::FAILURE;
     }
  
     // The following are all taken from the config
     // file
     m_rootTool->m_variableNames = env.GetValue("VariableNames", "");
     m_rootTool->m_cutLikelihood =
       AsgConfigHelper::HelperDouble("CutLikelihood", env);
     m_rootTool->m_cutLikelihoodPileupCorrection =
       AsgConfigHelper::HelperDouble("CutLikelihoodPileupCorrection", env);
     m_rootTool->m_cutLikelihood4GeV =
       AsgConfigHelper::HelperDouble("CutLikelihood4GeV", env);
     m_rootTool->m_cutLikelihoodPileupCorrection4GeV =
       AsgConfigHelper::HelperDouble("CutLikelihoodPileupCorrection4GeV", env);
     // do the ambiguity cut
     m_rootTool->m_cutAmbiguity =
       AsgConfigHelper::HelperInt("CutAmbiguity", env);
     // cut on b-layer
     m_rootTool->m_cutBL = AsgConfigHelper::HelperInt("CutBL", env);
     // cut on pixel hits
     m_rootTool->m_cutPi = AsgConfigHelper::HelperInt("CutPi", env);
     // cut on precision hits
     m_rootTool->m_cutSi = AsgConfigHelper::HelperInt("CutSi", env);
     // cut on d0
     m_rootTool->m_cutA0 = AsgConfigHelper::HelperDouble("CutA0", env);
     // cut on deltaEta
     m_rootTool->m_cutDeltaEta =
       AsgConfigHelper::HelperDouble("CutDeltaEta", env);
     // cut on deltaPhiRes
     m_rootTool->m_cutDeltaPhiRes =
       AsgConfigHelper::HelperDouble("CutDeltaPhiRes", env);
     // turn off f3 at high Et
     m_rootTool->m_doRemoveF3AtHighEt =
       env.GetValue("doRemoveF3AtHighEt", false);
     // turn off TRTPID at high Et
     m_rootTool->m_doRemoveTRTPIDAtHighEt =
       env.GetValue("doRemoveTRTPIDAtHighEt", false);
     // do smooth interpolation between bins
     m_rootTool->m_doSmoothBinInterpolation =
       env.GetValue("doSmoothBinInterpolation", false);
     m_caloOnly = env.GetValue("caloOnly", false);
  
     m_rootTool->m_useOneExtraHighETLHBin =
       env.GetValue("useOneExtraHighETLHBin", false);
     // cut on Wstot above HighETBinThreshold
     m_rootTool->m_cutWstotAtHighET =
       AsgConfigHelper::HelperDouble("CutWstotAtHighET", env);
     // cut on EoverP above HighETBinThreshold
     m_rootTool->m_cutEoverPAtHighET =
       AsgConfigHelper::HelperDouble("CutEoverPAtHighET", env);
     m_rootTool->m_highETBinThreshold = env.GetValue("HighETBinThreshold", 125);
  
     m_rootTool->m_doPileupTransform = env.GetValue("doPileupTransform", false);
     m_rootTool->m_doCentralityTransform =
       env.GetValue("doCentralityTransform", false);
     m_rootTool->m_discHardCutForPileupTransform =
       AsgConfigHelper::HelperDouble("DiscHardCutForPileupTransform", env);
     m_rootTool->m_discHardCutSlopeForPileupTransform =
       AsgConfigHelper::HelperDouble("DiscHardCutSlopeForPileupTransform", env);
     m_rootTool->m_discHardCutQuadForPileupTransform =
       AsgConfigHelper::HelperDouble("DiscHardCutQuadForPileupTransform", env);
     m_rootTool->m_discLooseForPileupTransform =
       AsgConfigHelper::HelperDouble("DiscLooseForPileupTransform", env);
     m_rootTool->m_discHardCutForPileupTransform4GeV =
       AsgConfigHelper::HelperDouble("DiscHardCutForPileupTransform4GeV", env);
     m_rootTool->m_discHardCutSlopeForPileupTransform4GeV =
       AsgConfigHelper::HelperDouble("DiscHardCutSlopeForPileupTransform4GeV",
                                     env);
     m_rootTool->m_discHardCutQuadForPileupTransform4GeV =
       AsgConfigHelper::HelperDouble("DiscHardCutQuadForPileupTransform4GeV",
                                     env);
     m_rootTool->m_discLooseForPileupTransform4GeV =
       AsgConfigHelper::HelperDouble("DiscLooseForPileupTransform4GeV", env);
     m_rootTool->m_discMaxForPileupTransform =
       env.GetValue("DiscMaxForPileupTransform", 2.0);
     m_rootTool->m_pileupMaxForPileupTransform =
       env.GetValue("PileupMaxForPileupTransform", 50);
     // if true, deltaEta1 will be corrected for the pear shape distortion of the
     // LAr
     m_correctDeltaEta = env.GetValue("doCorrectDeltaEta", false);
  
     if (m_rootTool->m_doCentralityTransform && m_useAverageMu) {
         ATH_MSG_ERROR("Cannot use centrality transform and average mu "
             << "at the same time as they affect the same variable");
         return StatusCode::FAILURE;
     }
   } else {  // Error if it cant find the conf
     ATH_MSG_ERROR("Could not find configuration file");
     return StatusCode::FAILURE;
   }
  
  
   // Setup primary vertex key handle
   ATH_CHECK(m_primVtxContKey.initialize(m_usePVCont));
   // Setup average mu key handle
   ATH_CHECK(m_avgMuKey.initialize(m_useAverageMu));
  
   // Setup HI container key handle (must come after init from env)
   bool doCentralityTransform = m_rootTool->m_doCentralityTransform;
   ATH_CHECK(
     m_HIESContKey.initialize(doCentralityTransform && m_useCaloSumsCont));
  
   // Get the message level and set the underlying ROOT tool message level
   // accordingly
   m_rootTool->msg().setLevel(this->msg().level());
  
   // We need to initialize the underlying ROOT TSelectorTool
   if (m_rootTool->initialize().isFailure()) {
     ATH_MSG_ERROR("Could not initialize the TElectronLikelihoodTool! "
                   "Configuration details: "
                   << "working point = \"" << m_WorkingPoint
                   << "\", config file = \"" << m_configFile
                   << "\", resolved file  = \"" << configFile
                   << "\", PDF file = \"" << PDFfilename
                   << "\", resolved file = \"" << resolvedPDF);
     return StatusCode::FAILURE;
   }
   return StatusCode::SUCCESS;
 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ isForwardElectron()

bool AsgElectronLikelihoodTool::isForwardElectron	(	const xAOD::Egamma *	eg,
		const float	eta
	)		const

private

check for FwdElectron

Definition at line 969 of file AsgElectronLikelihoodTool.cxx.

 {
  
   static const SG::AuxElement::ConstAccessor<uint16_t> accAuthor("author");
  
   if (accAuthor.isAvailable(*eg)) {
  
     // cannot just do eg->author() because it isn't always filled
     // at trigger level
     if (accAuthor(*eg) == xAOD::EgammaParameters::AuthorFwdElectron) {
       ATH_MSG_WARNING(
         "Failed, this is a forward electron! The AsgElectronLikelihoodTool is "
         "only suitable for central electrons!");
       return true;
     }
   } else {
     // Check for fwd via eta range the old logic
     if (std::abs(eta) > 2.5) {
       ATH_MSG_WARNING("Failed, cluster->etaBE(2) range due to "
                       << eta << " seems like a fwd electron");
       return true;
     }
   }
  
   return false;
 }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns: The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                   {
  
       return MSG::name( msg().level() );
    }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::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< AlgTool > >::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.

◆ print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

                              {
  
       ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
       return;
    }

◆ 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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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);
       }
     }
   }

Member Data Documentation

◆ m_avgMuKey

SG::ReadDecorHandleKey<xAOD::EventInfo> AsgElectronLikelihoodTool::m_avgMuKey

private

Initial value:

{
    this, "averageInteractionsPerCrossingKey",
    "EventInfo.averageInteractionsPerCrossing",
    "Decoration for Average Interaction Per Crossing"
  }

read handle key to averager mu

Definition at line 204 of file AsgElectronLikelihoodTool.h.

◆ m_caloOnly

bool AsgElectronLikelihoodTool::m_caloOnly = false

private

Flag for calo only LH.

Definition at line 176 of file AsgElectronLikelihoodTool.h.

◆ m_configFile

std::string AsgElectronLikelihoodTool::m_configFile

private

Definition at line 155 of file AsgElectronLikelihoodTool.h.

◆ m_correctDeltaEta

bool AsgElectronLikelihoodTool::m_correctDeltaEta = false

private

Flag to toggle the correction of deltaEta1 for the pear shape distortion of the LAr.

Definition at line 182 of file AsgElectronLikelihoodTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_fcalEtDefault

double AsgElectronLikelihoodTool::m_fcalEtDefault

private

defualt FCal ET (when not using CaloSums container, in HI events)

Definition at line 170 of file AsgElectronLikelihoodTool.h.

◆ m_HIESContKey

SG::ReadHandleKey<xAOD::HIEventShapeContainer> AsgElectronLikelihoodTool::m_HIESContKey

private

Initial value:

{
    this,
    "CaloSumsContainer",
    "CaloSums",
    "The CaloSums container name"
  }

read handle key to heavy ion container

Definition at line 188 of file AsgElectronLikelihoodTool.h.

◆ m_nPVdefault

unsigned int AsgElectronLikelihoodTool::m_nPVdefault

private

defualt nPV (when not using PVCont)

Definition at line 164 of file AsgElectronLikelihoodTool.h.

◆ m_pdfFileName

std::string AsgElectronLikelihoodTool::m_pdfFileName

private

The input ROOT file name that holds the PDFs.

Definition at line 173 of file AsgElectronLikelihoodTool.h.

◆ m_primVtxContKey

SG::ReadHandleKey<xAOD::VertexContainer> AsgElectronLikelihoodTool::m_primVtxContKey

private

Initial value:

{
    this,
    "primaryVertexContainer",
    "PrimaryVertices",
    "The primary vertex container name"
  }

read handle key to primary vertex container

Definition at line 196 of file AsgElectronLikelihoodTool.h.

◆ m_rootTool

Root::TElectronLikelihoodTool* AsgElectronLikelihoodTool::m_rootTool

private

Pointer to the underlying ROOT based tool.

Definition at line 158 of file AsgElectronLikelihoodTool.h.

◆ m_skipDeltaPoverP

bool AsgElectronLikelihoodTool::m_skipDeltaPoverP

private

Flag for skip the use of deltaPoverP in LH computation (like at HLT)

Definition at line 179 of file AsgElectronLikelihoodTool.h.

◆ m_useAverageMu

bool AsgElectronLikelihoodTool::m_useAverageMu = false

private

Definition at line 185 of file AsgElectronLikelihoodTool.h.

◆ m_useCaloSumsCont

bool AsgElectronLikelihoodTool::m_useCaloSumsCont

private

Whether or not to use the CaloSums container in HI events.

Definition at line 167 of file AsgElectronLikelihoodTool.h.

◆ m_usePVCont

bool AsgElectronLikelihoodTool::m_usePVCont

private

Whether to use the PV (not available for trigger)

Definition at line 161 of file AsgElectronLikelihoodTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_WorkingPoint

std::string AsgElectronLikelihoodTool::m_WorkingPoint

private

Working Point.

Definition at line 152 of file AsgElectronLikelihoodTool.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ ~AsgElectronLikelihoodTool()

Member Function Documentation

◆ accept() [1/6]

◆ accept() [2/6]

◆ accept() [3/6]

◆ accept() [4/6]

◆ accept() [5/6]

◆ accept() [6/6]

◆ calculate() [1/5]

◆ calculate() [2/5]

◆ calculate() [3/5]

◆ calculate() [4/5]

◆ calculate() [5/5]

◆ calculateMultipleOutputs()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ getAcceptInfo()

◆ getAverageMu()

◆ getFcalEt()

◆ getIpVariable()

◆ getKey()

◆ getName()

◆ getNPrimVertices()

◆ getOperatingPointName()

◆ getProperty()

◆ initialize()

◆ inputHandles()

◆ isForwardElectron()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msg_level_name()

◆ msgLvl()

◆ outputHandles()

◆ print()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_avgMuKey

◆ m_caloOnly

◆ m_configFile

◆ m_correctDeltaEta

◆ m_detStore

◆ m_evtStore

◆ m_fcalEtDefault

◆ m_HIESContKey

◆ m_nPVdefault

◆ m_pdfFileName

◆ m_primVtxContKey

◆ m_rootTool

◆ m_skipDeltaPoverP

◆ m_useAverageMu

◆ m_useCaloSumsCont

◆ m_usePVCont

◆ m_varHandleArraysDeclared

◆ m_vhka

◆ m_WorkingPoint