TElectronLikelihoodTool.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 */
 
// Dear emacs, this is -*-c++-*-
 
#ifndef TELECTRONLIKELIHOODTOOL_H
#define TELECTRONLIKELIHOODTOOL_H
 
// Include the return objects and the base class
#include "AsgMessaging/AsgMessaging.h"
#include "AsgTools/IAsgTool.h"
#include "PATCore/AcceptData.h"
#include "PATCore/AcceptInfo.h"
//
#include "SafeTH1.h"
#include <string> // for string
#include <vector> // for vector
class TFile;
 
namespace {
constexpr unsigned int IP_BINS = 1;
}
namespace LikeEnum {
 
struct LHAcceptVars_t
{
  double likelihood;
  double eta;
  double eT;
  int nSiHitsPlusDeadSensors;
  int nPixHitsPlusDeadSensors;
  bool passBLayerRequirement;
  uint8_t ambiguityBit;
  double d0;
  double deltaEta;
  double deltaphires;
  double wstot;
  double EoverP;
  double ip;
};
 
struct LHCalcVars_t
{
  double eta;
  double eT;
  double f3;
  double rHad;
  double rHad1;
  double Reta;
  double w2;
  double f1;
  double eratio;
  double deltaEta;
  double d0;
  double d0sigma;
  double rphi;
  double deltaPoverP;
  double deltaphires;
  double TRT_PID;
  double ip;
};
}
 
namespace Root {
class TElectronLikelihoodTool : public asg::AsgMessaging
{
 
public:
  TElectronLikelihoodTool(const char* name = "TElectronLikelihoodTool");
 
  // Main methods
public:
  StatusCode initialize();
 
  const asg::AcceptInfo& getAcceptInfo() const { return m_acceptInfo; }
 
  asg::AcceptData accept(LikeEnum::LHAcceptVars_t& vars_struct) const;
  asg::AcceptData accept(double likelihood,
                         double eta,
                         double eT,
                         int nSiHitsPlusDeadSensors,
                         int nPixHitsPlusDeadSensors,
                         bool passBLayerRequirement,
                         uint8_t ambiguityBit,
                         double d0,
                         double deltaEta,
                         double deltaphires,
                         double wstot,
                         double EoverP,
                         double ip) const;
  asg::AcceptData accept() const { return asg::AcceptData(&m_acceptInfo); }
 
  double calculate(LikeEnum::LHCalcVars_t& vars_struct) const;
  double calculate(double eta,
                   double eT,
                   double f3,
                   double rHad,
                   double rHad1,
                   double Reta,
                   double w2,
                   double f1,
                   double eratio,
                   double deltaEta,
                   double d0,
                   double d0sigma,
                   double rphi,
                   double deltaPoverP,
                   double deltaphires,
                   double TRT_PID,
                   double ip) const;
 
  inline void setPDFFileName(const std::string& val) { m_pdfFileName = val; }
 
  inline void setVariableNames(const std::string& val)
  {
    m_variableNames = val;
    m_variableBitMask = getLikelihoodBitmask(val);
  }
 
  int loadVarHistograms(const std::string& vstr,
                        TFile* pdfFile,
                        unsigned int varIndex);
 
  inline void setBinning(const std::string& val) { m_ipBinning = val; }
 
  unsigned int getBitmask(void) const { return m_variableBitMask; }
  inline void setBitmask(unsigned int val) { m_variableBitMask = val; };
 
  // Private methods
private:
  // For every input "varVector", make sure elements of vector are
  // in the same order as prescribed in fVariables
 
  double evaluateLikelihood(const std::vector<double>& varVector,
                            double et,
                            double eta,
                            double ip = 0) const;
 
  double evaluateLikelihood(const std::vector<float>& varVector,
                            double et,
                            double eta,
                            double ip = 0) const;
 
  unsigned int getLikelihoodBitmask(const std::string& vars) const;
 
