Root::TForwardElectronLikelihoodTool Class Reference

#include <TForwardElectronLikelihoodTool.h>

Inheritance diagram for Root::TForwardElectronLikelihoodTool:

Collaboration diagram for Root::TForwardElectronLikelihoodTool:

Public Member Functions
	TForwardElectronLikelihoodTool (const char *name="TForwardElectronLikelihoodTool")
	Standard constructor.
StatusCode	initialize ()
	Initialize this class.
const asg::AcceptInfo &	getAcceptInfo () const
	accesss to the accept info object
asg::AcceptData	accept (LikeEnumForward::LHAcceptVars_t &vars_struct) const
	The main accept method: the actual cuts are applied here.
asg::AcceptData	accept (double likelihood, double eta, double eT, double ip) const
asg::AcceptData	accept () const
	Return dummy accept with only info.
double	calculate (LikeEnumForward::LHCalcVars_t &vars_struct) const
double	calculate (double eta, double eT, double secondLambda, double lateral, double longitudinal, double centerLambda, double fracMax, double secondR, double significance, double secondDensity, double ip) const
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, 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
bool	m_doPileupCorrection
	Apply a transform to zoom into the LH output peaks.
std::vector< double >	m_cutLikelihood
	cut on likelihood output
std::vector< double >	m_cutLikelihoodPileupCorrectionA
	the cut on the PU discriminant is adjusted as a function of nVtx cut + nVtx*cutA + cutB this is different from the procedure for central electrons
std::vector< double >	m_cutLikelihoodPileupCorrectionB
	pileup constant factor for cut on likelihood output
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
	Mask out the variables ,out of all possible ones, that are not employed in the current configuration as read from the input config file.
double	TransformLikelihoodOutput (double ps, double pb) const
	Apply a transform to zoom into the LH output peaks.
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 and discriminant pdfs.
static unsigned int	getIpBin (double ip)
static std::string	getBinName (int etbin, int etabin, int ipbin, const std::string &iptype)

Private Attributes
unsigned int	m_variableBitMask
	The bitmask corresponding to the variables in the likelihood.
asg::AcceptInfo	m_acceptInfo
	Accept info.
std::string	m_ipBinning
	Deprecated.
TFile *	m_pdfFile {}
	Pointer to the opened TFile that holds the PDFs.
int	m_cutPosition_kinematicEta
	The position of the kinematic cuts bit in the AcceptInfo return object, separate for eta/Et.
int	m_cutPosition_kinematicEt
int	m_cutPosition_LH
	The position of the likelihood cut bit in the AcceptInfo return object.
