ATLAS Offline Software
Public Member Functions | Private Member Functions | Private Attributes | List of all members
LVL1::eFEXtauBDT Class Reference

The eFEXtauBDT class calculates the tau TOB variables. More...

#include <eFEXtauBDT.h>

Collaboration diagram for LVL1::eFEXtauBDT:

Public Member Functions

 eFEXtauBDT (AthAlgTool *log, std::string config_path)
 Constructors. More...
 
virtual ~eFEXtauBDT ()
 Destructor. More...
 
void next ()
 
void setPointerToSCell (int eta, int phi, int layer, unsigned int *sCellPtr)
 
void setPointerToFracMultipliersParam (int index, unsigned int *fracMultipliers)
 
void setPointerToBDTThresholdsParam (int index, unsigned int *bdtThresholds)
 
void setPointerToETThresholdParam (unsigned int *etThreshold)
 
void setPointerToMaxETParam (unsigned int *maxEtThreshold)
 
void setPointerToMaxETParamFrac (unsigned int *maxEtThreshold)
 
void setPointerToBDTMinETParam (unsigned int *bdtMinEtThreshold)
 
void buildBDTVariables ()
 
void computeBDTScore ()
 
void computeETEstimate ()
 
void computeEMETEstimate ()
 
void computeHADETEstimate ()
 
void computeFracCondition ()
 
void computeBDTCondition ()
 
void computeTowers ()
 
void computeIsCentralTowerSeed ()
 
void debugPrintBDTVariables ()
 
void debugPrintTowers ()
 
void initBDTVars ()
 
void initETPointers ()
 
void initEMETPointers ()
 
void initHADETPointers ()
 
void initTowersPointers ()
 
unsigned int getETEstimate () const
 
unsigned int getEMETEstimate () const
 
unsigned int getEMETEstimateOverflow () const
 
unsigned int getHADETEstimate () const
 
unsigned int getHADETEstimateOverflow () const
 
std::vector< unsigned int > & getBDTVars ()
 
std::vector< unsigned int > & getTowers ()
 
std::vector< unsigned int > & getEMMultipliedByFracParams ()
 
std::vector< unsigned int > & getEMMultipliedByFracParamsOverflow ()
 
unsigned int getBDTScoreShifted () const
 
unsigned int getET () const
 
unsigned int getTOBETOverflow () const
 
unsigned int getIsMax () const
 
unsigned int getBDTCondition () const
 
unsigned int getFracCondition () const
 
unsigned int getBDTScore () const
 
unsigned int multWithOverflow (unsigned int a, unsigned int b, bool &overflow, int resultNBits)
 
bool isOverflow (unsigned int number, int nBits)
 
unsigned int BitLeftShift (unsigned int number, int by, int totalNBits)
 
int flatTowerIndex (int eta, int phi)
 

Private Member Functions

void initPointers (const std::vector< std::vector< int >> &scells, std::vector< unsigned int * > &ptr_list)
 
unsigned int computeEstimate (std::vector< unsigned int * > &ptr_list, bool &overflow, int resultNBits)
 
unsigned int * superCellToPtr (int eta, int phi, int layer)
 

Private Attributes

unsigned int * m_em0cells [3][3] {}
 
unsigned int * m_em1cells [12][3] {}
 
unsigned int * m_em2cells [12][3] {}
 
unsigned int * m_em3cells [3][3] {}
 
unsigned int * m_hadcells [3][3] {}
 
unsigned int * m_fracMultipliers [3] {}
 
unsigned int * m_bdtThresholds [3] {}
 
unsigned int * m_etThreshold {}
 
unsigned int * m_maxEtThreshold {}
 
unsigned int * m_maxEtThresholdFrac {}
 
unsigned int * m_bdtMinEtThreshold {}
 
unsigned int m_bdtScore = 0
 
unsigned int m_bdtScoreShifted = 0
 
unsigned int m_eTEstimate = 0
 
bool m_eTEstimateOverflow = false
 
unsigned int m_EM_eTEstimate = 0
 
bool m_EM_eTEstimateOverflow = 0
 
unsigned int m_HAD_eTEstimate = 0
 
bool m_HAD_eTEstimateOverflow = false
 
unsigned int m_fracCondition = 0
 
unsigned int m_bdtCondition = 0
 
bool m_isSeeded = false
 
unsigned int m_hadEstimateShifted = 0
 
std::vector< unsigned int > m_emEtXMultiplier
 
std::vector< unsigned int > m_emEtXMultiplierOverflow
 
std::vector< unsigned int > m_towers
 
std::vector< unsigned int > m_bdtVars
 
std::vector< std::vector< unsigned int * > > m_bdtVarComputeSCellPointers
 
std::vector< unsigned int * > m_eTComputeSCellPointers
 
std::vector< unsigned int * > m_EM_eTComputeSCellPointers
 
std::vector< unsigned int * > m_HAD_eTComputeSCellPointers
 
std::vector< std::vector< unsigned int * > > m_towersComputeSCellPointers
 
bool m_bdtVarsComputed = false
 
eFEXBDT m_bdt
 
AthAlgTool * m_log
 

Detailed Description

The eFEXtauBDT class calculates the tau TOB variables.

Definition at line 26 of file eFEXtauBDT.h.

Constructor & Destructor Documentation

◆ eFEXtauBDT()

LVL1::eFEXtauBDT::eFEXtauBDT ( AthAlgTool *  log,
std::string  config_path 
)

Constructors.

Definition at line 19 of file eFEXtauBDT.cxx.

20  : m_bdt(config_path), m_log(log) {
21  m_log->msg(MSG::DEBUG) << "Configured BDT with this file: " << config_path
22  << endmsg;
23  m_bdtVars.resize(m_bdt.getVariables().size());
24  m_towers.resize(m_bdt.getNTowers());
25  int n_multipliers = sizeof(m_fracMultipliers) / sizeof(m_fracMultipliers[0]);
26  m_emEtXMultiplier.resize(n_multipliers);
27  m_emEtXMultiplierOverflow.resize(n_multipliers);
28 }