  double InterpolateCuts(const std::vector<double>& cuts,
                         const std::vector<double>& cuts_4gev,
                         double et,
                         double eta) const;
  double InterpolatePdfs(unsigned int s_or_b,
                         unsigned int ipbin,
                         double et,
                         double eta,
                         int bin,
                         unsigned int var) const;
 
public:
  std::vector<int> m_cutBL;
  std::vector<int> m_cutPi;
  std::vector<int> m_cutSi;
  std::vector<double> m_cutA0;
  std::vector<double> m_cutDeltaEta;
  // /** @brief do cut on delta phi bit*/
  std::vector<double> m_cutDeltaPhiRes;
  std::vector<int> m_cutAmbiguity;
  bool m_doRemoveF3AtHighEt;
  bool m_doRemoveTRTPIDAtHighEt;
  bool m_doSmoothBinInterpolation;
  bool m_useOneExtraHighETLHBin;
  double m_highETBinThreshold;
  // /** @brief do cut on wstot above HighETBinThreshold bit*/
  std::vector<double> m_cutWstotAtHighET;
  // /** @brief do cut on EoverP above HighETBinThreshold bit*/
  std::vector<double> m_cutEoverPAtHighET;
  bool m_doPileupTransform;
  bool m_doCentralityTransform;
  std::vector<double> m_cutLikelihood;
  std::vector<double> m_cutLikelihoodPileupCorrection;
  std::vector<double> m_cutLikelihood4GeV;
  std::vector<double> m_cutLikelihoodPileupCorrection4GeV;
  std::vector<double> m_discHardCutForPileupTransform;
  std::vector<double> m_discHardCutSlopeForPileupTransform;
  std::vector<double> m_discHardCutQuadForPileupTransform;
  std::vector<double> m_discLooseForPileupTransform;
  std::vector<double> m_discHardCutForPileupTransform4GeV;
  std::vector<double> m_discHardCutSlopeForPileupTransform4GeV;
  std::vector<double> m_discHardCutQuadForPileupTransform4GeV;
  std::vector<double> m_discLooseForPileupTransform4GeV;
  double m_discMaxForPileupTransform;
  double m_pileupMaxForPileupTransform;
  std::string m_variableNames;
  std::string m_pdfFileName;
 
  // Private methods
private:
  double TransformLikelihoodOutput(double ps,
                                   double pb,
                                   double ip,
                                   double et,
                                   double eta) const;
 
  static unsigned int getLikelihoodEtaBin(double eta) ;
 
  static unsigned int getLikelihoodEtHistBin(double eT) ;
 
  unsigned int getLikelihoodEtDiscBin(double eT, const bool isLHbinning) const;
 
  // Private member variables
private:
  std::string m_name;
 
  asg::AcceptInfo m_acceptInfo;
 
  unsigned int m_variableBitMask;
 
  std::string m_ipBinning;
 
  int m_cutPosition_kinematic;
 
  int m_cutPosition_NSilicon;
 
  int m_cutPosition_NPixel;
 
  int m_cutPosition_NBlayer;
 
  int m_cutPosition_ambiguity;
 
  int m_cutPosition_LH;
 
  int m_cutPositionTrackA0;
 
  int m_cutPositionTrackMatchEta;
 
  int m_cutPositionTrackMatchPhiRes;
 
  int m_cutPositionWstotAtHighET;
 
  int m_cutPositionEoverPAtHighET;
 
  static constexpr double s_fIpBounds[IP_BINS + 1] = { 0., 500. };
 
  // number of hists stored for original LH, including 4GeV bin (for backwards
  // compatibility)
  static constexpr unsigned int s_fnEtBinsHist = 7;
  // number of discs stored for original LH, excluding 4GeV bin (for
  // backwards compatibility)
  static constexpr unsigned int s_fnDiscEtBins = 9;
  // number of discs stored for original LH plus one for
  // HighETBinThreshold (useOneExtraHighETLHBin), excluding 4GeV bin
  static constexpr unsigned int s_fnDiscEtBinsOneExtra = 10;
  static constexpr unsigned int s_fnEtaBins = 10;
  static constexpr unsigned int s_fnVariables = 13;
  // 5D array of ptr to SafeTH1  // [sig(0)/bkg(1)][ip][et][eta][variable]
  EGSelectors::SafeTH1* fPDFbins[2][IP_BINS][s_fnEtBinsHist][s_fnEtaBins]
                                [s_fnVariables]{};
  static const std::string s_fVariables[s_fnVariables];
 
  static unsigned int getIpBin(double ip) ;
  static std::string getBinName(int etbin,
                                int etabin,
                                int ipbin,
                                const std::string& iptype) ;
};
 
} // End: namespace Root
 
#endif