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	setPointerToBDTMinETParam (unsigned int *bdtMinEtThreshold)
void	buildBDTVariables ()
void	computeBDTScore ()
void	computeETEstimate ()
void	computeEMETEstimate ()
void	computeHADETEstimate ()
void	computeFracCondition ()
void	computeBDTCondition ()
void	computeTowers ()
void	computeIsCentralTowerSeed ()
void	debugPrintSCellValues ()
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_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 20 of file eFEXtauBDT.cxx.

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

~eFEXtauBDT()

LVL1::eFEXtauBDT::~eFEXtauBDT ( )

virtual

Destructor.

Definition at line 32 of file eFEXtauBDT.cxx.

{}

Member Function Documentation

BitLeftShift()

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

inline

Definition at line 347 of file eFEXtauBDT.cxx.

                                                            {
  if ((number >> (totalNBits - by)) != 0) {
    return (1 << totalNBits) - 1;
  }
  return number << by;
}

buildBDTVariables()

void LVL1::eFEXtauBDT::buildBDTVariables

(

)

Definition at line 237 of file eFEXtauBDT.cxx.

                                       {
  debugPrintSCellValues();
  for (size_t i = 0; i < m_bdtVarComputeSCellPointers.size(); i++) {
    bool overflow;
    m_bdtVars[i] = computeEstimate(m_bdtVarComputeSCellPointers[i], overflow,
                                   ENERGY_WIDTH);
    if (overflow) {
      m_bdtVars[i] = (1 << ENERGY_WIDTH) - 1;
    }
  }
  debugPrintBDTVariables();
  m_bdtVarsComputed = true;
}

computeBDTCondition()

void LVL1::eFEXtauBDT::computeBDTCondition

(

)

Definition at line 387 of file eFEXtauBDT.cxx.

                                         {
  computeBDTScore();
  int n_thresholds = sizeof(m_bdtThresholds) / sizeof(m_bdtThresholds[0]);
 
  int toShiftRight = m_bdt.getScorePrecision() - PARAM_WIDTH;
  // Only compare the MSB bits of the BDT score to the thresholds provided in
  // the parameters
  m_bdtScoreShifted = (m_bdtScore >> toShiftRight);
 
  if ((m_eTEstimate >= *m_maxEtThreshold) or m_eTEstimateOverflow or
      m_eTEstimate < *m_bdtMinEtThreshold) {
 
    m_bdtCondition = (1 << (n_thresholds - 1)) - 1;
    return;
  }
 
  int i = 0;
  for (; i < n_thresholds; i++) {
    if (m_bdtScoreShifted < *(m_bdtThresholds[i])) {
      break;
    }
  }
  m_bdtCondition = i;
}

computeBDTScore()

void LVL1::eFEXtauBDT::computeBDTScore

(

)

Definition at line 251 of file eFEXtauBDT.cxx.

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

computeEMETEstimate()

void LVL1::eFEXtauBDT::computeEMETEstimate

(

)

Definition at line 268 of file eFEXtauBDT.cxx.

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

computeEstimate()

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

private

Definition at line 315 of file eFEXtauBDT.cxx.

                                                                   {
  unsigned int estimate = 0;
  overflow = false;
  for (unsigned int *it : ptr_list) {
    estimate += *it;
    if (isOverflow(estimate, resultNBits)) {
      overflow = true;
    }
  }
  return estimate;
}

computeETEstimate()

void LVL1::eFEXtauBDT::computeETEstimate

(

)

Definition at line 262 of file eFEXtauBDT.cxx.

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

computeFracCondition()

void LVL1::eFEXtauBDT::computeFracCondition

(

)

Definition at line 355 of file eFEXtauBDT.cxx.

                                          {
  int n_multipliers = sizeof(m_fracMultipliers) / sizeof(m_fracMultipliers[0]);
 
  if ((m_eTEstimate >= *m_maxEtThreshold) or m_eTEstimateOverflow or
      m_HAD_eTEstimateOverflow) {
 
    m_fracCondition = (1 << (n_multipliers - 1)) - 1;
    return;
  }
 
  if (m_EM_eTEstimateOverflow) {
    m_fracCondition = 0;
    return;
  }
 
  m_hadEstimateShifted = BitLeftShift(m_HAD_eTEstimate, 3, ENERGY_WIDTH);
  int i = 0;
  for (; i < n_multipliers; i++) {
 
    bool overflow;
    m_emEtXMultiplier[i] = multWithOverflow(
        *(m_fracMultipliers[i]), m_EM_eTEstimate, overflow, ENERGY_WIDTH);
    m_emEtXMultiplierOverflow[i] = (int)overflow;
 
    if ((m_hadEstimateShifted < m_emEtXMultiplier[i]) or
        m_emEtXMultiplierOverflow[i]) {
      break;
    }
  }
  m_fracCondition = i;
}

