Electron selector tool to select signal electrons using the ElectronDNNCalculator retrieve a score based on a DNN. More...

#include <AsgElectronSelectorTool.h>

Inheritance diagram for AsgElectronSelectorTool:

Collaboration diagram for AsgElectronSelectorTool:

Classes
struct	SelectorOutputs
struct	SelectionLayer

Public Member Functions
	AsgElectronSelectorTool (const std::string &myname)
	Standard constructor.
virtual	~AsgElectronSelectorTool ()
	Standard destructor.
virtual StatusCode	initialize () override
	Gaudi Service Interface method implementations.
virtual const asg::AcceptInfo &	getAcceptInfo () const override
	Method to get the plain AcceptInfo.
asg::AcceptData	accept (const xAOD::IParticle *part) const override
	The main accept method: using the generic interface.
asg::AcceptData	accept (const EventContext &ctx, const xAOD::IParticle *part) const override
asg::AcceptData	accept (const EventContext &ctx, const xAOD::Electron *eg) const override
	The main accept method: the actual cuts are applied here.
asg::AcceptData	accept (const EventContext &ctx, const xAOD::Egamma *eg) const override
	The main accept method: the actual cuts are applied here.
asg::AcceptData	accept (const EventContext &ctx, const xAOD::Electron *eg, double mu) const override
	The main accept method: in case mu not in EventInfo online.
asg::AcceptData	accept (const EventContext &ctx, const xAOD::Egamma *eg, double mu) const override
	The main accept method: in case mu not in EventInfo online.
double	calculate (const xAOD::IParticle *part) const
	The main result method: the actual mva score is calculated here.
double	calculate (const EventContext &ctx, const xAOD::IParticle *part) const override
	calculate method: for pointer to IParticle
double	calculate (const EventContext &ctx, const xAOD::Electron *eg) const override
	The main result method: the actual mva score is calculated here.
double	calculate (const EventContext &ctx, const xAOD::Egamma *eg) const override
	The main result method: the actual mva score is calculated here.
double	calculate (const EventContext &ctx, const xAOD::Electron *eg, double mu) const override
	The main result method: the actual mva score is calculated here.
double	calculate (const EventContext &ctx, const xAOD::Egamma *eg, double mu) const override
	The main result method: the actual mva score is calculated here.
SelectorOutputs	runSelections (const EventContext &ctx, const xAOD::Electron *eg, double mu) const
	The result method for multiple outputs: can return multiple outputs of the MVA.
virtual std::vector< float >	calculateMultipleOutputs (const EventContext &ctx, const xAOD::Electron *eg, double mu=-99) const override
	calculate all outputs of the underlying method (MVA) if it produces multiple outputs
std::vector< double >	getDiscriminant (const SelectorOutputs &mvaOutputs, const xAOD::Electron *egu) const
	Computes discrimiant value from mva output based on whether multiclass is true or false.
virtual std::string	getOperatingPointName () const override
	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
bool	isForwardElectron (const xAOD::Egamma *eg, const float eta) const
	check for FwdElectron
double	transformMLOutput (float score) const
	Applies a logit transformation to the score returned by the underlying MVA tool.
double	combineOutputs (const std::vector< float > &mvaScores, double eta, const std::vector< double > &fractions, bool cfSignal=false) const
	Combines the six output nodes of a multiclass model into one discriminant.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static double	combineOutputsCF (const std::vector< float > &mvaScores)
static unsigned int	getDiscEtaBin (double eta)
	Gets the Discriminant Eta bin [0,s_fnDiscEtaBins-1] given the eta.
static unsigned int	getDiscEtBin (double et)
	Gets the Descriminant Et bin the et (MeV) [0,s_fnDiscEtBins-1].
static double	interpolateCuts (const std::vector< double > &cuts, double et, double eta)
	Interpolates cut values along pt.

Private Attributes
asg::AcceptInfo	m_acceptMVA
	Accept info.
std::string	m_workingPoint
	Working Point.
std::string	m_configFile
	The input config file.
std::string	m_modelFileName
	The input file name that holds the model.
std::string	m_quantileFileName
	The input file name that holds the QuantileTransformer.
bool	m_skipDeltaPoverP
	Flag for skip the use of deltaPoverP in dnn calculation (like at HLT).
bool	m_skipAmbiguityCut
bool	m_doSmoothBinInterpolation {}
std::vector< SelectionLayer >	m_layers
int	m_cutPosition_kinematic {}
	The position of the kinematic cut bit in the AcceptInfo return object.
int	m_cutPosition_NSilicon {}
	The position of the NSilicon cut bit in the AcceptInfo return object.
int	m_cutPosition_NPixel {}
	The position of the NPixel cut bit in the AcceptInfo return object.
int	m_cutPosition_NBlayer {}
	The position of the NBlayer cut bit in the AcceptInfo return object.
int	m_cutPosition_ambiguity {}
	The position of the ambiguity cut bit in the AcceptInfo return object.
int	m_cutPosition_MVA {}
	The position of the MVA cut bit in the AcceptInfo return object.
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

Static Private Attributes
static const unsigned int	s_fnDiscEtBins = 10
static const unsigned int	s_fnDiscEtaBins = 10

Detailed Description

Electron selector tool to select signal electrons using the ElectronDNNCalculator retrieve a score based on a DNN.

This includes preprocessing/transformations of the input variables and the actual calculation of the score using lwtnn.

Author: Lukas Ehrke, Daniel Nielsen, Troels Petersen

Note: heavily adapted from AsgElectronLikelihoodTool

Definition at line 25 of file AsgElectronSelectorTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ AsgElectronSelectorTool()

AsgElectronSelectorTool::AsgElectronSelectorTool ( const std::string & myname )

Standard constructor.

Definition at line 213 of file AsgElectronSelectorTool.cxx.

                                                                          :
  AsgTool(myname),
  m_configFile{""}
{
 
  // Declare the needed properties
  declareProperty("WorkingPoint", m_workingPoint="", "The Working Point");
  declareProperty("ConfigFile", m_configFile="", "The config file to use");
 
  // model file name. Managed in the ElectronDNNCalculator.
  declareProperty("inputModelFileName", m_modelFileName="", "The input file name that holds the model" );
  // QuantileTransformer file name ( required for preprocessing ). Managed in the ElectronDNNCalculator.
  declareProperty("quantileFileName", m_quantileFileName="", "The input file name that holds the QuantileTransformer");
  // especially for  trigger electron
  declareProperty("skipDeltaPoverP",m_skipDeltaPoverP = false,"If true, it will skip the check of deltaPoverP");
 
  declareProperty("skipAmbiguityCut",m_skipAmbiguityCut = false,"If true, it will skip the ambiguity cut");
}