◆ ~eFEXtauBDT()

LVL1::eFEXtauBDT::~eFEXtauBDT ( )
virtual

Destructor.

Definition at line 31 of file eFEXtauBDT.cxx.

31 {}

Member Function Documentation

◆ BitLeftShift()

unsigned int LVL1::eFEXtauBDT::BitLeftShift ( unsigned int  number,
int  by,
int  totalNBits 
)
inline

Definition at line 310 of file eFEXtauBDT.cxx.

311  {
312  if ((number >> (totalNBits - by)) != 0) {
313  return (1 << totalNBits) - 1;
314  }
315  return number << by;
316 }

◆ buildBDTVariables()

void LVL1::eFEXtauBDT::buildBDTVariables ( )

Definition at line 201 of file eFEXtauBDT.cxx.

201  {
202  for (size_t i = 0; i < m_bdtVarComputeSCellPointers.size(); i++) {
203  bool overflow;
204  m_bdtVars[i] = computeEstimate(m_bdtVarComputeSCellPointers[i], overflow,
205  ENERGY_WIDTH);
206  if (overflow) {
207  m_bdtVars[i] = (1 << ENERGY_WIDTH) - 1;
208  }
209  }
210  debugPrintBDTVariables();
211  m_bdtVarsComputed = true;
212 }

◆ computeBDTCondition()

void LVL1::eFEXtauBDT::computeBDTCondition ( )

Definition at line 350 of file eFEXtauBDT.cxx.

350  {
351  computeBDTScore();
352  int n_thresholds = sizeof(m_bdtThresholds) / sizeof(m_bdtThresholds[0]);
353 
354  int toShiftRight = m_bdt.getScorePrecision() - PARAM_WIDTH;
355  // Only compare the MSB bits of the BDT score to the thresholds provided in
356  // the parameters
357  m_bdtScoreShifted = (m_bdtScore >> toShiftRight);
358 
359  if ((m_eTEstimate >= *m_maxEtThreshold) or m_eTEstimateOverflow or
360  m_eTEstimate < *m_bdtMinEtThreshold) {
361 
362  m_bdtCondition = (1 << (n_thresholds - 1)) - 1;
363  return;
364  }
365 
366  int i = 0;
367  for (; i < n_thresholds; i++) {
368  if (m_bdtScoreShifted < *(m_bdtThresholds[i])) {
369  break;
370  }
371  }
372  m_bdtCondition = i;
373 }

◆ computeBDTScore()

void LVL1::eFEXtauBDT::computeBDTScore ( )

Definition at line 214 of file eFEXtauBDT.cxx.

214  {
215  // Need BDT variables to be computed
216  if (m_bdtVarsComputed == false) {
217  m_log->msg(MSG::DEBUG)
218  << "BDT Variables not computed. BDT score will be garbage." << endmsg;
219  }
220 
221  m_bdtScore = m_bdt.getBDT().decision_function(m_bdtVars)[0];
222  m_log->msg(MSG::DEBUG) << "BDT Score: " << m_bdtScore << endmsg;
223 }

◆ computeEMETEstimate()

void LVL1::eFEXtauBDT::computeEMETEstimate ( )

Definition at line 231 of file eFEXtauBDT.cxx.

231  {
232  m_EM_eTEstimate = computeEstimate(m_EM_eTComputeSCellPointers,
233  m_EM_eTEstimateOverflow, ENERGY_WIDTH);
234  m_log->msg(MSG::DEBUG) << "EM ET Estimate: " << m_EM_eTEstimate << endmsg;
235 }

◆ computeEstimate()

unsigned int LVL1::eFEXtauBDT::computeEstimate ( std::vector< unsigned int * > &  ptr_list,
bool &  overflow,
int  resultNBits 
)
private

Definition at line 278 of file eFEXtauBDT.cxx.

279  {
280  unsigned int estimate = 0;
281  overflow = false;
282  for (unsigned int *it : ptr_list) {
283  estimate += *it;
284  if (isOverflow(estimate, resultNBits)) {
285  overflow = true;
286  }
287  }
288  return estimate;
289 }

◆ computeETEstimate()

void LVL1::eFEXtauBDT::computeETEstimate ( )

Definition at line 225 of file eFEXtauBDT.cxx.

225  {
226  m_eTEstimate = computeEstimate(m_eTComputeSCellPointers, m_eTEstimateOverflow,
227  ENERGY_WIDTH);
228  m_log->msg(MSG::DEBUG) << "ET Estimate: " << m_eTEstimate << endmsg;
229 }

◆ computeFracCondition()

void LVL1::eFEXtauBDT::computeFracCondition ( )

Definition at line 318 of file eFEXtauBDT.cxx.

318  {
319  int n_multipliers = sizeof(m_fracMultipliers) / sizeof(m_fracMultipliers[0]);
320 
321  if ((m_eTEstimate >= *m_maxEtThresholdFrac) or m_eTEstimateOverflow or
322  m_HAD_eTEstimateOverflow) {
323 
324  m_fracCondition = (1 << (n_multipliers - 1)) - 1;
325  return;
326  }
327 
328  if (m_EM_eTEstimateOverflow) {
329  m_fracCondition = 0;
330  return;
331  }
332 
333  m_hadEstimateShifted = BitLeftShift(m_HAD_eTEstimate, 3, ENERGY_WIDTH);
334  int i = 0;
335  for (; i < n_multipliers; i++) {
336 
337  bool overflow;
338  m_emEtXMultiplier[i] = multWithOverflow(
339  *(m_fracMultipliers[i]), m_EM_eTEstimate, overflow, ENERGY_WIDTH);
340  m_emEtXMultiplierOverflow[i] = (int)overflow;
341 
342  if ((m_hadEstimateShifted < m_emEtXMultiplier[i]) or
343  m_emEtXMultiplierOverflow[i]) {
344  break;
345  }
346  }
347  m_fracCondition = i;
348 }

