ATLAS Offline Software
Public Member Functions | Public Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | Static Private Attributes | List of all members
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. More...
 
StatusCode initialize ()
 Initialize this class. More...
 
const asg::AcceptInfogetAcceptInfo () const
 accesss to the accept info object More...
 
asg::AcceptData accept (LikeEnumForward::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, double ip) const
 
asg::AcceptData accept () const
 Return dummy accept with only info. More...
 
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. More...
 
void setVariableNames (const std::string &val)
 Define the variable names. More...
 
int loadVarHistograms (const std::string &vstr, 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

bool m_doPileupCorrection
 Apply a transform to zoom into the LH output peaks. More...
 
std::vector< double > m_cutLikelihood
 cut on likelihood output More...
 
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 More...
 
std::vector< double > m_cutLikelihoodPileupCorrectionB
 pileup constant factor for cut on likelihood output 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
 Mask out the variables ,out of all possible ones, that are not employed in the current configuration as read from the input config file. More...
 
double TransformLikelihoodOutput (double ps, double pb) const
 Apply a transform to zoom into the LH output peaks. 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 and discriminant pdfs. More...
 
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. More...
 
asg::AcceptInfo m_acceptInfo
 Accept info. More...
 
std::string m_ipBinning
 Deprecated. More...
 
TFile * m_pdfFile {}
 Pointer to the opened TFile that holds the PDFs. More...
 
int m_cutPosition_kinematicEta
 The position of the kinematic cuts bit in the AcceptInfo return object, separate for eta/Et. More...
 
int m_cutPosition_kinematicEt
 
int m_cutPosition_LH
 The position of the likelihood cut bit in the AcceptInfo return object. More...
 
std::unique_ptr< EGSelectors::SafeTH1m_fPDFbins [2][IP_FBINS][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 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.

24  : asg::AsgMessaging(std::string(name))
25  , m_doPileupCorrection(false)
26  , m_variableNames("")
27  , m_pdfFileName("")
28  , m_variableBitMask(0x0)
31  , m_cutPosition_LH(-9)
32 {
33 }

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.

109 { 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.

196 {
198 
199  vars.likelihood = likelihood;
200  vars.eta = eta;
201  vars.eT = eT;
202  vars.ip = ip;
203 
204  return accept(vars);
205 }

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

212 {
213  // Setup return accept with AcceptInfo
214  asg::AcceptData acceptData(&m_acceptInfo);
215 
216  // Set up the individual cuts
217  bool passKineEta(true);
218  bool passKineEt(true);
219  bool passLH(true);
220 
221  if (std::fabs(vars_struct.eta) < 2.5) {
222  ATH_MSG_DEBUG("This forward electron has"
223  << vars_struct.eta
224  << ", which is fabs(eta)<2.5 Returning False.");
225  passKineEta = false;
226  }
227  // Return if the kinematic requirements are not fulfilled
228  acceptData.setCutResult(m_cutPosition_kinematicEta, passKineEta);
229  if (!passKineEta) {
230  return acceptData;
231  }
232 
233  unsigned int etbin = getLikelihoodEtHistBin(vars_struct.eT);
234  unsigned int etabin = getLikelihoodEtaBin(vars_struct.eta);
235 
236  if (etbin >= s_fnDiscEtBins) {
237  ATH_MSG_WARNING("Cannot evaluate likelihood for Et "
238  << vars_struct.eT << ". Returning false..");
239  passKineEt = false;
240  }
241 
242  // Return if the kinematic requirements are not fulfilled
243  acceptData.setCutResult(m_cutPosition_kinematicEt, passKineEt);
244  if (!passKineEt) {
245  return acceptData;
246  }
247 
248  double cutDiscriminant = -999.;
249  unsigned int ibin_combined = etbin * s_fnEtaBins + etabin;
250 
251  if (!m_cutLikelihood.empty()) {
252 
253  cutDiscriminant = m_cutLikelihood[ibin_combined];
254  // If doPileupCorrection, then correct the discriminant itself instead of
255  // the cut value
256  if (m_doPileupCorrection) {
257  cutDiscriminant +=
258  vars_struct.ip * m_cutLikelihoodPileupCorrectionA[ibin_combined] +
259  m_cutLikelihoodPileupCorrectionB[ibin_combined];
260  }
261  }
262 
263  // Determine if the calculated likelihood value passes the cut
264  ATH_MSG_DEBUG("Likelihood macro: Discriminant: ");
265  if (vars_struct.likelihood < cutDiscriminant) {
266  ATH_MSG_DEBUG("Likelihood macro: Disciminant Cut Failed.");
267  passLH = false;
268  }
269  acceptData.setCutResult(m_cutPosition_LH, passLH);
270  return acceptData;
271 }

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

285 {
287  vars.eta = eta;
288  vars.eT = eT;
289  vars.secondLambda = secondLambda;
290  vars.lateral = lateral;
291  vars.longitudinal = longitudinal;
292  vars.centerLambda = centerLambda;
293  vars.fracMax = fracMax;
294  vars.secondR = secondR;
295  vars.significance = significance;
296  vars.secondDensity = secondDensity;
297  vars.ip = ip;
298  return calculate(vars);
299 }

◆ calculate() [2/2]

double Root::TForwardElectronLikelihoodTool::calculate ( LikeEnumForward::LHCalcVars_t vars_struct) const

Definition at line 303 of file TForwardElectronLikelihoodTool.cxx.

305 {
306  // Reset the results to defaul values
307  double result = -999;
308  double arr[] = { vars_struct.secondLambda, vars_struct.lateral,
309  vars_struct.longitudinal, vars_struct.centerLambda,
310  vars_struct.fracMax, vars_struct.secondR,
311  vars_struct.significance, vars_struct.secondDensity };
312  std::vector<double> vec(arr, arr + sizeof(arr) / sizeof(double));
313 
314  // Calculate the actual likelihood value and fill the return object
315  result = this->evaluateLikelihood(
316  vec, vars_struct.eT, vars_struct.eta, vars_struct.ip);
317  return result;
318 }

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

340 {
341  // const double GeV = 1000;
342  unsigned int etbin = getLikelihoodEtHistBin(et);
343  unsigned int etabin = getLikelihoodEtaBin(eta);
344  unsigned int ipbin = getIpBin(ip);
345 
346  if (etbin >= s_fnEtBinsHist) {
347  ATH_MSG_WARNING("skipping etbin " << etbin << ", et " << et);
348  return -999.;
349  }
350  if (etabin >= s_fnEtaBins) {
351  ATH_MSG_WARNING("skipping etabin " << etabin << ", eta " << eta);
352  return -999.;
353  }
354 
355  if (varVector.size() != s_fnVariables) {
356  ATH_MSG_WARNING("Error! Variable vector size mismatch! Check your vector!");
357  return -999.;
358  }
359 
360  double SigmaS = 1.;
361  double SigmaB = 1.;
362 
363  for (unsigned int var = 0; var < s_fnVariables; var++) {
364 
365  std::string varstr = fVariables[var];
366 
367  // Skip variables that are masked off (not used) in the likelihood
368  if (!(m_variableBitMask & (0x1 << var))) {
369  continue;
370  }
371 
372  for (unsigned int s_or_b = 0; s_or_b < 2; s_or_b++) {
373 
374  int bin =
375  m_fPDFbins[s_or_b][ipbin][etbin][etabin][var]->FindBin(varVector[var]);
376  double prob = 0;
377 
378  double integral =
379  double(m_fPDFbins[s_or_b][ipbin][etbin][etabin][var]->Integral());
380  if (integral == 0) { // currently, the crack always has integral == 0
382  "Error! PDF integral == 0!"); // changed it to debug message since we
383  // intend to run the tool in the
384  // derivations
385  return -1.35;
386  }
387 
388  prob = double(m_fPDFbins[s_or_b][ipbin][etbin][etabin][var]->GetBinContent(
389  bin)) /
390  integral;
391 
392  if (s_or_b == 0)
393  SigmaS *= prob;
394  else if (s_or_b == 1)
395  SigmaB *= prob;
396  }
397  }
398 
399  return TransformLikelihoodOutput(SigmaS, SigmaB);
400 }

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

326 {
327  std::vector<double> vec;
328  for (unsigned int var = 0; var < s_fnVariables; var++) {
329  vec.push_back(varVector[var]);
330  }
331  return evaluateLikelihood(vec, et, eta, ip);
332 }

◆ getAcceptInfo()

const asg::AcceptInfo& Root::TForwardElectronLikelihoodTool::getAcceptInfo ( ) const
inline

accesss to the accept info object

Definition at line 99 of file TForwardElectronLikelihoodTool.h.

99 { 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.

478 {
479  double eta_bounds[s_fnEtaBins] = { 2.5, 2.6, 2.7, 2.8, 2.9,
480  3.0, 3.1, 3.16, 3.35, 3.6 };
481  int et_bounds[s_fnEtBinsHist] = { 20, 30, 40, 50 };
482  if (!iptype.empty()) {
483  return std::format("{}{}et{:02}eta{:.2f}",
484  iptype, int(fIpBounds[ipbin]),
485  et_bounds[etbin], eta_bounds[etabin]);
486  } else {
487  return std::format("et{}eta{:.2f}",
488  et_bounds[etbin], eta_bounds[etabin]);
489  }
490 }

◆ getBitmask()

unsigned int Root::TForwardElectronLikelihoodTool::getBitmask ( void  ) const
inline

Definition at line 140 of file TForwardElectronLikelihoodTool.h.

140 { return m_variableBitMask; }

◆ getIpBin()

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

Definition at line 431 of file TForwardElectronLikelihoodTool.cxx.

432 {
433  for (unsigned int ipBin = 0; ipBin < IP_FBINS; ++ipBin) {
434  if (ip < fIpBounds[ipBin + 1])
435  return ipBin;
436  }
437  return 0;
438 }

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

495 {
496  unsigned int mask = 0x0;
497  ATH_MSG_DEBUG("Variables to be used: ");
498  for (unsigned int var = 0; var < s_fnVariables; var++) {
499  if (vars.find(fVariables[var]) != std::string::npos) {
501  mask = mask | 0x1 << var;
502  }
503  }
504  ATH_MSG_DEBUG("mask: " << mask);
505  return mask;
506 }

◆ getLikelihoodEtaBin()

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

Eta binning for pdfs and discriminant cuts.

Definition at line 442 of file TForwardElectronLikelihoodTool.cxx.

443 {
444  const unsigned int nEtaBins = s_fnEtaBins;
445  const double etaBins[nEtaBins] = { 2.6, 2.7, 2.8, 2.9, 3.0,
446  3.1, 3.16, 3.35, 3.6, 4.9 };
447  for (unsigned int etaBin = 0; etaBin < nEtaBins; ++etaBin) {
448  if (std::fabs(eta) < etaBins[etaBin])
449  return etaBin;
450  }
451  return (nEtaBins - 1);
452 }

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

456 {
457  const double GeV = 1000;
458  const unsigned int nEtBins = s_fnDiscEtBins;
459  const double eTBins[nEtBins] = {
460  30 * GeV, 40 * GeV, 50 * GeV, 7000 * GeV
461  }; // removed 20 GeV bin since we're upper bound oriented
462  for (unsigned int eTBin = 0; eTBin < nEtBins; ++eTBin) {
463  if (eT < eTBins[eTBin]) {
464  return eTBin;
465  }
466  }
467  return (nEtBins - 1); // Return the last bin if > the last bin.
468 }

◆ initialize()

StatusCode Root::TForwardElectronLikelihoodTool::initialize ( )

Initialize this class.

Definition at line 36 of file TForwardElectronLikelihoodTool.cxx.

37 {
38  ATH_MSG_DEBUG("TForwardElectronLikelihoodTool initialize.");
39  // use an int as a StatusCode
40  StatusCode sc(StatusCode::SUCCESS);
41 
42  // Check that all needed variables are setup
43  if (m_pdfFileName.empty()) {
45  "You need to specify the input PDF file name before you call "
46  "initialize() with setPDFFileName('your/file/name.root') ");
47  sc = StatusCode::FAILURE;
48  }
49 
50  unsigned int number_of_expected_bin = s_fnDiscEtBins * s_fnEtaBins;
51  if (m_cutLikelihood.size() != number_of_expected_bin) {
52  ATH_MSG_ERROR("Configuration issue : CutLikelihood expected size "
53  << number_of_expected_bin << " input size "
54  << m_cutLikelihood.size());
56  "Could NOT initialize! Please fix the errors mentioned above...");
57  sc = StatusCode::FAILURE;
58  return sc;
59  }
60 
61  // --------------------------------------------------------------------------
62  // Register the cuts and check that the registration worked:
63 
64  // Cut position for the kineatic pre-selection, separately for eta/Et
66  m_acceptInfo.addCut("kinematicEta", "pass kinematic eta");
68  sc = StatusCode::FAILURE;
70  m_acceptInfo.addCut("kinematicEt", "pass kinematic Et ");
72  sc = StatusCode::FAILURE;
73 
74  // Cut position for the likelihood selection - DO NOT CHANGE ORDER!
75  m_cutPosition_LH = m_acceptInfo.addCut("passLH", "pass Likelihood");
76  if (m_cutPosition_LH < 0) {
77  sc = StatusCode::FAILURE;
78  }
79 
80  // Check that we got everything OK
81  if (sc == StatusCode::FAILURE) {
83  "! Something went wrong with the setup of the return objects...");
84  return sc;
85  }
86 
87  // Get the correct bit mask for the current likelihood operating point
89 
90  //----------File/Histo operation------------------------------------
91  // Load the ROOT file containing the PDFs
92  TString tmpString(m_pdfFileName);
93  gSystem->ExpandPathName(tmpString);
94  std::string fname(tmpString.Data());
95  m_pdfFile = TFile::Open(fname.c_str(), "READ");
96  // Check that we could load the ROOT file
97  if (!m_pdfFile) {
98  ATH_MSG_ERROR(" No ROOT file found here: " << m_pdfFileName);
99  return StatusCode::FAILURE;
100  }
101 
102  // Load the histograms
103  for (unsigned int varIndex = 0; varIndex < s_fnVariables; varIndex++) {
104  const std::string& vstr = fVariables[varIndex];
105  // Skip the loading of PDFs for variables we don't care about for this
106  // operating point. If the string is empty (which is true in the default
107  // 2012 case), load all of them.
108  if (m_variableNames.find(vstr) == std::string::npos &&
109  !m_variableNames.empty()) {
110  continue;
111  }
112  loadVarHistograms(vstr, varIndex);
113  }
114 
115  // TFile close does not free the memory
116  m_pdfFile->Close();
117  // We need the destructor to be called
118  delete m_pdfFile;
119  //----------End File/Histo operation------------------------------------
120 
121  ATH_MSG_DEBUG("Initialization complete for a LH tool with these specs:"
122  << "\n - PdfFileName : "
123  << m_pdfFileName
124  << "\n - Variable bitmask : "
126  << "\n - VariableNames : "
127  << m_variableNames);
128  return sc;
129 }

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

