Root::TElectronLikelihoodTool Class Reference

#include <TElectronLikelihoodTool.h>

Inheritance diagram for Root::TElectronLikelihoodTool:

Collaboration diagram for Root::TElectronLikelihoodTool:

Public Member Functions
	TElectronLikelihoodTool (const char *name="TElectronLikelihoodTool")
	Standard constructor.
StatusCode	initialize ()
	Initialize this class.
const asg::AcceptInfo &	getAcceptInfo () const
	accesss to the accept info object
asg::AcceptData	accept (LikeEnum::LHAcceptVars_t &vars_struct) const
	The main accept method: the actual cuts are applied here.
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 dummy accept with only info.
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
void	setPDFFileName (const std::string &val)
	Add an input file that holds the PDFs.
void	setVariableNames (const std::string &val)
	Define the variable names.
int	loadVarHistograms (const std::string &vstr, TFile *pdfFile, unsigned int varIndex)
	Load the variable histograms from the pdf file.
void	setBinning (const std::string &val)
	Define the binning.
unsigned int	getBitmask (void) const
void	setBitmask (unsigned int val)
void	setLevel (MSG::Level lvl)
	Change the current logging level.
Functions providing the same interface as AthMessaging
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

Public Attributes
std::vector< int >	m_cutBL
	cut min on b-layer hits
std::vector< int >	m_cutPi
	cut min on pixel hits
std::vector< int >	m_cutSi
	cut min on precision hits
std::vector< double >	m_cutA0
	cut max on track d0 bit
std::vector< double >	m_cutDeltaEta
	do cut on delta eta bit
std::vector< double >	m_cutDeltaPhiRes
	do cut on delta phi bit
std::vector< int >	m_cutAmbiguity
	do cut on ambiguity bit
bool	m_doRemoveF3AtHighEt
	do remove f3 variable from likelihood at high Et (>80 GeV)
bool	m_doRemoveTRTPIDAtHighEt
	do remove TRTPID variable from likelihood at high Et (>80 GeV)
bool	m_doSmoothBinInterpolation
	do smooth interpolation between bins
bool	m_useOneExtraHighETLHBin
	use one extra bin for high ET LH
double	m_highETBinThreshold
	ET threshold for using high ET cuts and bin.
std::vector< double >	m_cutWstotAtHighET
	do cut on wstot above HighETBinThreshold bit
std::vector< double >	m_cutEoverPAtHighET
	do cut on EoverP above HighETBinThreshold bit
bool	m_doPileupTransform
	do pileup-dependent transform on discriminant value
bool	m_doCentralityTransform
	do centrality-dependent transform on discriminant value
std::vector< double >	m_cutLikelihood
	cut on likelihood output
std::vector< double >	m_cutLikelihoodPileupCorrection
	pileup correction factor for cut on likelihood output
std::vector< double >	m_cutLikelihood4GeV
	cut on likelihood output, 4 GeV bin
std::vector< double >	m_cutLikelihoodPileupCorrection4GeV
	pileup correction factor for cut on likelihood output, 4 GeV bin
std::vector< double >	m_discHardCutForPileupTransform
	reference disc for very hard cut; used by pileup transform
std::vector< double >	m_discHardCutSlopeForPileupTransform
	reference slope on disc for very hard cut; used by pileup transform
std::vector< double >	m_discHardCutQuadForPileupTransform
	reference quadratic apr on disc for very hard cut; used by centrality transform
std::vector< double >	m_discLooseForPileupTransform
	reference disc for a pileup independent loose menu; used by pileup transform
std::vector< double >	m_discHardCutForPileupTransform4GeV
	reference disc for very hard cut; used by pileup transform - 4-7 GeV
std::vector< double >	m_discHardCutSlopeForPileupTransform4GeV
	reference slope on disc for very hard cut; used by pileup transform
std::vector< double >	m_discHardCutQuadForPileupTransform4GeV
	reference quadratic par on disc for very hard cut; used by centrality transform - 4-7 GeV
std::vector< double >	m_discLooseForPileupTransform4GeV
	reference disc for a pileup independent loose menu; used by pileup transform - 4-7 GeV
double	m_discMaxForPileupTransform
	max discriminant for which pileup transform is to be used
double	m_pileupMaxForPileupTransform
	max nvtx or mu to be used in pileup transform
std::string	m_variableNames
	variables to use in the LH
std::string	m_pdfFileName
	Name of the pdf file.

Private Member Functions
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
double	TransformLikelihoodOutput (double ps, double pb, double ip, double et, double eta) const
	Apply a transform to zoom into the LH output peaks.
unsigned int	getLikelihoodEtDiscBin (double eT, const bool isLHbinning) const
	Fine Et binning. Used for the likelihood discriminant cuts.
void	initMessaging () const
	Initialize our message level and MessageSvc.

Static Private Member Functions
static unsigned int	getLikelihoodEtaBin (double eta)
	Eta binning for pdfs and discriminant cuts.
static unsigned int	getLikelihoodEtHistBin (double eT)
	Coarse Et binning. Used for the likelihood pdfs.
static unsigned int	getIpBin (double ip)
static std::string	getBinName (int etbin, int etabin, int ipbin, const std::string &iptype)

Private Attributes
std::string	m_name
	tool name
asg::AcceptInfo	m_acceptInfo
	Accept info.
unsigned int	m_variableBitMask
	The bitmask corresponding to the variables in the likelihood.
std::string	m_ipBinning
	Deprecated.
int	m_cutPosition_kinematic
	The position of the kinematic cut bit in the AcceptInfo return object.
int	m_cutPosition_NSilicon
	The position of the NSilicon cut bit in the AcceptInfo return object.
int	m_cutPosition_NPixel
	The position of the NPixel cut bit in the AcceptInfo return object.
int	m_cutPosition_NBlayer
	The position of the NBlayer cut bit in the AcceptInfo return object.
int	m_cutPosition_ambiguity
	The position of the ambiguity cut bit in the AcceptInfo return object.
int	m_cutPosition_LH
	The position of the likelihood cut bit in the AcceptInfo return object.
int	m_cutPositionTrackA0
	The position of the d0 cut bit in the AcceptInfo return object.
int	m_cutPositionTrackMatchEta
	The position of the deltaeta cut bit in the AcceptInfo return object.
int	m_cutPositionTrackMatchPhiRes
	The position of the deltaphi cut bit in the AcceptInfo return object.
int	m_cutPositionWstotAtHighET
	The position of the high ET wstot cut bit in the AcceptInfo return object.
int	m_cutPositionEoverPAtHighET
	The position of the high ET EoverP cut bit in the AcceptInfo return object.
std::unique_ptr< EGSelectors::SafeTH1 >	m_fPDFbins [2][IP_BINS][s_fnEtBinsHist][s_fnEtaBins][s_fnVariables]
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Static Private Attributes
static constexpr double	s_fIpBounds [IP_BINS+1] = { 0., 500. }
static constexpr unsigned int	s_fnEtBinsHist = 7
static constexpr unsigned int	s_fnDiscEtBins = 9
static constexpr unsigned int	s_fnDiscEtBinsOneExtra = 10
static constexpr unsigned int	s_fnEtaBins = 10
static constexpr unsigned int	s_fnVariables = 13
static const std::string	s_fVariables [s_fnVariables]

Detailed Description

Definition at line 78 of file TElectronLikelihoodTool.h.

Constructor & Destructor Documentation

TElectronLikelihoodTool()

Root::TElectronLikelihoodTool::TElectronLikelihoodTool

(

const char *

name = "TElectronLikelihoodTool"

)

Standard constructor.

Author : Kurt Brendlinger kurb@.nosp@m.sas..nosp@m.upenn.nosp@m..edu Please see TElectronLikelihoodTool.h for usage.

Definition at line 27 of file TElectronLikelihoodTool.cxx.

  : asg::AsgMessaging(std::string(name))
  , m_doRemoveF3AtHighEt(false)
  , m_doRemoveTRTPIDAtHighEt(false)
  , m_doSmoothBinInterpolation(false)
  , m_useOneExtraHighETLHBin(false)
  , m_highETBinThreshold(125)
  , m_doPileupTransform(false)
  , m_doCentralityTransform(false)
  , m_discMaxForPileupTransform(2.0)
  , m_pileupMaxForPileupTransform(50)
  , m_variableNames("")
  , m_pdfFileName("")
  , m_name(name)
  , m_variableBitMask(0x0)
  , m_ipBinning("")
  , m_cutPosition_kinematic(-9)
  , m_cutPosition_NSilicon(-9)
  , m_cutPosition_NPixel(-9)
  , m_cutPosition_NBlayer(-9)
  , m_cutPosition_ambiguity(-9)
  , m_cutPosition_LH(-9)
  , m_cutPositionTrackA0(-9)
  , m_cutPositionTrackMatchEta(-9)
  , m_cutPositionTrackMatchPhiRes(-9)
  , m_cutPositionWstotAtHighET(-9)
  , m_cutPositionEoverPAtHighET(-9)
{
}

Member Function Documentation

accept() [1/3]

asg::AcceptData Root::TElectronLikelihoodTool::accept ( ) const

inline

Return dummy accept with only info.

Definition at line 109 of file TElectronLikelihoodTool.h.