◆ computeHADETEstimate()

void LVL1::eFEXtauBDT::computeHADETEstimate ( )

Definition at line 237 of file eFEXtauBDT.cxx.

237  {
238  m_HAD_eTEstimate = computeEstimate(m_HAD_eTComputeSCellPointers,
239  m_HAD_eTEstimateOverflow, ENERGY_WIDTH);
240  m_log->msg(MSG::DEBUG) << "HAD ET Estimate: " << m_HAD_eTEstimate << endmsg;
241 }

◆ computeIsCentralTowerSeed()

void LVL1::eFEXtauBDT::computeIsCentralTowerSeed ( )

Definition at line 377 of file eFEXtauBDT.cxx.

377  {
378  m_isSeeded = true;
379 
380  // Get central tower ET
381  unsigned int centralET = m_towers[4];
382 
383  // Loop over all cells and check that the central tower is a local maximum
384  for (unsigned int beta = 0; beta < 3; beta++) {
385  for (unsigned int bphi = 0; bphi < 3; bphi++) {
386  int flatIndex = flatTowerIndex(beta, bphi);
387  // Don't need to compare central cell with itself
388  if ((beta == 1) && (bphi == 1)) {
389  continue;
390  }
391 
392  // Cells to the up and right must have strictly lesser ET
393  if (beta == 2 || (beta == 1 && bphi == 2)) {
394  if (centralET <= m_towers[flatIndex]) {
395  m_isSeeded = false;
396  }
397  }
398  // Cells down and to the left must have lesser or equal ET. If strictly
399  // lesser would create zero TOB if two adjacent cells had equal energy
400  else if (beta == 0 || (beta == 1 && bphi == 0)) {
401  if (centralET < m_towers[flatIndex]) {
402  m_isSeeded = false;
403  }
404  }
405  }
406  }
407 
408  if (m_eTEstimate < *m_etThreshold) {
409  m_isSeeded = false;
410  }
411 
412  m_log->msg(MSG::DEBUG) << "Seeded: " << (int)m_isSeeded << endmsg;
413 }

◆ computeTowers()

void LVL1::eFEXtauBDT::computeTowers ( )

Definition at line 257 of file eFEXtauBDT.cxx.

257  {
258  for (size_t i = 0; i < m_towers.size(); i++) {
259  bool overflow;
260  m_towers[i] = computeEstimate(m_towersComputeSCellPointers[i], overflow,
261  ENERGY_WIDTH);
262  if (overflow) {
263  m_towers[i] = (1 << ENERGY_WIDTH) - 1;
264  }
265  }
266 
267  debugPrintTowers();
268 }

◆ debugPrintBDTVariables()

void LVL1::eFEXtauBDT::debugPrintBDTVariables ( )

Definition at line 191 of file eFEXtauBDT.cxx.

191  {
192  std::string bdtVariables = "";
193  for (size_t i = 0; i < m_bdtVars.size(); i++) {
194  bdtVariables += std::to_string(m_bdtVars[i]) + " ";
195  }
196 
197  m_log->msg(MSG::DEBUG) << "BDT Variables: " << bdtVariables << endmsg;
198 }

◆ debugPrintTowers()

void LVL1::eFEXtauBDT::debugPrintTowers ( )

Definition at line 243 of file eFEXtauBDT.cxx.

243  {
244  m_log->msg(MSG::DEBUG) << "Towers Estimate: " << endmsg;
245  for (int eta = 0; eta < 3; eta++) {
246  for (int phi = 0; phi < 3; phi++) {
247  int flatIndex = flatTowerIndex(eta, phi);
248  m_log->msg(MSG::DEBUG)
249  << "Tower " << flatIndex << " ET (eta=" << eta << ", phi=" << phi
250  << "): " << m_towers[flatIndex] << endmsg;
251  }
252  }
253 }

◆ flatTowerIndex()

int LVL1::eFEXtauBDT::flatTowerIndex ( int  eta,
int  phi 
)
inline

Definition at line 255 of file eFEXtauBDT.cxx.

255 { return 3 * phi + eta; }

◆ getBDTCondition()

unsigned int LVL1::eFEXtauBDT::getBDTCondition ( ) const
inline

Definition at line 87 of file eFEXtauBDT.h.

87 { return m_bdtCondition; }

◆ getBDTScore()

unsigned int LVL1::eFEXtauBDT::getBDTScore ( ) const
inline

Definition at line 89 of file eFEXtauBDT.h.

89 { return m_bdtScore; }

◆ getBDTScoreShifted()

unsigned int LVL1::eFEXtauBDT::getBDTScoreShifted ( ) const
inline

Definition at line 79 of file eFEXtauBDT.h.

79 { return m_bdtScoreShifted; }

◆ getBDTVars()

std::vector<unsigned int>& LVL1::eFEXtauBDT::getBDTVars ( )
inline

Definition at line 71 of file eFEXtauBDT.h.

71 { return m_bdtVars; }

◆ getEMETEstimate()

unsigned int LVL1::eFEXtauBDT::getEMETEstimate ( ) const
inline

Definition at line 63 of file eFEXtauBDT.h.

63 { return m_EM_eTEstimate; }

◆ getEMETEstimateOverflow()

unsigned int LVL1::eFEXtauBDT::getEMETEstimateOverflow ( ) const
inline

Definition at line 64 of file eFEXtauBDT.h.

64  {
65  return m_EM_eTEstimateOverflow;
66  }

