#include <TElectronLikelihoodTool.h>

Inheritance diagram for Root::TElectronLikelihoodTool:

Collaboration diagram for Root::TElectronLikelihoodTool:

Public Member Functions
	TElectronLikelihoodTool (const char *name="TElectronLikelihoodTool")
	Standard constructor. More...

	~TElectronLikelihoodTool ()
	Standard destructor. More...

StatusCode	initialize ()
	Initialize this class. More...

const asg::AcceptInfo &	getAcceptInfo () const
	accesss to the accept info object More...

asg::AcceptData	accept (LikeEnum::LHAcceptVars_t &vars_struct) const
	The main accept method: the actual cuts are applied here. More...

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. More...

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. More...

void	setVariableNames (const std::string &val)
	Define the variable names. More...

int	loadVarHistograms (const std::string &vstr, TFile *pdfFile, unsigned int varIndex)
	Load the variable histograms from the pdf file. More...

void	setBinning (const std::string &val)
	Define the binning. More...

unsigned int	getBitmask (void) const

void	setBitmask (unsigned int val)

void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Public Attributes
std::vector< int >	m_cutBL
	cut min on b-layer hits More...

std::vector< int >	m_cutPi
	cut min on pixel hits More...

std::vector< int >	m_cutSi
	cut min on precision hits More...

std::vector< double >	m_cutA0
	cut max on track d0 bit More...

std::vector< double >	m_cutDeltaEta
	do cut on delta eta bit More...

std::vector< double >	m_cutDeltaPhiRes

std::vector< int >	m_cutAmbiguity
	do cut on ambiguity bit More...

bool	m_doRemoveF3AtHighEt
	do remove f3 variable from likelihood at high Et (>80 GeV) More...

bool	m_doRemoveTRTPIDAtHighEt
	do remove TRTPID variable from likelihood at high Et (>80 GeV) More...

bool	m_doSmoothBinInterpolation
	do smooth interpolation between bins More...

bool	m_useOneExtraHighETLHBin
	use one extra bin for high ET LH More...

double	m_highETBinThreshold
	ET threshold for using high ET cuts and bin. More...

std::vector< double >	m_cutWstotAtHighET

std::vector< double >	m_cutEoverPAtHighET

bool	m_doPileupTransform
	do pileup-dependent transform on discriminant value More...

bool	m_doCentralityTransform
	do centrality-dependent transform on discriminant value More...

std::vector< double >	m_cutLikelihood
	cut on likelihood output More...

std::vector< double >	m_cutLikelihoodPileupCorrection
	pileup correction factor for cut on likelihood output More...

std::vector< double >	m_cutLikelihood4GeV
	cut on likelihood output, 4 GeV bin More...

std::vector< double >	m_cutLikelihoodPileupCorrection4GeV
	pileup correction factor for cut on likelihood output, 4 GeV bin More...

std::vector< double >	m_discHardCutForPileupTransform
	reference disc for very hard cut; used by pileup transform More...

std::vector< double >	m_discHardCutSlopeForPileupTransform
	reference slope on disc for very hard cut; used by pileup transform More...

std::vector< double >	m_discHardCutQuadForPileupTransform
	reference quadratic apr on disc for very hard cut; used by centrality transform More...

std::vector< double >	m_discLooseForPileupTransform
	reference disc for a pileup independent loose menu; used by pileup transform More...

std::vector< double >	m_discHardCutForPileupTransform4GeV
	reference disc for very hard cut; used by pileup transform - 4-7 GeV More...

std::vector< double >	m_discHardCutSlopeForPileupTransform4GeV
	reference slope on disc for very hard cut; used by pileup transform More...

std::vector< double >	m_discHardCutQuadForPileupTransform4GeV
	reference quadratic par on disc for very hard cut; used by centrality transform - 4-7 GeV More...

std::vector< double >	m_discLooseForPileupTransform4GeV
	reference disc for a pileup independent loose menu; used by pileup transform - 4-7 GeV More...

double	m_discMaxForPileupTransform
	max discriminant for which pileup transform is to be used More...

double	m_pileupMaxForPileupTransform
	max nvtx or mu to be used in pileup transform More...

std::string	m_variableNames
	variables to use in the LH More...

std::string	m_pdfFileName
	Name of the pdf file. More...

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. More...

unsigned int	getLikelihoodEtDiscBin (double eT, const bool isLHbinning) const
	Fine Et binning. Used for the likelihood discriminant cuts. More...

void	initMessaging () const
	Initialize our message level and MessageSvc. More...

Static Private Member Functions
static unsigned int	getLikelihoodEtaBin (double eta)
	Eta binning for pdfs and discriminant cuts. More...

static unsigned int	getLikelihoodEtHistBin (double eT)
	Coarse Et binning. Used for the likelihood pdfs. More...

static unsigned int	getIpBin (double ip)