{ return asg::AcceptData(&m_acceptInfo); }

accept() [2/3]

asg::AcceptData Root::TElectronLikelihoodTool::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

Definition at line 400 of file TElectronLikelihoodTool.cxx.

{
  LikeEnum::LHAcceptVars_t vars{};
  vars.likelihood = likelihood;
  vars.eta = eta;
  vars.eT = eT;
  vars.nSiHitsPlusDeadSensors = nSiHitsPlusDeadSensors;
  vars.nPixHitsPlusDeadSensors = nPixHitsPlusDeadSensors;
  vars.passBLayerRequirement = passBLayerRequirement;
  vars.ambiguityBit = ambiguityBit;
  vars.d0 = d0;
  vars.deltaEta = deltaEta;
  vars.deltaphires = deltaphires;
  vars.wstot = wstot;
  vars.EoverP = EoverP;
  vars.ip = ip;
 
  return accept(vars);
}

accept() [3/3]

asg::AcceptData Root::TElectronLikelihoodTool::accept

(

LikeEnum::LHAcceptVars_t &

vars_struct

)

const

The main accept method: the actual cuts are applied here.

Definition at line 435 of file TElectronLikelihoodTool.cxx.

{
  // Setup return accept with AcceptInfo
  asg::AcceptData acceptData(&m_acceptInfo);
 
  // Set up the individual cuts
  bool passKine(true);
  bool passNSilicon(true);
  bool passNPixel(true);
  bool passNBlayer(true);
  bool passAmbiguity(true);
  bool passLH(true);
  bool passTrackA0(true);
  bool passDeltaEta(true);
  bool passDeltaPhiRes(true);
  bool passWstotAtHighET(true);
  bool passEoverPAtHighET(true);
 
  if (std::abs(vars_struct.eta) > 2.47) {
    ATH_MSG_DEBUG("This electron is std::abs(eta)>2.47 Returning False.");
    passKine = false;
  }
 
  unsigned int etbinLH = getLikelihoodEtDiscBin(vars_struct.eT, true);
  unsigned int etbinOther = getLikelihoodEtDiscBin(vars_struct.eT, false);
  unsigned int etabin = getLikelihoodEtaBin(vars_struct.eta);
 
  // sanity
  if (etbinLH >= s_fnDiscEtBinsOneExtra) {
    ATH_MSG_WARNING("Cannot evaluate likelihood for Et "
                    << vars_struct.eT << ". Returning false..");
    passKine = false;
  }
  // sanity
  if (etbinOther >= s_fnDiscEtBins) {
    ATH_MSG_WARNING("Cannot evaluate likelihood for Et "
                    << vars_struct.eT << ". Returning false..");
    passKine = false;
  }
 
  // Return if the kinematic requirements are not fulfilled
  acceptData.setCutResult(m_cutPosition_kinematic, passKine);
  if (!passKine) {
    return acceptData;
  }
 
  // ambiguity bit
  if (!m_cutAmbiguity.empty()) {
    if (!ElectronSelectorHelpers::passAmbiguity(
          (xAOD::AmbiguityTool::AmbiguityType)vars_struct.ambiguityBit,
          m_cutAmbiguity[etabin])) {
      ATH_MSG_DEBUG("Likelihood macro: ambiguity Bit Failed.");
      passAmbiguity = false;
    }
  }
 
  // blayer cut
  if (!m_cutBL.empty()) {
    if (m_cutBL[etabin] == 1 && !vars_struct.passBLayerRequirement) {
      ATH_MSG_DEBUG("Likelihood macro: Blayer cut failed.");
      passNBlayer = false;
    }
  }
  // pixel cut
  if (!m_cutPi.empty()) {
    if (vars_struct.nPixHitsPlusDeadSensors < m_cutPi[etabin]) {
      ATH_MSG_DEBUG("Likelihood macro: Pixels Failed.");
      passNPixel = false;
    }
  }
  // silicon cut
  if (!m_cutSi.empty()) {
    if (vars_struct.nSiHitsPlusDeadSensors < m_cutSi[etabin]) {
      ATH_MSG_DEBUG("Likelihood macro: Silicon Failed.");
      passNSilicon = false;
    }
  }
 
  double cutDiscriminant;
  unsigned int ibin_combinedLH =
    etbinLH * s_fnEtaBins + etabin; // Must change if number of eta bins
                                    // changes!. Also starts from 7-10 GeV bin.
  unsigned int ibin_combinedOther =
    etbinOther * s_fnEtaBins +
    etabin; // Must change if number of eta bins changes!. Also
            // starts from 7-10 GeV bin.
 
  if (!m_cutLikelihood.empty()) {
    // To protect against a binning mismatch, which should never happen
    if (ibin_combinedLH >= m_cutLikelihood.size()) {
      ATH_MSG_ERROR("The desired eta/pt bin "
                    << ibin_combinedLH
                    << " is outside of the range specified by the input"
                    << m_cutLikelihood.size() << "This should never happen!");
      return acceptData;
    }
 
    if (m_doSmoothBinInterpolation) {
      cutDiscriminant = InterpolateCuts(
        m_cutLikelihood, m_cutLikelihood4GeV, vars_struct.eT, vars_struct.eta);
      if (!m_doPileupTransform && !m_cutLikelihoodPileupCorrection.empty() &&
          !m_cutLikelihoodPileupCorrection4GeV.empty())
        cutDiscriminant +=
          vars_struct.ip * InterpolateCuts(m_cutLikelihoodPileupCorrection,
                                           m_cutLikelihoodPileupCorrection4GeV,
                                           vars_struct.eT,
                                           vars_struct.eta);
    } else {
      if (vars_struct.eT > 7000. || m_cutLikelihood4GeV.empty()) {
        cutDiscriminant = m_cutLikelihood[ibin_combinedLH];
        // If doPileupTransform, then correct the discriminant itself instead of
        // the cut value
        if (!m_doPileupTransform && !m_cutLikelihoodPileupCorrection.empty()) {
          cutDiscriminant +=
            vars_struct.ip * m_cutLikelihoodPileupCorrection[ibin_combinedLH];
        }
      } else {
        cutDiscriminant = m_cutLikelihood4GeV[etabin];
        if (!m_doPileupTransform &&
            !m_cutLikelihoodPileupCorrection4GeV.empty())
          cutDiscriminant +=
            vars_struct.ip * m_cutLikelihoodPileupCorrection4GeV[etabin];
      }
    }
 
    // Determine if the calculated likelihood value passes the cut
    ATH_MSG_DEBUG("Likelihood macro: Discriminant: ");
    if (vars_struct.likelihood < cutDiscriminant) {
      ATH_MSG_DEBUG("Likelihood macro: Disciminant Cut Failed.");
      passLH = false;
    }
  }
 
  // d0 cut
  if (!m_cutA0.empty()) {
    if (std::abs(vars_struct.d0) > m_cutA0[ibin_combinedOther]) {
      ATH_MSG_DEBUG("Likelihood macro: D0 Failed.");
      passTrackA0 = false;
    }
  }
 
  // deltaEta cut
  if (!m_cutDeltaEta.empty()) {
    if (std::abs(vars_struct.deltaEta) > m_cutDeltaEta[ibin_combinedOther]) {
      ATH_MSG_DEBUG("Likelihood macro: deltaEta Failed.");
      passDeltaEta = false;
    }
  }
 
  // deltaPhiRes cut
  if (!m_cutDeltaPhiRes.empty()) {
    if (std::abs(vars_struct.deltaphires) >
        m_cutDeltaPhiRes[ibin_combinedOther]) {
      ATH_MSG_DEBUG("Likelihood macro: deltaphires Failed.");
      passDeltaPhiRes = false;
    }
  }
 
  // Only do this above HighETBinThreshold [in GeV]
  if (vars_struct.eT > m_highETBinThreshold * 1000) {
    // wstot cut
    if (!m_cutWstotAtHighET.empty()) {
      if (std::abs(vars_struct.wstot) > m_cutWstotAtHighET[etabin]) {
        ATH_MSG_DEBUG("Likelihood macro: wstot Failed.");
        passWstotAtHighET = false;
      }
    }
 
    // EoverP cut
    if (!m_cutEoverPAtHighET.empty()) {
      if (std::abs(vars_struct.EoverP) > m_cutEoverPAtHighET[etabin]) {
        ATH_MSG_DEBUG("Likelihood macro: EoverP Failed.");
        passEoverPAtHighET = false;
      }
    }
  }
 
  // Set the individual cut bits in the return object
  acceptData.setCutResult(m_cutPosition_NSilicon, passNSilicon);
  acceptData.setCutResult(m_cutPosition_NPixel, passNPixel);
  acceptData.setCutResult(m_cutPosition_NBlayer, passNBlayer);
  acceptData.setCutResult(m_cutPosition_ambiguity, passAmbiguity);
  acceptData.setCutResult(m_cutPosition_LH, passLH);
  acceptData.setCutResult(m_cutPositionTrackA0, passTrackA0);
  acceptData.setCutResult(m_cutPositionTrackMatchEta, passDeltaEta);
  acceptData.setCutResult(m_cutPositionTrackMatchPhiRes, passDeltaPhiRes);
  acceptData.setCutResult(m_cutPositionWstotAtHighET, passWstotAtHighET);
  acceptData.setCutResult(m_cutPositionEoverPAtHighET, passEoverPAtHighET);
  return acceptData;
}