◆ getEMMultipliedByFracParams()

std::vector<unsigned int>& LVL1::eFEXtauBDT::getEMMultipliedByFracParams ( )
inline

Definition at line 73 of file eFEXtauBDT.h.

73  {
74  return m_emEtXMultiplier;
75  }

◆ getEMMultipliedByFracParamsOverflow()

std::vector<unsigned int>& LVL1::eFEXtauBDT::getEMMultipliedByFracParamsOverflow ( )
inline

Definition at line 76 of file eFEXtauBDT.h.

76  {
77  return m_emEtXMultiplierOverflow;
78  }

◆ getET()

unsigned int LVL1::eFEXtauBDT::getET ( ) const

Definition at line 415 of file eFEXtauBDT.cxx.

415  {
416  if (m_eTEstimateOverflow) {
417  return (1 << ENERGY_WIDTH) - 1;
418  }
419  if (m_eTEstimate < *m_etThreshold) {
420  return 0;
421  }
422  return m_eTEstimate;
423 }

◆ getETEstimate()

unsigned int LVL1::eFEXtauBDT::getETEstimate ( ) const
inline

Definition at line 62 of file eFEXtauBDT.h.

62 { return m_eTEstimate; }

◆ getFracCondition()

unsigned int LVL1::eFEXtauBDT::getFracCondition ( ) const
inline

Definition at line 88 of file eFEXtauBDT.h.

88 { return m_fracCondition; }

◆ getHADETEstimate()

unsigned int LVL1::eFEXtauBDT::getHADETEstimate ( ) const
inline

Definition at line 67 of file eFEXtauBDT.h.

67 { return m_HAD_eTEstimate; }

◆ getHADETEstimateOverflow()

unsigned int LVL1::eFEXtauBDT::getHADETEstimateOverflow ( ) const
inline

Definition at line 68 of file eFEXtauBDT.h.

68  {
69  return m_HAD_eTEstimateOverflow;
70  }

◆ getIsMax()

unsigned int LVL1::eFEXtauBDT::getIsMax ( ) const
inline

Definition at line 86 of file eFEXtauBDT.h.

86 { return m_isSeeded; }

◆ getTOBETOverflow()

unsigned int LVL1::eFEXtauBDT::getTOBETOverflow ( ) const
inline

Definition at line 85 of file eFEXtauBDT.h.

85 { return m_eTEstimateOverflow; }

◆ getTowers()

std::vector<unsigned int>& LVL1::eFEXtauBDT::getTowers ( )
inline

Definition at line 72 of file eFEXtauBDT.h.

72 { return m_towers; }

◆ initBDTVars()

void LVL1::eFEXtauBDT::initBDTVars ( )

Definition at line 149 of file eFEXtauBDT.cxx.

149  {
150  for (size_t i = 0; i < m_bdt.getVariables().size(); i++) {
151  BDTVariable var = m_bdt.getVariables()[i];
152 
153  m_log->msg(MSG::DEBUG) << i << " is " << var.m_name << ", sum of supercells"
154  << endmsg;
155  std::vector<unsigned int *> pointersToSCells;
156  for (size_t j = 0; j < var.m_scells.size(); j++) {
157  int eta = var.m_scells[j][0];
158  int phi = var.m_scells[j][1];
159  int layer = var.m_scells[j][2];
160  m_log->msg(MSG::DEBUG) << "\teta=" << eta << "\tphi=" << phi
161  << "\tlayer=" << layer << endmsg;
162  unsigned int *ptr = superCellToPtr(eta, phi, layer);
163  if (ptr == 0) {
164  m_log->msg(MSG::DEBUG)
165  << "Could not convert eta=" << eta << " phi=" << phi
166  << " layer=" << layer
167  << " to a pointer to supercell. Are they within range?" << endmsg;
168  throw std::domain_error(
169  std::string("Could not convert eta=") + std::to_string(eta) +
170  " phi=" + std::to_string(phi) + " layer=" + std::to_string(layer) +
171  " to a pointer to supercell. Are they within range?");
172  }
173  pointersToSCells.push_back(ptr);
174  }
175 
176  m_bdtVarComputeSCellPointers.push_back(pointersToSCells);
177  }
178 }

◆ initEMETPointers()

void LVL1::eFEXtauBDT::initEMETPointers ( )

Definition at line 109 of file eFEXtauBDT.cxx.

109  {
110  initPointers(m_bdt.getEMETSCells(), m_EM_eTComputeSCellPointers);
111 }

◆ initETPointers()

void LVL1::eFEXtauBDT::initETPointers ( )

Definition at line 105 of file eFEXtauBDT.cxx.

105  {
106  initPointers(m_bdt.getETSCells(), m_eTComputeSCellPointers);
107 }

◆ initHADETPointers()

void LVL1::eFEXtauBDT::initHADETPointers ( )

Definition at line 113 of file eFEXtauBDT.cxx.

113  {
114  initPointers(m_bdt.getHADETSCells(), m_HAD_eTComputeSCellPointers);
115 }

◆ initPointers()

void LVL1::eFEXtauBDT::initPointers ( const std::vector< std::vector< int >> &  scells,
std::vector< unsigned int * > &  ptr_list 
)
private

Definition at line 117 of file eFEXtauBDT.cxx.

