AsgElectronSelectorTool Class Reference

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:

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.
double	getDiscriminant (std::vector< float > &mvaOutputs, const xAOD::Electron *egu) const
	Computes discrimiant value from mva output based on whether multiclass is true or false.
std::vector< float >	calculateMultipleOutputs (const EventContext &ctx, const xAOD::Electron *eg, double mu=-99) const override
	The result method for multiple outputs: can return multiple outputs of the MVA.
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
	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::unique_ptr< const ElectronDNNCalculator >	m_mvaTool
	Pointer to the class that calculates the MVA score.
std::string	m_modelFileName
	The input file name that holds the model.
std::string	m_quantileFileName
	The input file name that holds the QuantileTransformer.
std::vector< std::string >	m_variables
	Variables used in the MVA Tool.
std::vector< int >	m_enum_variables
	Enum version of used variables.
bool	m_skipDeltaPoverP
	Flag for skip the use of deltaPoverP in dnn calculation (like at HLT)
bool	m_skipAmbiguityCut
bool	m_multiClass {}
	Multiclass model or not.
bool	m_CFReject {}
	Run CF rejection or not.
bool	m_cfSignal {}
	Use the CF output node in the numerator or the denominator.
std::vector< double >	m_fractions
	Fractions to combine the output nodes of a multiclass model into one discriminant.
std::vector< int >	m_cutAmbiguity
	do cut on ambiguity bit
std::vector< int >	m_cutBL
	cut min on b-layer hits
std::vector< int >	m_cutPi
	cut min on pixel hits
std::vector< int >	m_cutSCT
	cut min on precision hits
bool	m_doSmoothBinInterpolation {}
	do smooth interpolation between bins
std::vector< double >	m_cutSelector
	cut on mva output
std::vector< double >	m_cutSelectorCF
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.
std::vector< float >	m_defaultVector
	Default vector to return if calculation fails.
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
	number of discrimintants vs Et
static const unsigned int	s_fnDiscEtaBins = 10
	number of discriminants vs |eta|

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 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

AsgElectronSelectorTool()

AsgElectronSelectorTool::AsgElectronSelectorTool

(

const std::string &

myname

)

Standard constructor.