calculate() [1/2]

double Root::TElectronLikelihoodTool::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

Definition at line 628 of file TElectronLikelihoodTool.cxx.

{
 
  LikeEnum::LHCalcVars_t vars{};
 
  vars.eta = eta;
  vars.eT = eT;
  vars.f3 = f3;
  vars.rHad = rHad;
  vars.rHad1 = rHad1;
  vars.Reta = Reta;
  vars.w2 = w2;
  vars.f1 = f1;
  vars.eratio = eratio;
  vars.deltaEta = deltaEta;
  vars.d0 = d0;
  vars.d0sigma = d0sigma;
  vars.rphi = rphi;
  vars.deltaPoverP = deltaPoverP;
  vars.deltaphires = deltaphires;
  vars.TRT_PID = TRT_PID;
  vars.ip = ip;
 
  return calculate(vars);
}

calculate() [2/2]

double Root::TElectronLikelihoodTool::calculate

(

LikeEnum::LHCalcVars_t &

vars_struct

)

const

Definition at line 672 of file TElectronLikelihoodTool.cxx.

{
  // Reset the results to defaul values
  double result = -999;
 
  unsigned int etabin = getLikelihoodEtaBin(vars_struct.eta);
  double rhad_corr;
  if (etabin == 3 || etabin == 4) {
    rhad_corr = vars_struct.rHad;
  } else {
    rhad_corr = vars_struct.rHad1;
  }
  double d0significance = vars_struct.d0sigma == 0
                            ? 0.
                            : std::abs(vars_struct.d0) / vars_struct.d0sigma;
 
  std::vector<double> vec = {
    d0significance,     vars_struct.eratio,      vars_struct.deltaEta,
    vars_struct.f1,     vars_struct.f3,          vars_struct.Reta,
    rhad_corr,          vars_struct.rphi,        vars_struct.d0,
    vars_struct.w2,     vars_struct.deltaPoverP, vars_struct.deltaphires,
    vars_struct.TRT_PID
  };
  // Calculate the actual likelihood value and fill the return object
  result = this->evaluateLikelihood(
    vec, vars_struct.eT, vars_struct.eta, vars_struct.ip);
 
  return result;
}

evaluateLikelihood() [1/2]

double Root::TElectronLikelihoodTool::evaluateLikelihood ( const std::vector< double > & varVector, double et, double eta, double ip = 0 ) const

private

Definition at line 719 of file TElectronLikelihoodTool.cxx.

{
 
  const double GeV = 1000;
  unsigned int etbin = getLikelihoodEtHistBin(et); // hist binning
  unsigned int etabin = getLikelihoodEtaBin(eta);
  unsigned int ipbin = getIpBin(ip);
 
  ATH_MSG_DEBUG("et: " << et << " eta: " << eta << " etbin: " << etbin
                       << " etabin: " << etabin);
 
  if (etbin >= s_fnEtBinsHist) {
    ATH_MSG_WARNING("skipping etbin " << etbin << ", et " << et);
    return -999.;
  }
  if (etabin >= s_fnEtaBins) {
    ATH_MSG_WARNING("skipping etabin " << etabin << ", eta " << eta);
    return -999.;
  }
 
  if (varVector.size() != s_fnVariables) {
    ATH_MSG_WARNING("Error! Variable vector size mismatch! Check your vector!");
  }
 
  double SigmaS = 1.;
  double SigmaB = 1.;
 
  // define some string constants
  const std::string TRT_string = "TRT";
  const std::string el_f3_string = "el_f3";
  const std::string el_TRT_PID_string = "el_TRT_PID";
 
  for (unsigned int var = 0; var < s_fnVariables; var++) {
 
    const std::string& varstr = s_fVariables[var];
 
    // Skip variables that are masked off (not used) in the likelihood
    if (!(m_variableBitMask & (0x1 << var))) {
      continue;
    }
    // Don't use TRT for outer eta bins (2.01,2.37)
    if (((etabin == 8) || (etabin == 9)) &&
        (varstr.find(TRT_string) != std::string::npos)) {
      continue;
    }
    // Don't use f3 for outer eta bin (2.37)
    if ((etabin == 9) && (varstr.find(el_f3_string) != std::string::npos)) {
      continue;
    }
    // Don't use f3 for high et (>80 GeV)
    if (m_doRemoveF3AtHighEt && (et > 80 * GeV) &&
        (varstr.find(el_f3_string) != std::string::npos)) {
      continue;
    }
    // Don't use TRTPID for high et (>80 GeV)
    if (m_doRemoveTRTPIDAtHighEt && (et > 80 * GeV) &&
        (varstr.find(el_TRT_PID_string) != std::string::npos)) {
      continue;
    }
    for (unsigned int s_or_b = 0; s_or_b < 2; s_or_b++) {
 
      int bin =
        m_fPDFbins[s_or_b][ipbin][etbin][etabin][var]->FindBin(varVector[var]);
 
      double prob = 0;
      if (m_doSmoothBinInterpolation) {
        prob = InterpolatePdfs(s_or_b, ipbin, et, eta, bin, var);
      } else {
        double integral =
          double(m_fPDFbins[s_or_b][ipbin][etbin][etabin][var]->Integral());
        if (integral == 0) {
          ATH_MSG_WARNING("Error! PDF integral == 0!");
          return -1.35;
        }
 
        prob =
          double(
            m_fPDFbins[s_or_b][ipbin][etbin][etabin][var]->GetBinContent(bin)) /
          integral;
      }
 
      if (s_or_b == 0) {
        SigmaS *= prob;
      } else if (s_or_b == 1) {
        SigmaB *= prob;
      }
    }
  }
 
  return TransformLikelihoodOutput(SigmaS, SigmaB, ip, et, eta);
}

evaluateLikelihood() [2/2]

double Root::TElectronLikelihoodTool::evaluateLikelihood ( const std::vector< float > & varVector, double et, double eta, double ip = 0 ) const

private

Definition at line 704 of file TElectronLikelihoodTool.cxx.

{
  std::vector<double> vec;
  vec.reserve(s_fnVariables);
for (unsigned int var = 0; var < s_fnVariables; var++) {
    vec.push_back(varVector[var]);
  }
  return evaluateLikelihood(vec, et, eta, ip);
}

getAcceptInfo()

const asg::AcceptInfo & Root::TElectronLikelihoodTool::getAcceptInfo ( ) const

inline

accesss to the accept info object

Definition at line 91 of file TElectronLikelihoodTool.h.

{ return m_acceptInfo; }

getBinName()

std::string Root::TElectronLikelihoodTool::getBinName ( int etbin, int etabin, int ipbin, const std::string & iptype )

staticprivate

Definition at line 1063 of file TElectronLikelihoodTool.cxx.

{
  const double eta_bounds[9] = { 0.0, 0.6, 0.8, 1.15, 1.37, 1.52, 1.81, 2.01, 2.37 };
  const int et_bounds[s_fnEtBinsHist] = { 4, 7, 10, 15, 20, 30, 40 };
  if (!iptype.empty()) {
    return std::format("{}{}et{:02}eta{:.2f}",
                       iptype, int(s_fIpBounds[ipbin]),
                       et_bounds[etbin], eta_bounds[etabin]);
  } else {
    return std::format("et{}eta{:.2f}",
                       et_bounds[etbin], eta_bounds[etabin]);
  }
}

getBitmask()

unsigned int Root::TElectronLikelihoodTool::getBitmask ( void ) const

inline

Definition at line 148 of file TElectronLikelihoodTool.h.

{ return m_variableBitMask; }

getIpBin()

unsigned int Root::TElectronLikelihoodTool::getIpBin ( double ip )

staticprivate

Definition at line 976 of file TElectronLikelihoodTool.cxx.

{
  for (unsigned int ipBin = 0; ipBin < IP_BINS; ++ipBin) {
    if (ip < s_fIpBounds[ipBin + 1])
      return ipBin;
  }
  return 0;
}

getLikelihoodBitmask()

unsigned int Root::TElectronLikelihoodTool::getLikelihoodBitmask ( const std::string & vars ) const

private

Definition at line 1081 of file TElectronLikelihoodTool.cxx.

{
  unsigned int mask = 0x0;
  ATH_MSG_DEBUG("Variables to be used: ");
  for (unsigned int var = 0; var < s_fnVariables; var++) {
    if (vars.find(s_fVariables[var]) != std::string::npos) {
      ATH_MSG_DEBUG(s_fVariables[var]);
      mask = mask | 0x1 << var;
    }
  }
  ATH_MSG_DEBUG("mask: " << mask);
  return mask;
}

getLikelihoodEtaBin()

unsigned int Root::TElectronLikelihoodTool::getLikelihoodEtaBin ( double eta )

staticprivate

Eta binning for pdfs and discriminant cuts.

Definition at line 988 of file TElectronLikelihoodTool.cxx.