◆ ~AsgElectronSelectorTool()

AsgElectronSelectorTool::~AsgElectronSelectorTool ( )

virtualdefault

Standard destructor.

Member Function Documentation

◆ accept() [1/6]

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

inlineoverridevirtual

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

Implements IAsgElectronLikelihoodTool.

Definition at line 64 of file AsgElectronSelectorTool.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 AsgElectronSelectorTool::accept	(	const EventContext &	ctx,
		const xAOD::Egamma *	eg,
		double	mu ) const

overridevirtual

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

Implements IAsgElectronLikelihoodTool.

Definition at line 931 of file AsgElectronSelectorTool.cxx.

{
  ATH_MSG_VERBOSE("\t AsgElectronSelectorTool::accept( &ctx, *eg, mu= "<<(&ctx)<<", "<<eg<<", "<<mu<<" )");
  const xAOD::Electron* ele = dynamic_cast<const xAOD::Electron*>(eg);
  if (ele){
    return accept(ctx, ele, mu);
  }
  else {
    ATH_MSG_DEBUG("AsgElectronSelectorTool::could not cast to const Electron");
    // Setup return accept with AcceptInfo
    asg::AcceptData acceptData(&m_acceptMVA);
    return acceptData;
  }
}

◆ accept() [3/6]

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

inlineoverridevirtual

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

Implements IAsgElectronLikelihoodTool.

Definition at line 59 of file AsgElectronSelectorTool.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 AsgElectronSelectorTool::accept	(	const EventContext &	ctx,
		const xAOD::Electron *	eg,
		double	mu ) const

overridevirtual

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

Implements IAsgElectronLikelihoodTool.

Definition at line 360 of file AsgElectronSelectorTool.cxx.

