TForwardElectronLikelihoodTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

   details
 
    The forward likelihood ID relies on the following list of topo-cluster
   variables: el_secondLambda : longitudinal second moment el_lateral      :
   normalised lateral moment el_longitudinal : normalised longitudinal moment
    el_centerLambda : shower depth
    el_fracMax      : fraction of cluster energy in the most energetic cell
    el_secondR      : transverse second moment
    el_significance : cluster energy divided by cluster noise
    el_secondDensity: second moment of signal density
 
    Major revision when migrating to rel 21 in August 2018
*/
 
#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;
};
 
} // 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(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;
 
  // 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 unique_ptr to SafeTH1  // [sig(0)/bkg(1)][ip][et][eta][variable]
  std::unique_ptr<EGSelectors::SafeTH1> m_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