118  {
119  m_log->msg(MSG::DEBUG) << "Will use sum of supercells: " << endmsg;
120  for (const auto& scell : scells) {
121  int eta = scell[0];
122  int phi = scell[1];
123  int layer = scell[2];
124  m_log->msg(MSG::DEBUG) << "\teta=" << eta << "\tphi=" << phi
125  << "\tlayer=" << layer << endmsg;
126  unsigned int *ptr = superCellToPtr(eta, phi, layer);
127  if (ptr == 0) {
128  m_log->msg(MSG::DEBUG)
129  << "Could not convert eta=" << eta << " phi=" << phi
130  << " layer=" << layer
131  << " to a pointer to supercell. Are they within range?" << endmsg;
132  throw std::domain_error(
133  std::string("Could not convert eta=") + std::to_string(eta) +
134  " phi=" + std::to_string(phi) + " layer=" + std::to_string(layer) +
135  " to a pointer to supercell. Are they within range?");
136  }
137  ptr_list.push_back(ptr);
138  }
139 }

◆ initTowersPointers()

void LVL1::eFEXtauBDT::initTowersPointers ( )

Definition at line 141 of file eFEXtauBDT.cxx.

141  {
142  m_towersComputeSCellPointers.resize(m_bdt.getNTowers());
143  for (size_t i = 0; i < m_towers.size(); i++) {
144  m_log->msg(MSG::DEBUG) << "Tower " << i << endmsg;
145  initPointers(m_bdt.getTowerSCells(i), m_towersComputeSCellPointers[i]);
146  }
147 }

◆ isOverflow()

bool LVL1::eFEXtauBDT::isOverflow ( unsigned int  number,
int  nBits 
)
inline

Definition at line 270 of file eFEXtauBDT.cxx.

270  {
271  if ((number >> nBits) != 0) {
272  return true;
273  }
274  return false;
275 }

◆ multWithOverflow()

unsigned int LVL1::eFEXtauBDT::multWithOverflow ( unsigned int  a,
unsigned int  b,
bool &  overflow,
int  resultNBits 
)

Definition at line 291 of file eFEXtauBDT.cxx.

293  {
294  overflow = false;
295  if (b == 0) {
296  return 0;
297  }
298  unsigned int result = a * b;
299  if (a != result / b) {
300  // This shouldn't happen (a and b are in reality 16 bit numbers), but just
301  // in case.
302  overflow = true;
303  }
304 
305  overflow = isOverflow(result, resultNBits);
306 
307  return result;
308 }

◆ next()

void LVL1::eFEXtauBDT::next ( )

Definition at line 180 of file eFEXtauBDT.cxx.

180  {
181  buildBDTVariables();
182  computeTowers();
183  computeETEstimate();
184  computeHADETEstimate();
185  computeEMETEstimate();
186  computeBDTCondition();
187  computeFracCondition();
188  computeIsCentralTowerSeed();
189 }

◆ setPointerToBDTMinETParam()

void LVL1::eFEXtauBDT::setPointerToBDTMinETParam ( unsigned int *  bdtMinEtThreshold)

Definition at line 78 of file eFEXtauBDT.cxx.

79  {
80  m_bdtMinEtThreshold = bdtMinEtThreshold;
81 }

◆ setPointerToBDTThresholdsParam()

void LVL1::eFEXtauBDT::setPointerToBDTThresholdsParam ( int  index,
unsigned int *  bdtThresholds 
)

Definition at line 59 of file eFEXtauBDT.cxx.

60  {
61  m_bdtThresholds[index] = bdtThresholdPtr;
62 }

◆ setPointerToETThresholdParam()

void LVL1::eFEXtauBDT::setPointerToETThresholdParam ( unsigned int *  etThreshold)

Definition at line 64 of file eFEXtauBDT.cxx.

64  {
65  m_etThreshold = etThreshold;
66 }

◆ setPointerToFracMultipliersParam()

void LVL1::eFEXtauBDT::setPointerToFracMultipliersParam ( int  index,
unsigned int *  fracMultipliers 
)

Definition at line 54 of file eFEXtauBDT.cxx.

55  {
56  m_fracMultipliers[index] = fracMultiplierPtr;
57 }

◆ setPointerToMaxETParam()

void LVL1::eFEXtauBDT::setPointerToMaxETParam ( unsigned int *  maxEtThreshold)

Definition at line 68 of file eFEXtauBDT.cxx.

69  {
70  m_maxEtThreshold = maxEtThreshold;
71 }

◆ setPointerToMaxETParamFrac()

void LVL1::eFEXtauBDT::setPointerToMaxETParamFrac ( unsigned int *  maxEtThreshold)

Definition at line 73 of file eFEXtauBDT.cxx.

74  {
75  m_maxEtThresholdFrac = maxEtThreshold;
76 }

◆ setPointerToSCell()

void LVL1::eFEXtauBDT::setPointerToSCell ( int  eta,
int  phi,
int  layer,
unsigned int *  sCellPtr 
)

Definition at line 33 of file eFEXtauBDT.cxx.

34  {
35  switch (layer) {
36  case 0:
37  m_em0cells[eta][phi] = sCellPtr;
38  break;
39  case 1:
40  m_em1cells[eta][phi] = sCellPtr;
41  break;
42  case 2:
43  m_em2cells[eta][phi] = sCellPtr;
44  break;
45  case 3:
46  m_em3cells[eta][phi] = sCellPtr;
47  break;
48  case 4:
49  m_hadcells[eta][phi] = sCellPtr;
50  break;
51  }
52 }

◆ superCellToPtr()

unsigned int * LVL1::eFEXtauBDT::superCellToPtr ( int  eta,
int  phi,
int  layer 
)
private

Definition at line 83 of file eFEXtauBDT.cxx.

83  {
84  unsigned int *ptr = 0;
85  switch (layer) {
86  case 0:
87  ptr = m_em0cells[eta][phi];
88  break;
89  case 1:
90  ptr = m_em1cells[eta][phi];
91  break;
92  case 2:
93  ptr = m_em2cells[eta][phi];
94  break;
95  case 3:
96  ptr = m_em3cells[eta][phi];
97  break;
98  case 4:
99  ptr = m_hadcells[eta][phi];
100  break;
101  }
102  return ptr;
103 }

Member Data Documentation