{
  ATH_MSG_VERBOSE("\t AsgElectronSelectorTool::accept( &ctx, *eg, mu= "<<(&ctx)<<", "<<eg<<", "<<mu<<" )");
 
  // Setup return accept with AcceptInfo
  asg::AcceptData acceptData(&m_acceptMVA);
 
  if (!eg){
    throw std::runtime_error("AsgElectronSelectorTool: Failed, no electron object was passed");
  }
 
  const xAOD::CaloCluster* cluster = eg->caloCluster();
  if (!cluster){
    ATH_MSG_DEBUG("exiting because cluster is NULL " << cluster);
    return acceptData;
  }
 
  if(!cluster->hasSampling(CaloSampling::CaloSample::EMB2) && !cluster->hasSampling(CaloSampling::CaloSample::EME2)){
    ATH_MSG_DEBUG("Failed, cluster is missing samplings EMB2 and EME2");
    return acceptData;
  }
 
  const double energy = cluster->e();
  const float eta = cluster->etaBE(2);
 
  if(isForwardElectron(eg, eta)){
    ATH_MSG_DEBUG("Failed, this is a forward electron! The AsgElectronSelectorTool is only suitable for central electrons!");
    return acceptData;
  }
 
  const xAOD::TrackParticle* track = eg->trackParticle();
  if (!track){
    ATH_MSG_DEBUG("exiting because track is NULL " << track);
    return acceptData;
  }
 
  // transverse energy of the electron (using the track eta)
  double et = (std::cosh(track->eta()) != 0.) ? energy / std::cosh(track->eta()) : 0.;
 
  // number of track hits
  uint8_t nSiHitsPlusDeadSensors(0);
  uint8_t nPixHitsPlusDeadSensors(0);
  bool passBLayerRequirement(false);
  uint8_t ambiguityBit(0);
 
  bool allFound = true;
  std::string notFoundList = "";
 
  // get the ambiguity type from the decoration
  if (!m_skipAmbiguityCut){
    static const SG::Accessor<uint8_t> ambiguityTypeAcc("ambiguityType");
    if (ambiguityTypeAcc.isAvailable(*eg)) {
      ambiguityBit = ambiguityTypeAcc(*eg);
    }
    else {
      allFound = false;
      notFoundList += "ambiguityType ";
    }
  }
 
  nSiHitsPlusDeadSensors = ElectronSelectorHelpers::numberOfSiliconHitsAndDeadSensors(*track);
  nPixHitsPlusDeadSensors = ElectronSelectorHelpers::numberOfPixelHitsAndDeadSensors(*track);
  passBLayerRequirement = ElectronSelectorHelpers::passBLayerRequirement(*track);
 
  // calculate the output of the selector tool
  SelectorOutputs mvaOutputs = runSelections(ctx, eg, mu);
 
  if (!allFound){
    throw std::runtime_error("AsgElectronSelectorTool: Not all variables needed for the decision are found. The following variables are missing: " + notFoundList );
  }
 
  // Set up the individual cuts
  bool passKine(true);
  bool passNSilicon(true);
  bool passNPixel(true);
  bool passNBlayer(true);
  bool passAmbiguity(true);
  bool passMVA(true);
 
 
  if (std::abs(eta) > 2.47){
    ATH_MSG_DEBUG("This electron is fabs(eta)>2.47 Returning False.");
    passKine = false;
  }
 
  unsigned int etBin = getDiscEtBin(et);
  unsigned int etaBin = getDiscEtaBin(eta);
 
  // sanity
  if (etBin >= s_fnDiscEtBins){
    ATH_MSG_DEBUG("Cannot evaluate model for Et " << et << ". Returning false..");
    passKine = false;
  }
 
  // Return if the kinematic requirements are not fulfilled
  acceptData.setCutResult(m_cutPosition_kinematic, passKine);
  if (!passKine){return acceptData;}
 
for (size_t idx = 0; idx < m_layers.size(); ++idx) {
    const auto& layer = m_layers[idx];
    const auto& scores = mvaOutputs.layerOutputs[idx];
 
  // ambiguity bit
  if (!layer.m_cutAmbiguity.empty()){
    if (!ElectronSelectorHelpers::passAmbiguity((xAOD::AmbiguityTool::AmbiguityType)ambiguityBit, layer.m_cutAmbiguity[etaBin])){
      ATH_MSG_DEBUG("MVA macro: ambiguity Bit cut failed.");
      passAmbiguity = false;
    }
  }
 
  // blayer cut
  if (!layer.m_cutBL.empty()) {
    if(layer.m_cutBL[etaBin] == 1 && !passBLayerRequirement){
      ATH_MSG_DEBUG("MVA macro: Blayer cut failed.");
      passNBlayer = false;
    }
  }
  // pixel cut
  if (!layer.m_cutPi.empty()){
    if (nPixHitsPlusDeadSensors < layer.m_cutPi[etaBin]){
      ATH_MSG_DEBUG("MVA macro: Pixels Failed.");
      passNPixel = false;
    }
  }
  // SCT cut
  if (!layer.m_cutSCT.empty()){
    if (nSiHitsPlusDeadSensors < layer.m_cutSCT[etaBin]){
      ATH_MSG_DEBUG( "MVA macro: Silicon Failed.");
      passNSilicon = false;
    }
  }
  unsigned int ibin_combinedMVA = etBin*s_fnDiscEtaBins+etaBin; // Must change if number of eta bins changes!.
  
  // First cut on the CF discriminant
  // If empty, continue only with prompt ID
  if (!layer.m_cutSelectorCF.empty()){
    double cutDiscriminantCF;
    // To protect against a binning mismatch, which should never happen
    if (ibin_combinedMVA >= layer.m_cutSelectorCF.size()){
      throw std::runtime_error("AsgElectronSelectorTool: The desired eta/pt bin is outside of the range specified by the input. This should never happen! This indicates a mismatch between the binning in the configuration file and the tool implementation." );
    }
    if (m_doSmoothBinInterpolation){
      cutDiscriminantCF = interpolateCuts(layer.m_cutSelectorCF, et, eta);
    }
    else{
      cutDiscriminantCF = layer.m_cutSelectorCF.at(ibin_combinedMVA);
    }
    // Determine if the calculated mva score value passes the combined cut
    ATH_MSG_DEBUG("MVA macro: CF Discriminant: ");
    double mvaScoreCF = combineOutputsCF(scores);
    if (mvaScoreCF < cutDiscriminantCF){
      ATH_MSG_DEBUG("MVA macro: CF cut failed.");
      passMVA = false;
    }
  }
  // (Second) cut on prompt discriminant
  // Cut on Score MVA First Selection
  if (!layer.m_cutSelector.empty()) {
    double cutDiscriminant;
    // To protect against a binning mismatch, which should never happen
    if (ibin_combinedMVA >= layer.m_cutSelector.size()){
      throw std::runtime_error("AsgElectronSelectorTool: The desired eta/pt bin is outside of the range specified by the input. This should never happen! This indicates a mismatch between the binning in the configuration file and the tool implementation." );
    }
    if (m_doSmoothBinInterpolation){
      cutDiscriminant = interpolateCuts(layer.m_cutSelector, et, eta);
    }
    else{
      cutDiscriminant = layer.m_cutSelector.at(ibin_combinedMVA);
    }
    
    // Determine if the calculated mva score value passes the combined cut
    ATH_MSG_DEBUG("MVA macro: Prompt Discriminant: ");
    double disc = layer.m_multiClass
            ? combineOutputs(scores, eta, layer.m_fractions, layer.m_cfSignal)
            : transformMLOutput(scores.at(0));
 
        if (disc < cutDiscriminant) {
            ATH_MSG_DEBUG("MVA macro: Prompt cut failed in layer " << layer.name);
            passMVA = false;
        }
  }
    if (!passMVA || !passNSilicon || !passNPixel || !passNBlayer || !passAmbiguity) {
        break;
    }
} 
  // Set the individual cut bits in the return object
  acceptData.setCutResult(m_cutPosition_NSilicon, passNSilicon);
  acceptData.setCutResult(m_cutPosition_NPixel, passNPixel);
  acceptData.setCutResult(m_cutPosition_NBlayer, passNBlayer);
  acceptData.setCutResult(m_cutPosition_ambiguity, passAmbiguity);
  acceptData.setCutResult(m_cutPosition_MVA, passMVA);
 
  return acceptData;
 
}

◆ accept() [5/6]

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

overridevirtual

Implements IAsgElectronLikelihoodTool.

Definition at line 902 of file AsgElectronSelectorTool.cxx.

{
  ATH_MSG_VERBOSE("\t AsgElectronSelectorTool::accept( &ctx, *part= "<<(&ctx)<<", "<<part<<" )");
  const xAOD::Electron* eg = dynamic_cast<const xAOD::Electron*>(part);
  if (eg){
    return accept(ctx, eg);
  }
  else {
    ATH_MSG_DEBUG("AsgElectronSelectorTool::could not cast to const Electron");
    // Setup return accept with AcceptInfo
    asg::AcceptData acceptData(&m_acceptMVA);
    return acceptData;
  }
}

◆ accept() [6/6]

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

overridevirtual

The main accept method: using the generic interface.

Implements IAsgElectronLikelihoodTool.

Definition at line 898 of file AsgElectronSelectorTool.cxx.

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

◆ calculate() [1/6]

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

inlineoverridevirtual

The main result method: the actual mva score is calculated here.

Implements IAsgElectronLikelihoodTool.

Definition at line 86 of file AsgElectronSelectorTool.h.

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

◆ calculate() [2/6]

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

overridevirtual

The main result method: the actual mva score is calculated here.

Implements IAsgElectronLikelihoodTool.

Definition at line 946 of file AsgElectronSelectorTool.cxx.

{
  ATH_MSG_VERBOSE("\t AsgElectronSelectorTool::calculate( &ctx, *eg, mu= "<<(&ctx)<<", "<<eg<<", "<<mu<<" )");
  const xAOD::Electron* ele = dynamic_cast<const xAOD::Electron*>(eg);
  if (ele){
    return calculate(ctx, ele, mu);
  }
  else {
    ATH_MSG_DEBUG("AsgElectronSelectorTool::could not cast to const Electron");
    return -999.;
  }
}