{
  const unsigned int nEtaBins = s_fnEtaBins;
  const double etaBins[nEtaBins] = { 0.1,  0.6,  0.8,  1.15, 1.37,
                                     1.52, 1.81, 2.01, 2.37, 2.47 };
 
  for (unsigned int etaBin = 0; etaBin < nEtaBins; ++etaBin) {
    if (std::abs(eta) < etaBins[etaBin])
      return etaBin;
  }
 
  return 9;
}

getLikelihoodEtDiscBin()

unsigned int Root::TElectronLikelihoodTool::getLikelihoodEtDiscBin ( double eT, const bool isLHbinning ) const

private

Fine Et binning. Used for the likelihood discriminant cuts.

Definition at line 1024 of file TElectronLikelihoodTool.cxx.

{
  const double GeV = 1000;
 
  if (m_useOneExtraHighETLHBin && isLHbinning) {
    const unsigned int nEtBins = s_fnDiscEtBinsOneExtra;
    const double eTBins[nEtBins] = {
      10 * GeV,  15 * GeV, 20 * GeV,
      25 * GeV,  30 * GeV, 35 * GeV,
      40 * GeV,  45 * GeV, m_highETBinThreshold * GeV,
      6000 * GeV
    };
 
    for (unsigned int eTBin = 0; eTBin < nEtBins; ++eTBin) {
      if (eT < eTBins[eTBin])
        return eTBin;
    }
 
    return nEtBins - 1; // Return the last bin if > the last bin.
  }
 
  const unsigned int nEtBins = s_fnDiscEtBins;
  const double eTBins[nEtBins] = { 10 * GeV, 15 * GeV, 20 * GeV,
                                   25 * GeV, 30 * GeV, 35 * GeV,
                                   40 * GeV, 45 * GeV, 50 * GeV };
 
  for (unsigned int eTBin = 0; eTBin < nEtBins; ++eTBin) {
    if (eT < eTBins[eTBin])
      return eTBin;
  }
 
  return nEtBins - 1; // Return the last bin if > the last bin.
}

getLikelihoodEtHistBin()

unsigned int Root::TElectronLikelihoodTool::getLikelihoodEtHistBin ( double eT )

staticprivate

Coarse Et binning. Used for the likelihood pdfs.

Definition at line 1004 of file TElectronLikelihoodTool.cxx.

{
  const double GeV = 1000;
 
  const unsigned int nEtBins = s_fnEtBinsHist;
  const double eTBins[nEtBins] = { 7 * GeV,  10 * GeV, 15 * GeV, 20 * GeV,
                                   30 * GeV, 40 * GeV, 50 * GeV };
 
  for (unsigned int eTBin = 0; eTBin < nEtBins; ++eTBin) {
    if (eT < eTBins[eTBin]) {
      return eTBin;
    }
  }
 
  return nEtBins - 1; // Return the last bin if > the last bin.
}

initialize()

StatusCode Root::TElectronLikelihoodTool::initialize

(

)

Initialize this class.

Definition at line 58 of file TElectronLikelihoodTool.cxx.