static void	getBinName (char *buffer, int etbin, int etabin, int ipbin, const std::string &iptype)

Private Attributes
std::string	m_name
	tool name More...

asg::AcceptInfo	m_acceptInfo
	Accept info. More...

unsigned int	m_variableBitMask
	The bitmask corresponding to the variables in the likelihood. More...

std::string	m_ipBinning
	Deprecated. More...

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

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

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

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

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

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

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

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

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

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

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

EGSelectors::SafeTH1 *	fPDFbins [2][IP_BINS][s_fnEtBinsHist][s_fnEtaBins][s_fnVariables] {}

std::string	m_nm
	Message source name. More...

boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...

std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...

std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...

std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

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 28 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)
 {
   for (unsigned int varIndex = 0; varIndex < s_fnVariables; varIndex++) {
     for (auto & fPDFbin : fPDFbins) {
       for (auto & ip : fPDFbin) {
         for (unsigned int et = 0; et < s_fnEtBinsHist; et++) {
           for (unsigned int eta = 0; eta < s_fnEtaBins; eta++) {
             ip[et][eta][varIndex] = nullptr;
           }
         }
       }
     }
   }
 }

◆ ~TElectronLikelihoodTool()

Root::TElectronLikelihoodTool::~TElectronLikelihoodTool ( )

Standard destructor.

Definition at line 72 of file TElectronLikelihoodTool.cxx.

 {
   for (unsigned int varIndex = 0; varIndex < s_fnVariables; varIndex++) {
     for (auto & fPDFbin : fPDFbins) {
       for (auto & ip : fPDFbin) {
         for (unsigned int et = 0; et < s_fnEtBinsHist; et++) {
           for (unsigned int eta = 0; eta < s_fnEtaBins; eta++) {
             if (ip[et][eta][varIndex]) {
               delete ip[et][eta][varIndex];
               ip[et][eta][varIndex] = nullptr;
             }
           }
         }
       }
     }
   }
 }

Member Function Documentation

◆ accept() [1/3]

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

inline

Return dummy accept with only info.

Definition at line 113 of file TElectronLikelihoodTool.h.