std::unique_ptr< EGSelectors::SafeTH1 >	m_fPDFbins [2][IP_FBINS][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 const double	fIpBounds [IP_FBINS+1]
static const unsigned int	s_fnEtBinsHist
static const unsigned int	s_fnDiscEtBins
static const unsigned int	s_fnEtaBins = 10
static const unsigned int	s_fnVariables = 8
static const std::string	fVariables [s_fnVariables]

Detailed Description

Definition at line 86 of file TForwardElectronLikelihoodTool.h.

Constructor & Destructor Documentation

TForwardElectronLikelihoodTool()

Root::TForwardElectronLikelihoodTool::TForwardElectronLikelihoodTool

(

const char *

name = "TForwardElectronLikelihoodTool"

)

Standard constructor.

Definition at line 22 of file TForwardElectronLikelihoodTool.cxx.

  : asg::AsgMessaging(std::string(name))
  , m_doPileupCorrection(false)
  , m_variableNames("")
  , m_pdfFileName("")
  , m_variableBitMask(0x0)
  , m_cutPosition_kinematicEta(-9)
  , m_cutPosition_kinematicEt(-9)
  , m_cutPosition_LH(-9)
{
}

Member Function Documentation

accept() [1/3]

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

inline

Return dummy accept with only info.

Definition at line 109 of file TForwardElectronLikelihoodTool.h.

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

accept() [2/3]

asg::AcceptData Root::TForwardElectronLikelihoodTool::accept	(	double	likelihood,
		double	eta,
		double	eT,
		double	ip ) const

Definition at line 192 of file TForwardElectronLikelihoodTool.cxx.

{
  LikeEnumForward::LHAcceptVars_t vars{};
 
  vars.likelihood = likelihood;
  vars.eta = eta;
  vars.eT = eT;
  vars.ip = ip;
 
  return accept(vars);
}

accept() [3/3]

asg::AcceptData Root::TForwardElectronLikelihoodTool::accept

(

LikeEnumForward::LHAcceptVars_t &

vars_struct

)

const

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

Definition at line 210 of file TForwardElectronLikelihoodTool.cxx.

{
  // Setup return accept with AcceptInfo
  asg::AcceptData acceptData(&m_acceptInfo);
 
  // Set up the individual cuts
  bool passKineEta(true);
  bool passKineEt(true);
  bool passLH(true);
 
  if (std::fabs(vars_struct.eta) < 2.5) {
    ATH_MSG_DEBUG("This forward electron has"
                  << vars_struct.eta
                  << ", which is fabs(eta)<2.5 Returning False.");
    passKineEta = false;
  }
  // Return if the kinematic requirements are not fulfilled
  acceptData.setCutResult(m_cutPosition_kinematicEta, passKineEta);
  if (!passKineEta) {
    return acceptData;
  }
 
  unsigned int etbin = getLikelihoodEtHistBin(vars_struct.eT);
  unsigned int etabin = getLikelihoodEtaBin(vars_struct.eta);
 
  if (etbin >= s_fnDiscEtBins) {
    ATH_MSG_WARNING("Cannot evaluate likelihood for Et "
                    << vars_struct.eT << ". Returning false..");
    passKineEt = false;
  }
 
  // Return if the kinematic requirements are not fulfilled
  acceptData.setCutResult(m_cutPosition_kinematicEt, passKineEt);
  if (!passKineEt) {
    return acceptData;
  }
 
  double cutDiscriminant = -999.;
  unsigned int ibin_combined = etbin * s_fnEtaBins + etabin;
 
  if (!m_cutLikelihood.empty()) {
 
    cutDiscriminant = m_cutLikelihood[ibin_combined];
    // If doPileupCorrection, then correct the discriminant itself instead of
    // the cut value
    if (m_doPileupCorrection) {
      cutDiscriminant +=
        vars_struct.ip * m_cutLikelihoodPileupCorrectionA[ibin_combined] +
        m_cutLikelihoodPileupCorrectionB[ibin_combined];
    }
  }
 
  // 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;
  }
  acceptData.setCutResult(m_cutPosition_LH, passLH);
  return acceptData;
}

calculate() [1/2]

double Root::TForwardElectronLikelihoodTool::calculate	(	double	eta,
		double	eT,
		double	secondLambda,
		double	lateral,
		double	longitudinal,
		double	centerLambda,
		double	fracMax,
		double	secondR,
		double	significance,
		double	secondDensity,
		double	ip ) const

Definition at line 274 of file TForwardElectronLikelihoodTool.cxx.

{
  LikeEnumForward::LHCalcVars_t vars{};
  vars.eta = eta;
  vars.eT = eT;
  vars.secondLambda = secondLambda;
  vars.lateral = lateral;
  vars.longitudinal = longitudinal;
  vars.centerLambda = centerLambda;
  vars.fracMax = fracMax;
  vars.secondR = secondR;
  vars.significance = significance;
  vars.secondDensity = secondDensity;
  vars.ip = ip;
  return calculate(vars);
}

calculate() [2/2]

double Root::TForwardElectronLikelihoodTool::calculate

(

LikeEnumForward::LHCalcVars_t &

vars_struct

)

const

Definition at line 303 of file TForwardElectronLikelihoodTool.cxx.

