AsgElectronChargeIDSelectorTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
// Dear emacs, this is -*-c++-*-
#ifndef __ASGELECTRONCHARGEIDSELECTORTOOL__
#define __ASGELECTRONCHARGEIDSELECTORTOOL__
 
// Atlas includes
#include "AsgDataHandles/ReadHandleKey.h"
#include "AsgTools/AsgTool.h"
#include "EgammaAnalysisInterfaces/IAsgElectronLikelihoodTool.h"
#include "ElectronPhotonSelectorTools/AsgElectronLikelihoodTool.h"
#include "MVAUtils/BDT.h"
#include "PATCore/AcceptData.h"
#include <unordered_map>
 
class AsgElectronChargeIDSelectorTool
  : public asg::AsgTool
  , virtual public IAsgElectronLikelihoodTool
{
  ASG_TOOL_CLASS2(AsgElectronChargeIDSelectorTool,
                  IAsgElectronLikelihoodTool,
                  IAsgSelectionTool)
 
public:
  AsgElectronChargeIDSelectorTool(const std::string& myname);
 
  virtual ~AsgElectronChargeIDSelectorTool();
 
public: // /** Gaudi Service
                                                        // Interface method
                                                        // implementations */
  virtual StatusCode initialize() override; //   virtual StatusCode finalize();
 
  // Main methods for IAsgSelectorTool interface
 
  // virtual const asg::AcceptInfo& getAcceptInfo() const override; KM: inlined
  // blow
 
  virtual asg::AcceptData accept(
    const xAOD::IParticle* part) const override final;
  virtual asg::AcceptData accept(
    const EventContext& ctx,
    const xAOD::IParticle* part) const override final;
 
  virtual asg::AcceptData accept(const EventContext& ctx,
                                 const xAOD::Electron* eg) const override final
  {
    return accept(ctx, eg, -99); // mu = -99 as input will force accept to grab
                                 // the pileup variable from the xAOD object
  }
 
  virtual asg::AcceptData accept(const EventContext& ctx,
                                 const xAOD::Egamma* eg) const override final
  {
    return accept(ctx, eg, -99); // mu = -99 as input will force accept to grab
                                 // the pileup variable from the xAOD object
  }
 
  virtual asg::AcceptData accept(const EventContext& ctx,
                         const xAOD::Electron* eg,
                         double mu) const override final;
 
  virtual asg::AcceptData accept(const EventContext& ctx,
                         const xAOD::Egamma* eg,
                         double mu) const override final;
 
  // Main methods for IAsgCalculatorTool interface
public:
  virtual double calculate(const EventContext& ctx,
                           const xAOD::IParticle* part) const override final;
 
  virtual double calculate(const EventContext& ctx,
                           const xAOD::Electron* eg) const override final
  {
    return calculate(
      ctx, eg, -99); // mu = -99 as input will force accept to grab the pileup
                     // variable from the xAOD object
  }
  virtual double calculate(const EventContext& ctx,
                           const xAOD::Egamma* eg) const override final
  {
    return calculate(
      ctx, eg, -99); // mu = -99 as input will force accept to grab the pileup
                     // variable from the xAOD object
  }
 
  virtual double calculate(const EventContext& ctx,
                           const xAOD::Electron* eg,
                           double mu) const override final;
 
  virtual double calculate(const EventContext& ctx,
                           const xAOD::Egamma* eg,
                           double mu) const override final;
 
  virtual std::vector<float> calculateMultipleOutputs(const EventContext &ctx,
                                                      const xAOD::Electron *eg,
                                                      double mu = -99) const override final
  {
    return {static_cast<float>(calculate(ctx, eg, mu))};
  }
 
  //===========================================================================================
  // same until here
  inline virtual std::string getOperatingPointName() const override final
  {
    return m_WorkingPoint;
  };
 
  inline virtual const asg::AcceptInfo& getAcceptInfo() const override final
  {
    return m_acceptInfo;
  };
 
  // Private methods
private:
  unsigned int getNPrimVertices(const EventContext& ctx) const;
 
  // BDT instances for different ID operating points (Tight, Medium, Loose) and
  // the vector corresponds to n-fold
  std::vector<MVAUtils::BDT*> m_v_bdts;
 
  TString m_pid_name;
  float m_cutOnBDT;
 
  int m_cutPosition_bdt{};
  asg::AcceptInfo m_acceptInfo;
 
  // Private member variables
private:
  std::string m_WorkingPoint;
 
  bool m_usePVCont;
 
  unsigned int m_nPVdefault;
 
  SG::ReadHandleKey<xAOD::VertexContainer> m_primVtxContKey{
    this,
    "primaryVertexContainer",
    "PrimaryVertices",
    "The primary vertex container name"
  };
 
  std::string m_trainingFile;
 
  // BDT input variables
  std::vector<std::string> m_inputVars;
 
}; // End: class definition
 
#endif