{
  ATH_MSG_DEBUG("TElectronLikelihoodTool initialize.");
 
  // use an int as a StatusCode
  StatusCode sc(StatusCode::SUCCESS);
 
  // Check that all needed variables are setup
  if (m_pdfFileName.empty()) {
    ATH_MSG_WARNING("You need to specify the input PDF file name before you "
                    "call initialize() with "
                    "setPDFFileName('your/file/name.root') ");
    sc = StatusCode::FAILURE;
  }
 
  unsigned int number_of_expected_bin_combinedLH;
  if (m_useOneExtraHighETLHBin)
    number_of_expected_bin_combinedLH = s_fnDiscEtBinsOneExtra * s_fnEtaBins;
  else
    number_of_expected_bin_combinedLH = s_fnDiscEtBins * s_fnEtaBins;
  unsigned int number_of_expected_bin_combinedOther =
    s_fnDiscEtBins * s_fnEtaBins;
 
  if (m_cutLikelihood.size() != number_of_expected_bin_combinedLH) {
    ATH_MSG_ERROR("Configuration issue :  cutLikelihood expected size "
                  << number_of_expected_bin_combinedLH << " input size "
                  << m_cutLikelihood.size());
    sc = StatusCode::FAILURE;
  }
 
  if (!m_discHardCutForPileupTransform.empty()) {
    if (m_discHardCutForPileupTransform.size() !=
        number_of_expected_bin_combinedLH) {
      ATH_MSG_ERROR(
        "Configuration issue :   DiscHardCutForPileupTransform expected size "
        << number_of_expected_bin_combinedLH << " input size "
        << m_discHardCutForPileupTransform.size());
      sc = StatusCode::FAILURE;
    }
  }
  if (!m_discHardCutSlopeForPileupTransform.empty()) {
    if (m_discHardCutSlopeForPileupTransform.size() !=
        number_of_expected_bin_combinedLH) {
      ATH_MSG_ERROR("Configuration issue :   "
                    "DiscHardCutSlopeForPileupTransform expected size "
                    << number_of_expected_bin_combinedLH << " input size "
                    << m_discHardCutSlopeForPileupTransform.size());
      sc = StatusCode::FAILURE;
    }
  }
  if (!m_discLooseForPileupTransform.empty()) {
    if (m_discLooseForPileupTransform.size() !=
        number_of_expected_bin_combinedLH) {
      ATH_MSG_ERROR(
        "Configuration issue :   DiscLooseForPileupTransform expected size "
        << number_of_expected_bin_combinedLH << " input size "
        << m_discLooseForPileupTransform.size());
      sc = StatusCode::FAILURE;
    }
  }
 
  // d0 cut
  if (!m_cutA0.empty()) {
    if (m_cutA0.size() != number_of_expected_bin_combinedOther) {
      ATH_MSG_ERROR("Configuration issue :   CutA0  expected size "
                    << number_of_expected_bin_combinedOther << " input size "
                    << m_cutA0.size());
      sc = StatusCode::FAILURE;
    }
  }
 
  // deltaEta cut
  if (!m_cutDeltaEta.empty()) {
    if (m_cutDeltaEta.size() != number_of_expected_bin_combinedOther) {
      ATH_MSG_ERROR("Configuration issue :  CutDeltaEta  expected size "
                    << number_of_expected_bin_combinedOther << " input size "
                    << m_cutDeltaEta.size());
      sc = StatusCode::FAILURE;
    }
  }
 
  // deltaPhiRes cut
  if (!m_cutDeltaPhiRes.empty()) {
    if (m_cutDeltaPhiRes.size() != number_of_expected_bin_combinedOther) {
      ATH_MSG_ERROR("Configuration issue :  CutDeltaPhiRes  expected size "
                    << number_of_expected_bin_combinedOther << " input size "
                    << m_cutDeltaPhiRes.size());
      sc = StatusCode::FAILURE;
    }
  }
  if (sc == StatusCode::FAILURE) {
    ATH_MSG_ERROR(
      "Could NOT initialize! Please fix the errors mentioned above...");
    return sc;
  }
 
  // --------------------------------------------------------------------------
  // Register the cuts and check that the registration worked:
  // NOTE: THE ORDER IS IMPORTANT!!! Cut0 corresponds to bit 0, Cut1 to bit
  // 1,... Cut position for the kineatic pre-selection
  m_cutPosition_kinematic = m_acceptInfo.addCut("kinematic", "pass kinematic");
  if (m_cutPosition_kinematic < 0) {
    sc = StatusCode::FAILURE;
  }
 
  // NSilicon
  m_cutPosition_NSilicon = m_acceptInfo.addCut("NSilicon", "pass NSilicon");
  if (m_cutPosition_NSilicon < 0) {
    sc = StatusCode::FAILURE;
  }
 
  // NPixel
  m_cutPosition_NPixel = m_acceptInfo.addCut("NPixel", "pass NPixel");
  if (m_cutPosition_NPixel < 0) {
    sc = StatusCode::FAILURE;
  }
 
  // NBlayer
  m_cutPosition_NBlayer = m_acceptInfo.addCut("NBlayer", "pass NBlayer");
  if (m_cutPosition_NBlayer < 0) {
    sc = StatusCode::FAILURE;
  }
 
  // Ambiguity
  m_cutPosition_ambiguity = m_acceptInfo.addCut("ambiguity", "pass ambiguity");
  if (m_cutPosition_ambiguity < 0) {
    sc = StatusCode::FAILURE;
  }
 
  // Cut position for the likelihood selection - DO NOT CHANGE ORDER!
  m_cutPosition_LH = m_acceptInfo.addCut("passLH", "pass Likelihood");
  if (m_cutPosition_LH < 0) {
    sc = StatusCode::FAILURE;
  }
 
  // D0
  m_cutPositionTrackA0 =
    m_acceptInfo.addCut("TrackA0", "A0 (aka d0) wrt beam spot < Cut");
  if (m_cutPositionTrackA0 < 0) {
    sc = StatusCode::FAILURE;
  }
 
  // deltaeta
  m_cutPositionTrackMatchEta = m_acceptInfo.addCut(
    "TrackMatchEta", "Track match deta in 1st sampling < Cut");
  if (m_cutPositionTrackMatchEta < 0) {
    sc = StatusCode::FAILURE;
  }
 
  // deltaphi
  m_cutPositionTrackMatchPhiRes = m_acceptInfo.addCut(
    "TrackMatchPhiRes", "Track match dphi in 2nd sampling, rescaled < Cut");
  if (m_cutPositionTrackMatchPhiRes < 0) {
    sc = StatusCode::FAILURE;
  }
 
  // Wstot
  m_cutPositionWstotAtHighET = m_acceptInfo.addCut(
    "WstotAtHighET", "Above HighETBinThreshold, Wstot < Cut");
  if (m_cutPositionWstotAtHighET < 0) {
    sc = StatusCode::FAILURE;
  }
 
  // EoverP
  m_cutPositionEoverPAtHighET = m_acceptInfo.addCut(
    "EoverPAtHighET", "Above HighETBinThreshold, EoverP < Cut");
  if (m_cutPositionEoverPAtHighET < 0) {
    sc = StatusCode::FAILURE;
  }
 
  // Check that we got everything OK
  if (sc == StatusCode::FAILURE) {
    ATH_MSG_ERROR(
      "! Something went wrong with the setup of the decision objects...");
    return sc;
  }
 
  // ----------------------------------
  // Get the correct bit mask for the current likelihood operating point
  m_variableBitMask = getLikelihoodBitmask(m_variableNames);
 
  //----------File/Histo operation------------------------------------
  // Load the ROOT file containing the PDFs
  TString tmpString(m_pdfFileName);
  gSystem->ExpandPathName(tmpString);
  std::string fname(tmpString.Data());
  auto pdfFile = std::unique_ptr<TFile>(TFile::Open(fname.c_str(), "READ"));
  // Check that we could load the ROOT file
  if (!pdfFile) {
    ATH_MSG_ERROR(" No ROOT file found here: " << m_pdfFileName);
    return StatusCode::FAILURE;
  }
 
  // Load the histograms
  for (unsigned int varIndex = 0; varIndex < s_fnVariables; varIndex++) {
    const std::string& vstr = s_fVariables[varIndex];
    // Skip the loading of PDFs for variables we don't care about for this
    // operating point. If the string is empty (which is true in the default
    // 2012 case), load all of them.
    if (m_variableNames.find(vstr) == std::string::npos &&
        !m_variableNames.empty()) {
      continue;
    }
    loadVarHistograms(vstr, pdfFile.get(), varIndex);
  }
 
  // TFile close does not free the memory
  pdfFile->Close();
  //----------End File/Histo operation------------------------------------
 
  ATH_MSG_DEBUG("Initialization complete for a LH tool with these specs:"
                << "\n - pdfFileName                                  : "
                << m_pdfFileName
                << "\n - Variable bitmask                             : "
                << m_variableBitMask);
 
  ATH_MSG_DEBUG("\n - VariableNames                                : "
                << m_variableNames
                << "\n - (bool)CutBL (yes/no)                         : "
                << (!m_cutBL.empty() ? "yes" : "no")
                << "\n - (bool)CutPi (yes/no)                         : "
                << (!m_cutPi.empty() ? "yes" : "no")
                << "\n - (bool)CutSi (yes/no)                         : "
                << (!m_cutSi.empty() ? "yes" : "no")
                << "\n - (bool)CutAmbiguity (yes/no)                  : "
                << (!m_cutAmbiguity.empty() ? "yes" : "no")
                << "\n - (bool)doRemoveF3AtHighEt (yes/no)            : "
                << (m_doRemoveF3AtHighEt ? "yes" : "no")
                << "\n - (bool)doRemoveTRTPIDAtHighEt (yes/no)        : "
                << (m_doRemoveTRTPIDAtHighEt ? "yes" : "no")
                << "\n - (bool)doSmoothBinInterpolation (yes/no)      : "
                << (m_doSmoothBinInterpolation ? "yes" : "no")
                << "\n - (bool)useOneExtraHighETLHBin(yes/no)         : "
                << (m_useOneExtraHighETLHBin ? "yes" : "no")
                << "\n - (double)HighETBinThreshold                   : "
                << m_highETBinThreshold
                << "\n - (bool)doPileupTransform (yes/no)             : "
                << (m_doPileupTransform ? "yes" : "no")
                << "\n - (bool)doCentralityTransform (yes/no)         : "
                << (m_doCentralityTransform ? "yes" : "no")
                << "\n - (bool)CutLikelihood (yes/no)                 : "
                << (!m_cutLikelihood.empty() ? "yes" : "no")
                << "\n - (bool)CutLikelihoodPileupCorrection (yes/no) : "
                << (!m_cutLikelihoodPileupCorrection.empty() ? "yes" : "no")
                << "\n - (bool)CutA0 (yes/no)                         : "
                << (!m_cutA0.empty() ? "yes" : "no")
                << "\n - (bool)CutDeltaEta (yes/no)                   : "
                << (!m_cutDeltaEta.empty() ? "yes" : "no")
                << "\n - (bool)CutDeltaPhiRes (yes/no)                : "
                << (!m_cutDeltaPhiRes.empty() ? "yes" : "no")
                << "\n - (bool)CutWstotAtHighET (yes/no)              : "
                << (!m_cutWstotAtHighET.empty() ? "yes" : "no")
                << "\n - (bool)CutEoverPAtHighET (yes/no)             : "
                << (!m_cutEoverPAtHighET.empty() ? "yes" : "no"));
  return sc;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

InterpolateCuts()

double Root::TElectronLikelihoodTool::InterpolateCuts ( const std::vector< double > & cuts, const std::vector< double > & cuts_4gev, double et, double eta ) const

private

Definition at line 1100 of file TElectronLikelihoodTool.cxx.

{
 
 
  //get the value of the cut 
  unsigned int etbinLH = getLikelihoodEtDiscBin(et, true);
  unsigned int etabin = getLikelihoodEtaBin(eta);
  unsigned int ibin_combinedLH = etbinLH * s_fnEtaBins + etabin;
  double cut = cuts.at(ibin_combinedLH);
 
  //Special low pt cuts
  if (!cuts_4gev.empty()) {
    if (et < 7000.) {
      cut = cuts_4gev.at(etabin);
    }
    // Below 6 GeV we do not interpolate
    if (et < 6000) {
      return cut;
    }
  } else {// No special low Et cuts
    // and below 8500 we do not interpolate
    if (et < 8500.) {
      return cut;
    }
  }
  // We interpolate until 47500 (last bin)
  // size of array is s_fnDiscEtBins
  if (et > 47500. || !(etbinLH < s_fnDiscEtBins)) {
    return cut;
  }
  // Interpolate
  double bin_width = 5000.;
  if (7000. < et && et < 10000.) {
    bin_width = 3000.;
  }
  if (et < 7000.) {
    bin_width = 2000.;
  }
  const double GeV = 1000;
  const double eTBins[s_fnDiscEtBins] = { 8.5 * GeV,  12.5 * GeV, 17.5 * GeV,
                                          22.5 * GeV, 27.5 * GeV, 32.5 * GeV,
                                          37.5 * GeV, 42.5 * GeV, 47.5 * GeV };
  double bin_center = eTBins[etbinLH];
  if (et > bin_center) {
    double cut_next = cut;
    if (etbinLH + 1 <= 8)
      cut_next = cuts.at((etbinLH + 1) * s_fnEtaBins + etabin);
    return cut + (cut_next - cut) * (et - bin_center) / (bin_width);
  }
  // or else if et < bin_center :
  double cut_before = cut;
  if (etbinLH >= 1) {
    cut_before = cuts.at((etbinLH - 1) * s_fnEtaBins + etabin);
  } else if (etbinLH == 0 && !cuts_4gev.empty()) {
    cut_before = cuts_4gev.at(etabin);
  }
 
  return cut - (cut - cut_before) * (bin_center - et) / (bin_width);
}

InterpolatePdfs()

double Root::TElectronLikelihoodTool::InterpolatePdfs ( unsigned int s_or_b, unsigned int ipbin, double et, double eta, int bin, unsigned int var ) const

private

Definition at line 1168 of file TElectronLikelihoodTool.cxx.

{
  // histograms exist for the following bins: 4, 7, 10, 15, 20, 30, 40.
  // Interpolation between histograms must follow fairly closely the
  // interpolation scheme between cuts - so be careful!
  int etbin = getLikelihoodEtHistBin(et); // hist binning
  int etabin = getLikelihoodEtaBin(eta);
  double integral =
    double(m_fPDFbins[s_or_b][ipbin][etbin][etabin][var]->Integral());
  double prob =
    double(m_fPDFbins[s_or_b][ipbin][etbin][etabin][var]->GetBinContent(bin)) /
    integral;
 
  int Nbins = m_fPDFbins[s_or_b][ipbin][etbin][etabin][var]->GetNbinsX();
  if (et > 42500.) {
    return prob; // interpolation stops here.
  }
  if (et < 6000.) {
    return prob; // interpolation stops here.
  }
  if (22500. < et && et < 27500.) {
    return prob; // region of non-interpolation for pdfs
  }
  if (32500. < et && et < 37500.) {
    return prob; // region of non-interpolation for pdfs
  }
  double bin_width = 5000.;
  if (7000. < et && et < 10000.) {
    bin_width = 3000.;
  }
  if (et < 7000.) {
    bin_width = 2000.;
  }
  const double GeV = 1000;
  const double eTHistBins[s_fnEtBinsHist] = { 6. * GeV,   8.5 * GeV,
                                              12.5 * GeV, 17.5 * GeV,
                                              22.5 * GeV, 32.5 * GeV,
                                              42.5 * GeV };
  double bin_center = eTHistBins[etbin];
  if (etbin == 4 && et >= 27500.) {
    bin_center = 27500.; // special: interpolate starting from 27.5 here
  }
  if (etbin == 5 && et >= 37500.) {
    bin_center = 37500.; // special: interpolate starting from 37.5 here
  }
  if (et > bin_center) {
    double prob_next = prob;
    if (etbin + 1 <= 6) {
      // account for potential histogram bin inequalities
      int NbinsPlus =
        m_fPDFbins[s_or_b][ipbin][etbin + 1][etabin][var]->GetNbinsX();
      int binplus = bin;
      if (Nbins < NbinsPlus) {
        binplus = int(round(bin * (Nbins / NbinsPlus)));
      } else if (Nbins > NbinsPlus) {
        binplus = int(round(bin * (NbinsPlus / Nbins)));
      }
      // do interpolation
      double integral_next =
        double(m_fPDFbins[s_or_b][ipbin][etbin + 1][etabin][var]->Integral());
      prob_next =
        double(m_fPDFbins[s_or_b][ipbin][etbin + 1][etabin][var]->GetBinContent(
          binplus)) /
        integral_next;
      return prob + (prob_next - prob) * (et - bin_center) / (bin_width);
    }
  }
  // or else if et < bin_center :
  double prob_before = prob;
  if (etbin - 1 >= 0) {
    // account for potential histogram bin inequalities
    int NbinsMinus =
      m_fPDFbins[s_or_b][ipbin][etbin - 1][etabin][var]->GetNbinsX();
    int binminus = bin;
    if (Nbins < NbinsMinus) {
      binminus = int(round(bin * (Nbins / NbinsMinus)));
    } else if (Nbins > NbinsMinus) {
      binminus = int(round(bin * (NbinsMinus / Nbins)));
    }
    double integral_before =
      double(m_fPDFbins[s_or_b][ipbin][etbin - 1][etabin][var]->Integral());
    prob_before =
      double(m_fPDFbins[s_or_b][ipbin][etbin - 1][etabin][var]->GetBinContent(
        binminus)) /
      integral_before;
  }
  return prob - (prob - prob_before) * (bin_center - et) / (bin_width);
}

loadVarHistograms()

int Root::TElectronLikelihoodTool::loadVarHistograms	(	const std::string &	vstr,
		TFile *	pdfFile,
		unsigned int	varIndex )

Load the variable histograms from the pdf file.

Definition at line 316 of file TElectronLikelihoodTool.cxx.

{
  for (unsigned int s_or_b = 0; s_or_b < 2; ++s_or_b) {
    for (unsigned int ip = 0; ip < IP_BINS; ++ip) {
      for (unsigned int et = 0; et < s_fnEtBinsHist; ++et) {
        for (unsigned int eta = 0; eta < s_fnEtaBins; ++eta) {
 
          std::string sig_bkg = (s_or_b == 0) ? "sig" : "bkg";
          // Because eta bins in the root file don't match up exactly with cut
          // menu definitions, the second eta bin is an exact copy of the first,
          // and all subsequent eta bins are pushed back by one.
          unsigned int eta_tmp = (eta > 0) ? eta - 1 : eta;
          // The 7-10 GeV, crack bin uses the 10-15 Gev pdfs. WE DO NOT DO THIS
          // ANYMORE! unsigned int et_tmp = (eta == 5 && et == 1) ? 1 : et;
          unsigned int et_tmp = et;
          std::string binname = getBinName(et_tmp, eta_tmp, ip, m_ipBinning);
 
          if (((std::string(binname).find("2.37") != std::string::npos)) &&
              (vstr.find("el_f3") != std::string::npos)) {
            continue;
          }
 
          if (((std::string(binname).find("2.01") != std::string::npos) ||
               (std::string(binname).find("2.37") != std::string::npos)) &&
              (vstr.find("TRT") != std::string::npos)) {
            continue;
          }
 
          const std::string pdfdir = std::format("{}/{}", vstr, sig_bkg);
 
          std::string pdf = std::format("{}_{}_smoothed_hist_from_KDE_{}",
                                        vstr, sig_bkg, binname);
 
          std::string pdf_newname = std::format("{}_{}_{}_LHtool_copy_{}",
                                                m_name, vstr, sig_bkg, binname);
 
          if (!pdfFile->GetListOfKeys()->Contains(vstr.c_str())) {
            ATH_MSG_INFO("Warning: skipping variable "
                         << vstr << " because the folder does not exist.");
            return 1;
          }
          if (!((TDirectory*)pdfFile->Get(vstr.c_str()))
                 ->GetListOfKeys()
                 ->Contains(sig_bkg.c_str())) {
            ATH_MSG_INFO("Warning: skipping variable "
                         << vstr << " because the folder does not exist.");
            return 1;
          }
 
          // If the 0th et bin (4-7 GeV) histogram does not exist in the root
          // file, then just use the 7-10 GeV bin histogram. This should
          // preserve backward compatibility
          if (et == 0 && !((TDirectory*)pdfFile->Get(pdfdir.c_str()))
                            ->GetListOfKeys()
                            ->Contains(pdf.c_str())) {
            binname = getBinName(et_tmp + 1, eta_tmp, ip, m_ipBinning);
 
            pdf = std::format("{}_{}_smoothed_hist_from_KDE_{}",
                              vstr, sig_bkg, binname);
 
            pdf_newname = std::format("{}_{}_{}_LHtool_copy4GeV_{}",
                                      m_name, vstr, sig_bkg, binname);
          }
          if (((TDirectory*)pdfFile->Get(pdfdir.c_str()))
                ->GetListOfKeys()
                ->Contains(pdf.c_str())) {
            TH1F* hist = (TH1F*)(((TDirectory*)pdfFile->Get(pdfdir.c_str()))->Get(pdf.c_str()));
            m_fPDFbins[s_or_b][ip][et][eta][varIndex] =
              std::make_unique<EGSelectors::SafeTH1>(hist);
          } else {
            ATH_MSG_INFO("Warning: Object " << pdf << " does not exist.");
            ATH_MSG_INFO("Skipping all other histograms with this variable.");
            return 1;
          }
        }
      }
    }
  }
  return 1;
}

msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns

A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns

A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns

boolean Indicting if messages at given level will be printed

true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

setBinning()

void Root::TElectronLikelihoodTool::setBinning ( const std::string & val )

inline

Define the binning.

Definition at line 146 of file TElectronLikelihoodTool.h.

{ m_ipBinning = val; }

setBitmask()

void Root::TElectronLikelihoodTool::setBitmask ( unsigned int val )

inline

Definition at line 149 of file TElectronLikelihoodTool.h.

{ m_variableBitMask = val; };

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setPDFFileName()

void Root::TElectronLikelihoodTool::setPDFFileName ( const std::string & val )

inline

Add an input file that holds the PDFs.

Definition at line 131 of file TElectronLikelihoodTool.h.

{ m_pdfFileName = val; }

setVariableNames()

void Root::TElectronLikelihoodTool::setVariableNames ( const std::string & val )

inline

Define the variable names.

Definition at line 134 of file TElectronLikelihoodTool.h.

  {
    m_variableNames = val;
    m_variableBitMask = getLikelihoodBitmask(val);
  }

TransformLikelihoodOutput()

double Root::TElectronLikelihoodTool::TransformLikelihoodOutput ( double ps, double pb, double ip, double et, double eta ) const

private

Apply a transform to zoom into the LH output peaks.

Optionally do pileup correction too

Definition at line 817 of file TElectronLikelihoodTool.cxx.

{
  // returns transformed or non-transformed output
  // (Taken mostly from TMVA likelihood code)
  double fEpsilon = 1e-99;
  // If both signal and bkg are 0, we want it to fail.
  if (ps < fEpsilon)
    ps = 0;
  if (pb < fEpsilon)
    pb = fEpsilon;
  double disc = ps / double(ps + pb);
 
  if (disc >= 1.0) {
    disc = 1. - 1.e-15;
  } else if (disc <= 0.0) {
    disc = fEpsilon;
  }
 
  double tau = 15.0;
  disc = -std::log(1.0 / disc - 1.0) * (1. / double(tau));
 
  // Linearly transform the discriminant as a function of pileup, rather than
  // the old scheme of changing the cut value based on pileup. This is simpler
  // for the tuning, as well as ensuring subsets / making discriminants more
  // transparent. In the HI case, a quadratic centrality transform is applied
  // instead.
  if (m_doPileupTransform) {
 
    // The variables used by the transform:
    //
    // - hard_cut_ref = extremely tight discriminant cut as reference to ensure
    // pileup correction for looser menus is less than for tighter menus.
    // - loose_ref = a loose menu with no pileup correction. Any tighter
    // menu with same inputs will necessarily have pileup dependence built in
    // - disc_max = max disc value for which pileup correction is desired.
    // - pileup_max = max nvtx or mu for calculating the transform. Any larger
    // pileup values will use this maximum value in the transform.
 
    if (m_discHardCutForPileupTransform.empty() ||
        m_discHardCutSlopeForPileupTransform.empty() ||
        m_discLooseForPileupTransform.empty()) {
      ATH_MSG_WARNING(
        "Vectors needed for pileup-dependent transform not correctly filled! "
        "Skipping the transform.");
      return disc;
    }
 
    if (m_doCentralityTransform &&
        m_discHardCutQuadForPileupTransform.empty()) {
      ATH_MSG_WARNING("Vectors needed for centrality-dependent transform not "
                      "correctly filled! "
                      "Skipping the transform.");
      return disc;
    }
 
    unsigned int etabin = getLikelihoodEtaBin(eta);
 
    double disc_hard_cut_ref = 0;
    double disc_hard_cut_ref_slope = 0;
    double disc_hard_cut_ref_quad =
      0; // only used for heavy ion implementation of the LH
    double disc_loose_ref = 0;
    double disc_max = m_discMaxForPileupTransform;
    double pileup_max = m_pileupMaxForPileupTransform;
 
    if (m_doSmoothBinInterpolation) {
      disc_hard_cut_ref = InterpolateCuts(m_discHardCutForPileupTransform,
                                          m_discHardCutForPileupTransform4GeV,
                                          et,
                                          eta);
      disc_hard_cut_ref_slope =
        InterpolateCuts(m_discHardCutSlopeForPileupTransform,
                        m_discHardCutSlopeForPileupTransform4GeV,
                        et,
                        eta);
      if (m_doCentralityTransform)
        disc_hard_cut_ref_quad =
          InterpolateCuts(m_discHardCutQuadForPileupTransform,
                          m_discHardCutQuadForPileupTransform4GeV,
                          et,
                          eta);
      disc_loose_ref = InterpolateCuts(m_discLooseForPileupTransform,
                                       m_discLooseForPileupTransform4GeV,
                                       et,
                                       eta);
    } else {
      // default situation, in the case where 4-7 GeV bin is not defined
      if (et > 7000. || m_discHardCutForPileupTransform4GeV.empty()) {
        unsigned int etfinebinLH = getLikelihoodEtDiscBin(et, true);
        unsigned int ibin_combined = etfinebinLH * s_fnEtaBins + etabin;
        disc_hard_cut_ref = m_discHardCutForPileupTransform[ibin_combined];
        disc_hard_cut_ref_slope =
          m_discHardCutSlopeForPileupTransform[ibin_combined];
        if (m_doCentralityTransform)
          disc_hard_cut_ref_quad =
            m_discHardCutQuadForPileupTransform[ibin_combined];
        disc_loose_ref = m_discLooseForPileupTransform[ibin_combined];
      } else {
        if (m_discHardCutForPileupTransform4GeV.empty() ||
            m_discHardCutSlopeForPileupTransform4GeV.empty() ||
            m_discLooseForPileupTransform4GeV.empty()) {
          ATH_MSG_WARNING("Vectors needed for pileup-dependent transform not "
                          "correctly filled for 4-7 GeV "
                          "bin! Skipping the transform.");
          return disc;
        }
        if (m_doCentralityTransform &&
            m_discHardCutQuadForPileupTransform4GeV.empty()) {
          ATH_MSG_WARNING("Vectors needed for centrality-dependent transform "
                          "not correctly filled for 4-7 "
                          "GeV bin! Skipping the transform.");
          return disc;
        }
        disc_hard_cut_ref = m_discHardCutForPileupTransform4GeV[etabin];
        disc_hard_cut_ref_slope =
          m_discHardCutSlopeForPileupTransform4GeV[etabin];
        if (m_doCentralityTransform)
          disc_hard_cut_ref_quad =
            m_discHardCutQuadForPileupTransform4GeV[etabin];
        disc_loose_ref = m_discLooseForPileupTransform4GeV[etabin];
      }
    }
 
    double ip_for_corr =
      std::min(ip, pileup_max); // turn off correction for values > pileup_max
    double disc_hard_cut_ref_prime =
      disc_hard_cut_ref + disc_hard_cut_ref_slope * ip_for_corr +
      disc_hard_cut_ref_quad * ip_for_corr * ip_for_corr;
 
    if (disc <= disc_loose_ref) {
      // Below threshold for applying pileup correction
    } else if (disc <= disc_hard_cut_ref_prime) {
      // Between the loose and hard cut reference points for pileup correction
      double denom = double(disc_hard_cut_ref_prime - disc_loose_ref);
      if (denom < 0.001)
        denom = 0.001;
      disc = disc_loose_ref + (disc - disc_loose_ref) *
                                (disc_hard_cut_ref - disc_loose_ref) / denom;
    } else if (disc_hard_cut_ref_prime < disc && disc <= disc_max) {
      // Between the hard cut and max reference points for pileup correction
      double denom = double(disc_max - disc_hard_cut_ref_prime);
      if (denom < 0.001)
        denom = 0.001;
      disc = disc_hard_cut_ref + (disc - disc_hard_cut_ref_prime) *
                                   (disc_max - disc_hard_cut_ref) / denom;
    }
  }
 
  ATH_MSG_DEBUG("disc is " << disc);
  return disc;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_acceptInfo

asg::AcceptInfo Root::TElectronLikelihoodTool::m_acceptInfo

private

Accept info.

Definition at line 277 of file TElectronLikelihoodTool.h.

m_cutA0

std::vector<double> Root::TElectronLikelihoodTool::m_cutA0

cut max on track d0 bit

Definition at line 187 of file TElectronLikelihoodTool.h.

m_cutAmbiguity

std::vector<int> Root::TElectronLikelihoodTool::m_cutAmbiguity

do cut on ambiguity bit

Definition at line 193 of file TElectronLikelihoodTool.h.

m_cutBL

std::vector<int> Root::TElectronLikelihoodTool::m_cutBL

cut min on b-layer hits

Definition at line 181 of file TElectronLikelihoodTool.h.

m_cutDeltaEta

std::vector<double> Root::TElectronLikelihoodTool::m_cutDeltaEta

do cut on delta eta bit

Definition at line 189 of file TElectronLikelihoodTool.h.

m_cutDeltaPhiRes

std::vector<double> Root::TElectronLikelihoodTool::m_cutDeltaPhiRes

do cut on delta phi bit

Definition at line 191 of file TElectronLikelihoodTool.h.

m_cutEoverPAtHighET

std::vector<double> Root::TElectronLikelihoodTool::m_cutEoverPAtHighET

do cut on EoverP above HighETBinThreshold bit

Definition at line 207 of file TElectronLikelihoodTool.h.

m_cutLikelihood

std::vector<double> Root::TElectronLikelihoodTool::m_cutLikelihood

cut on likelihood output

Definition at line 213 of file TElectronLikelihoodTool.h.

m_cutLikelihood4GeV

std::vector<double> Root::TElectronLikelihoodTool::m_cutLikelihood4GeV

cut on likelihood output, 4 GeV bin

Definition at line 217 of file TElectronLikelihoodTool.h.

m_cutLikelihoodPileupCorrection

std::vector<double> Root::TElectronLikelihoodTool::m_cutLikelihoodPileupCorrection

pileup correction factor for cut on likelihood output

Definition at line 215 of file TElectronLikelihoodTool.h.

m_cutLikelihoodPileupCorrection4GeV

std::vector<double> Root::TElectronLikelihoodTool::m_cutLikelihoodPileupCorrection4GeV

pileup correction factor for cut on likelihood output, 4 GeV bin

Definition at line 219 of file TElectronLikelihoodTool.h.

m_cutPi

std::vector<int> Root::TElectronLikelihoodTool::m_cutPi

cut min on pixel hits

Definition at line 183 of file TElectronLikelihoodTool.h.

m_cutPosition_ambiguity

int Root::TElectronLikelihoodTool::m_cutPosition_ambiguity

private

The position of the ambiguity cut bit in the AcceptInfo return object.

Definition at line 299 of file TElectronLikelihoodTool.h.

m_cutPosition_kinematic

int Root::TElectronLikelihoodTool::m_cutPosition_kinematic

private

The position of the kinematic cut bit in the AcceptInfo return object.

Definition at line 287 of file TElectronLikelihoodTool.h.

m_cutPosition_LH

int Root::TElectronLikelihoodTool::m_cutPosition_LH

private

The position of the likelihood cut bit in the AcceptInfo return object.

Definition at line 302 of file TElectronLikelihoodTool.h.

m_cutPosition_NBlayer

int Root::TElectronLikelihoodTool::m_cutPosition_NBlayer

private

The position of the NBlayer cut bit in the AcceptInfo return object.

Definition at line 296 of file TElectronLikelihoodTool.h.

m_cutPosition_NPixel

int Root::TElectronLikelihoodTool::m_cutPosition_NPixel

private

The position of the NPixel cut bit in the AcceptInfo return object.

Definition at line 293 of file TElectronLikelihoodTool.h.

m_cutPosition_NSilicon

int Root::TElectronLikelihoodTool::m_cutPosition_NSilicon

private

The position of the NSilicon cut bit in the AcceptInfo return object.

Definition at line 290 of file TElectronLikelihoodTool.h.

m_cutPositionEoverPAtHighET

int Root::TElectronLikelihoodTool::m_cutPositionEoverPAtHighET

private

The position of the high ET EoverP cut bit in the AcceptInfo return object.

Definition at line 319 of file TElectronLikelihoodTool.h.

m_cutPositionTrackA0

int Root::TElectronLikelihoodTool::m_cutPositionTrackA0

private

The position of the d0 cut bit in the AcceptInfo return object.

Definition at line 305 of file TElectronLikelihoodTool.h.

m_cutPositionTrackMatchEta

int Root::TElectronLikelihoodTool::m_cutPositionTrackMatchEta

private

The position of the deltaeta cut bit in the AcceptInfo return object.

Definition at line 308 of file TElectronLikelihoodTool.h.

m_cutPositionTrackMatchPhiRes

int Root::TElectronLikelihoodTool::m_cutPositionTrackMatchPhiRes

private

The position of the deltaphi cut bit in the AcceptInfo return object.

Definition at line 311 of file TElectronLikelihoodTool.h.

m_cutPositionWstotAtHighET

int Root::TElectronLikelihoodTool::m_cutPositionWstotAtHighET

private

The position of the high ET wstot cut bit in the AcceptInfo return object.

Definition at line 315 of file TElectronLikelihoodTool.h.

m_cutSi

std::vector<int> Root::TElectronLikelihoodTool::m_cutSi

cut min on precision hits

Definition at line 185 of file TElectronLikelihoodTool.h.

m_cutWstotAtHighET

std::vector<double> Root::TElectronLikelihoodTool::m_cutWstotAtHighET

do cut on wstot above HighETBinThreshold bit

Definition at line 205 of file TElectronLikelihoodTool.h.

m_discHardCutForPileupTransform

std::vector<double> Root::TElectronLikelihoodTool::m_discHardCutForPileupTransform

reference disc for very hard cut; used by pileup transform

Definition at line 221 of file TElectronLikelihoodTool.h.

m_discHardCutForPileupTransform4GeV

std::vector<double> Root::TElectronLikelihoodTool::m_discHardCutForPileupTransform4GeV

reference disc for very hard cut; used by pileup transform - 4-7 GeV

Definition at line 233 of file TElectronLikelihoodTool.h.

m_discHardCutQuadForPileupTransform

std::vector<double> Root::TElectronLikelihoodTool::m_discHardCutQuadForPileupTransform

reference quadratic apr on disc for very hard cut; used by centrality transform

Definition at line 227 of file TElectronLikelihoodTool.h.

m_discHardCutQuadForPileupTransform4GeV

std::vector<double> Root::TElectronLikelihoodTool::m_discHardCutQuadForPileupTransform4GeV

reference quadratic par on disc for very hard cut; used by centrality transform - 4-7 GeV

Definition at line 239 of file TElectronLikelihoodTool.h.

m_discHardCutSlopeForPileupTransform

std::vector<double> Root::TElectronLikelihoodTool::m_discHardCutSlopeForPileupTransform

reference slope on disc for very hard cut; used by pileup transform

Definition at line 224 of file TElectronLikelihoodTool.h.

m_discHardCutSlopeForPileupTransform4GeV

std::vector<double> Root::TElectronLikelihoodTool::m_discHardCutSlopeForPileupTransform4GeV

reference slope on disc for very hard cut; used by pileup transform

• 4-7 GeV

Definition at line 236 of file TElectronLikelihoodTool.h.

m_discLooseForPileupTransform

std::vector<double> Root::TElectronLikelihoodTool::m_discLooseForPileupTransform

reference disc for a pileup independent loose menu; used by pileup transform

Definition at line 230 of file TElectronLikelihoodTool.h.

m_discLooseForPileupTransform4GeV

std::vector<double> Root::TElectronLikelihoodTool::m_discLooseForPileupTransform4GeV

reference disc for a pileup independent loose menu; used by pileup transform - 4-7 GeV

Definition at line 242 of file TElectronLikelihoodTool.h.

m_discMaxForPileupTransform

double Root::TElectronLikelihoodTool::m_discMaxForPileupTransform

max discriminant for which pileup transform is to be used

Definition at line 244 of file TElectronLikelihoodTool.h.

m_doCentralityTransform

bool Root::TElectronLikelihoodTool::m_doCentralityTransform

do centrality-dependent transform on discriminant value

Definition at line 211 of file TElectronLikelihoodTool.h.

m_doPileupTransform

bool Root::TElectronLikelihoodTool::m_doPileupTransform

do pileup-dependent transform on discriminant value

Definition at line 209 of file TElectronLikelihoodTool.h.

m_doRemoveF3AtHighEt

bool Root::TElectronLikelihoodTool::m_doRemoveF3AtHighEt

do remove f3 variable from likelihood at high Et (>80 GeV)

Definition at line 195 of file TElectronLikelihoodTool.h.

m_doRemoveTRTPIDAtHighEt

bool Root::TElectronLikelihoodTool::m_doRemoveTRTPIDAtHighEt

do remove TRTPID variable from likelihood at high Et (>80 GeV)

Definition at line 197 of file TElectronLikelihoodTool.h.

m_doSmoothBinInterpolation

bool Root::TElectronLikelihoodTool::m_doSmoothBinInterpolation

do smooth interpolation between bins

Definition at line 199 of file TElectronLikelihoodTool.h.

m_fPDFbins

std::unique_ptr<EGSelectors::SafeTH1> Root::TElectronLikelihoodTool::m_fPDFbins[2][IP_BINS][s_fnEtBinsHist][s_fnEtaBins][s_fnVariables]

private

Definition at line 335 of file TElectronLikelihoodTool.h.

m_highETBinThreshold

double Root::TElectronLikelihoodTool::m_highETBinThreshold

ET threshold for using high ET cuts and bin.

Definition at line 203 of file TElectronLikelihoodTool.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_ipBinning

std::string Root::TElectronLikelihoodTool::m_ipBinning

private

Deprecated.

Definition at line 284 of file TElectronLikelihoodTool.h.

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_name

std::string Root::TElectronLikelihoodTool::m_name

private

tool name

Definition at line 274 of file TElectronLikelihoodTool.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_pdfFileName

std::string Root::TElectronLikelihoodTool::m_pdfFileName

Name of the pdf file.

Definition at line 250 of file TElectronLikelihoodTool.h.

m_pileupMaxForPileupTransform

double Root::TElectronLikelihoodTool::m_pileupMaxForPileupTransform

max nvtx or mu to be used in pileup transform

Definition at line 246 of file TElectronLikelihoodTool.h.

m_useOneExtraHighETLHBin

bool Root::TElectronLikelihoodTool::m_useOneExtraHighETLHBin

use one extra bin for high ET LH

Definition at line 201 of file TElectronLikelihoodTool.h.

m_variableBitMask

unsigned int Root::TElectronLikelihoodTool::m_variableBitMask

private

The bitmask corresponding to the variables in the likelihood.

For internal use.

Definition at line 281 of file TElectronLikelihoodTool.h.

m_variableNames

std::string Root::TElectronLikelihoodTool::m_variableNames

variables to use in the LH

Definition at line 248 of file TElectronLikelihoodTool.h.

s_fIpBounds

double Root::TElectronLikelihoodTool::s_fIpBounds[IP_BINS+1] = { 0., 500. }

staticconstexprprivate

Definition at line 321 of file TElectronLikelihoodTool.h.

{ 0., 500. };

s_fnDiscEtBins

unsigned int Root::TElectronLikelihoodTool::s_fnDiscEtBins = 9

staticconstexprprivate

Definition at line 328 of file TElectronLikelihoodTool.h.

s_fnDiscEtBinsOneExtra

unsigned int Root::TElectronLikelihoodTool::s_fnDiscEtBinsOneExtra = 10

staticconstexprprivate

Definition at line 331 of file TElectronLikelihoodTool.h.

s_fnEtaBins

unsigned int Root::TElectronLikelihoodTool::s_fnEtaBins = 10

staticconstexprprivate

Definition at line 332 of file TElectronLikelihoodTool.h.

s_fnEtBinsHist

unsigned int Root::TElectronLikelihoodTool::s_fnEtBinsHist = 7

staticconstexprprivate

Definition at line 325 of file TElectronLikelihoodTool.h.

s_fnVariables

unsigned int Root::TElectronLikelihoodTool::s_fnVariables = 13

staticconstexprprivate

Definition at line 333 of file TElectronLikelihoodTool.h.

s_fVariables

const std::string Root::TElectronLikelihoodTool::s_fVariables

staticprivate

Initial value:

                                                              = {
  "el_d0significance",
  "el_eratio",
  "el_deltaeta1",
  "el_f1",
  "el_f3",
  "el_reta",
  "el_rhad",
  "el_rphi",
  "el_trackd0pvunbiased",
  "el_weta2",
  "el_DeltaPoverP",
  "el_deltaphiRescaled",
  "el_TRT_PID"
}

Definition at line 1265 of file TElectronLikelihoodTool.h.

          {
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 unique_ptr to SafeTH1  // [sig(0)/bkg(1)][ip][et][eta][variable]
  std::unique_ptr<EGSelectors::SafeTH1> m_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

---

The documentation for this class was generated from the following files:

• TElectronLikelihoodTool.h
• TElectronLikelihoodTool.cxx