computeHADETEstimate()

void LVL1::eFEXtauBDT::computeHADETEstimate

(

)

Definition at line 274 of file eFEXtauBDT.cxx.

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

computeIsCentralTowerSeed()

void LVL1::eFEXtauBDT::computeIsCentralTowerSeed

(

)

Definition at line 414 of file eFEXtauBDT.cxx.

                                               {
  m_isSeeded = true;
 
  // Get central tower ET
  unsigned int centralET = m_towers[4];
 
  // Loop over all cells and check that the central tower is a local maximum
  for (unsigned int beta = 0; beta < 3; beta++) {
    for (unsigned int bphi = 0; bphi < 3; bphi++) {
      int flatIndex = flatTowerIndex(beta, bphi);
      // Don't need to compare central cell with itself
      if ((beta == 1) && (bphi == 1)) {
        continue;
      }
 
      // Cells to the up and right must have strictly lesser ET
      if (beta == 2 || (beta == 1 && bphi == 2)) {
        if (centralET <= m_towers[flatIndex]) {
          m_isSeeded = false;
        }
      }
      // Cells down and to the left must have lesser or equal ET. If strictly
      // lesser would create zero TOB if two adjacent cells had equal energy
      else if (beta == 0 || (beta == 1 && bphi == 0)) {
        if (centralET < m_towers[flatIndex]) {
          m_isSeeded = false;
        }
      }
    }
  }
 
  if (m_eTEstimate < *m_etThreshold) {
    m_isSeeded = false;
  }
 
  m_log->msg(MSG::DEBUG) << "Seeded: " << (int)m_isSeeded << endmsg;
}

computeTowers()

void LVL1::eFEXtauBDT::computeTowers

(

)

Definition at line 294 of file eFEXtauBDT.cxx.

                                   {
  for (size_t i = 0; i < m_towers.size(); i++) {
    bool overflow;
    m_towers[i] = computeEstimate(m_towersComputeSCellPointers[i], overflow,
                                  ENERGY_WIDTH);
    if (overflow) {
      m_towers[i] = (1 << ENERGY_WIDTH) - 1;
    }
  }
 
  debugPrintTowers();
}

debugPrintBDTVariables()

void LVL1::eFEXtauBDT::debugPrintBDTVariables

(

)

Definition at line 227 of file eFEXtauBDT.cxx.

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

debugPrintSCellValues()

void LVL1::eFEXtauBDT::debugPrintSCellValues

(

)

Definition at line 187 of file eFEXtauBDT.cxx.

                                           {
 
  std::string scellValues = "";
  std::string em0Values = "";
  std::string em1Values = "";
  std::string em2Values = "";
  std::string em3Values = "";
  std::string hadValues = "";
  for (size_t i = 0; i < LVL1::locMap.size(); i++) {
    int eta = LVL1::locMap[i][0];
    int phi = LVL1::locMap[i][1];
    int layer = LVL1::locMap[i][2];
    scellValues += std::to_string(*superCellToPtr(eta, phi, layer)) + " ";
    switch (layer) {
    case 0:
      em0Values += std::to_string(*m_em0cells[eta][phi]) + " ";
      break;
    case 1:
      em1Values += std::to_string(*m_em1cells[eta][phi]) + " ";
      break;
    case 2:
      em2Values += std::to_string(*m_em2cells[eta][phi]) + " ";
      break;
    case 3:
      em3Values += std::to_string(*m_em3cells[eta][phi]) + " ";
      break;
    case 4:
      hadValues += std::to_string(*m_hadcells[eta][phi]) + " ";
      break;
    }
  }
 
  m_log->msg(MSG::DEBUG) << "SCell values: " << scellValues << endmsg;
  m_log->msg(MSG::DEBUG) << "layer 0 values: " << em0Values << endmsg;
  m_log->msg(MSG::DEBUG) << "layer 1 values: " << em1Values << endmsg;
  m_log->msg(MSG::DEBUG) << "layer 2 values: " << em2Values << endmsg;
  m_log->msg(MSG::DEBUG) << "layer 3 values: " << em3Values << endmsg;
  m_log->msg(MSG::DEBUG) << "layer 4 values: " << hadValues << endmsg;
}

