AsgElectronSelectorTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// Dear emacs, this is -*-c++-*-
 
#ifndef __ASGELECTRONSELECTORTOOL__
#define __ASGELECTRONSELECTORTOOL__
#include "TEnv.h"
// This include is needed at the top before any includes regarding Eigen
// since it includes Eigen in a specific way which causes compilation errors
// if not included before Eigen
#include "EventPrimitives/EventPrimitives.h"
 
// Atlas includes
#include "AsgTools/AsgTool.h"
#include "EgammaAnalysisInterfaces/IAsgElectronLikelihoodTool.h"
#include "xAODEgamma/ElectronFwd.h"
#include <Eigen/Dense>
 
class EventContext;
 
class ElectronDNNCalculator;
 
class AsgElectronSelectorTool final : public asg::AsgTool,
                                      virtual public IAsgElectronLikelihoodTool
{
  ASG_TOOL_CLASS2(AsgElectronSelectorTool, IAsgElectronLikelihoodTool, IAsgSelectionTool)
 
public:
  AsgElectronSelectorTool( const std::string& myname );
 

  virtual ~AsgElectronSelectorTool();
public:
 
   struct SelectorOutputs {
 
    std::vector<std::vector<float>> layerOutputs;
    
  };

  virtual StatusCode initialize() override;
 
  // Main methods for IAsgSelectorTool interface
  virtual const asg::AcceptInfo& getAcceptInfo() const override;

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

  asg::AcceptData accept( const EventContext& ctx, const xAOD::Electron* eg ) const override {
    return accept (ctx, eg, -99); // mu = -99 as input will force accept to grab the pileup variable from the xAOD object
  }

  asg::AcceptData accept( const EventContext& ctx, const xAOD::Egamma* eg ) const override {
    return accept (ctx, eg, -99); // mu = -99 as input will force accept to grab the pileup variable from the xAOD object
  }

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

  asg::AcceptData accept( const EventContext& ctx, const xAOD::Egamma* eg, double mu ) const override;
 
  // Main methods for IAsgCalculatorTool interface
public:
  double calculate( const xAOD::IParticle* part ) const;
  double calculate( const EventContext &ctx, const xAOD::IParticle* part ) const override;

  double calculate( const EventContext &ctx, const xAOD::Electron* eg ) const override {
    return calculate (ctx, eg, -99); // mu = -99 as input will force accept to grab the pileup variable from the xAOD object
  }

  double calculate( const EventContext &ctx, const xAOD::Egamma* eg ) const override {
    return calculate (ctx, eg, -99); // mu = -99 as input will force accept to grab the pileup variable from the xAOD object
  }
  
  double calculate( const EventContext &ctx, const xAOD::Electron* eg, double mu ) const override;

  double calculate( const EventContext &ctx, const xAOD::Egamma* eg, double mu ) const override;
  
  SelectorOutputs runSelections(const EventContext &ctx,const xAOD::Electron *eg, double mu) const;
 
  virtual std::vector<float> calculateMultipleOutputs( const EventContext &ctx, const xAOD::Electron *eg, double mu = -99) const override;
  
  std::vector<double> getDiscriminant(const SelectorOutputs& mvaOutputs, const xAOD::Electron* egu ) const;
   
  virtual std::string getOperatingPointName() const override;
 
  // Private methods
private:
  asg::AcceptInfo m_acceptMVA;

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

  double transformMLOutput( float score ) const;

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

  static unsigned int getDiscEtaBin( double eta ) ;

  static unsigned int getDiscEtBin( double et ) ;
 
  // NOTE that this will only perform the cut interpolation up to ~45 GeV, so
  // no smoothing is done above this for the high ET MVA binning yet
  static double interpolateCuts( const std::vector<double>& cuts, double et, double eta ) ;
 
 
 
  // Private member variables
private:
 
    struct SelectionLayer {
    std::string name;             // e.g. "FirstSelection" or "SecondSelection"
    std::string prefix;           // e.g. "" for Layer 0, "SecondSelection." for Layer 1
    
    std::unique_ptr<const ElectronDNNCalculator> m_mvaTool;
        
    std::vector<std::string> m_variables;
    
    std::vector<int> m_enum_variables;
    
    unsigned int m_nOutputs = 0;
    
    bool m_multiClass{};
    bool m_CFReject{};
    bool m_cfSignal{};
    std::vector<double> m_fractions;
    std::vector<int> m_cutAmbiguity;
    std::vector<int> m_cutBL;
    std::vector<int> m_cutPi;
    std::vector<int> m_cutSCT;
    std::vector<double> m_cutSelector;
    std::vector<double> m_cutSelectorCF;
    std::vector<float> m_defaultOutputs;
    
    bool initialize(TEnv& env,
                    const std::string& prefixName,
                    const std::string& layerName,
                    const std::string& m_modelFileName,
                    const std::string& m_quantileFileName,
                    asg::AsgTool* parentTool); 
    std::vector<float> evaluate(const std::vector<double>& inputs) const;  
  };

  std::string m_workingPoint;

  std::string m_configFile;
  std::string m_modelFileName;
    
  std::string m_quantileFileName;
  bool m_skipDeltaPoverP;
  bool m_skipAmbiguityCut;
  bool m_doSmoothBinInterpolation{};
  static const unsigned int s_fnDiscEtBins = 10;
  static const unsigned int s_fnDiscEtaBins = 10;
 
  std::vector<SelectionLayer> m_layers;
  int m_cutPosition_kinematic{};
  int m_cutPosition_NSilicon{};
  int m_cutPosition_NPixel{};
  int m_cutPosition_NBlayer{};
  int m_cutPosition_ambiguity{};
  int m_cutPosition_MVA{};  
 
}; // End: class definition
 
#endif