{
  // Reset the results to defaul values
  double result = -999;
  double arr[] = { vars_struct.secondLambda, vars_struct.lateral,
                   vars_struct.longitudinal, vars_struct.centerLambda,
                   vars_struct.fracMax,      vars_struct.secondR,
                   vars_struct.significance, vars_struct.secondDensity };
  std::vector<double> vec(arr, arr + sizeof(arr) / sizeof(double));
 
  // 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::TForwardElectronLikelihoodTool::evaluateLikelihood ( const std::vector< double > & varVector, double et, double eta, double ip = 0 ) const

private

Definition at line 335 of file TForwardElectronLikelihoodTool.cxx.

{
  // const double GeV = 1000;
  unsigned int etbin = getLikelihoodEtHistBin(et);
  unsigned int etabin = getLikelihoodEtaBin(eta);
  unsigned int ipbin = getIpBin(ip);
 
  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!");
    return -999.;
  }
 
  double SigmaS = 1.;
  double SigmaB = 1.;
 
  for (unsigned int var = 0; var < s_fnVariables; var++) {
 
    std::string varstr = fVariables[var];
 
    // Skip variables that are masked off (not used) in the likelihood
    if (!(m_variableBitMask & (0x1 << var))) {
      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;
 
      double integral =
        double(m_fPDFbins[s_or_b][ipbin][etbin][etabin][var]->Integral());
      if (integral == 0) { // currently, the crack always has integral == 0
        ATH_MSG_DEBUG(
          "Error! PDF integral == 0!"); // changed it to debug message since we
                                        // intend to run the tool in the
                                        // derivations
        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);
}

evaluateLikelihood() [2/2]

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

private

Definition at line 321 of file TForwardElectronLikelihoodTool.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::TForwardElectronLikelihoodTool::getAcceptInfo ( ) const

inline

accesss to the accept info object

Definition at line 99 of file TForwardElectronLikelihoodTool.h.

{ return m_acceptInfo; }

getBinName()

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

staticprivate

Definition at line 473 of file TForwardElectronLikelihoodTool.cxx.

{
  double eta_bounds[s_fnEtaBins] = { 2.5, 2.6, 2.7,  2.8,  2.9,
                                     3.0, 3.1, 3.16, 3.35, 3.6 };
  int et_bounds[s_fnEtBinsHist] = { 20, 30, 40, 50 };
  if (!iptype.empty()) {
    return std::format("{}{}et{:02}eta{:.2f}",
                       iptype, int(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::TForwardElectronLikelihoodTool::getBitmask ( void ) const

inline

Definition at line 140 of file TForwardElectronLikelihoodTool.h.

{ return m_variableBitMask; }

getIpBin()

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

staticprivate

Definition at line 431 of file TForwardElectronLikelihoodTool.cxx.

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

getLikelihoodBitmask()

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

private

Mask out the variables ,out of all possible ones, that are not employed in the current configuration as read from the input config file.

Definition at line 493 of file TForwardElectronLikelihoodTool.cxx.

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

getLikelihoodEtaBin()

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

staticprivate

Eta binning for pdfs and discriminant cuts.

Definition at line 442 of file TForwardElectronLikelihoodTool.cxx.

{
  const unsigned int nEtaBins = s_fnEtaBins;
  const double etaBins[nEtaBins] = { 2.6, 2.7,  2.8,  2.9, 3.0,
                                     3.1, 3.16, 3.35, 3.6, 4.9 };
  for (unsigned int etaBin = 0; etaBin < nEtaBins; ++etaBin) {
    if (std::fabs(eta) < etaBins[etaBin])
      return etaBin;
  }
  return (nEtaBins - 1);
}

getLikelihoodEtHistBin()

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

staticprivate

Coarse Et binning. Used for the likelihood and discriminant pdfs.

Definition at line 455 of file TForwardElectronLikelihoodTool.cxx.

{
  const double GeV = 1000;
  const unsigned int nEtBins = s_fnDiscEtBins;
  const double eTBins[nEtBins] = {
    30 * GeV, 40 * GeV, 50 * GeV, 7000 * GeV
  }; // removed 20 GeV bin since we're upper bound oriented
  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::TForwardElectronLikelihoodTool::initialize

(

)

Initialize this class.

Definition at line 36 of file TForwardElectronLikelihoodTool.cxx.

{
  ATH_MSG_DEBUG("TForwardElectronLikelihoodTool 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 = s_fnDiscEtBins * s_fnEtaBins;
  if (m_cutLikelihood.size() != number_of_expected_bin) {
    ATH_MSG_ERROR("Configuration issue :  CutLikelihood expected size "
                  << number_of_expected_bin << " input size "
                  << m_cutLikelihood.size());
    ATH_MSG_ERROR(
      "Could NOT initialize! Please fix the errors mentioned above...");
    sc = StatusCode::FAILURE;
    return sc;
  }
 
  // --------------------------------------------------------------------------
  // Register the cuts and check that the registration worked:
 
  // Cut position for the kineatic pre-selection, separately for eta/Et
  m_cutPosition_kinematicEta =
    m_acceptInfo.addCut("kinematicEta", "pass kinematic eta");
  if (m_cutPosition_kinematicEta < 0)
    sc = StatusCode::FAILURE;
  m_cutPosition_kinematicEt =
    m_acceptInfo.addCut("kinematicEt", "pass kinematic Et ");
  if (m_cutPosition_kinematicEt < 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;
  }
 
  // Check that we got everything OK
  if (sc == StatusCode::FAILURE) {
    ATH_MSG_ERROR(
      "! Something went wrong with the setup of the return 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());
  m_pdfFile = TFile::Open(fname.c_str(), "READ");
  // Check that we could load the ROOT file
  if (!m_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 = 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, varIndex);
  }
 
  // TFile close does not free the memory
  m_pdfFile->Close();
  // We need the destructor to be called
  delete m_pdfFile;
  //----------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
                << "\n - VariableNames                                : "
                << m_variableNames);
  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;
  }
}

loadVarHistograms()

int Root::TForwardElectronLikelihoodTool::loadVarHistograms	(	const std::string &	vstr,
		unsigned int	varIndex )

Load the variable histograms from the pdf file.

Definition at line 132 of file TForwardElectronLikelihoodTool.cxx.

{
  for (unsigned int s_or_b = 0; s_or_b < 2; ++s_or_b) {
    for (unsigned int ip = 0; ip < IP_FBINS; ++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";
          // For the fwd LH PDFs and optimisation have matching eta bin
          // boundaries unsigned int eta_tmp = (eta > 0) ? eta-1 : eta ;
          unsigned int eta_tmp = eta;
          unsigned int et_tmp = et;
          std::string binname = getBinName(et_tmp, eta_tmp, ip, m_ipBinning);
 
          const std::string pdfdir = std::format("{}/{}", vstr, sig_bkg);
          std::string pdf = std::format("{}_{}_smoothed_hist_from_KDE_{}",
                                        vstr, sig_bkg, binname);
 
          if (!m_pdfFile->GetListOfKeys()->Contains(vstr.c_str())) {
            ATH_MSG_INFO("Warning: skipping variable "
                         << vstr << " because the folder does not exist.");
            return 1;
          }
          if (!((TDirectory*)m_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;
          }
          // Use the first Et bin given in the root file for all Et ranges below
          if (et == 0 && !((TDirectory*)m_pdfFile->Get(pdfdir.c_str()))
                            ->GetListOfKeys()
                            ->Contains(pdf.c_str())) {
            ATH_MSG_INFO("using lowest GeV bin in place of all below.");
            binname = getBinName(et_tmp + 1, eta_tmp, ip, m_ipBinning);
            pdf = std::format("{}_{}_smoothed_hist_from_KDE_{}",
                              vstr, sig_bkg, binname);
          }
          if (((TDirectory*)m_pdfFile->Get(pdfdir.c_str()))
                ->GetListOfKeys()
                ->Contains(pdf.c_str())) {
            TH1F* hist =
              (TH1F*)(((TDirectory*)m_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::TForwardElectronLikelihoodTool::setBinning ( const std::string & val )

inline

Define the binning.

Definition at line 138 of file TForwardElectronLikelihoodTool.h.

{ m_ipBinning = val; }

setBitmask()

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

inline

Definition at line 141 of file TForwardElectronLikelihoodTool.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::TForwardElectronLikelihoodTool::setPDFFileName ( const std::string & val )

inline

Add an input file that holds the PDFs.

Definition at line 125 of file TForwardElectronLikelihoodTool.h.

{ m_pdfFileName = val; }

setVariableNames()

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

inline

Define the variable names.

Definition at line 128 of file TForwardElectronLikelihoodTool.h.

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

TransformLikelihoodOutput()

double Root::TForwardElectronLikelihoodTool::TransformLikelihoodOutput ( double ps, double pb ) const

private

Apply a transform to zoom into the LH output peaks.

Optionally do pileup correction too

Definition at line 404 of file TForwardElectronLikelihoodTool.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));
 
  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.

fIpBounds

const double Root::TForwardElectronLikelihoodTool::fIpBounds

staticprivate

Initial value:

= {
  0.,
  500.
}

Definition at line 11 of file TForwardElectronLikelihoodTool.h.

            : el_secondLambda : longitudinal second moment el_lateral      :

fVariables

const std::string Root::TForwardElectronLikelihoodTool::fVariables

staticprivate

Initial value:

= {
    "el_secondLambda", "el_lateral", "el_longitudinal", "el_centerLambda",
    "el_fracMax",      "el_secondR", "el_significance", "el_secondDensity"
  }

Definition at line 17 of file TForwardElectronLikelihoodTool.h.

                    : fraction of cluster energy in the most energetic cell
    el_secondR      : transverse second moment
    el_significance : cluster energy divided by cluster noise
    el_secondDensity: second moment of signal density

m_acceptInfo

asg::AcceptInfo Root::TForwardElectronLikelihoodTool::m_acceptInfo

private

Accept info.

Definition at line 216 of file TForwardElectronLikelihoodTool.h.

m_cutLikelihood

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

cut on likelihood output

Definition at line 183 of file TForwardElectronLikelihoodTool.h.

m_cutLikelihoodPileupCorrectionA

std::vector<double> Root::TForwardElectronLikelihoodTool::m_cutLikelihoodPileupCorrectionA

the cut on the PU discriminant is adjusted as a function of nVtx cut + nVtx*cutA + cutB this is different from the procedure for central electrons

pileup slope factor for cut on likelihood output

Definition at line 189 of file TForwardElectronLikelihoodTool.h.

m_cutLikelihoodPileupCorrectionB

std::vector<double> Root::TForwardElectronLikelihoodTool::m_cutLikelihoodPileupCorrectionB

pileup constant factor for cut on likelihood output

Definition at line 191 of file TForwardElectronLikelihoodTool.h.

m_cutPosition_kinematicEt

int Root::TForwardElectronLikelihoodTool::m_cutPosition_kinematicEt

private

Definition at line 227 of file TForwardElectronLikelihoodTool.h.

m_cutPosition_kinematicEta

int Root::TForwardElectronLikelihoodTool::m_cutPosition_kinematicEta

private

The position of the kinematic cuts bit in the AcceptInfo return object, separate for eta/Et.

Definition at line 226 of file TForwardElectronLikelihoodTool.h.

m_cutPosition_LH

int Root::TForwardElectronLikelihoodTool::m_cutPosition_LH

private

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

Definition at line 229 of file TForwardElectronLikelihoodTool.h.

m_doPileupCorrection

bool Root::TForwardElectronLikelihoodTool::m_doPileupCorrection

Apply a transform to zoom into the LH output peaks.

Eta binning for pdfs and discriminant cuts. Et binning for for the likelihood pdfs and discriminants.

do pileup-dependent correction on discriminant value

Definition at line 181 of file TForwardElectronLikelihoodTool.h.

m_fPDFbins

std::unique_ptr<EGSelectors::SafeTH1> Root::TForwardElectronLikelihoodTool::m_fPDFbins[2][IP_FBINS][s_fnEtBinsHist][s_fnEtaBins][s_fnVariables]

private

Definition at line 240 of file TForwardElectronLikelihoodTool.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::TForwardElectronLikelihoodTool::m_ipBinning

private

Deprecated.

Definition at line 219 of file TForwardElectronLikelihoodTool.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_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_pdfFile

TFile* Root::TForwardElectronLikelihoodTool::m_pdfFile {}

private

Pointer to the opened TFile that holds the PDFs.

Definition at line 222 of file TForwardElectronLikelihoodTool.h.

{};

m_pdfFileName

std::string Root::TForwardElectronLikelihoodTool::m_pdfFileName

Name of the pdf file.

Definition at line 195 of file TForwardElectronLikelihoodTool.h.

m_variableBitMask

unsigned int Root::TForwardElectronLikelihoodTool::m_variableBitMask

private

The bitmask corresponding to the variables in the likelihood.

For internal use.

Definition at line 213 of file TForwardElectronLikelihoodTool.h.

m_variableNames

std::string Root::TForwardElectronLikelihoodTool::m_variableNames

variables to use in the LH

Definition at line 193 of file TForwardElectronLikelihoodTool.h.

s_fnDiscEtBins

const unsigned int Root::TForwardElectronLikelihoodTool::s_fnDiscEtBins

staticprivate

Initial value:

=
    4

Definition at line 234 of file TForwardElectronLikelihoodTool.h.

s_fnEtaBins

const unsigned int Root::TForwardElectronLikelihoodTool::s_fnEtaBins = 10

staticprivate

Definition at line 236 of file TForwardElectronLikelihoodTool.h.

s_fnEtBinsHist

const unsigned int Root::TForwardElectronLikelihoodTool::s_fnEtBinsHist

staticprivate

Initial value:

=
    4

Definition at line 232 of file TForwardElectronLikelihoodTool.h.

s_fnVariables

const unsigned int Root::TForwardElectronLikelihoodTool::s_fnVariables = 8

staticprivate

Definition at line 237 of file TForwardElectronLikelihoodTool.h.

---

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

• TForwardElectronLikelihoodTool.h
• TForwardElectronLikelihoodTool.cxx