40 {
42  m_lvl = m_imsg ?
43  static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
44  MSG::INFO;
45 }

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

134 {
135  for (unsigned int s_or_b = 0; s_or_b < 2; ++s_or_b) {
136  for (unsigned int ip = 0; ip < IP_FBINS; ++ip) {
137  for (unsigned int et = 0; et < s_fnEtBinsHist; ++et) {
138  for (unsigned int eta = 0; eta < s_fnEtaBins; ++eta) {
139 
140  std::string sig_bkg = (s_or_b == 0) ? "sig" : "bkg";
141  // For the fwd LH PDFs and optimisation have matching eta bin
142  // boundaries unsigned int eta_tmp = (eta > 0) ? eta-1 : eta ;
143  unsigned int eta_tmp = eta;
144  unsigned int et_tmp = et;
145  std::string binname = getBinName(et_tmp, eta_tmp, ip, m_ipBinning);
146 
147  const std::string pdfdir = std::format("{}/{}", vstr, sig_bkg);
148  std::string pdf = std::format("{}_{}_smoothed_hist_from_KDE_{}",
149  vstr, sig_bkg, binname);
150 
151  if (!m_pdfFile->GetListOfKeys()->Contains(vstr.c_str())) {
152  ATH_MSG_INFO("Warning: skipping variable "
153  << vstr << " because the folder does not exist.");
154  return 1;
155  }
156  if (!((TDirectory*)m_pdfFile->Get(vstr.c_str()))
157  ->GetListOfKeys()
158  ->Contains(sig_bkg.c_str())) {
159  ATH_MSG_INFO("Warning: skipping variable "
160  << vstr << " because the folder does not exist.");
161  return 1;
162  }
163  // Use the first Et bin given in the root file for all Et ranges below
164  if (et == 0 && !((TDirectory*)m_pdfFile->Get(pdfdir.c_str()))
165  ->GetListOfKeys()
166  ->Contains(pdf.c_str())) {
167  ATH_MSG_INFO("using lowest GeV bin in place of all below.");
168  binname = getBinName(et_tmp + 1, eta_tmp, ip, m_ipBinning);
169  pdf = std::format("{}_{}_smoothed_hist_from_KDE_{}",
170  vstr, sig_bkg, binname);
171  }
172  if (((TDirectory*)m_pdfFile->Get(pdfdir.c_str()))
173  ->GetListOfKeys()
174  ->Contains(pdf.c_str())) {
175  TH1F* hist =
176  (TH1F*)(((TDirectory*)m_pdfFile->Get(pdfdir.c_str()))->Get(pdf.c_str()));
177  m_fPDFbins[s_or_b][ip][et][eta][varIndex] =
178  std::make_unique<EGSelectors::SafeTH1>(hist);
179  } else {
180  ATH_MSG_INFO("Warning: Object " << pdf << " does not exist.");
181  ATH_MSG_INFO("Skipping all other histograms with this variable.");
182  return 1;
183  }
184  }
185  }
186  }
187  }
188  return 1;
189 }

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