Definition at line 91 of file AsgElectronSelectorTool.cxx.

                                                                          :
  AsgTool(myname),
  m_configFile{""},
  m_mvaTool(nullptr)
{
 
  // 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 58 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 913 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 53 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 354 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::AuxElement::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
 
  std::vector<float> mvaOutputs = calculateMultipleOutputs(ctx, eg, mu);
  double mvaScore = getDiscriminant(mvaOutputs, eg);
  ATH_MSG_VERBOSE(Form("PassVars: MVA=%8.5f, eta=%8.5f, et=%8.5f, nSiHitsPlusDeadSensors=%i, nHitsPlusPixDeadSensors=%i, passBLayerRequirement=%i, ambiguityBit=%i, mu=%8.5f",
                       mvaScore, eta, et,
                       nSiHitsPlusDeadSensors, nPixHitsPlusDeadSensors,
                       passBLayerRequirement,
                       ambiguityBit, mu));
  double mvaScoreCF = 0;
  if (m_CFReject){
    mvaScoreCF = combineOutputsCF(mvaOutputs);
    ATH_MSG_VERBOSE(Form("PassVars: MVA=%8.5f, eta=%8.5f, et=%8.5f, nSiHitsPlusDeadSensors=%i, nHitsPlusPixDeadSensors=%i, passBLayerRequirement=%i, ambiguityBit=%i, mu=%8.5f",
                        mvaScoreCF, eta, et,
                        nSiHitsPlusDeadSensors, nPixHitsPlusDeadSensors,
                        passBLayerRequirement,
                        ambiguityBit, 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;}
 
  // ambiguity bit
  if (!m_cutAmbiguity.empty()){
    if (!ElectronSelectorHelpers::passAmbiguity((xAOD::AmbiguityTool::AmbiguityType)ambiguityBit, m_cutAmbiguity[etaBin])){
      ATH_MSG_DEBUG("MVA macro: ambiguity Bit Failed.");
      passAmbiguity = false;
    }
  }
 
  // blayer cut
  if (!m_cutBL.empty()) {
    if(m_cutBL[etaBin] == 1 && !passBLayerRequirement){
      ATH_MSG_DEBUG("MVA macro: Blayer cut failed.");
      passNBlayer = false;
    }
  }
  // pixel cut
  if (!m_cutPi.empty()){
    if (nPixHitsPlusDeadSensors < m_cutPi[etaBin]){
      ATH_MSG_DEBUG("MVA macro: Pixels Failed.");
      passNPixel = false;
    }
  }
  // SCT cut
  if (!m_cutSCT.empty()){
    if (nSiHitsPlusDeadSensors < 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 (!m_cutSelectorCF.empty()){
    double cutDiscriminantCF;
    // To protect against a binning mismatch, which should never happen
    if (ibin_combinedMVA >= 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(m_cutSelectorCF, et, eta);
    }
    else{
      cutDiscriminantCF = m_cutSelectorCF.at(ibin_combinedMVA);
    }
    // Determine if the calculated mva score value passes the combined cut
    ATH_MSG_DEBUG("MVA macro: CF Discriminant: ");
    if (mvaScoreCF < cutDiscriminantCF){
      ATH_MSG_DEBUG("MVA macro: CF cut failed.");
      passMVA = false;
    }
  }
 
// (Second) cut on prompt discriminant
  if (!m_cutSelector.empty()){
    double cutDiscriminant;
    // To protect against a binning mismatch, which should never happen
    if (ibin_combinedMVA >= 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(m_cutSelector, et, eta);
    }
    else{
      cutDiscriminant = m_cutSelector.at(ibin_combinedMVA);
    }
    // Determine if the calculated mva score value passes the combined cut
    ATH_MSG_DEBUG("MVA macro: Prompt Discriminant: ");
    if (mvaScore < cutDiscriminant){
      ATH_MSG_DEBUG("MVA macro: Prompt cut failed.");
      passMVA = false;
    }
  }
 
  // 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 879 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 875 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 80 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 928 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 75 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 556 of file AsgElectronSelectorTool.cxx.

{
  // Get all outputs of the mva tool
  std::vector<float> mvaOutputs = calculateMultipleOutputs(ctx, eg, mu);
 
  return getDiscriminant(mvaOutputs, eg);
}

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

Definition at line 894 of file AsgElectronSelectorTool.cxx.

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

calculateMultipleOutputs()

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

overridevirtual

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

Implements IAsgElectronLikelihoodTool.

Definition at line 582 of file AsgElectronSelectorTool.cxx.

{
  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
    return m_defaultVector;
  }
 
  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
    return m_defaultVector;
  }
 
  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
    return m_defaultVector;
  }
 
  const xAOD::TrackParticle* track = eg->trackParticle();
  if (!track){
    ATH_MSG_DEBUG("Failed, no track.");
    // Return a default value
    return m_defaultVector;
  }
 
  // 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 = std::abs(d0 / d0sigma);
 
  const static SG::AuxElement::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 );
  }
 
  std::vector<double> variableValues;
  for(const auto varID : 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;
    }
  }
 
  Eigen::Matrix<float, -1, 1> mvaScores = m_mvaTool->calculate(variableValues);
 
  // Return a vector of all outputs of the MVA
  std::vector<float> mvaOutputs;
  mvaOutputs.reserve(mvaScores.rows());
  for (int i = 0; i < mvaScores.rows(); i++) {
    mvaOutputs.push_back(mvaScores(i, 0));
  }
 
  return mvaOutputs;
}

combineOutputs()

double AsgElectronSelectorTool::combineOutputs ( const std::vector< float > & mvaScores, double eta ) const

private

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

Definition at line 979 of file AsgElectronSelectorTool.cxx.