◆ calculate() [3/6]

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

inlineoverridevirtual

The main result method: the actual mva score is calculated here.

Implements IAsgElectronLikelihoodTool.

Definition at line 81 of file AsgElectronSelectorTool.h.

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

◆ calculate() [4/6]

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

overridevirtual

The main result method: the actual mva score is calculated here.

Implements IAsgElectronLikelihoodTool.

Definition at line 559 of file AsgElectronSelectorTool.cxx.

{
  // Get all outputs of the mva tool
  SelectorOutputs mvaOutputs = runSelections(ctx, eg, mu);
  if (mvaOutputs.layerOutputs.empty()) return -999.0;
 
    auto discScores = getDiscriminant(mvaOutputs, eg);
    return discScores.empty() ? -999.0 : discScores.back(); //Returns final layer score
}

◆ calculate() [5/6]

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

overridevirtual

calculate method: for pointer to IParticle

Implements IAsgElectronLikelihoodTool.

Definition at line 917 of file AsgElectronSelectorTool.cxx.

{
  ATH_MSG_VERBOSE("\t AsgElectronSelectorTool::calculate( &ctx, *part"<<(&ctx)<<", "<<part<<" )");
  const xAOD::Electron* eg = dynamic_cast<const xAOD::Electron*>(part);
  if (eg){
    return calculate(ctx, eg);
  }
  else {
    ATH_MSG_DEBUG("AsgElectronSelectorTool::could not cast to const Electron");
    // Return a default value
    return -999.;
  }
}

◆ calculate() [6/6]

double AsgElectronSelectorTool::calculate ( const xAOD::IParticle * part ) const

The main result method: the actual mva score is calculated here.

◆ calculateMultipleOutputs()

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

overridevirtual

calculate all outputs of the underlying method (MVA) if it produces multiple outputs

Implements IAsgElectronLikelihoodTool.

Definition at line 591 of file AsgElectronSelectorTool.cxx.

{
  SelectorOutputs mvaOutputs = runSelections(ctx, eg, mu);
  
  if (!mvaOutputs.layerOutputs.empty()) {
      return mvaOutputs.layerOutputs.back();
  }
  return {};
}

◆ combineOutputs()

double AsgElectronSelectorTool::combineOutputs	(	const std::vector< float > &	mvaScores,
		double	eta,
		const std::vector< double > &	fractions,
		bool	cfSignal = false ) const

private

Combines the six output nodes of a multiclass model into one discriminant.

Definition at line 997 of file AsgElectronSelectorTool.cxx.

{
  unsigned int etaBin = getDiscEtaBin(eta);
  double disc = 0;
  size_t nClasses = mvaScores.size();
  size_t nFractionsPerBin = nClasses - 1;
 
  if (cfSignal && nClasses >= 3) {
 
    double numerator = mvaScores.at(0) * (1.0 - fractions.at(nFractionsPerBin * etaBin + 0)) +
                       mvaScores.at(1) * fractions.at(nFractionsPerBin * etaBin + 0);
                       
    double denominator = 0.0;
    for (size_t i = 2; i < nClasses; ++i) {
      denominator += mvaScores.at(i) * fractions.at(nFractionsPerBin * etaBin + i - 1);
    }
    if (denominator != 0.0) {
      disc = numerator / denominator;
    }
  }
  else {
 
    double numerator = mvaScores.at(0);
    double denominator = 0.0;
    
    for (size_t i = 1; i < nClasses; ++i) {
      denominator += mvaScores.at(i) * fractions.at(nFractionsPerBin * etaBin + i - 1);
    }
    if (denominator != 0.0) {
      disc = numerator / denominator;
    }
  }
  // Log transform to have values in reasonable range
  return std::log(disc);
}

◆ combineOutputsCF()

double AsgElectronSelectorTool::combineOutputsCF ( const std::vector< float > & mvaScores )

staticprivate

Definition at line 1033 of file AsgElectronSelectorTool.cxx.

{
  double disc = 0;
  disc = mvaScores.at(0) / mvaScores.at(1);
 
  return std::log(disc);
}

◆ 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.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:381

◆ 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.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:378

◆ 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 & AsgElectronSelectorTool::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 352 of file AsgElectronSelectorTool.cxx.

{
  return m_acceptMVA;
}

◆ getDiscEtaBin()

unsigned int AsgElectronSelectorTool::getDiscEtaBin ( double eta )

staticprivate

Gets the Discriminant Eta bin [0,s_fnDiscEtaBins-1] given the eta.

Definition at line 1043 of file AsgElectronSelectorTool.cxx.

{
  const unsigned int nEtaBins = s_fnDiscEtaBins;
  const double etaBins[nEtaBins] = {0.1, 0.6, 0.8, 1.15, 1.37, 1.52, 1.81, 2.01, 2.37, 2.47};
  for (unsigned int etaBin = 0; etaBin < nEtaBins; ++etaBin){
    if (std::abs(eta) < etaBins[etaBin]) return etaBin;
  }
  return (nEtaBins-1);
}

◆ getDiscEtBin()

unsigned int AsgElectronSelectorTool::getDiscEtBin ( double et )

staticprivate

Gets the Descriminant Et bin the et (MeV) [0,s_fnDiscEtBins-1].

Definition at line 1054 of file AsgElectronSelectorTool.cxx.

{
  static const double GeV = 1000;
  const unsigned int nEtBins = s_fnDiscEtBins;
  const double etBins[nEtBins] = {7*GeV,10*GeV,15*GeV,20*GeV,25*GeV,30*GeV,35*GeV,40*GeV,45*GeV,6000*GeV};
  for (unsigned int etBin = 0; etBin < nEtBins; ++etBin){
    if (et < etBins[etBin]) return etBin;
  }
  return (nEtBins-1);
}

◆ getDiscriminant()

std::vector< double > AsgElectronSelectorTool::getDiscriminant	(	const SelectorOutputs &	mvaOutputs,
		const xAOD::Electron *	egu ) const

Computes discrimiant value from mva output based on whether multiclass is true or false.

Definition at line 569 of file AsgElectronSelectorTool.cxx.