113 { 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 452 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 487 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 680 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 724 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 770 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 =
         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(fPDFbins[s_or_b][ipbin][etbin][etabin][var]->Integral());
         if (integral == 0) {
           ATH_MSG_WARNING("Error! PDF integral == 0!");
           return -1.35;
         }
  
         prob =
           double(
             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 756 of file TElectronLikelihoodTool.cxx.

 {
   std::vector<double> vec;
   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 95 of file TElectronLikelihoodTool.h.

95 { return m_acceptInfo; }

◆ getBinName()

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

staticprivate

Definition at line 1114 of file TElectronLikelihoodTool.cxx.

 {
   double eta_bounds[9] = { 0.0, 0.6, 0.8, 1.15, 1.37, 1.52, 1.81, 2.01, 2.37 };
   int et_bounds[s_fnEtBinsHist] = { 4, 7, 10, 15, 20, 30, 40 };
   if (!iptype.empty()) {
     snprintf(buffer,
              200,
              "%s%det%02deta%0.2f",
              iptype.c_str(),
              int(s_fIpBounds[ipbin]),
              et_bounds[etbin],
              eta_bounds[etabin]);
   } else {
     snprintf(buffer, 200, "et%deta%0.2f", et_bounds[etbin], eta_bounds[etabin]);
   }
 }

◆ getBitmask()

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

inline

Definition at line 152 of file TElectronLikelihoodTool.h.

152 { return m_variableBitMask; }

◆ getIpBin()

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

staticprivate

Definition at line 1027 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 1136 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 1039 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 1075 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 1055 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 91 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();
   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 1155 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 1223 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(fPDFbins[s_or_b][ipbin][etbin][etabin][var]->Integral());
   double prob =
     double(fPDFbins[s_or_b][ipbin][etbin][etabin][var]->GetBinContent(bin)) /
     integral;
  
   int Nbins = 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 =
         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(fPDFbins[s_or_b][ipbin][etbin + 1][etabin][var]->Integral());
       prob_next =
         double(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 =
       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(fPDFbins[s_or_b][ipbin][etbin - 1][etabin][var]->Integral());
     prob_before =
       double(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 349 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;
           char binname[200];
           getBinName(binname, 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;
           }
  
           char pdfdir[500];
           snprintf(pdfdir, 500, "%s/%s", vstr.c_str(), sig_bkg.c_str());
           char pdf[500];
           snprintf(pdf,
                    500,
                    "%s_%s_smoothed_hist_from_KDE_%s",
                    vstr.c_str(),
                    sig_bkg.c_str(),
                    binname);
           char pdf_newname[500];
           snprintf(pdf_newname,
                    500,
                    "%s_%s_%s_LHtool_copy_%s",
                    m_name.c_str(),
                    vstr.c_str(),
                    sig_bkg.c_str(),
                    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))
                             ->GetListOfKeys()
                             ->Contains(pdf)) {
             getBinName(binname, et_tmp + 1, eta_tmp, ip, m_ipBinning);
             snprintf(pdf,
                      500,
                      "%s_%s_smoothed_hist_from_KDE_%s",
                      vstr.c_str(),
                      sig_bkg.c_str(),
                      binname);
             snprintf(pdf_newname,
                      500,
                      "%s_%s_%s_LHtool_copy4GeV_%s",
                      m_name.c_str(),
                      vstr.c_str(),
                      sig_bkg.c_str(),
                      binname);
           }
           if (((TDirectory*)pdfFile->Get(pdfdir))
                 ->GetListOfKeys()
                 ->Contains(pdf)) {
             TH1F* hist = (TH1F*)(((TDirectory*)pdfFile->Get(pdfdir))->Get(pdf));
             fPDFbins[s_or_b][ip][et][eta][varIndex] =
               new EGSelectors::SafeTH1(hist);
             delete 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 150 of file TElectronLikelihoodTool.h.

150 { m_ipBinning = val; }

◆ setBitmask()

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

inline

Definition at line 153 of file TElectronLikelihoodTool.h.

153 { 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 135 of file TElectronLikelihoodTool.h.

135 { m_pdfFileName = val; }

◆ setVariableNames()

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

inline

Define the variable names.

Definition at line 138 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 868 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 = -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.

◆ fPDFbins

EGSelectors::SafeTH1* Root::TElectronLikelihoodTool::fPDFbins[2][IP_BINS][s_fnEtBinsHist][s_fnEtaBins][s_fnVariables] {}

private

Definition at line 339 of file TElectronLikelihoodTool.h.

◆ m_acceptInfo

asg::AcceptInfo Root::TElectronLikelihoodTool::m_acceptInfo

private

Accept info.

Definition at line 281 of file TElectronLikelihoodTool.h.

◆ m_cutA0

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

cut max on track d0 bit

Definition at line 191 of file TElectronLikelihoodTool.h.

◆ m_cutAmbiguity

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

do cut on ambiguity bit

Definition at line 197 of file TElectronLikelihoodTool.h.

◆ m_cutBL

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

cut min on b-layer hits

Definition at line 185 of file TElectronLikelihoodTool.h.

◆ m_cutDeltaEta

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

do cut on delta eta bit

Definition at line 193 of file TElectronLikelihoodTool.h.

◆ m_cutDeltaPhiRes

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

Definition at line 195 of file TElectronLikelihoodTool.h.

◆ m_cutEoverPAtHighET

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

Definition at line 211 of file TElectronLikelihoodTool.h.

◆ m_cutLikelihood

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

cut on likelihood output

Definition at line 217 of file TElectronLikelihoodTool.h.

◆ m_cutLikelihood4GeV

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

cut on likelihood output, 4 GeV bin

Definition at line 221 of file TElectronLikelihoodTool.h.

◆ m_cutLikelihoodPileupCorrection

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

pileup correction factor for cut on likelihood output

Definition at line 219 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 223 of file TElectronLikelihoodTool.h.

◆ m_cutPi

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

cut min on pixel hits

Definition at line 187 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 303 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 291 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 306 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 300 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 297 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 294 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 323 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 309 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 312 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 315 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 319 of file TElectronLikelihoodTool.h.

◆ m_cutSi

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

cut min on precision hits

Definition at line 189 of file TElectronLikelihoodTool.h.

◆ m_cutWstotAtHighET

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

Definition at line 209 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 225 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 237 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 231 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 243 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 228 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 240 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 234 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 246 of file TElectronLikelihoodTool.h.

◆ m_discMaxForPileupTransform

double Root::TElectronLikelihoodTool::m_discMaxForPileupTransform

max discriminant for which pileup transform is to be used

Definition at line 248 of file TElectronLikelihoodTool.h.

◆ m_doCentralityTransform

bool Root::TElectronLikelihoodTool::m_doCentralityTransform

do centrality-dependent transform on discriminant value

Definition at line 215 of file TElectronLikelihoodTool.h.

◆ m_doPileupTransform

bool Root::TElectronLikelihoodTool::m_doPileupTransform

do pileup-dependent transform on discriminant value

Definition at line 213 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 199 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 201 of file TElectronLikelihoodTool.h.

◆ m_doSmoothBinInterpolation

bool Root::TElectronLikelihoodTool::m_doSmoothBinInterpolation

do smooth interpolation between bins

Definition at line 203 of file TElectronLikelihoodTool.h.

◆ m_highETBinThreshold

double Root::TElectronLikelihoodTool::m_highETBinThreshold

ET threshold for using high ET cuts and bin.

Definition at line 207 of file TElectronLikelihoodTool.h.

◆ m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_ipBinning

std::string Root::TElectronLikelihoodTool::m_ipBinning

private

Deprecated.

Definition at line 288 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.

◆ 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 278 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 254 of file TElectronLikelihoodTool.h.

◆ m_pileupMaxForPileupTransform

double Root::TElectronLikelihoodTool::m_pileupMaxForPileupTransform

max nvtx or mu to be used in pileup transform

Definition at line 250 of file TElectronLikelihoodTool.h.

◆ m_useOneExtraHighETLHBin

bool Root::TElectronLikelihoodTool::m_useOneExtraHighETLHBin

use one extra bin for high ET LH

Definition at line 205 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 285 of file TElectronLikelihoodTool.h.

◆ m_variableNames

std::string Root::TElectronLikelihoodTool::m_variableNames

variables to use in the LH

Definition at line 252 of file TElectronLikelihoodTool.h.

◆ s_fIpBounds

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

staticconstexprprivate

Definition at line 325 of file TElectronLikelihoodTool.h.

◆ s_fnDiscEtBins

constexpr unsigned int Root::TElectronLikelihoodTool::s_fnDiscEtBins = 9

staticconstexprprivate

Definition at line 332 of file TElectronLikelihoodTool.h.

◆ s_fnDiscEtBinsOneExtra

constexpr unsigned int Root::TElectronLikelihoodTool::s_fnDiscEtBinsOneExtra = 10

staticconstexprprivate

Definition at line 335 of file TElectronLikelihoodTool.h.

◆ s_fnEtaBins

constexpr unsigned int Root::TElectronLikelihoodTool::s_fnEtaBins = 10

staticconstexprprivate

Definition at line 336 of file TElectronLikelihoodTool.h.

◆ s_fnEtBinsHist

constexpr unsigned int Root::TElectronLikelihoodTool::s_fnEtBinsHist = 7

staticconstexprprivate

Definition at line 329 of file TElectronLikelihoodTool.h.

◆ s_fnVariables

constexpr unsigned int Root::TElectronLikelihoodTool::s_fnVariables = 13

staticconstexprprivate

Definition at line 337 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 341 of file TElectronLikelihoodTool.h.

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

Public Member Functions

Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TElectronLikelihoodTool()

◆ ~TElectronLikelihoodTool()

Member Function Documentation

◆ accept() [1/3]

◆ accept() [2/3]

◆ accept() [3/3]

◆ calculate() [1/2]

◆ calculate() [2/2]

◆ evaluateLikelihood() [1/2]

◆ evaluateLikelihood() [2/2]

◆ getAcceptInfo()

◆ getBinName()

◆ getBitmask()

◆ getIpBin()

◆ getLikelihoodBitmask()

◆ getLikelihoodEtaBin()

◆ getLikelihoodEtDiscBin()

◆ getLikelihoodEtHistBin()

◆ initialize()

◆ initMessaging()

◆ InterpolateCuts()

◆ InterpolatePdfs()

◆ loadVarHistograms()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ setBinning()

◆ setBitmask()

◆ setLevel()

◆ setPDFFileName()

◆ setVariableNames()

◆ TransformLikelihoodOutput()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ fPDFbins

◆ m_acceptInfo

◆ m_cutA0

◆ m_cutAmbiguity

◆ m_cutBL

◆ m_cutDeltaEta

◆ m_cutDeltaPhiRes

◆ m_cutEoverPAtHighET

◆ m_cutLikelihood

◆ m_cutLikelihood4GeV

◆ m_cutLikelihoodPileupCorrection

◆ m_cutLikelihoodPileupCorrection4GeV

◆ m_cutPi

◆ m_cutPosition_ambiguity

◆ m_cutPosition_kinematic

◆ m_cutPosition_LH

◆ m_cutPosition_NBlayer

◆ m_cutPosition_NPixel

◆ m_cutPosition_NSilicon

◆ m_cutPositionEoverPAtHighET

◆ m_cutPositionTrackA0

◆ m_cutPositionTrackMatchEta

◆ m_cutPositionTrackMatchPhiRes

◆ m_cutPositionWstotAtHighET

◆ m_cutSi

◆ m_cutWstotAtHighET

◆ m_discHardCutForPileupTransform

◆ m_discHardCutForPileupTransform4GeV

◆ m_discHardCutQuadForPileupTransform

◆ m_discHardCutQuadForPileupTransform4GeV

◆ m_discHardCutSlopeForPileupTransform

◆ m_discHardCutSlopeForPileupTransform4GeV

◆ m_discLooseForPileupTransform

◆ m_discLooseForPileupTransform4GeV

◆ m_discMaxForPileupTransform

◆ m_doCentralityTransform

◆ m_doPileupTransform

◆ m_doRemoveF3AtHighEt