49  {
50 #ifndef XAOD_STANDALONE
52 #else // not XAOD_STANDALONE
53  return m_msg;
54 #endif // not XAOD_STANDALONE
55  }

◆ msg() [2/2]

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

The standard message stream.

Parameters
lvlThe 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.

57  {
58 #ifndef XAOD_STANDALONE
60 #else // not XAOD_STANDALONE
61  m_msg << lvl;
62  return m_msg;
63 #endif // not XAOD_STANDALONE
64  }

◆ msgLvl()

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

Test the output level of the object.

Parameters
lvlThe 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.

41  {
42 #ifndef XAOD_STANDALONE
43  return ::AthMessaging::msgLvl( lvl );
44 #else // not XAOD_STANDALONE
45  return m_msg.msgLevel( lvl );
46 #endif // not XAOD_STANDALONE
47  }

◆ setBinning()

void Root::TForwardElectronLikelihoodTool::setBinning ( const std::string &  val)
inline

Define the binning.

Definition at line 138 of file TForwardElectronLikelihoodTool.h.

138 { m_ipBinning = val; }

◆ setBitmask()

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

Definition at line 141 of file TForwardElectronLikelihoodTool.h.

141 { 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.

29 {
30  m_lvl = lvl;
31 }

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

125 { 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.

129  {
132  }

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

406 {
407  // returns transformed or non-transformed output
408  // (Taken mostly from TMVA likelihood code)
409  double fEpsilon = 1e-99;
410  // If both signal and bkg are 0, we want it to fail.
411  if (ps < fEpsilon)
412  ps = 0;
413  if (pb < fEpsilon)
414  pb = fEpsilon;
415  double disc = ps / double(ps + pb);
416 
417  if (disc >= 1.0)
418  disc = 1. - 1.e-15;
419  else if (disc <= 0.0)
420  disc = fEpsilon;
421 
422  double tau = 15.0;
423  disc = -std::log(1.0 / disc - 1.0) * (1. / double(tau));
424 
425  ATH_MSG_DEBUG("disc is " << disc);
426  return disc;
427 }

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 231 of file TForwardElectronLikelihoodTool.h.

◆ 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 238 of file TForwardElectronLikelihoodTool.h.

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

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

◆ 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:
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition: AthMessaging.h:138
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:215
LikeEnumForward::LHCalcVars_t::secondDensity
double secondDensity
Definition: TForwardElectronLikelihoodTool.h:78
beamspotnt.var
var
Definition: bin/beamspotnt.py:1393
et
Extra patterns decribing particle interation process.
LikeEnumForward::LHCalcVars_t::secondLambda
double secondLambda
Definition: TForwardElectronLikelihoodTool.h:72
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:18
get_generator_info.result
result
Definition: get_generator_info.py:21
Root::TForwardElectronLikelihoodTool::s_fnEtBinsHist
static const unsigned int s_fnEtBinsHist
Definition: TForwardElectronLikelihoodTool.h:232
vtune_athena.format
format
Definition: vtune_athena.py:14
keylayer_zslicemap.pb
pb
Definition: keylayer_zslicemap.py:188
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TCS::KFMET::nEtaBins
constexpr unsigned nEtaBins
Definition: KalmanMETCorrectionConstants.h:18
Root::TForwardElectronLikelihoodTool::TransformLikelihoodOutput
double TransformLikelihoodOutput(double ps, double pb) const
Apply a transform to zoom into the LH output peaks.
Definition: TForwardElectronLikelihoodTool.cxx:404
integral
double integral(TH1 *h)
Definition: computils.cxx:59
xAOD::et
et
Definition: TrigEMCluster_v1.cxx:25
LikeEnumForward::LHAcceptVars_t::eta
double eta
Definition: TForwardElectronLikelihoodTool.h:63
LikeEnumForward::LHCalcVars_t::eta
double eta
Definition: TForwardElectronLikelihoodTool.h:70
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
Root::TForwardElectronLikelihoodTool::loadVarHistograms
int loadVarHistograms(const std::string &vstr, unsigned int varIndex)
Load the variable histograms from the pdf file.
Definition: TForwardElectronLikelihoodTool.cxx:132
LikeEnumForward::LHCalcVars_t::longitudinal
double longitudinal
Definition: TForwardElectronLikelihoodTool.h:74
Root::TForwardElectronLikelihoodTool::m_fPDFbins
std::unique_ptr< EGSelectors::SafeTH1 > m_fPDFbins[2][IP_FBINS][s_fnEtBinsHist][s_fnEtaBins][s_fnVariables]
Definition: TForwardElectronLikelihoodTool.h:240
plotmaker.hist
hist
Definition: plotmaker.py:148
Root::TForwardElectronLikelihoodTool::m_cutPosition_LH
int m_cutPosition_LH
The position of the likelihood cut bit in the AcceptInfo return object.
Definition: TForwardElectronLikelihoodTool.h:229
LikeEnumForward::LHCalcVars_t::eT
double eT
Definition: TForwardElectronLikelihoodTool.h:71
ConvertOldUJHistosToNewHistos.etaBins
list etaBins
Definition: ConvertOldUJHistosToNewHistos.py:145
bin
Definition: BinsDiffFromStripMedian.h:43
Root::TForwardElectronLikelihoodTool::accept
asg::AcceptData accept() const
Return dummy accept with only info.
Definition: TForwardElectronLikelihoodTool.h:109
LikeEnumForward::LHAcceptVars_t::ip
double ip
Definition: TForwardElectronLikelihoodTool.h:65
Root::TForwardElectronLikelihoodTool::m_cutLikelihoodPileupCorrectionA
std::vector< double > m_cutLikelihoodPileupCorrectionA
the cut on the PU discriminant is adjusted as a function of nVtx cut + nVtx*cutA + cutB this is diffe...
Definition: TForwardElectronLikelihoodTool.h:189
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:9
Root::TForwardElectronLikelihoodTool::m_acceptInfo
asg::AcceptInfo m_acceptInfo
Accept info.
Definition: TForwardElectronLikelihoodTool.h:216
covarianceTool.prob
prob
Definition: covarianceTool.py:678
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition: AthMessaging.h:135
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:459
Root::TForwardElectronLikelihoodTool::calculate
double calculate(LikeEnumForward::LHCalcVars_t &vars_struct) const
Definition: TForwardElectronLikelihoodTool.cxx:303
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
Root::TForwardElectronLikelihoodTool::getBinName
static std::string getBinName(int etbin, int etabin, int ipbin, const std::string &iptype)
Definition: TForwardElectronLikelihoodTool.cxx:473
CxxUtils::vec
typename vecDetail::vec_typedef< T, N >::type vec
Define a nice alias for the vectorized type.
Definition: vec.h:207
Root::TForwardElectronLikelihoodTool::getIpBin
static unsigned int getIpBin(double ip)
Definition: TForwardElectronLikelihoodTool.cxx:431
Root::TForwardElectronLikelihoodTool::m_cutLikelihood
std::vector< double > m_cutLikelihood
cut on likelihood output
Definition: TForwardElectronLikelihoodTool.h:183
xAOD::etaBin
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap etaBin
Definition: L2StandAloneMuon_v1.cxx:149
Root::TForwardElectronLikelihoodTool::fVariables
static const std::string fVariables[s_fnVariables]
Definition: TForwardElectronLikelihoodTool.h:238
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
IDTPM::eT
float eT(const U &p)
Accessor utility function for getting the value of Tranverse energy.
Definition: TrackParametersHelper.h:122
Root::TForwardElectronLikelihoodTool::fIpBounds
static const double fIpBounds[IP_FBINS+1]
Definition: TForwardElectronLikelihoodTool.h:231
Root::TForwardElectronLikelihoodTool::m_pdfFileName
std::string m_pdfFileName
Name of the pdf file.
Definition: TForwardElectronLikelihoodTool.h:195
python.SystemOfUnits.ps
float ps
Definition: SystemOfUnits.py:150
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
LikeEnumForward::LHCalcVars_t::lateral
double lateral
Definition: TForwardElectronLikelihoodTool.h:73
LikeEnumForward::LHCalcVars_t::ip
double ip
Definition: TForwardElectronLikelihoodTool.h:80
LikeEnumForward::LHCalcVars_t::significance
double significance
Definition: TForwardElectronLikelihoodTool.h:79
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Root::TForwardElectronLikelihoodTool::m_ipBinning
std::string m_ipBinning
Deprecated.
Definition: TForwardElectronLikelihoodTool.h:219
Root::TForwardElectronLikelihoodTool::getLikelihoodEtaBin
static unsigned int getLikelihoodEtaBin(double eta)
Eta binning for pdfs and discriminant cuts.
Definition: TForwardElectronLikelihoodTool.cxx:442
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
Root::TForwardElectronLikelihoodTool::evaluateLikelihood
double evaluateLikelihood(const std::vector< double > &varVector, double et, double eta, double ip=0) const
Definition: TForwardElectronLikelihoodTool.cxx:335
Root::TForwardElectronLikelihoodTool::m_cutPosition_kinematicEt
int m_cutPosition_kinematicEt
Definition: TForwardElectronLikelihoodTool.h:227
Root::TForwardElectronLikelihoodTool::getLikelihoodEtHistBin
static unsigned int getLikelihoodEtHistBin(double eT)
Coarse Et binning. Used for the likelihood and discriminant pdfs.
Definition: TForwardElectronLikelihoodTool.cxx:455
Root::TForwardElectronLikelihoodTool::s_fnVariables
static const unsigned int s_fnVariables
Definition: TForwardElectronLikelihoodTool.h:237
LikeEnumForward::LHAcceptVars_t::eT
double eT
Definition: TForwardElectronLikelihoodTool.h:64
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
asg::AsgMessaging
Class mimicking the AthMessaging class from the offline software.
Definition: AsgMessaging.h:40
LikeEnumForward::LHCalcVars_t::fracMax
double fracMax
Definition: TForwardElectronLikelihoodTool.h:75
Root::TForwardElectronLikelihoodTool::s_fnEtaBins
static const unsigned int s_fnEtaBins
Definition: TForwardElectronLikelihoodTool.h:236
LikeEnumForward::LHAcceptVars_t
Definition: TForwardElectronLikelihoodTool.h:61
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:66
Root::TForwardElectronLikelihoodTool::m_doPileupCorrection
bool m_doPileupCorrection
Apply a transform to zoom into the LH output peaks.
Definition: TForwardElectronLikelihoodTool.h:181
Root::TForwardElectronLikelihoodTool::getLikelihoodBitmask
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 ...
Definition: TForwardElectronLikelihoodTool.cxx:493
Root::TForwardElectronLikelihoodTool::m_variableBitMask
unsigned int m_variableBitMask
The bitmask corresponding to the variables in the likelihood.
Definition: TForwardElectronLikelihoodTool.h:213
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
Root::TForwardElectronLikelihoodTool::s_fnDiscEtBins
static const unsigned int s_fnDiscEtBins
Definition: TForwardElectronLikelihoodTool.h:234
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
LikeEnumForward::LHCalcVars_t::centerLambda
double centerLambda
Definition: TForwardElectronLikelihoodTool.h:76
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition: AthMessaging.h:129
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
PowhegPythia8EvtGen_jetjet.pdf
pdf
Definition: PowhegPythia8EvtGen_jetjet.py:4
LikeEnumForward::LHCalcVars_t::secondR
double secondR
Definition: TForwardElectronLikelihoodTool.h:77
LikeEnumForward::LHAcceptVars_t::likelihood
double likelihood
Definition: TForwardElectronLikelihoodTool.h:62
LikeEnumForward::LHCalcVars_t
Definition: TForwardElectronLikelihoodTool.h:69
Root::TForwardElectronLikelihoodTool::m_cutPosition_kinematicEta
int m_cutPosition_kinematicEta
The position of the kinematic cuts bit in the AcceptInfo return object, separate for eta/Et.
Definition: TForwardElectronLikelihoodTool.h:226
Root::TForwardElectronLikelihoodTool::m_variableNames
std::string m_variableNames
variables to use in the LH
Definition: TForwardElectronLikelihoodTool.h:193
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
Root::TForwardElectronLikelihoodTool::m_cutLikelihoodPileupCorrectionB
std::vector< double > m_cutLikelihoodPileupCorrectionB
pileup constant factor for cut on likelihood output
Definition: TForwardElectronLikelihoodTool.h:191
asg::AcceptData
Definition: AcceptData.h:30
Root::TForwardElectronLikelihoodTool::m_pdfFile
TFile * m_pdfFile
Pointer to the opened TFile that holds the PDFs.
Definition: TForwardElectronLikelihoodTool.h:222
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
asg::AcceptInfo::addCut
int addCut(const std::string &cutName, const std::string &cutDescription)
Add a cut; returning the cut position.
Definition: AcceptInfo.h:53