{
  std::vector<double> discriminants;
  const xAOD::CaloCluster* cluster = eg->caloCluster();
  const float eta = cluster->etaBE(2);
  // If a binary model is used, vector will have one entry
 
  for (size_t i = 0; i < mvaOutputs.layerOutputs.size(); ++i) {
        const auto& scores = mvaOutputs.layerOutputs[i];
        if (scores.empty()) continue;
 
        const auto& layer = m_layers[i];
        double disc = layer.m_multiClass
            ? combineOutputs(scores, eta, layer.m_fractions, layer.m_cfSignal)
            : transformMLOutput(scores.at(0));
 
        discriminants.push_back(disc);
    }
 
  return discriminants;
}

◆ 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::Event 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::Event, 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::Event 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::Event, 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
   }

◆ getOperatingPointName()

std::string AsgElectronSelectorTool::getOperatingPointName ( ) const

overridevirtual

Get the name of the current operating point.

Implements IAsgElectronLikelihoodTool.

Definition at line 892 of file AsgElectronSelectorTool.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 AsgElectronSelectorTool::initialize ( void )

overridevirtual

Gaudi Service Interface method implementations.

Reimplemented from asg::AsgTool.

Definition at line 243 of file AsgElectronSelectorTool.cxx.

{
  
if (m_configFile.empty()) {
  if (!m_workingPoint.empty()){
    m_configFile = AsgConfigHelper::findConfigFile(m_workingPoint, EgammaSelectors::ElectronDNNPointToConfFile);
    ATH_MSG_INFO("operating point : " << this->getOperatingPointName());
  }
}
else {
  ATH_MSG_INFO("Using USER provided config file: " << m_configFile);
}
  if (m_configFile.empty()){
    ATH_MSG_ERROR("Could not find configuration file " << m_configFile);
    return StatusCode::FAILURE;
  }
 
  std::string configFile = PathResolverFindCalibFile(m_configFile);
 ATH_MSG_INFO("CONFIG FILE (logical): " << m_configFile);
 ATH_MSG_INFO("CONFIG FILE (resolved full path): " << configFile);
 
 if (configFile.empty()){
    ATH_MSG_ERROR("Could not locate " << m_configFile);
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG("Configfile to use: " << m_configFile);
  TEnv env;
  env.ReadFile(configFile.c_str(), kEnvLocal);
 
  int nLayers = env.GetValue("nSelectionLayers", 1);
 
    const std::vector<std::string> defaultPrefixes = {
        "",                     // Layer 0: No prefix 
        "SecondSelection.",     // Layer 1
        "ThirdSelection.",      // Layer 2
        "FourthSelection."      // Layer 3
    };
 
    m_layers.clear();  
    for (int i = 0; i < nLayers; ++i) {
        std::string prefix = (i < static_cast<int>(defaultPrefixes.size()))
            ? defaultPrefixes[i]
            : ("Layer" + std::to_string(i + 1) + ".");
 
        std::string layerName = (i == 0) ? "FirstSelection"
            : (i == 1) ? "SecondSelection"
            : ("Layer" + std::to_string(i + 1));
 
        SelectionLayer layer;
        std::string userModel = (i == 0) ? m_modelFileName : "";
        std::string userQuantile = (i == 0) ? m_quantileFileName : "";
 
        if (!layer.initialize(env, prefix, layerName, userModel, userQuantile, this)) {
            ATH_MSG_ERROR("Error initializing layer " << i << " with prefix: " << prefix);
            return StatusCode::FAILURE;
        }
        m_layers.push_back(std::move(layer));
    }
 
  // do smooth interpolation between bins
  m_doSmoothBinInterpolation = env.GetValue("doSmoothBinInterpolation", false);
 
  // --------------------------------------------------------------------------
  // Register the cuts and check that the registration worked:
  // NOTE: THE ORDER IS IMPORTANT!!! Cut0 corresponds to bit 0, Cut1 to bit 1,...
  // use an int as a StatusCode
  int sc(1);
 
  // Cut position for the kineatic pre-selection
  m_cutPosition_kinematic = m_acceptMVA.addCut("kinematic", "pass kinematic");
  if (m_cutPosition_kinematic < 0) sc = 0;
 
  // NSilicon
  m_cutPosition_NSilicon = m_acceptMVA.addCut("NSCT", "pass NSCT");
  if (m_cutPosition_NSilicon < 0) sc = 0;
 
  // NPixel
  m_cutPosition_NPixel = m_acceptMVA.addCut("NPixel", "pass NPixel");
  if (m_cutPosition_NPixel < 0) sc = 0;
 
  // NBlayer
  m_cutPosition_NBlayer = m_acceptMVA.addCut("NBlayer", "pass NBlayer");
  if (m_cutPosition_NBlayer < 0) sc = 0;
 
  // Ambiguity
  m_cutPosition_ambiguity = m_acceptMVA.addCut("ambiguity", "pass ambiguity");
  if (m_cutPosition_ambiguity < 0) sc = 0;
 
 
  // Cut position for the likelihood selection - DO NOT CHANGE ORDER!
  m_cutPosition_MVA = m_acceptMVA.addCut("passMVA", "pass MVA");
  if (m_cutPosition_MVA < 0) sc = 0;
 
  // Check that we got everything OK
  if (sc == 0){
    ATH_MSG_ERROR("ERROR: Something went wrong with the setup of the decision objects...");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_INFO("Initialization SUCCESS");
  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.

◆ interpolateCuts()

double AsgElectronSelectorTool::interpolateCuts	(	const std::vector< double > &	cuts,
		double	et,
		double	eta )

staticprivate

Interpolates cut values along pt.

Definition at line 1068 of file AsgElectronSelectorTool.cxx.

{
  const int etbin = getDiscEtBin(et);
  const int etabin = getDiscEtaBin(eta);
  unsigned int ibin_combinedML = etbin*s_fnDiscEtaBins+etabin;
  double cut = cuts.at(ibin_combinedML);
  const double GeV = 1000;
  const double eTBins[10] = {5.5*GeV,8.5*GeV,12.5*GeV,17.5*GeV,22.5*GeV,27.5*GeV,32.5*GeV,37.5*GeV,42.5*GeV,47.5*GeV};
 
  if (et >= eTBins[9]) return cut; // no interpolation for electrons above 47.5 GeV
  if (et <= eTBins[0]) return cut; // no interpolation for electrons below 5.5 GeV
 
  // find the bin where the value is smaller than the next bin
  // Start with bin = 1, since it always has to be at least in
  // bin 1 because of previous cut
  int bin = 1;
  while ( et > eTBins[bin] ) bin++;
 
  double etLow = eTBins[bin-1];
  double etUp = eTBins[bin];
  double discLow = cuts.at((bin-1) * s_fnDiscEtaBins+etabin);
  double discUp = cuts.at((bin) * s_fnDiscEtaBins+etabin);
 
  double gradient = ( discUp - discLow ) / ( etUp - etLow );
 
  return discLow + (et - etLow) * gradient;
}

◆ isForwardElectron()

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

private

check for FwdElectron

Definition at line 959 of file AsgElectronSelectorTool.cxx.

{
  static const SG::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_DEBUG("Failed, this is a forward electron! The AsgElectronSelectorTool 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_DEBUG("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, 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 368 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 352 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ runSelections()

AsgElectronSelectorTool::SelectorOutputs AsgElectronSelectorTool::runSelections	(	const EventContext &	ctx,
		const xAOD::Electron *	eg,
		double	mu ) const

The result method for multiple outputs: can return multiple outputs of the MVA.

Definition at line 600 of file AsgElectronSelectorTool.cxx.

{
  
  SelectorOutputs mvaOutputs;
  ATH_MSG_VERBOSE("\t AsgElectronSelectorTool::calculateMultipleOutputs( &ctx, *eg, mu= "<<(&ctx)<<", "<<eg<<", "<<mu<<" )");
  if (!eg){
    throw std::runtime_error("AsgElectronSelectorTool: Failed, no electron object was passed" );
  }
 
  const xAOD::CaloCluster* cluster = eg->caloCluster();
  if (!cluster){
    ATH_MSG_DEBUG("Failed, no cluster.");
    // Return a default value
    for (const auto& l : m_layers) mvaOutputs.layerOutputs.push_back(l.m_defaultOutputs);
    return mvaOutputs;    
  }
 
  if (!cluster->hasSampling(CaloSampling::CaloSample::EMB2) && !cluster->hasSampling(CaloSampling::CaloSample::EME2)){
    ATH_MSG_DEBUG("Failed, cluster is missing samplings EMB2 and EME2.");
    // Return a default value
    for (const auto& l : m_layers) mvaOutputs.layerOutputs.push_back(l.m_defaultOutputs);
    return mvaOutputs;
  }
 
  const double energy = cluster->e();
  const float eta = cluster->etaBE(2);
 
  if (isForwardElectron(eg, eta)){
    ATH_MSG_DEBUG("Failed, this is a forward electron! The AsgElectronSelectorTool is only suitable for central electrons!");
    // Return a default value
    for (const auto& l : m_layers) mvaOutputs.layerOutputs.push_back(l.m_defaultOutputs);
    return mvaOutputs;    
  }
 
  const xAOD::TrackParticle* track = eg->trackParticle();
  if (!track){
    ATH_MSG_DEBUG("Failed, no track.");
    // Return a default value
    for (const auto& l : m_layers) mvaOutputs.layerOutputs.push_back(l.m_defaultOutputs);
    return mvaOutputs;    
  }
 
  // transverse energy of the electron (using the track eta)
  const double et = energy / std::cosh(track->eta());
 
  // Variables used in the ML model
  // track quantities
  double  SCTWeightedCharge(0.0);
  uint8_t nSCTHitsPlusDeadSensors(0);
  uint8_t nPixHitsPlusDeadSensors(0);
  float d0(0.0), d0sigma(0.0), d0significance(0.0), qd0(0.0);
  float trackqoverp(0.0);
  double dPOverP(0.0);
  float TRT_PID(0.0);
  double trans_TRTPID(0.0);
 
  // Track Cluster matching
  float deltaEta1(0), deltaPhiRescaled2(0), EoverP(0);
 
  // Calorimeter
  float Reta(0), Rphi(0), Rhad1(0), Rhad(0), w2(0), f1(0), Eratio(0), f3(0), wtots1(0);
 
  bool allFound = true;
  std::string notFoundList = "";
 
  // retrieve track variables
  trackqoverp = track->qOverP();
  d0 = track->d0();
  qd0 = (eg->charge())*track->d0();
  float vard0 = track->definingParametersCovMatrix()(0, 0);
  if (vard0 > 0){
    d0sigma = std::sqrt(vard0);
  }
  d0significance = (d0sigma == 0.) ? -99999. : std::abs(d0 / d0sigma);
 
  const static SG::Accessor<float> trans_TRT_PID_acc("transformed_e_probability_ht");
  if (!trans_TRT_PID_acc.isAvailable(*eg)) {
    // most probable case, need to compute the variable
 
    if (!track->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_TRTPID = -std::log(1.0 / pid_tmp - 1.0) * (1. / 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_TRTPID = trans_TRT_PID_acc(*eg);
  }
 
  //Change default value of TRT PID to 0.15 instead of 0 when there is no information from the TRT
  if ((std::abs(trans_TRTPID) < 1.0e-6) && (std::abs(eta) > 2.01)){
      trans_TRTPID = 0.15;
  }
 
  unsigned int index;
  if (track->indexOfParameterAtPosition(index, xAOD::LastMeasurement)){
    double refittedTrack_LMqoverp = track->charge() / std::sqrt(std::pow(track->parameterPX(index), 2) +
                                                                std::pow(track->parameterPY(index), 2) +
                                                                std::pow(track->parameterPZ(index), 2));
 
    dPOverP = 1 - trackqoverp / (refittedTrack_LMqoverp);
  }
  else if (!m_skipDeltaPoverP) {
    allFound = false;
    notFoundList += "deltaPoverP ";
  }
 
  EoverP =  energy * std::abs(trackqoverp);
 
  nPixHitsPlusDeadSensors = ElectronSelectorHelpers::numberOfPixelHitsAndDeadSensors(*track);
  nSCTHitsPlusDeadSensors = ElectronSelectorHelpers::numberOfSCTHitsAndDeadSensors(*track);
 
  float charge = 0;
  uint8_t SCT = 0;
  for (unsigned TPit = 0; TPit < eg->nTrackParticles(); TPit++) {
    uint8_t temp_NSCTHits = 0;
    if (eg->trackParticle(TPit)) {
      eg->trackParticle(TPit)->summaryValue(temp_NSCTHits, xAOD::numberOfSCTHits);
      SCT += temp_NSCTHits;
      charge += temp_NSCTHits*(eg->trackParticle(TPit)->charge());
    }
  }
  if (SCT)
    SCTWeightedCharge = (eg->charge()*charge/SCT);
  else {
    ATH_MSG_WARNING("No SCT hit for any track associated to electron ! nTP = " << eg->nTrackParticles());
  }
 
  // retrieve Calorimeter variables
  // 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 ";
  }
 
  // Set f3 to default value in eta region where it is poorly modelled
  if (std::abs(eta) > 2.01) {
    f3 = 0.05;
  }
 
  // Shower width in first sampling of the calorimeter
  if (!eg->showerShapeValue(wtots1, xAOD::EgammaParameters::wtots1)){
    allFound = false;
    notFoundList += "wtots1 ";
  }
 
  // retrieve Track Cluster matching variables
  // difference between cluster eta (sampling 1) and the eta of the track
  if (!eg->trackCaloMatchValue(deltaEta1, xAOD::EgammaParameters::deltaEta1)){
    allFound = false;
    notFoundList += "deltaEta1 ";
  }
  // difference between the cluster phi (sampling 2) and the phi of the track extrapolated from the last measurement point.
  if (!eg->trackCaloMatchValue(deltaPhiRescaled2, xAOD::EgammaParameters::deltaPhiRescaled2)){
    allFound = false;
    notFoundList += "deltaPhiRescaled2 ";
  }
 
 
  ATH_MSG_VERBOSE(Form("Vars: eta=%8.5f, et=%8.5f, f3=%8.5f, rHad==%8.5f, rHad1=%8.5f, Reta=%8.5f, w2=%8.5f, f1=%8.5f, Emaxs1=%8.5f, deltaEta1=%8.5f, d0=%8.5f, qd0=%8.5f, d0significance=%8.5f, Rphi=%8.5f, dPOverP=%8.5f, deltaPhiRescaled2=%8.5f, TRT_PID=%8.5f, trans_TRTPID=%8.5f, mu=%8.5f, wtots1=%8.5f, EoverP=%8.5f, nPixHitsPlusDeadSensors=%2df, nSCTHitsPlusDeadSensors=%2df, SCTWeightedCharge=%8.5f",
                       eta, et, f3, Rhad, Rhad1, Reta,
                       w2, f1, Eratio,
                       deltaEta1, d0, qd0,
                       d0significance,
                       Rphi, dPOverP, deltaPhiRescaled2,
                       TRT_PID, trans_TRTPID,
                       mu,
                       wtots1, EoverP, int(nPixHitsPlusDeadSensors), int(nSCTHitsPlusDeadSensors), SCTWeightedCharge));
 
  if (!allFound){
    throw std::runtime_error("AsgElectronSelectorTool: Not all variables needed for MVA calculation are found. The following variables are missing: " + notFoundList );
  }
 
  
  mvaOutputs.layerOutputs.reserve(m_layers.size());
  for (const auto& layer : m_layers) {
      std::vector<double> variableValues;
      variableValues.reserve(layer.m_enum_variables.size());
      for (const auto varID : layer.m_enum_variables) {
          
        switch(varID)
      {
        case AllowedVariables::eta:
          variableValues.push_back(std::abs(eta));  break; // TODO - rename to abseta?
        case AllowedVariables::et:
          variableValues.push_back(et); break;
        case AllowedVariables::f3:
          variableValues.push_back(f3); break;
        case AllowedVariables::Rhad:
          variableValues.push_back(Rhad); break;
        case AllowedVariables::Rhad1:
          variableValues.push_back(Rhad1); break;
        case AllowedVariables::Reta:
          variableValues.push_back(Reta); break;
        case AllowedVariables::weta2:
          variableValues.push_back(w2); break;
        case AllowedVariables::f1:
          variableValues.push_back(f1); break;
        case AllowedVariables::Eratio:
          variableValues.push_back(Eratio); break;
        case AllowedVariables::deltaEta1:
          variableValues.push_back(deltaEta1); break;
        case AllowedVariables::d0:
          variableValues.push_back(d0); break;
        case AllowedVariables::qd0:
          variableValues.push_back(qd0); break;
        case AllowedVariables::d0significance:
          variableValues.push_back(d0significance); break;
        case AllowedVariables::Rphi:
          variableValues.push_back(Rphi); break;
        case AllowedVariables::dPOverP:
          variableValues.push_back(dPOverP); break;
        case AllowedVariables::deltaPhiRescaled2:
          variableValues.push_back(deltaPhiRescaled2); break;
        case AllowedVariables::trans_TRTPID:
          variableValues.push_back(trans_TRTPID); break;
        case AllowedVariables::wtots1:
          variableValues.push_back(wtots1); break;
        case AllowedVariables::EoverP:
          variableValues.push_back(EoverP); break;
        case AllowedVariables::nPixHitsPlusDeadSensors:
          variableValues.push_back(nPixHitsPlusDeadSensors); break;
        case AllowedVariables::nSCTHitsPlusDeadSensors:
          variableValues.push_back(nSCTHitsPlusDeadSensors); break;
        case AllowedVariables::SCTWeightedCharge:
          variableValues.push_back(SCTWeightedCharge); break;
        default:
          // Handle unknown varID or error case
          throw std::runtime_error("AsgElectronSelectorTool: unknown variable "
            "index, something went wrong in initialization!" );
          break;
 
      }
    }
 
      mvaOutputs.layerOutputs.push_back(layer.evaluate(variableValues));
  }  
    
return mvaOutputs;
}

◆ 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 >, and AthCheckedComponent<::AthAlgTool >.

◆ 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.

◆ transformMLOutput()

double AsgElectronSelectorTool::transformMLOutput ( float score ) const

private

Applies a logit transformation to the score returned by the underlying MVA tool.

Definition at line 983 of file AsgElectronSelectorTool.cxx.

{
  // returns transformed or non-transformed output
  constexpr double oneOverTau = 1 ;
  constexpr double fEpsilon = 1.0e-30; // to avoid zero division
  if (score >= 1.0) score = 1.0 - 1.0e-15; // this number comes from TMVA
  else if (score <= fEpsilon) score = fEpsilon;
  //cppcheck-suppress invalidFunctionArg
  score = -std::log(1.0 / score - 1.0) * oneOverTau;
  ATH_MSG_DEBUG("score is " << score);
  return score;
}

◆ updateVHKA()

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

inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

                                               {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

◆ m_acceptMVA

asg::AcceptInfo AsgElectronSelectorTool::m_acceptMVA

private

Accept info.

Definition at line 109 of file AsgElectronSelectorTool.h.

◆ m_configFile

std::string AsgElectronSelectorTool::m_configFile

private

The input config file.

Definition at line 186 of file AsgElectronSelectorTool.h.

◆ m_cutPosition_ambiguity

int AsgElectronSelectorTool::m_cutPosition_ambiguity {}

private

The position of the ambiguity cut bit in the AcceptInfo return object.

Definition at line 209 of file AsgElectronSelectorTool.h.

209{};

◆ m_cutPosition_kinematic

int AsgElectronSelectorTool::m_cutPosition_kinematic {}

private

The position of the kinematic cut bit in the AcceptInfo return object.

Definition at line 201 of file AsgElectronSelectorTool.h.

201{};

◆ m_cutPosition_MVA

int AsgElectronSelectorTool::m_cutPosition_MVA {}

private

The position of the MVA cut bit in the AcceptInfo return object.

Definition at line 211 of file AsgElectronSelectorTool.h.

211{};

◆ m_cutPosition_NBlayer

int AsgElectronSelectorTool::m_cutPosition_NBlayer {}

private

The position of the NBlayer cut bit in the AcceptInfo return object.

Definition at line 207 of file AsgElectronSelectorTool.h.

207{};

◆ m_cutPosition_NPixel

int AsgElectronSelectorTool::m_cutPosition_NPixel {}

private

The position of the NPixel cut bit in the AcceptInfo return object.

Definition at line 205 of file AsgElectronSelectorTool.h.

205{};

◆ m_cutPosition_NSilicon

int AsgElectronSelectorTool::m_cutPosition_NSilicon {}

private

The position of the NSilicon cut bit in the AcceptInfo return object.

Definition at line 203 of file AsgElectronSelectorTool.h.

203{};

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

◆ m_doSmoothBinInterpolation

bool AsgElectronSelectorTool::m_doSmoothBinInterpolation {}

private

Definition at line 195 of file AsgElectronSelectorTool.h.

195{};

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

◆ m_layers

std::vector<SelectionLayer> AsgElectronSelectorTool::m_layers

private

Definition at line 199 of file AsgElectronSelectorTool.h.

◆ m_modelFileName

std::string AsgElectronSelectorTool::m_modelFileName

private

The input file name that holds the model.

Definition at line 188 of file AsgElectronSelectorTool.h.

◆ m_quantileFileName

std::string AsgElectronSelectorTool::m_quantileFileName

private

The input file name that holds the QuantileTransformer.

Definition at line 191 of file AsgElectronSelectorTool.h.

◆ m_skipAmbiguityCut

bool AsgElectronSelectorTool::m_skipAmbiguityCut

private

Definition at line 194 of file AsgElectronSelectorTool.h.

◆ m_skipDeltaPoverP

bool AsgElectronSelectorTool::m_skipDeltaPoverP

private

Flag for skip the use of deltaPoverP in dnn calculation (like at HLT).

Definition at line 193 of file AsgElectronSelectorTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

◆ m_workingPoint

std::string AsgElectronSelectorTool::m_workingPoint

private

Working Point.

Definition at line 183 of file AsgElectronSelectorTool.h.

◆ s_fnDiscEtaBins

const unsigned int AsgElectronSelectorTool::s_fnDiscEtaBins = 10

staticprivate

Definition at line 197 of file AsgElectronSelectorTool.h.

◆ s_fnDiscEtBins

const unsigned int AsgElectronSelectorTool::s_fnDiscEtBins = 10

staticprivate

Definition at line 196 of file AsgElectronSelectorTool.h.

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

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ AsgElectronSelectorTool()

◆ ~AsgElectronSelectorTool()

Member Function Documentation

◆ accept() [1/6]

◆ accept() [2/6]

◆ accept() [3/6]

◆ accept() [4/6]

◆ accept() [5/6]

◆ accept() [6/6]

◆ calculate() [1/6]

◆ calculate() [2/6]

◆ calculate() [3/6]

◆ calculate() [4/6]

◆ calculate() [5/6]

◆ calculate() [6/6]

◆ calculateMultipleOutputs()

◆ combineOutputs()

◆ combineOutputsCF()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ getAcceptInfo()

◆ getDiscEtaBin()

◆ getDiscEtBin()

◆ getDiscriminant()

◆ getKey()

◆ getName()

◆ getOperatingPointName()

◆ getProperty()

◆ initialize()

◆ inputHandles()

◆ interpolateCuts()

◆ isForwardElectron()

◆ msg()

◆ msg_level_name()

◆ msgLvl()

◆ outputHandles()

◆ print()

◆ renounce()

◆ renounceArray()

◆ runSelections()

◆ sysInitialize()

◆ sysStart()

◆ transformMLOutput()

◆ updateVHKA()

Member Data Documentation

◆ m_acceptMVA

◆ m_configFile

◆ m_cutPosition_ambiguity

◆ m_cutPosition_kinematic

◆ m_cutPosition_MVA

◆ m_cutPosition_NBlayer

◆ m_cutPosition_NPixel

◆ m_cutPosition_NSilicon

◆ m_detStore

◆ m_doSmoothBinInterpolation

◆ m_evtStore

◆ m_layers

◆ m_modelFileName

◆ m_quantileFileName

◆ m_skipAmbiguityCut

◆ m_skipDeltaPoverP

◆ m_varHandleArraysDeclared

◆ m_vhka

◆ m_workingPoint

◆ s_fnDiscEtaBins