debugPrintTowers()

void LVL1::eFEXtauBDT::debugPrintTowers

(

)

Definition at line 280 of file eFEXtauBDT.cxx.

                                      {
  m_log->msg(MSG::DEBUG) << "Towers Estimate: " << endmsg;
  for (int eta = 0; eta < 3; eta++) {
    for (int phi = 0; phi < 3; phi++) {
      int flatIndex = flatTowerIndex(eta, phi);
      m_log->msg(MSG::DEBUG)
          << "Tower " << flatIndex << " ET (eta=" << eta << ", phi=" << phi
          << "): " << m_towers[flatIndex] << endmsg;
    }
  }
}

flatTowerIndex()

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

inline

Definition at line 292 of file eFEXtauBDT.cxx.

{ return 3 * phi + eta; }

getBDTCondition()

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

inline

Definition at line 87 of file eFEXtauBDT.h.

{ return m_bdtCondition; }

getBDTScore()

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

inline

Definition at line 89 of file eFEXtauBDT.h.

{ return m_bdtScore; }

getBDTScoreShifted()

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

inline

Definition at line 79 of file eFEXtauBDT.h.

{ return m_bdtScoreShifted; }

getBDTVars()

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

inline

Definition at line 71 of file eFEXtauBDT.h.

{ return m_bdtVars; }

getEMETEstimate()

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

inline

Definition at line 63 of file eFEXtauBDT.h.

{ return m_EM_eTEstimate; }

getEMETEstimateOverflow()

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

inline

Definition at line 64 of file eFEXtauBDT.h.

                                               {
    return m_EM_eTEstimateOverflow;
  }

getEMMultipliedByFracParams()

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

inline

Definition at line 73 of file eFEXtauBDT.h.

                                                         {
    return m_emEtXMultiplier;
  }

getEMMultipliedByFracParamsOverflow()

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

inline

Definition at line 76 of file eFEXtauBDT.h.

                                                                 {
    return m_emEtXMultiplierOverflow;
  }

getET()

unsigned int LVL1::eFEXtauBDT::getET

(

)

const

Definition at line 452 of file eFEXtauBDT.cxx.

                                         {
  if (m_eTEstimateOverflow) {
    return (1 << ENERGY_WIDTH) - 1;
  }
  if (m_eTEstimate < *m_etThreshold) {
    return 0;
  }
  return m_eTEstimate;
}

getETEstimate()

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

inline

Definition at line 62 of file eFEXtauBDT.h.

{ return m_eTEstimate; }

getFracCondition()

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

inline

Definition at line 88 of file eFEXtauBDT.h.

{ return m_fracCondition; }

getHADETEstimate()

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

inline

Definition at line 67 of file eFEXtauBDT.h.

{ return m_HAD_eTEstimate; }

getHADETEstimateOverflow()

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

inline

Definition at line 68 of file eFEXtauBDT.h.

                                                {
    return m_HAD_eTEstimateOverflow;
  }

getIsMax()

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

inline

Definition at line 86 of file eFEXtauBDT.h.

{ return m_isSeeded; }

getTOBETOverflow()

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

inline

Definition at line 85 of file eFEXtauBDT.h.

{ return m_eTEstimateOverflow; }

getTowers()

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

inline

Definition at line 72 of file eFEXtauBDT.h.

{ return m_towers; }

initBDTVars()

void LVL1::eFEXtauBDT::initBDTVars

(

)

Definition at line 145 of file eFEXtauBDT.cxx.

                                 {
  for (size_t i = 0; i < m_bdt.getVariables().size(); i++) {
    BDTVariable var = m_bdt.getVariables()[i];
 
    m_log->msg(MSG::DEBUG) << i << " is " << var.m_name << ", sum of supercells"
                           << endmsg;
    std::vector<unsigned int *> pointersToSCells;
    for (size_t j = 0; j < var.m_scells.size(); j++) {
      int eta = var.m_scells[j][0];
      int phi = var.m_scells[j][1];
      int layer = var.m_scells[j][2];
      m_log->msg(MSG::DEBUG) << "\teta=" << eta << "\tphi=" << phi
                             << "\tlayer=" << layer << endmsg;
      unsigned int *ptr = superCellToPtr(eta, phi, layer);
      if (ptr == 0) {
        m_log->msg(MSG::DEBUG)
            << "Could not convert eta=" << eta << " phi=" << phi
            << " layer=" << layer
            << " to a pointer to supercell. Are they within range?" << endmsg;
        throw std::domain_error(
            std::string("Could not convert eta=") + std::to_string(eta) +
            " phi=" + std::to_string(phi) + " layer=" + std::to_string(layer) +
            " to a pointer to supercell. Are they within range?");
      }
      pointersToSCells.push_back(ptr);
    }
 
    m_bdtVarComputeSCellPointers.push_back(pointersToSCells);
  }
}

