TForwardElectronLikelihoodTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TFORWARDELECTRONLIKELIHOODTOOL_H
#define TFORWARDELECTRONLIKELIHOODTOOL_H
 
#include <string> // for string
#include <vector> // for vector
 
// ROOT includes
#include "TFile.h"
#include "TH1.h"
 
// Include the return objects and the base class
//#include "PATCore/TAccept.h"
//#include "PATCore/TResult.h"
#include "PATCore/AcceptData.h"
#include "PATCore/AcceptInfo.h"
//#include "PATCore/TCalculatorToolBase.h"
//#include "PATCore/TSelectorToolBase.h"
#include "AsgMessaging/AsgMessaging.h"
#include "AsgTools/IAsgTool.h"
#include "SafeTH1.h"
#include "memory"
 
namespace {
const unsigned int IP_FBINS = 1;
}
 
namespace LikeEnumForward {
enum Menu
{
  Loose,
  Medium,
  Tight,
  CustomOperatingPoint
};
 
struct LHAcceptVars_t
{
  double likelihood;
  double eta;
  double eT;
  double ip;
};
 
struct LHCalcVars_t
{
  double eta;
  double eT;
  double secondLambda;
  double lateral;
  double longitudinal;
  double fracMax;
  double centerLambda;
  double secondR;
  double secondDensity;
  double significance;
  double ip;
};
 
struct ROOT6_NamespaceAutoloadHook
{};
} // namespace LikeEnumForward
 
namespace Root {
class TForwardElectronLikelihoodTool : public asg::AsgMessaging
{
 
public:
  TForwardElectronLikelihoodTool(
    const char* name = "TForwardElectronLikelihoodTool");
 
public:
  StatusCode initialize();
 
  const asg::AcceptInfo& getAcceptInfo() const { return m_acceptInfo; }
 
  asg::AcceptData accept(LikeEnumForward::LHAcceptVars_t& vars_struct) const;
  asg::AcceptData accept(double likelihood,
                         double eta,
                         double eT,
                         double ip) const;
 
  asg::AcceptData accept() const { return asg::AcceptData(&m_acceptInfo); }
 
  double calculate(LikeEnumForward::LHCalcVars_t& vars_struct) const;
  double calculate(double eta,
                   double eT,
                   double secondLambda,
                   double lateral,
                   double longitudinal,
                   double centerLambda,
                   double fracMax,
                   double secondR,
                   double significance,
                   double secondDensity,
                   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, 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
  // Internal methods to calculate the LH discriminant from a set of variables
  double evaluateLikelihood(std::vector<double>& varVector,
                            double et,
                            double eta,
                            double ip = 0) const;
  double evaluateLikelihood(std::vector<float>& varVector,
                            double et,
                            double eta,
                            double ip = 0) const;
 
  unsigned int getLikelihoodBitmask(const std::string& vars) const;
 
  // PHILIP interpolation is unused
  /* 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; */
 
  // double TransformLikelihoodOutput(double ps, double pb) const;
  // unsigned int getLikelihoodEtaBin(double eta) const;
  // unsigned int getLikelihoodEtBin(double et) const;
  // Pile-up binning
  // unsigned int getIpBin(double ip) const;
  // get the bin names as is in the input file
  // void getBinName(char *buffer, int etbin, int etabin) const;
 
public:
  bool m_doPileupCorrection;
  std::vector<double> m_cutLikelihood;
  std::vector<double> m_cutLikelihoodPileupCorrectionA;
  std::vector<double> m_cutLikelihoodPileupCorrectionB;
  std::string m_variableNames;
  std::string m_pdfFileName;
 
  // Private methods
private:
  double TransformLikelihoodOutput(double ps, double pb) const;
 
  static unsigned int getLikelihoodEtaBin(double eta) ;
 
  static unsigned int getLikelihoodEtHistBin(double eT) ;
 
  // Private member variables
private:
  unsigned int m_variableBitMask;
 
  asg::AcceptInfo m_acceptInfo;
 
  std::string m_ipBinning;
 
  TFile* m_pdfFile{};
 
  int m_cutPosition_kinematicEta;
  int m_cutPosition_kinematicEt;
  int m_cutPosition_LH;
 
  static const double fIpBounds[IP_FBINS + 1];
  static const unsigned int s_fnEtBinsHist =
    4; // number of hists stored for nominal LH
  static const unsigned int s_fnDiscEtBins =
    4; // number of discs stored for original LH
  static const unsigned int s_fnEtaBins = 10;
  static const unsigned int s_fnVariables = 8;
  static const std::string fVariables[s_fnVariables];
  // 5D array of ptr to SafeTH1  // [sig(0)/bkg(1)][ip][et][eta][variable]
  EGSelectors::SafeTH1* fPDFbins[2][IP_FBINS][s_fnEtBinsHist][s_fnEtaBins]
                                [s_fnVariables]{};
 
  static unsigned int getIpBin(double ip) ;
  static std::string getBinName(int etbin,
                                int etabin,
                                int ipbin,
                                const std::string& iptype) ;
};
 
} // namespace Root
 
#endif