◆ m_bdt

eFEXBDT LVL1::eFEXtauBDT::m_bdt
private

Definition at line 149 of file eFEXtauBDT.h.

◆ m_bdtCondition

unsigned int LVL1::eFEXtauBDT::m_bdtCondition = 0
private

Definition at line 126 of file eFEXtauBDT.h.

◆ m_bdtMinEtThreshold

unsigned int* LVL1::eFEXtauBDT::m_bdtMinEtThreshold {}
private

Definition at line 116 of file eFEXtauBDT.h.

◆ m_bdtScore

unsigned int LVL1::eFEXtauBDT::m_bdtScore = 0
private

Definition at line 117 of file eFEXtauBDT.h.

◆ m_bdtScoreShifted

unsigned int LVL1::eFEXtauBDT::m_bdtScoreShifted = 0
private

Definition at line 118 of file eFEXtauBDT.h.

◆ m_bdtThresholds

unsigned int* LVL1::eFEXtauBDT::m_bdtThresholds[3] {}
private

Definition at line 112 of file eFEXtauBDT.h.

◆ m_bdtVarComputeSCellPointers

std::vector<std::vector<unsigned int *> > LVL1::eFEXtauBDT::m_bdtVarComputeSCellPointers
private

Definition at line 139 of file eFEXtauBDT.h.

◆ m_bdtVars

std::vector<unsigned int> LVL1::eFEXtauBDT::m_bdtVars
private

Definition at line 134 of file eFEXtauBDT.h.

◆ m_bdtVarsComputed

bool LVL1::eFEXtauBDT::m_bdtVarsComputed = false
private

Definition at line 148 of file eFEXtauBDT.h.

◆ m_em0cells

unsigned int* LVL1::eFEXtauBDT::m_em0cells[3][3] {}
private

Definition at line 106 of file eFEXtauBDT.h.

◆ m_em1cells

unsigned int* LVL1::eFEXtauBDT::m_em1cells[12][3] {}
private

Definition at line 107 of file eFEXtauBDT.h.

◆ m_em2cells

unsigned int* LVL1::eFEXtauBDT::m_em2cells[12][3] {}
private

Definition at line 108 of file eFEXtauBDT.h.

◆ m_em3cells

unsigned int* LVL1::eFEXtauBDT::m_em3cells[3][3] {}
private

Definition at line 109 of file eFEXtauBDT.h.

◆ m_EM_eTComputeSCellPointers

std::vector<unsigned int *> LVL1::eFEXtauBDT::m_EM_eTComputeSCellPointers
private

Definition at line 144 of file eFEXtauBDT.h.

◆ m_EM_eTEstimate

unsigned int LVL1::eFEXtauBDT::m_EM_eTEstimate = 0
private

Definition at line 121 of file eFEXtauBDT.h.

◆ m_EM_eTEstimateOverflow

bool LVL1::eFEXtauBDT::m_EM_eTEstimateOverflow = 0
private

Definition at line 122 of file eFEXtauBDT.h.

◆ m_emEtXMultiplier

std::vector<unsigned int> LVL1::eFEXtauBDT::m_emEtXMultiplier
private

Definition at line 129 of file eFEXtauBDT.h.

◆ m_emEtXMultiplierOverflow

std::vector<unsigned int> LVL1::eFEXtauBDT::m_emEtXMultiplierOverflow
private

Definition at line 130 of file eFEXtauBDT.h.

◆ m_eTComputeSCellPointers

std::vector<unsigned int *> LVL1::eFEXtauBDT::m_eTComputeSCellPointers
private

Definition at line 143 of file eFEXtauBDT.h.

◆ m_eTEstimate

unsigned int LVL1::eFEXtauBDT::m_eTEstimate = 0
private

Definition at line 119 of file eFEXtauBDT.h.

◆ m_eTEstimateOverflow

bool LVL1::eFEXtauBDT::m_eTEstimateOverflow = false
private

Definition at line 120 of file eFEXtauBDT.h.

◆ m_etThreshold

unsigned int* LVL1::eFEXtauBDT::m_etThreshold {}
private

Definition at line 113 of file eFEXtauBDT.h.

◆ m_fracCondition

unsigned int LVL1::eFEXtauBDT::m_fracCondition = 0
private

Definition at line 125 of file eFEXtauBDT.h.

◆ m_fracMultipliers

unsigned int* LVL1::eFEXtauBDT::m_fracMultipliers[3] {}
private

Definition at line 111 of file eFEXtauBDT.h.

◆ m_HAD_eTComputeSCellPointers

std::vector<unsigned int *> LVL1::eFEXtauBDT::m_HAD_eTComputeSCellPointers
private

Definition at line 145 of file eFEXtauBDT.h.

◆ m_HAD_eTEstimate

unsigned int LVL1::eFEXtauBDT::m_HAD_eTEstimate = 0
private

Definition at line 123 of file eFEXtauBDT.h.

◆ m_HAD_eTEstimateOverflow

bool LVL1::eFEXtauBDT::m_HAD_eTEstimateOverflow = false
private

Definition at line 124 of file eFEXtauBDT.h.

◆ m_hadcells

unsigned int* LVL1::eFEXtauBDT::m_hadcells[3][3] {}
private

Definition at line 110 of file eFEXtauBDT.h.

◆ m_hadEstimateShifted

unsigned int LVL1::eFEXtauBDT::m_hadEstimateShifted = 0
private

Definition at line 128 of file eFEXtauBDT.h.

◆ m_isSeeded

bool LVL1::eFEXtauBDT::m_isSeeded = false
private

Definition at line 127 of file eFEXtauBDT.h.

◆ m_log

AthAlgTool* LVL1::eFEXtauBDT::m_log
private

Definition at line 150 of file eFEXtauBDT.h.

◆ m_maxEtThreshold