initEMETPointers()

void LVL1::eFEXtauBDT::initEMETPointers

(

)

Definition at line 105 of file eFEXtauBDT.cxx.

                                      {
  initPointers(m_bdt.getEMETSCells(), m_EM_eTComputeSCellPointers);
}

initETPointers()

void LVL1::eFEXtauBDT::initETPointers

(

)

Definition at line 101 of file eFEXtauBDT.cxx.

                                    {
  initPointers(m_bdt.getETSCells(), m_eTComputeSCellPointers);
}

initHADETPointers()

void LVL1::eFEXtauBDT::initHADETPointers

(

)

Definition at line 109 of file eFEXtauBDT.cxx.

                                       {
  initPointers(m_bdt.getHADETSCells(), m_HAD_eTComputeSCellPointers);
}

initPointers()

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

private

Definition at line 113 of file eFEXtauBDT.cxx.

                                                                         {
  m_log->msg(MSG::DEBUG) << "Will use sum of supercells: " << endmsg;
  for (auto scell : scells) {
    int eta = scell[0];
    int phi = scell[1];
    int layer = scell[2];
    m_log->msg(MSG::DEBUG) << "\teta=" << eta << "\tphi=" << phi
                           << "\tlayer=" << layer << endmsg;
    unsigned int *ptr = superCellToPtr(eta, phi, layer);
    if (ptr == 0) {
      m_log->msg(MSG::DEBUG)
          << "Could not convert eta=" << eta << " phi=" << phi
          << " layer=" << layer
          << " to a pointer to supercell. Are they within range?" << endmsg;
      throw std::domain_error(
          std::string("Could not convert eta=") + std::to_string(eta) +
          " phi=" + std::to_string(phi) + " layer=" + std::to_string(layer) +
          " to a pointer to supercell. Are they within range?");
    }
    ptr_list.push_back(ptr);
  }
}

initTowersPointers()

void LVL1::eFEXtauBDT::initTowersPointers

(

)

Definition at line 137 of file eFEXtauBDT.cxx.

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

isOverflow()

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

inline

Definition at line 307 of file eFEXtauBDT.cxx.

                                                              {
  if ((number >> nBits) != 0) {
    return true;
  }
  return false;
}

multWithOverflow()

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

Definition at line 328 of file eFEXtauBDT.cxx.

                                                                 {
  overflow = false;
  if (b == 0) {
    return 0;
  }
  unsigned int result = a * b;
  if (a != result / b) {
    // This shouldn't happen (a and b are in reality 16 bit numbers), but just
    // in case.
    overflow = true;
  }
 
  overflow = isOverflow(result, resultNBits);
 
  return result;
}

next()

void LVL1::eFEXtauBDT::next

(

)

Definition at line 176 of file eFEXtauBDT.cxx.

                          {
  buildBDTVariables();
  computeTowers();
  computeETEstimate();
  computeHADETEstimate();
  computeEMETEstimate();
  computeBDTCondition();
  computeFracCondition();
  computeIsCentralTowerSeed();
}

setPointerToBDTMinETParam()

void LVL1::eFEXtauBDT::setPointerToBDTMinETParam

(

unsigned int *

bdtMinEtThreshold

)

Definition at line 74 of file eFEXtauBDT.cxx.

                                     {
  m_bdtMinEtThreshold = bdtMinEtThreshold;
}

setPointerToBDTThresholdsParam()

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

Definition at line 60 of file eFEXtauBDT.cxx.

                                              {
  m_bdtThresholds[index] = bdtThresholdPtr;
}

setPointerToETThresholdParam()

void LVL1::eFEXtauBDT::setPointerToETThresholdParam

(

unsigned int *

etThreshold

)

Definition at line 65 of file eFEXtauBDT.cxx.

                                                                           {
  m_etThreshold = etThreshold;
}

setPointerToFracMultipliersParam()

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

Definition at line 55 of file eFEXtauBDT.cxx.

                                                {
  m_fracMultipliers[index] = fracMultiplierPtr;
}

setPointerToMaxETParam()

void LVL1::eFEXtauBDT::setPointerToMaxETParam

