AsgElectronSelectorTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
// Dear emacs, this is -*-c++-*-
 
#ifndef __ASGELECTRONSELECTORTOOL__
#define __ASGELECTRONSELECTORTOOL__
 
// 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:
  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;
 
  double getDiscriminant(std::vector<float>& mvaOutputs, const xAOD::Electron* egu ) const;
 
  std::vector<float> calculateMultipleOutputs( const EventContext &ctx, const xAOD::Electron *eg, double mu = -99) const override;
 
  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;
  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:
 
  std::string m_workingPoint;
 
  std::string m_configFile;
 
  std::unique_ptr<const ElectronDNNCalculator> m_mvaTool;
 
  std::string m_modelFileName;
 
  std::string m_quantileFileName;
 
  std::vector<std::string> m_variables;
 
  std::vector<int> m_enum_variables;
 
  bool m_skipDeltaPoverP;
 
  bool m_skipAmbiguityCut;
 
  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;
  bool m_doSmoothBinInterpolation{};
  std::vector<double> m_cutSelector;
  std::vector<double> m_cutSelectorCF;
 
 
  int m_cutPosition_kinematic{};
  int m_cutPosition_NSilicon{};
  int m_cutPosition_NPixel{};
  int m_cutPosition_NBlayer{};
  int m_cutPosition_ambiguity{};
  int m_cutPosition_MVA{};
 
  std::vector<float> m_defaultVector;
 
  static const unsigned int s_fnDiscEtBins = 10;
  static const unsigned int s_fnDiscEtaBins = 10;
 
 
}; // End: class definition
 
#endif