unsigned int* LVL1::eFEXtauBDT::m_maxEtThreshold {}
private

Definition at line 114 of file eFEXtauBDT.h.

◆ m_maxEtThresholdFrac

unsigned int* LVL1::eFEXtauBDT::m_maxEtThresholdFrac {}
private

Definition at line 115 of file eFEXtauBDT.h.

◆ m_towers

std::vector<unsigned int> LVL1::eFEXtauBDT::m_towers
private

Definition at line 131 of file eFEXtauBDT.h.

◆ m_towersComputeSCellPointers

std::vector<std::vector<unsigned int *> > LVL1::eFEXtauBDT::m_towersComputeSCellPointers
private

Definition at line 146 of file eFEXtauBDT.h.

The documentation for this class was generated from the following files:
LVL1::eFEXtauBDT::computeBDTCondition
void computeBDTCondition()
Definition: eFEXtauBDT.cxx:350
LVL1::eFEXtauBDT::m_towers
std::vector< unsigned int > m_towers
Definition: eFEXtauBDT.h:131
beamspotnt.var
var
Definition: bin/beamspotnt.py:1393
LVL1::eFEXtauBDT::m_maxEtThresholdFrac
unsigned int * m_maxEtThresholdFrac
Definition: eFEXtauBDT.h:115
LVL1::eFEXtauBDT::m_bdt
eFEXBDT m_bdt
Definition: eFEXtauBDT.h:149
LVL1::eFEXtauBDT::flatTowerIndex
int flatTowerIndex(int eta, int phi)
Definition: eFEXtauBDT.cxx:255
LVL1::eFEXtauBDT::m_HAD_eTEstimate
unsigned int m_HAD_eTEstimate
Definition: eFEXtauBDT.h:123
LVL1::eFEXtauBDT::m_bdtVarComputeSCellPointers
std::vector< std::vector< unsigned int * > > m_bdtVarComputeSCellPointers
Definition: eFEXtauBDT.h:139
get_generator_info.result
result
Definition: get_generator_info.py:21
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
LVL1::eFEXtauBDT::initPointers
void initPointers(const std::vector< std::vector< int >> &scells, std::vector< unsigned int * > &ptr_list)
Definition: eFEXtauBDT.cxx:117
eFEXBDT::getBDT
const conifer::BDT< unsigned int, unsigned int > & getBDT() const
Definition: eFEXBDT.h:72
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
LVL1::eFEXtauBDT::m_eTComputeSCellPointers
std::vector< unsigned int * > m_eTComputeSCellPointers
Definition: eFEXtauBDT.h:143
eFEXBDT::getVariables
const std::vector< BDTVariable > & getVariables() const
Definition: eFEXBDT.h:58
LVL1::eFEXtauBDT::m_maxEtThreshold
unsigned int * m_maxEtThreshold
Definition: eFEXtauBDT.h:114
skel.it
it
Definition: skel.GENtoEVGEN.py:407
LVL1::eFEXtauBDT::debugPrintBDTVariables
void debugPrintBDTVariables()
Definition: eFEXtauBDT.cxx:191
LVL1::eFEXtauBDT::debugPrintTowers
void debugPrintTowers()
Definition: eFEXtauBDT.cxx:243
LVL1::eFEXtauBDT::isOverflow
bool isOverflow(unsigned int number, int nBits)
Definition: eFEXtauBDT.cxx:270
LVL1::eFEXtauBDT::m_eTEstimateOverflow
bool m_eTEstimateOverflow
Definition: eFEXtauBDT.h:120
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
LVL1::eFEXtauBDT::computeETEstimate
void computeETEstimate()
Definition: eFEXtauBDT.cxx:225
LVL1::eFEXtauBDT::computeEMETEstimate
void computeEMETEstimate()
Definition: eFEXtauBDT.cxx:231
LVL1::eFEXtauBDT::m_bdtVarsComputed
bool m_bdtVarsComputed
Definition: eFEXtauBDT.h:148
ENERGY_WIDTH
#define ENERGY_WIDTH
Definition: eFEXtauBDT.cxx:15
LVL1::eFEXtauBDT::computeTowers
void computeTowers()
Definition: eFEXtauBDT.cxx:257
LVL1::eFEXtauBDT::m_bdtMinEtThreshold
unsigned int * m_bdtMinEtThreshold
Definition: eFEXtauBDT.h:116
LVL1::eFEXtauBDT::m_bdtScoreShifted
unsigned int m_bdtScoreShifted
Definition: eFEXtauBDT.h:118
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
LVL1::eFEXtauBDT::m_log
AthAlgTool * m_log
Definition: eFEXtauBDT.h:150
LVL1::eFEXtauBDT::m_hadcells
unsigned int * m_hadcells[3][3]
Definition: eFEXtauBDT.h:110
lumiFormat.i
int i
Definition: lumiFormat.py:85
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
LVL1::eFEXtauBDT::m_EM_eTComputeSCellPointers
std::vector< unsigned int * > m_EM_eTComputeSCellPointers
Definition: eFEXtauBDT.h:144
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
LVL1::eFEXtauBDT::m_towersComputeSCellPointers
std::vector< std::vector< unsigned int * > > m_towersComputeSCellPointers
Definition: eFEXtauBDT.h:146
conifer::BDT::decision_function
std::vector< U > decision_function(std::vector< T > x) const
Definition: conifer.h:121
eFEXBDT::getETSCells
const std::vector< std::vector< int > > & getETSCells() const
Definition: eFEXBDT.h:60
LVL1::eFEXtauBDT::m_em0cells
unsigned int * m_em0cells[3][3]
Definition: eFEXtauBDT.h:106
fitman.by
by
Definition: fitman.py:411
LVL1::eFEXtauBDT::m_EM_eTEstimate
unsigned int m_EM_eTEstimate
Definition: eFEXtauBDT.h:121
LVL1::eFEXtauBDT::m_hadEstimateShifted
unsigned int m_hadEstimateShifted
Definition: eFEXtauBDT.h:128
LVL1::eFEXtauBDT::m_fracCondition
unsigned int m_fracCondition
Definition: eFEXtauBDT.h:125
internal_poltrig::estimate
REAL estimate(const int &elen, REAL *e)
Definition: PolygonTriangulator.cxx:451
eFEXBDT::getEMETSCells
const std::vector< std::vector< int > > & getEMETSCells() const
Definition: eFEXBDT.h:64
LVL1::eFEXtauBDT::m_em3cells
unsigned int * m_em3cells[3][3]
Definition: eFEXtauBDT.h:109
python.selection.number
number
Definition: selection.py:20
LVL1::eFEXtauBDT::m_HAD_eTComputeSCellPointers
std::vector< unsigned int * > m_HAD_eTComputeSCellPointers
Definition: eFEXtauBDT.h:145
LVL1::eFEXtauBDT::m_emEtXMultiplier
std::vector< unsigned int > m_emEtXMultiplier
Definition: eFEXtauBDT.h:129
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
LVL1::eFEXtauBDT::m_fracMultipliers
unsigned int * m_fracMultipliers[3]
Definition: eFEXtauBDT.h:111
eFEXBDT::getNTowers
int getNTowers() const
Definition: eFEXBDT.h:80
LVL1::eFEXtauBDT::buildBDTVariables
void buildBDTVariables()
Definition: eFEXtauBDT.cxx:201
DeMoScan.index
string index
Definition: DeMoScan.py:362
LVL1::eFEXtauBDT::m_em2cells
unsigned int * m_em2cells[12][3]
Definition: eFEXtauBDT.h:108
a
TList * a
Definition: liststreamerinfos.cxx:10
eFEXBDT::getScorePrecision
int getScorePrecision() const
Definition: eFEXBDT.h:82
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
LVL1::eFEXtauBDT::computeBDTScore
void computeBDTScore()
Definition: eFEXtauBDT.cxx:214
LVL1::eFEXtauBDT::m_bdtScore
unsigned int m_bdtScore
Definition: eFEXtauBDT.h:117
DEBUG
#define DEBUG
Definition: page_access.h:11
eFEXBDT::getTowerSCells
const std::vector< std::vector< int > > & getTowerSCells(int towerIndex) const
Definition: eFEXBDT.h:76
LVL1::eFEXtauBDT::m_isSeeded
bool m_isSeeded
Definition: eFEXtauBDT.h:127
AthCommonMsg::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
LVL1::eFEXtauBDT::computeFracCondition
void computeFracCondition()
Definition: eFEXtauBDT.cxx:318
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
PARAM_WIDTH
#define PARAM_WIDTH
Definition: eFEXtauBDT.cxx:16
LVL1::eFEXtauBDT::superCellToPtr
unsigned int * superCellToPtr(int eta, int phi, int layer)
Definition: eFEXtauBDT.cxx:83
LVL1::eFEXtauBDT::m_bdtThresholds
unsigned int * m_bdtThresholds[3]
Definition: eFEXtauBDT.h:112
LVL1::eFEXtauBDT::m_emEtXMultiplierOverflow
std::vector< unsigned int > m_emEtXMultiplierOverflow
Definition: eFEXtauBDT.h:130
LVL1::eFEXtauBDT::BitLeftShift
unsigned int BitLeftShift(unsigned int number, int by, int totalNBits)
Definition: eFEXtauBDT.cxx:310
LVL1::eFEXtauBDT::m_etThreshold
unsigned int * m_etThreshold
Definition: eFEXtauBDT.h:113
LVL1::eFEXtauBDT::m_HAD_eTEstimateOverflow
bool m_HAD_eTEstimateOverflow
Definition: eFEXtauBDT.h:124
MuonParameters::beta
@ beta
Definition: MuonParamDefs.h:144
LVL1::eFEXtauBDT::m_bdtVars
std::vector< unsigned int > m_bdtVars
Definition: eFEXtauBDT.h:134
LVL1::eFEXtauBDT::m_eTEstimate
unsigned int m_eTEstimate
Definition: eFEXtauBDT.h:119
LVL1::eFEXtauBDT::m_bdtCondition
unsigned int m_bdtCondition
Definition: eFEXtauBDT.h:126
LVL1::eFEXtauBDT::m_em1cells
unsigned int * m_em1cells[12][3]
Definition: eFEXtauBDT.h:107
LVL1::eFEXtauBDT::computeIsCentralTowerSeed
void computeIsCentralTowerSeed()
Definition: eFEXtauBDT.cxx:377
eFEXBDT::getHADETSCells
const std::vector< std::vector< int > > & getHADETSCells() const
Definition: eFEXBDT.h:68
LVL1::eFEXtauBDT::computeEstimate
unsigned int computeEstimate(std::vector< unsigned int * > &ptr_list, bool &overflow, int resultNBits)
Definition: eFEXtauBDT.cxx:278
LVL1::eFEXtauBDT::computeHADETEstimate
void computeHADETEstimate()
Definition: eFEXtauBDT.cxx:237
LVL1::eFEXtauBDT::multWithOverflow
unsigned int multWithOverflow(unsigned int a, unsigned int b, bool &overflow, int resultNBits)
Definition: eFEXtauBDT.cxx:291
BDTVariable
Definition: eFEXBDT.h:16
LVL1::eFEXtauBDT::m_EM_eTEstimateOverflow
bool m_EM_eTEstimateOverflow
Definition: eFEXtauBDT.h:122
Generated on Mon Sep 29 2025 22:06:08 for ATLAS Offline Software by   doxygen 1.8.18