(

unsigned int *

maxEtThreshold

)

Definition at line 69 of file eFEXtauBDT.cxx.

                                  {
  m_maxEtThreshold = maxEtThreshold;
}

setPointerToSCell()

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

Definition at line 34 of file eFEXtauBDT.cxx.

                                                                 {
  switch (layer) {
  case 0:
    m_em0cells[eta][phi] = sCellPtr;
    break;
  case 1:
    m_em1cells[eta][phi] = sCellPtr;
    break;
  case 2:
    m_em2cells[eta][phi] = sCellPtr;
    break;
  case 3:
    m_em3cells[eta][phi] = sCellPtr;
    break;
  case 4:
    m_hadcells[eta][phi] = sCellPtr;
    break;
  }
}

superCellToPtr()

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

private

Definition at line 79 of file eFEXtauBDT.cxx.

                                                                        {
  unsigned int *ptr = 0;
  switch (layer) {
  case 0:
    ptr = m_em0cells[eta][phi];
    break;
  case 1:
    ptr = m_em1cells[eta][phi];
    break;
  case 2:
    ptr = m_em2cells[eta][phi];
    break;
  case 3:
    ptr = m_em3cells[eta][phi];
    break;
  case 4:
    ptr = m_hadcells[eta][phi];
    break;
  }
  return ptr;
}

Member Data Documentation

m_bdt

eFEXBDT LVL1::eFEXtauBDT::m_bdt

private

Definition at line 148 of file eFEXtauBDT.h.

m_bdtCondition

unsigned int LVL1::eFEXtauBDT::m_bdtCondition = 0

private

Definition at line 125 of file eFEXtauBDT.h.

m_bdtMinEtThreshold

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

private

Definition at line 115 of file eFEXtauBDT.h.

m_bdtScore

unsigned int LVL1::eFEXtauBDT::m_bdtScore = 0

private

Definition at line 116 of file eFEXtauBDT.h.

m_bdtScoreShifted

unsigned int LVL1::eFEXtauBDT::m_bdtScoreShifted = 0

private

Definition at line 117 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 138 of file eFEXtauBDT.h.

m_bdtVars

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

private

Definition at line 133 of file eFEXtauBDT.h.

m_bdtVarsComputed

bool LVL1::eFEXtauBDT::m_bdtVarsComputed = false

private

Definition at line 147 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 143 of file eFEXtauBDT.h.

m_EM_eTEstimate

unsigned int LVL1::eFEXtauBDT::m_EM_eTEstimate = 0

private

Definition at line 120 of file eFEXtauBDT.h.

m_EM_eTEstimateOverflow

bool LVL1::eFEXtauBDT::m_EM_eTEstimateOverflow = 0

private

Definition at line 121 of file eFEXtauBDT.h.

m_emEtXMultiplier

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

private

Definition at line 128 of file eFEXtauBDT.h.

m_emEtXMultiplierOverflow

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

private

Definition at line 129 of file eFEXtauBDT.h.

m_eTComputeSCellPointers

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

private

Definition at line 142 of file eFEXtauBDT.h.

m_eTEstimate

unsigned int LVL1::eFEXtauBDT::m_eTEstimate = 0

private

Definition at line 118 of file eFEXtauBDT.h.

m_eTEstimateOverflow

bool LVL1::eFEXtauBDT::m_eTEstimateOverflow = false

private

Definition at line 119 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 124 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 144 of file eFEXtauBDT.h.

m_HAD_eTEstimate

unsigned int LVL1::eFEXtauBDT::m_HAD_eTEstimate = 0

private

Definition at line 122 of file eFEXtauBDT.h.

m_HAD_eTEstimateOverflow

bool LVL1::eFEXtauBDT::m_HAD_eTEstimateOverflow = false

private

Definition at line 123 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 127 of file eFEXtauBDT.h.

m_isSeeded

bool LVL1::eFEXtauBDT::m_isSeeded = false

private

Definition at line 126 of file eFEXtauBDT.h.

m_log

AthAlgTool* LVL1::eFEXtauBDT::m_log

private

Definition at line 149 of file eFEXtauBDT.h.

m_maxEtThreshold

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

private

Definition at line 114 of file eFEXtauBDT.h.

m_towers

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

private

Definition at line 130 of file eFEXtauBDT.h.

m_towersComputeSCellPointers

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

private

Definition at line 145 of file eFEXtauBDT.h.

---

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

• eFEXtauBDT.h
• eFEXtauBDT.cxx