AsgElectronLikelihoodTool Class Reference

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.
virtual const asg::AcceptInfo &	getAcceptInfo () const override
	Method to get the plain AcceptInfo.
virtual asg::AcceptData	accept (const xAOD::IParticle *part) const override final
	The main accept method: using the generic interface.
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.
virtual asg::AcceptData	accept (const EventContext &ctx, const xAOD::Egamma *eg) const override final
	The main accept method: the actual cuts are applied here.
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.
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.
virtual double	calculate (const EventContext &ctx, const xAOD::IParticle *part) const override final
	calculate method: for pointer to IParticle
virtual double	calculate (const EventContext &ctx, const xAOD::Electron *eg) const override final
	The main result method: the actual likelihood is calculated here.
virtual double	calculate (const EventContext &ctx, const xAOD::Egamma *eg) const override final
	The main result method: the actual likelihood is calculated here.
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.
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.
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.
virtual std::string	getOperatingPointName () const override final
	Get the name of the current operating point.
virtual void	print () const
	Print the state of the tool.
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	sysInitialize () override
	Perform system initialization for an algorithm.
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
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

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
virtual ASG_TOOL_CLASS2(AsgElectronLikelihoodTool, IAsgElectronLikelihoodTool, IAsgSelectionTool) public	~AsgElectronLikelihoodTool ()
	Standard constructor.
double	getIpVariable (double mu, const EventContext &ctx) const
	Get IP variable based on user configuration.
unsigned int	getNPrimVertices (const EventContext &ctx) const
	Get the number of primary vertices.
double	getAverageMu (const EventContext &ctx) const
	Get the average mu.
double	getFcalEt (const EventContext &ctx) const
	Get the FCal ET for centrality determination (for HI collisions)
bool	isForwardElectron (const xAOD::Egamma *eg, const float eta) const
	check for FwdElectron
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_WorkingPoint
	Working Point.
std::string	m_configFile
Root::TElectronLikelihoodTool *	m_rootTool
	Pointer to the underlying ROOT based tool.
bool	m_usePVCont
	Whether to use the PV (not available for trigger)
unsigned int	m_nPVdefault
	defualt nPV (when not using PVCont)
bool	m_useCaloSumsCont
	Whether or not to use the CaloSums container in HI events.
double	m_fcalEtDefault
	defualt FCal ET (when not using CaloSums container, in HI events)
std::string	m_pdfFileName
	The input ROOT file name that holds the PDFs.
bool	m_caloOnly = false
	Flag for calo only LH.
bool	m_skipDeltaPoverP
	Flag for skip the use of deltaPoverP in LH computation (like at HLT)
bool	m_correctDeltaEta = false
	Flag to toggle the correction of deltaEta1 for the pear shape distortion of the LAr.
bool	m_useAverageMu = false
SG::ReadHandleKey< xAOD::HIEventShapeContainer >	m_HIESContKey
	read handle key to heavy ion container
SG::ReadHandleKey< xAOD::VertexContainer >	m_primVtxContKey
	read handle key to primary vertex container
SG::ReadDecorHandleKey< xAOD::EventInfo >	m_avgMuKey
	read handle key to averager mu
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

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.

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

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

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.

{ return m_detStore; }

evtStore()

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.

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

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

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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 AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, KtDeltaRTool, and LundVariablesTool.

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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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);
      }
    }
  }

~AsgElectronLikelihoodTool()

AsgElectronLikelihoodTool::~AsgElectronLikelihoodTool ( )

privatevirtual

Standard constructor.

Standard destructor

Definition at line 74 of file AsgElectronLikelihoodTool.cxx.

{
  delete m_rootTool;
}

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.

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

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.

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

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.

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

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:

• AsgElectronLikelihoodTool.h
• AsgElectronLikelihoodTool.cxx