{
  unsigned int etaBin = getDiscEtaBin(eta);
  double disc = 0;
 
  if (m_cfSignal){
    // Put cf node into numerator
 
    disc = (mvaScores.at(0) * (1 - m_fractions.at(5 * etaBin + 0)) +
            (mvaScores.at(1) * m_fractions.at(5 * etaBin + 0))) /
           ((mvaScores.at(2) * m_fractions.at(5 * etaBin + 1)) +
            (mvaScores.at(3) * m_fractions.at(5 * etaBin + 2)) +
            (mvaScores.at(4) * m_fractions.at(5 * etaBin + 3)) +
            (mvaScores.at(5) * m_fractions.at(5 * etaBin + 4)));
  }
  else{
    // Put cf node in denominator
    disc = mvaScores.at(0) /
           ((mvaScores.at(1) * m_fractions.at(5 * etaBin + 0)) +
            (mvaScores.at(2) * m_fractions.at(5 * etaBin + 1)) +
            (mvaScores.at(3) * m_fractions.at(5 * etaBin + 2)) +
            (mvaScores.at(4) * m_fractions.at(5 * etaBin + 3)) +
            (mvaScores.at(5) * m_fractions.at(5 * etaBin + 4)));
  }
 
  // 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 1008 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.

{ 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 & 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 346 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 1018 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 1029 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()

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

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

Definition at line 564 of file AsgElectronSelectorTool.cxx.

{
  double discriminant = 0;
  // If a binary model is used, vector will have one entry, if multiclass is used vector will have six entries
  if (!m_multiClass){
    discriminant = transformMLOutput(mvaOutputs.at(0));
  }
  else{
    const xAOD::CaloCluster* cluster = eg->caloCluster();
    const float eta = cluster->etaBE(2);
    // combine the six output nodes into one discriminant to cut on, any necessary transformation is applied within combineOutputs()
    discriminant = combineOutputs(mvaOutputs, eta);
  }
 
  return discriminant;
}

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
   }

getOperatingPointName()

std::string AsgElectronSelectorTool::getOperatingPointName ( ) const

overridevirtual

Get the name of the current operating point.

Implements IAsgElectronLikelihoodTool.

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

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

Reimplemented from asg::AsgTool.

Definition at line 122 of file AsgElectronSelectorTool.cxx.

{
  if (!m_workingPoint.empty()){
    m_configFile = AsgConfigHelper::findConfigFile(m_workingPoint, EgammaSelectors::ElectronDNNPointToConfFile);
    ATH_MSG_INFO("operating point : " << this->getOperatingPointName());
  }
 
  if (m_configFile.empty()){
    ATH_MSG_ERROR("Could not find configuration file " << m_configFile);
    return StatusCode::FAILURE;
  }
 
  std::string configFile = PathResolverFindCalibFile(m_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);
 
  std::string modelFilename("");
  std::string quantileFilename("");
 
  // Get the input model in the tool.
  ATH_MSG_DEBUG("Get the input model in the tool.");
 
  if (!m_modelFileName.empty()){  // If the property was set by the user, take that.
    ATH_MSG_INFO("Setting user specified Model file: " << m_modelFileName);
    modelFilename = m_modelFileName;
  }
  else {
    modelFilename = env.GetValue("inputModelFileName", "ElectronPhotonSelectorTools/offline/mc16_20210204/ElectronDNNNetwork.json");
    ATH_MSG_DEBUG("Getting the input Model from: " << modelFilename );
  }
  std::string filename = PathResolverFindCalibFile(modelFilename);
  if (filename.empty()){
    ATH_MSG_ERROR("Could not find model file " << modelFilename);
    return StatusCode::FAILURE;
  }
 
  // Get the input transformer in the tool.
  ATH_MSG_DEBUG("Get the input transformer in the tool.");
 
  if (!m_quantileFileName.empty()){  // If the property was set by the user, take that.
    ATH_MSG_INFO("Setting user specified QuantileTransformer file: " << m_quantileFileName);
    quantileFilename = m_quantileFileName;
  }
  else {
    quantileFilename = env.GetValue("inputQuantileFileName", "ElectronPhotonSelectorTools/offline/mc16_20210204/ElectronDNNQuantileTransformer.root");
    ATH_MSG_DEBUG("Getting the input QuantileTransformer from: " << quantileFilename);
  }
  std::string qfilename = PathResolverFindCalibFile(quantileFilename);
  if (qfilename.empty()){
      ATH_MSG_ERROR("Could not find QuantileTransformer file " << quantileFilename);
      return StatusCode::FAILURE;
  }
 
  // Variables used in the MVA tool as comma separated string;
  std::stringstream vars(env.GetValue("Variables", ""));
  // parse variables string into vector
  while(vars.good()){
    std::string substr;
    std::getline(vars, substr, ',');
    m_variables.push_back( substr );
    if(!AllowedVariables::variableMap.contains(substr)){
      ATH_MSG_ERROR("Unsupported variable " << substr << " found in the config.");
      return StatusCode::FAILURE;
    }
    m_enum_variables.push_back(AllowedVariables::variableMap.at(substr));
  }
 
  // Model is multiclass or not, default is binary model
  m_multiClass = env.GetValue("multiClass", false);
  // Include cf node in numerator or denominator when combining different outputs
  m_cfSignal = env.GetValue("cfSignal", true);
  // Fractions to multiply different outputs with before combining
  m_fractions = AsgConfigHelper::HelperDouble("Fractions", env);
 
  // cut on MVA discriminant
  m_cutSelector = AsgConfigHelper::HelperDouble("CutSelector", env);
  m_cutSelectorCF = AsgConfigHelper::HelperDouble("CutSelectorCF", env);
 
  // cut on ambiguity bit
  m_cutAmbiguity = AsgConfigHelper::HelperInt("CutAmbiguity", env);
  // cut on b-layer
  m_cutBL = AsgConfigHelper::HelperInt("CutBL", env);
  // cut on pixel hits
  m_cutPi = AsgConfigHelper::HelperInt("CutPi", env);
  // cut on precision hits
  m_cutSCT = AsgConfigHelper::HelperInt("CutSCT", env);
  // do smooth interpolation between bins
  m_doSmoothBinInterpolation = env.GetValue("doSmoothBinInterpolation", false);
 
 
 
  unsigned int numberOfExpectedBinCombinedMVA ;
  numberOfExpectedBinCombinedMVA = s_fnDiscEtBins * s_fnDiscEtaBins;
  unsigned int numberOfExpectedEtaBins = s_fnDiscEtBins;
 
  if (m_cutSelector.size() != numberOfExpectedBinCombinedMVA){
    ATH_MSG_ERROR("Configuration issue :  cutSelector expected size " << numberOfExpectedBinCombinedMVA <<
                  " input size " << m_cutSelector.size());
    return StatusCode::FAILURE;
  }
 
  if (!m_cutSelectorCF.empty()){
    m_CFReject = true;
    if (m_cutSelectorCF.size() != numberOfExpectedBinCombinedMVA){
      ATH_MSG_ERROR("Configuration issue :  cutSelectorCF expected size " << numberOfExpectedBinCombinedMVA <<
                    " input size " << m_cutSelectorCF.size());
      return StatusCode::FAILURE;
    }
    if(!m_multiClass){
      ATH_MSG_ERROR("Configuration issue :  CF rejection is only defined "
                    "for multiClass: TRUE");
      return StatusCode::FAILURE;
    }
  }
  else {
    m_CFReject = false;
  }
  // Create an instance of the class calculating the DNN score
  m_mvaTool = std::make_unique<ElectronDNNCalculator>(this, filename.c_str(), qfilename.c_str(), m_variables, m_multiClass);
 
  if (m_multiClass){
    // Fractions are only needed if multiclass model is used
    // There are five fractions for the combination, the signal fraction is either one (cfSignal == false) or 1 - cf fraction (cfSignal == true)
    if (m_fractions.size() != numberOfExpectedEtaBins * 5){
      ATH_MSG_ERROR("Configuration issue : multiclass but not the right amount of fractions." << m_fractions.size());
      return StatusCode::FAILURE;
    }
  }
 
  if (!m_cutSCT.empty()){
    if (m_cutSCT.size() != numberOfExpectedEtaBins){
      ATH_MSG_ERROR("Configuration issue :  cutSCT expected size " << numberOfExpectedEtaBins <<
                    " input size " << m_cutSCT.size());
      return StatusCode::FAILURE;
    }
  }
 
  if (!m_cutPi.empty()){
    if (m_cutPi.size() != numberOfExpectedEtaBins){
      ATH_MSG_ERROR("Configuration issue :  cutPi expected size " << numberOfExpectedEtaBins <<
                    " input size " << m_cutPi.size());
      return StatusCode::FAILURE;
    }
  }
 
  if (!m_cutBL.empty()){
    if (m_cutBL.size() != numberOfExpectedEtaBins){
      ATH_MSG_ERROR("Configuration issue :  cutBL expected size " << numberOfExpectedEtaBins <<
                    " input size " << m_cutBL.size());
      return StatusCode::FAILURE;
    }
  }
 
  if (!m_cutAmbiguity.empty()){
    if (m_cutAmbiguity.size() != numberOfExpectedEtaBins){
      ATH_MSG_ERROR("Configuration issue :  cutAmbiguity expected size " << numberOfExpectedEtaBins <<
                    " input size " << m_cutAmbiguity.size());
      return StatusCode::FAILURE;
    }
  }
 
  // --------------------------------------------------------------------------
  // 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;
  }

 
  // define a default vector to return in the calculateMultipleOutputs methods
  // depending on the number of expected outputs
  if (m_multiClass){
    m_defaultVector = {-999., -999., -999., -999., -999., -999.};
  }
  else{
    m_defaultVector = {-999.};
  }
 
  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 1043 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 941 of file AsgElectronSelectorTool.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_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, 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.

transformMLOutput()

double AsgElectronSelectorTool::transformMLOutput ( float score ) const

private

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

Definition at line 965 of file AsgElectronSelectorTool.cxx.

{
  // returns transformed or non-transformed output
  constexpr double oneOverTau = 1. / 10;
  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 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_acceptMVA

asg::AcceptInfo AsgElectronSelectorTool::m_acceptMVA

private

Accept info.

Definition at line 101 of file AsgElectronSelectorTool.h.

m_CFReject

bool AsgElectronSelectorTool::m_CFReject {}

private

Run CF rejection or not.

Definition at line 158 of file AsgElectronSelectorTool.h.

{};

m_cfSignal

bool AsgElectronSelectorTool::m_cfSignal {}

private

Use the CF output node in the numerator or the denominator.

Definition at line 160 of file AsgElectronSelectorTool.h.

{};

m_configFile

std::string AsgElectronSelectorTool::m_configFile

private

The input config file.

Definition at line 133 of file AsgElectronSelectorTool.h.

m_cutAmbiguity

std::vector<int> AsgElectronSelectorTool::m_cutAmbiguity

private

do cut on ambiguity bit

Definition at line 165 of file AsgElectronSelectorTool.h.

m_cutBL

std::vector<int> AsgElectronSelectorTool::m_cutBL

private

cut min on b-layer hits

Definition at line 167 of file AsgElectronSelectorTool.h.

m_cutPi

std::vector<int> AsgElectronSelectorTool::m_cutPi

private

cut min on pixel hits

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

{};

m_cutPosition_kinematic

int AsgElectronSelectorTool::m_cutPosition_kinematic {}

private

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

Definition at line 180 of file AsgElectronSelectorTool.h.

{};

m_cutPosition_MVA

int AsgElectronSelectorTool::m_cutPosition_MVA {}

private

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

Definition at line 190 of file AsgElectronSelectorTool.h.

{};

m_cutPosition_NBlayer

int AsgElectronSelectorTool::m_cutPosition_NBlayer {}

private

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

Definition at line 186 of file AsgElectronSelectorTool.h.

{};

m_cutPosition_NPixel

int AsgElectronSelectorTool::m_cutPosition_NPixel {}

private

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

Definition at line 184 of file AsgElectronSelectorTool.h.

{};

m_cutPosition_NSilicon

int AsgElectronSelectorTool::m_cutPosition_NSilicon {}

private

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

Definition at line 182 of file AsgElectronSelectorTool.h.

{};

m_cutSCT

std::vector<int> AsgElectronSelectorTool::m_cutSCT

private

cut min on precision hits

Definition at line 171 of file AsgElectronSelectorTool.h.

m_cutSelector

std::vector<double> AsgElectronSelectorTool::m_cutSelector

private

cut on mva output

Definition at line 175 of file AsgElectronSelectorTool.h.

m_cutSelectorCF

std::vector<double> AsgElectronSelectorTool::m_cutSelectorCF

private

Definition at line 176 of file AsgElectronSelectorTool.h.

m_defaultVector

std::vector<float> AsgElectronSelectorTool::m_defaultVector

private

Default vector to return if calculation fails.

Definition at line 193 of file AsgElectronSelectorTool.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_doSmoothBinInterpolation

bool AsgElectronSelectorTool::m_doSmoothBinInterpolation {}

private

do smooth interpolation between bins

Definition at line 173 of file AsgElectronSelectorTool.h.

{};

m_enum_variables

std::vector<int> AsgElectronSelectorTool::m_enum_variables

private

Enum version of used variables.

Definition at line 148 of file AsgElectronSelectorTool.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_fractions

std::vector<double> AsgElectronSelectorTool::m_fractions

private

Fractions to combine the output nodes of a multiclass model into one discriminant.

Definition at line 162 of file AsgElectronSelectorTool.h.

m_modelFileName

std::string AsgElectronSelectorTool::m_modelFileName

private

The input file name that holds the model.

Definition at line 139 of file AsgElectronSelectorTool.h.

m_multiClass

bool AsgElectronSelectorTool::m_multiClass {}

private

Multiclass model or not.

Definition at line 156 of file AsgElectronSelectorTool.h.

{};

m_mvaTool

std::unique_ptr<const ElectronDNNCalculator> AsgElectronSelectorTool::m_mvaTool

private

Pointer to the class that calculates the MVA score.

const for thread safety

Definition at line 136 of file AsgElectronSelectorTool.h.

m_quantileFileName

std::string AsgElectronSelectorTool::m_quantileFileName

private

The input file name that holds the QuantileTransformer.

Definition at line 142 of file AsgElectronSelectorTool.h.

m_skipAmbiguityCut

bool AsgElectronSelectorTool::m_skipAmbiguityCut

private

Definition at line 153 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 151 of file AsgElectronSelectorTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_variables

std::vector<std::string> AsgElectronSelectorTool::m_variables

private

Variables used in the MVA Tool.

Definition at line 145 of file AsgElectronSelectorTool.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 AsgElectronSelectorTool::m_workingPoint

private

Working Point.

Definition at line 130 of file AsgElectronSelectorTool.h.

s_fnDiscEtaBins

const unsigned int AsgElectronSelectorTool::s_fnDiscEtaBins = 10

staticprivate

number of discriminants vs |eta|

Definition at line 198 of file AsgElectronSelectorTool.h.

s_fnDiscEtBins

const unsigned int AsgElectronSelectorTool::s_fnDiscEtBins = 10

staticprivate

number of discrimintants vs Et

Definition at line 196 of file AsgElectronSelectorTool.h.

---

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

• AsgElectronSelectorTool.h
• AsgElectronSelectorTool.cxx