AsgElectronLikelihoodTool.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 __ASGELECTRONLIKELIHOODTOOL__
#define __ASGELECTRONLIKELIHOODTOOL__
 
// Atlas includes
#include "AsgDataHandles/ReadHandleKey.h"
#include "AsgDataHandles/ReadDecorHandleKey.h"
#include "AsgTools/AsgTool.h"
#include "EgammaAnalysisInterfaces/IAsgElectronLikelihoodTool.h"
#include "PATCore/AcceptData.h"
#include "xAODEgamma/ElectronFwd.h"
#include "xAODHIEvent/HIEventShapeContainer.h"
#include "xAODTracking/VertexContainer.h"
#include "xAODEventInfo/EventInfo.h"
 
class EventContext;
 
namespace Root {
class TElectronLikelihoodTool;
}
 
class AsgElectronLikelihoodTool
  : public asg::AsgTool
  , virtual public IAsgElectronLikelihoodTool
{
  ASG_TOOL_CLASS2(AsgElectronLikelihoodTool,
                  IAsgElectronLikelihoodTool,
                  IAsgSelectionTool)
 
public:
  AsgElectronLikelihoodTool(const std::string& myname);

  virtual ~AsgElectronLikelihoodTool();
 
public:
  virtual StatusCode initialize() override;
 
  // Main methods for IAsgSelectorTool interface

  virtual const asg::AcceptInfo& getAcceptInfo() const override;

  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))};
  }

  virtual std::string getOperatingPointName() const override final;
 
  // Private methods
private:
  double getIpVariable(double mu, const EventContext& ctx) const;

  unsigned int getNPrimVertices(const EventContext& ctx) const;

  double getAverageMu(const EventContext& ctx) const;

  double getFcalEt(const EventContext& ctx) const;

  bool isForwardElectron(const xAOD::Egamma* eg, const float eta) const;
 
  // Private member variables
private:
  std::string m_WorkingPoint;
 
  // The input config file.
  std::string m_configFile;

  Root::TElectronLikelihoodTool* m_rootTool;

  bool m_usePVCont;

  unsigned int m_nPVdefault;

  bool m_useCaloSumsCont;

  double m_fcalEtDefault;

  std::string m_pdfFileName;

  bool m_caloOnly = false;

  bool m_skipDeltaPoverP;

  bool m_correctDeltaEta = false;
 
  // Whether to use average mu instead of NPV
  bool m_useAverageMu = false;

  SG::ReadHandleKey<xAOD::HIEventShapeContainer> m_HIESContKey{
    this,
    "CaloSumsContainer",
    "CaloSums",
    "The CaloSums container name"
  };

  SG::ReadHandleKey<xAOD::VertexContainer> m_primVtxContKey{
    this,
    "primaryVertexContainer",
    "PrimaryVertices",
    "The primary vertex container name"
  };

  SG::ReadDecorHandleKey<xAOD::EventInfo> m_avgMuKey {
    this, "averageInteractionsPerCrossingKey",
    "EventInfo.averageInteractionsPerCrossing",
    "Decoration for Average Interaction Per Crossing"
  };
}; // End: class definition
 
#endif