AsgForwardElectronLikelihoodTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// Dear emacs, this is -*-c++-*-
 
#ifndef __ASGFORWARDELECTRONLIKELIHOODTOOL__
#define __ASGFORWARDELECTRONLIKELIHOODTOOL__
 
// Atlas includes
#include "AsgDataHandles/ReadHandleKey.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"
 
class EventContext;
 
namespace Root {
class TForwardElectronLikelihoodTool;
}
 
class AsgForwardElectronLikelihoodTool
  : public asg::AsgTool
  , virtual public IAsgElectronLikelihoodTool
{
  ASG_TOOL_CLASS2(AsgForwardElectronLikelihoodTool,
                  IAsgElectronLikelihoodTool,
                  IAsgSelectionTool)
 
public:
  AsgForwardElectronLikelihoodTool(const std::string& myname);
 
  virtual ~AsgForwardElectronLikelihoodTool();
 
  virtual StatusCode initialize() override final;
 
  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 xAOD::Electron* eg) const
  {
    return accept(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) 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 xAOD::Egamma* eg) const
  {
    return accept(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 xAOD::Electron* eg, double mu) const;
  asg::AcceptData accept(const EventContext& ctx,
                         const xAOD::Electron* eg,
                         double mu) const override;
 
  asg::AcceptData accept(const xAOD::Egamma* eg, double mu) const;
  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 xAOD::Electron* eg) const
  {
    return calculate(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) 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 xAOD::Egamma* eg) const
  {
    return calculate(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 xAOD::Electron* eg, double mu) const;
  double calculate(const EventContext& ctx,
                   const xAOD::Electron* eg,
                   double mu) const override;
 
  double calculate(const xAOD::Egamma* eg, double mu) const;
  double calculate(const EventContext& ctx,
                   const xAOD::Egamma* eg,
                   double mu) const override;
 
  virtual std::vector<float> calculateMultipleOutputs(const EventContext &ctx,
                                                      const xAOD::Electron *eg,
                                                      double mu = -99) const override
  {
    return {static_cast<float>(calculate(ctx, eg, mu))};
  }
 
  virtual std::string getOperatingPointName() const override;
 
  // Private methods
private:
  unsigned int getNPrimVertices(const EventContext& ctx) const;
 
 
  // Private member variables
private:
  /* The Working Point */
  std::string m_WorkingPoint;
 
  // The input config file.
  std::string m_configFile;
 
  Root::TForwardElectronLikelihoodTool* m_rootForwardTool;
 
  bool m_usePVCont;
 
  unsigned int m_nPVdefault;
 
  SG::ReadHandleKey<xAOD::VertexContainer> m_primVtxContKey{
    this,
    "primaryVertexContainer",
    "PrimaryVertices",
    "The primary vertex container name"
  };
 
  std::string m_pdfFileName;
 
}; // End: class definition
 
#endif